From 21e998876f637920ebdaf92030f5d8b0d761fdf1 Mon Sep 17 00:00:00 2001
From: Maximilian Weber <maxweber@fb.com>
Date: Wed, 22 Jun 2022 00:45:38 -0700
Subject: [PATCH 001/235] Refactored reconstruction.py with less calls to
 np.radians

Reviewed By: fabianschenk

Differential Revision: D37315331

fbshipit-source-id: 5016c6d45d528c2fff5d8e32d03bcf4577c27f47
---
 opensfm/reconstruction.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index dac671c0e..117816dc5 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -910,6 +910,8 @@ def triangulate_robust(
         all_combinations = list(combinations(range(len(ids)), 2))
 
         thresholds = len(os) * [reproj_threshold]
+        min_ray_angle_radians = np.radians(min_ray_angle_degrees)
+        max_ray_angle_radians = np.pi - min_ray_angle_radians
         for i in range(ransac_tries):
             random_id = int(np.random.rand() * (len(all_combinations) - 1))
             if random_id in combinatiom_tried:
@@ -925,8 +927,8 @@ def triangulate_robust(
                 os_t,
                 bs_t,
                 thresholds,
-                np.radians(min_ray_angle_degrees),
-                np.radians(180.0 - min_ray_angle_degrees),
+                min_ray_angle_radians,
+                max_ray_angle_radians,
             )
             X = pygeometry.point_refinement(os_t, bs_t, X, iterations)
 
@@ -942,8 +944,8 @@ def triangulate_robust(
                         os[inliers],
                         bs[inliers],
                         len(inliers) * [reproj_threshold],
-                        np.radians(min_ray_angle_degrees),
-                        np.radians(180.0 - min_ray_angle_degrees),
+                        min_ray_angle_radians,
+                        max_ray_angle_radians,
                     )
                     new_X = pygeometry.point_refinement(
                         os[inliers], bs[inliers], X, iterations
@@ -997,12 +999,13 @@ def triangulate(
 
         if len(os) >= 2:
             thresholds = len(os) * [reproj_threshold]
+            min_ray_angle_radians = np.radians(min_ray_angle_degrees)
             valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
                 np.asarray(os),
                 np.asarray(bs),
                 thresholds,
-                np.radians(min_ray_angle_degrees),
-                np.radians(180.0 - min_ray_angle_degrees),
+                min_ray_angle_radians,
+                np.pi - min_ray_angle_radians,
             )
             if valid_triangulation:
                 X = pygeometry.point_refinement(

From c91ed5547075a06c6da721d1dbdbb875d5ee2c23 Mon Sep 17 00:00:00 2001
From: Farooq Zuberi <farooqzuberi@fb.com>
Date: Wed, 22 Jun 2022 08:35:42 -0700
Subject: [PATCH 002/235] Refactor motion_from_plane_homography in openSFM
 Multiviewpy

Reviewed By: fabianschenk

Differential Revision: D37341649

fbshipit-source-id: d090ea5977b13ffdd61802f80cd4a412fce613d1
---
 opensfm/multiview.py | 52 ++++++++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 21 deletions(-)

diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index cf38d0d6f..65dd3ea07 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -566,33 +566,43 @@ def motion_from_plane_homography(
     ]
     solutions = []
 
-    # Case d' > 0
+    # Compute solutions for the two cases (1) case d' > 0 and
+    # (2) case d' < 0
+
     for x1, x3 in possible_x1_x3:
-        sin_theta = (d1 - d3) * x1 * x3 / d2
-        cos_theta = (d1 * x3**2 + d3 * x1**2) / d2
-        Rp = np.array(
+        # compute sin and cos for d'>0 (theta, _n) and d'<0 (phi, _n) cases
+        sin_term = x1 * x3 / d2
+        sin_theta = (d1 - d3) * sin_term
+        sin_phi = (d1 + d3) * sin_term
+
+        d1_x3_2 = (d1 * x3**2)
+        d3_x1_2 = (d3 * x1**2)
+        cos_theta = (d3_x1_2 + d1_x3_2) / d2
+        cos_phi = (d3_x1_2 - d1_x3_2) / d2
+
+        # define rotation matrices for both cases
+        Rp_p = np.array(
             [[cos_theta, 0, -sin_theta], [0, 1, 0], [sin_theta, 0, cos_theta]]
-        )
-        tp = (d1 - d3) * np.array([x1, 0, -x3])
+        )  # case d' > 0
+        Rp_n = np.array(
+            [[cos_phi, 0, sin_phi], [0, -1, 0], [sin_phi, 0, -cos_phi]]
+        )  # case d' < 0
+
+        # compute transformations
         np_ = np.array([x1, 0, x3])
-        R = s * np.dot(np.dot(u, Rp), vh)
-        t = np.dot(u, tp)
+
+        tp_p = (d1 - d3) * np.array([x1, 0, -x3])  # case d' > 0
+        tp_n = (d1 + d3) * np_  # case d' < 0
+
+        R_p = s * np.dot(np.dot(u, Rp_p), vh)  # case d' > 0
+        R_n = s * np.dot(np.dot(u, Rp_n), vh)  # case d' < 0
+        t_p = np.dot(u, tp_p)  # case d' > 0
+        t_n = np.dot(u, tp_n)  # case d' < 0
         n = -np.dot(vh.T, np_)
         d = s * d2
-        solutions.append((R, t, n, d))
 
-    # Case d' < 0
-    for x1, x3 in possible_x1_x3:
-        sin_phi = (d1 + d3) * x1 * x3 / d2
-        cos_phi = (d3 * x1**2 - d1 * x3**2) / d2
-        Rp = np.array([[cos_phi, 0, sin_phi], [0, -1, 0], [sin_phi, 0, -cos_phi]])
-        tp = (d1 + d3) * np.array([x1, 0, x3])
-        np_ = np.array([x1, 0, x3])
-        R = s * np.dot(np.dot(u, Rp), vh)
-        t = np.dot(u, tp)
-        n = -np.dot(vh.T, np_)
-        d = -s * d2
-        solutions.append((R, t, n, d))
+        solutions.append((R_p, t_p, n, d))  # case d' > 0
+        solutions.append((R_n, t_n, n, -d))  # case d' < 0
 
     return solutions
 

From 8e7b11c19b76ce39ee7598109087ddffc4502171 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@fb.com>
Date: Mon, 27 Jun 2022 03:56:39 -0700
Subject: [PATCH 003/235] Remove unused acceleration_ and add const wherever
 possible

Summary:
This diff does the following:
- removes the unused `acceleration_` variable
- adds `const` to parameters and members in `bundle` wherever possible

Reviewed By: tobias-o

Differential Revision: D37339308

fbshipit-source-id: 69432532dd706df612004e05602bb16d53808221
---
 .../src/bundle/error/absolute_motion_errors.h | 20 +++++++++----------
 opensfm/src/bundle/error/error_utils.h        |  2 +-
 .../src/bundle/error/motion_prior_errors.h    |  7 +++----
 opensfm/src/bundle/error/parameters_errors.h  |  6 +++---
 opensfm/src/bundle/error/prior_error.h        |  2 +-
 opensfm/src/bundle/error/projection_errors.h  | 12 +++++------
 6 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/opensfm/src/bundle/error/absolute_motion_errors.h b/opensfm/src/bundle/error/absolute_motion_errors.h
index e3bc62c5d..407267a91 100644
--- a/opensfm/src/bundle/error/absolute_motion_errors.h
+++ b/opensfm/src/bundle/error/absolute_motion_errors.h
@@ -28,7 +28,7 @@ struct UpVectorError {
   }
 
   Vec3d acceleration_;
-  double scale_;
+  const double scale_;
 };
 
 struct PanAngleError {
@@ -53,8 +53,8 @@ struct PanAngleError {
     return true;
   }
 
-  double angle_;
-  double scale_;
+  const double angle_;
+  const double scale_;
 };
 
 struct TiltAngleError {
@@ -77,8 +77,8 @@ struct TiltAngleError {
     return true;
   }
 
-  double angle_;
-  double scale_;
+  const double angle_;
+  const double scale_;
 };
 
 struct RollAngleError {
@@ -122,8 +122,8 @@ struct RollAngleError {
     return true;
   }
 
-  double angle_;
-  double scale_;
+  const double angle_;
+  const double scale_;
 };
 
 struct HeatmapdCostFunctor {
@@ -180,12 +180,12 @@ struct TranslationPriorError {
   template <typename T>
   bool operator()(const T* const rig_instance1, const T* const rig_instance2,
                   T* residuals) const {
-    auto t1 = Eigen::Map<const Vec3<T>>(rig_instance1 + Pose::Parameter::TX);
-    auto t2 = Eigen::Map<const Vec3<T>>(rig_instance2 + Pose::Parameter::TX);
+    const auto t1 = Eigen::Map<const Vec3<T>>(rig_instance1 + Pose::Parameter::TX);
+    const auto t2 = Eigen::Map<const Vec3<T>>(rig_instance2 + Pose::Parameter::TX);
     residuals[0] = log((t1 - t2).norm() / T(prior_norm_));
     return true;
   }
 
-  double prior_norm_;
+  const double prior_norm_;
 };
 }  // namespace bundle
diff --git a/opensfm/src/bundle/error/error_utils.h b/opensfm/src/bundle/error/error_utils.h
index b038d37c5..2ff7619a1 100644
--- a/opensfm/src/bundle/error/error_utils.h
+++ b/opensfm/src/bundle/error/error_utils.h
@@ -84,7 +84,7 @@ void WorldToCameraCoordinatesRig(const T* scale, const T* const rig_instance,
 }
 
 template <typename T>
-T DiffBetweenAngles(T a, T b) {
+T DiffBetweenAngles(const T a, const T b) {
   T d = a - b;
   if (d > T(M_PI)) {
     return d - T(2 * M_PI);
diff --git a/opensfm/src/bundle/error/motion_prior_errors.h b/opensfm/src/bundle/error/motion_prior_errors.h
index 7e80c479f..61ef5d3d9 100644
--- a/opensfm/src/bundle/error/motion_prior_errors.h
+++ b/opensfm/src/bundle/error/motion_prior_errors.h
@@ -47,10 +47,9 @@ struct LinearMotionError {
         T(position_scale_) * MultRotations(R2_R0t.eval(), R0_R1t);
     return true;
   }
-  double alpha_;
-  Vec3d acceleration_;
-  double position_scale_;
-  double orientation_scale_;
+  const double alpha_;
+  const double position_scale_;
+  const double orientation_scale_;
 
   int shot0_rig_camera_index{FUNCTOR_NOT_SET};
   int shot1_rig_camera_index{FUNCTOR_NOT_SET};
diff --git a/opensfm/src/bundle/error/parameters_errors.h b/opensfm/src/bundle/error/parameters_errors.h
index 9b2613956..394b52c04 100644
--- a/opensfm/src/bundle/error/parameters_errors.h
+++ b/opensfm/src/bundle/error/parameters_errors.h
@@ -30,8 +30,8 @@ struct ParameterBarrier {
     return true;
   }
 
-  double lower_bound_;
-  double upper_bound_;
-  int index_;
+  const double lower_bound_;
+  const double upper_bound_;
+  const int index_;
 };
 }  // namespace bundle
diff --git a/opensfm/src/bundle/error/prior_error.h b/opensfm/src/bundle/error/prior_error.h
index 695ee888e..40719fac1 100644
--- a/opensfm/src/bundle/error/prior_error.h
+++ b/opensfm/src/bundle/error/prior_error.h
@@ -107,7 +107,7 @@ struct DataPriorError {
   VecXd scales_;
 
   // Are scale being adjusted for (global multiplier) ?
-  bool adjust_scales_;
+  const bool adjust_scales_;
   static constexpr int parameter_index = 0;
   static constexpr int transform_index = 1;
   static constexpr int scale_index = 2;
diff --git a/opensfm/src/bundle/error/projection_errors.h b/opensfm/src/bundle/error/projection_errors.h
index a103d115a..c8bf8f239 100644
--- a/opensfm/src/bundle/error/projection_errors.h
+++ b/opensfm/src/bundle/error/projection_errors.h
@@ -22,10 +22,10 @@ class ReprojectionError {
         use_rig_camera_(use_rig_camera) {}
 
  protected:
-  geometry::ProjectionType type_;
-  Vec2d observed_;
-  double scale_;
-  bool use_rig_camera_;
+  const geometry::ProjectionType type_;
+  const Vec2d observed_;
+  const double scale_;
+  const bool use_rig_camera_;
 };
 
 class ReprojectionError2D : public ReprojectionError {
@@ -215,8 +215,8 @@ class ReprojectionError3D : public ReprojectionError {
                       const Vec2d& observed, double std_deviation,
                       bool use_rig_camera)
       : ReprojectionError(type, observed, std_deviation, use_rig_camera) {
-    double lon = observed[0] * 2 * M_PI;
-    double lat = -observed[1] * 2 * M_PI;
+    const double lon = observed[0] * 2 * M_PI;
+    const double lat = -observed[1] * 2 * M_PI;
     bearing_vector_[0] = std::cos(lat) * std::sin(lon);
     bearing_vector_[1] = -std::sin(lat);
     bearing_vector_[2] = std::cos(lat) * std::cos(lon);

From ce5ad2732e2b97ac06d6600317af2aa8e22b537e Mon Sep 17 00:00:00 2001
From: Sebastian Haner <seb.haner@gmail.com>
Date: Tue, 28 Jun 2022 06:13:32 -0700
Subject: [PATCH 004/235] Fix descriptor dtype issue (#805)

Summary:
If a user selects the feature type using
lower case letters, e.g. "orb", detect_features
will cast to upper case and proceed normally.
However, when saving the features no casting
is performed, and descriptors are saved to disk
as float, leading to the wrong matcher being
selected in the next stage, silently leading
to poor matching performance.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/805

Reviewed By: YanNoun

Differential Revision: D37379909

Pulled By: fabianschenk

fbshipit-source-id: 0c6b817bf5f88d2b736eb66c3bb42f9f8cc1e6aa
---
 opensfm/features.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/features.py b/opensfm/features.py
index 56eac1500..c6bcf048e 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -94,7 +94,7 @@ def mask(self, mask: np.ndarray) -> "FeaturesData":
 
     def save(self, fileobject: Any, config: Dict[str, Any]):
         """Save features from file (path like or file object like)"""
-        feature_type = config["feature_type"]
+        feature_type = config["feature_type"].upper()
         if (
             (
                 feature_type == "AKAZE"

From cc222579826bfc6b6f76f811eb68d63904df624a Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@fb.com>
Date: Tue, 28 Jun 2022 06:13:59 -0700
Subject: [PATCH 005/235] Update pyi files

Summary: Update `*.pyi` files

Reviewed By: tobias-o

Differential Revision: D37451823

fbshipit-source-id: e3a73870358c842fbffa0468930cac5c7687572e
---
 opensfm/src/bundle/pybundle.pyi     |  7 ++++++-
 opensfm/src/dense/pydense.pyi       |  7 ++++++-
 opensfm/src/features/pyfeatures.pyi |  7 ++++++-
 opensfm/src/geo/pygeo.pyi           | 17 +++++++++++------
 opensfm/src/robust/pyrobust.pyi     |  7 ++++++-
 opensfm/src/sfm/pysfm.pyi           |  7 ++++++-
 6 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/opensfm/src/bundle/pybundle.pyi b/opensfm/src/bundle/pybundle.pyi
index 4e53f78a8..da53f049e 100644
--- a/opensfm/src/bundle/pybundle.pyi
+++ b/opensfm/src/bundle/pybundle.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/bundle:pybundle_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import numpy
 import opensfm.pygeometry
diff --git a/opensfm/src/dense/pydense.pyi b/opensfm/src/dense/pydense.pyi
index 13a398277..afc938c44 100644
--- a/opensfm/src/dense/pydense.pyi
+++ b/opensfm/src/dense/pydense.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/dense:pydense_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import numpy
 from typing import *
diff --git a/opensfm/src/features/pyfeatures.pyi b/opensfm/src/features/pyfeatures.pyi
index 755d7c89d..543e1feee 100644
--- a/opensfm/src/features/pyfeatures.pyi
+++ b/opensfm/src/features/pyfeatures.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/features:pyfeatures_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import numpy
 from typing import *
diff --git a/opensfm/src/geo/pygeo.pyi b/opensfm/src/geo/pygeo.pyi
index 0e5f2774f..809b80dda 100644
--- a/opensfm/src/geo/pygeo.pyi
+++ b/opensfm/src/geo/pygeo.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/geo:pygeo_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import numpy
 from typing import *
@@ -37,19 +42,19 @@ def ecef_from_topocentric_transform(arg0: float, arg1: float, arg2: float) -> nu
 @overload
 def ecef_from_topocentric_transform(arg0: numpy.ndarray) -> numpy.ndarray:...
 @overload
-def ecef_from_topocentric_transform_finite_diff(arg0: numpy.ndarray) -> numpy.ndarray:...
-@overload
 def ecef_from_topocentric_transform_finite_diff(arg0: float, arg1: float, arg2: float) -> numpy.ndarray:...
+@overload
+def ecef_from_topocentric_transform_finite_diff(arg0: numpy.ndarray) -> numpy.ndarray:...
 def gps_distance(arg0: numpy.ndarray, arg1: numpy.ndarray) -> float:...
 @overload
 def lla_from_ecef(arg0: numpy.ndarray) -> numpy.ndarray:...
 @overload
 def lla_from_ecef(arg0: float, arg1: float, arg2: float) -> numpy.ndarray:...
 @overload
-def lla_from_topocentric(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
-@overload
 def lla_from_topocentric(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float) -> numpy.ndarray:...
 @overload
-def topocentric_from_lla(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
+def lla_from_topocentric(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
 @overload
 def topocentric_from_lla(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float) -> numpy.ndarray:...
+@overload
+def topocentric_from_lla(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
diff --git a/opensfm/src/robust/pyrobust.pyi b/opensfm/src/robust/pyrobust.pyi
index 0846303e9..ec78203b7 100644
--- a/opensfm/src/robust/pyrobust.pyi
+++ b/opensfm/src/robust/pyrobust.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/robust:pyrobust_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import numpy
 from typing import *
diff --git a/opensfm/src/sfm/pysfm.pyi b/opensfm/src/sfm/pysfm.pyi
index 78b943472..96df11d6e 100644
--- a/opensfm/src/sfm/pysfm.pyi
+++ b/opensfm/src/sfm/pysfm.pyi
@@ -2,8 +2,13 @@
 # Do not manually edit
 # To regenerate:
 #   $ buck run //mapillary/opensfm/opensfm/src/sfm:pysfm_stubgen
-# Use proper mode, e.g. @arvr/mode/linux/dev for arvr
 # @generated
+#
+# Tip: Be sure to run this with the build mode you use for your project, e.g.,
+# @//arvr/mode/linux/opt (or dev) in arvr.
+#
+# Ignore errors for [5] global variable types and [24] untyped generics.
+# pyre-ignore-all-errors[5,24]
 
 import opensfm.pybundle
 import opensfm.pygeometry

From 23550288a376ecd9c9027c75216b462764c1ac41 Mon Sep 17 00:00:00 2001
From: Piero Toffanin <pt@masseranolabs.com>
Date: Tue, 28 Jun 2022 06:14:42 -0700
Subject: [PATCH 006/235] Fix qhull crash during matching on small image set
 (#878)

Summary:
Hey there :hand:

When trying to reconstruct a small image set (2 or 3 images) and `matching_graph_rounds` is enabled, the pipeline will fail at the feature matching step:

```
Traceback (most recent call last):
  File "/code/SuperBuild/install/bin/opensfm/bin/opensfm_main.py", line 25, in <module>
    commands.command_runner(
  File "/code/SuperBuild/install/bin/opensfm/opensfm/commands/command_runner.py", line 37, in command_runner
    command.run(data, args)
  File "/code/SuperBuild/install/bin/opensfm/opensfm/commands/command.py", line 12, in run
    self.run_impl(data, args)
  File "/code/SuperBuild/install/bin/opensfm/opensfm/commands/match_features.py", line 11, in run_impl
    match_features.run_dataset(dataset)
  File "/code/SuperBuild/install/bin/opensfm/opensfm/actions/match_features.py", line 14, in run_dataset
    pairs_matches, preport = matching.match_images(data, {}, images, images)
  File "/code/SuperBuild/install/bin/opensfm/opensfm/matching.py", line 46, in match_images
    pairs, preport = pairs_selection.match_candidates_from_metadata(
  File "/code/SuperBuild/install/bin/opensfm/opensfm/pairs_selection.py", line 630, in match_candidates_from_metadata
    g = match_candidates_by_graph(
  File "/code/SuperBuild/install/bin/opensfm/opensfm/pairs_selection.py", line 253, in match_candidates_by_graph
    triangles = spatial.Delaunay(points).simplices
  File "qhull.pyx", line 1840, in scipy.spatial.qhull.Delaunay.__init__
  File "qhull.pyx", line 356, in scipy.spatial.qhull._Qhull.__init__
scipy.spatial.qhull.QhullError: QH6214 qhull input error: not enough points(2) to construct initial simplex (need 4)

While executing:  | qhull d Qt Qc Q12 Qbb Qz
Options selected for Qhull 2019.1.r 2019/06/21:
  run-id 521442032  delaunay  Qtriangulate  Qcoplanar-keep  Q12-allow-wide
  Qbbound-last  Qz-infinity-point  _pre-merge  _zero-centrum  Qinterior-keep
  _maxoutside  0
```

This is solved by having `match_candidates_by_graph` return early if there's less than 4 input images.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/878

Reviewed By: YanNoun

Differential Revision: D37379926

Pulled By: fabianschenk

fbshipit-source-id: 3390446668faa5a5680b772ddeb3bda7f9cc575e
---
 opensfm/pairs_selection.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 0aa3b5ea3..8174c742c 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -222,7 +222,7 @@ def match_candidates_by_graph(
     rounds: int,
 ) -> Set[Tuple[str, str]]:
     """Find by triangulating the GPS points on X/Y axises"""
-    if len(images_cand) == 0 or rounds < 1:
+    if len(images_cand) < 4 or rounds < 1:
         return set()
 
     images_cand_set = set(images_cand)

From 2aabdcb1d545ea67f04ef0dbc53365adab724b1d Mon Sep 17 00:00:00 2001
From: Piero Toffanin <pt@masseranolabs.com>
Date: Tue, 28 Jun 2022 09:02:25 -0700
Subject: [PATCH 007/235] Export image masks to OpenMVS (#921)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Summary:
Hello :hand:

This PR adds support for exporting image masks to OpenMVS, if they are set.

Hope this can be useful to others. :pray:

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/921

Reviewed By: YanNoun

Differential Revision: D37410286

Pulled By: fabianschenk

fbshipit-source-id: 6a2ea96c95a91e0dc9f36c5ad0ab4931c02b98aa
---
 opensfm/actions/export_openmvs.py    | 5 +++++
 opensfm/src/dense/openmvs_exporter.h | 3 ++-
 opensfm/src/dense/pydense.pyi        | 2 +-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/opensfm/actions/export_openmvs.py b/opensfm/actions/export_openmvs.py
index 23a346e11..7d3edc8ab 100644
--- a/opensfm/actions/export_openmvs.py
+++ b/opensfm/actions/export_openmvs.py
@@ -44,8 +44,13 @@ def export(reconstruction, tracks_manager, udata: UndistortedDataSet, export_onl
 
         if shot.camera.projection_type == "perspective":
             image_path = udata._undistorted_image_file(shot.id)
+            mask_path = udata._undistorted_mask_file(shot.id)
+            if not os.path.isfile(mask_path):
+                mask_path = ""
+
             exporter.add_shot(
                 str(os.path.abspath(image_path)),
+                str(os.path.abspath(mask_path)),
                 str(shot.id),
                 str(shot.camera.id),
                 shot.pose.get_rotation_matrix(),
diff --git a/opensfm/src/dense/openmvs_exporter.h b/opensfm/src/dense/openmvs_exporter.h
index e4f7ce15e..088223f7b 100644
--- a/opensfm/src/dense/openmvs_exporter.h
+++ b/opensfm/src/dense/openmvs_exporter.h
@@ -21,7 +21,7 @@ class OpenMVSExporter {
     scene_.platforms.push_back(platform);
   }
 
-  void AddShot(const std::string &path, const std::string &shot_id,
+  void AddShot(const std::string &path, const std::string &maskPath, const std::string &shot_id,
                const std::string &camera_id, pyarray_d R, pyarray_d C) {
     const double *C_data = C.data();
 
@@ -36,6 +36,7 @@ class OpenMVSExporter {
 
     MVS::Interface::Image image;
     image.name = path;
+    image.maskName = maskPath;
     image.platformID = platform_id;
     image.cameraID = 0;
     image.poseID = pose_id;
diff --git a/opensfm/src/dense/pydense.pyi b/opensfm/src/dense/pydense.pyi
index afc938c44..498f19bf2 100644
--- a/opensfm/src/dense/pydense.pyi
+++ b/opensfm/src/dense/pydense.pyi
@@ -43,5 +43,5 @@ class OpenMVSExporter:
     def __init__(self) -> None: ...
     def add_camera(self, arg0: str, arg1: numpy.ndarray, arg2: int, arg3: int) -> None: ...
     def add_point(self, arg0: numpy.ndarray, arg1: list) -> None: ...
-    def add_shot(self, arg0: str, arg1: str, arg2: str, arg3: numpy.ndarray, arg4: numpy.ndarray) -> None: ...
+    def add_shot(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: numpy.ndarray, arg5: numpy.ndarray) -> None: ...
     def export(self, arg0: str) -> None: ...

From 3b3e23694ff6edd3bfeec5834716f92075a83974 Mon Sep 17 00:00:00 2001
From: Lawrence Neal <nealla@lwneal.com>
Date: Thu, 30 Jun 2022 05:21:48 -0700
Subject: [PATCH 008/235] Add required opencv requirement for linux (#910)

Summary:
Fixes `ModuleNotFoundError: No module named 'cv2'` when following the [Building](https://opensfm.readthedocs.io/en/latest/building.html) instructions on Ubuntu 20.04 with virtualenv or similar.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/910

Reviewed By: YanNoun

Differential Revision: D37346114

Pulled By: fabianschenk

fbshipit-source-id: 72e2f2d810c31945fe543bc4367ef68997e4a8df
---
 requirements.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 430906385..947c3ec9b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,6 @@
 cloudpickle==0.4.0
 exifread==2.1.2
-flask==1.1.2
+flask==2.1.2
 fpdf2==2.4.6
 joblib==0.14.1
 matplotlib
@@ -17,3 +17,4 @@ six
 xmltodict==0.10.2
 wheel
 opencv-python==4.5.1.48 ; sys_platform == "win32"
+opencv-python ; sys_platform == "linux"

From 0e7bf61cc3bb32584c2dc362d25e0804cdf441e3 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Mon, 4 Jul 2022 05:06:06 -0700
Subject: [PATCH 009/235] feat: non-shrinking motion prior error

Summary:
This Diff changes the linear motion prior from additive to multiplicative form, in order to avoid shrinking effects that could arise.

However, we need to switch back to additive from in case of coincident centers (is breaking error function continuity).

Reviewed By: fabianschenk

Differential Revision: D37345489

fbshipit-source-id: f69e763f6f797c40b181ceb576bb6ad3be6e547f
---
 .../src/bundle/error/motion_prior_errors.h    | 21 ++++++++++++++++---
 opensfm/synthetic_data/synthetic_generator.py | 20 +++++++++++-------
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/opensfm/src/bundle/error/motion_prior_errors.h b/opensfm/src/bundle/error/motion_prior_errors.h
index 61ef5d3d9..83e4be9ae 100644
--- a/opensfm/src/bundle/error/motion_prior_errors.h
+++ b/opensfm/src/bundle/error/motion_prior_errors.h
@@ -37,14 +37,29 @@ struct LinearMotionError {
     Eigen::Map<Eigen::Matrix<T, 6, 1> > residual(r);
 
     // Position residual : op is translation
-    residual.segment(0, 3) =
-        T(position_scale_) * (T(alpha_) * (t2 - t0) + (t0 - t1));
+    const auto eps = T(1e-15);
+    const auto t2_t0 = (t2 - t0);
+    const auto t1_t0 = (t1 - t0);
+    const auto t2_t0_norm = t2_t0.norm();
+    const auto t1_t0_norm = t1_t0.norm();
+    for (int i = 0; i < 3; ++i) {
+      // in case of non-zero speed, use speed ratio as it isn't subject
+      //  to collapse when used together with position variance estimation
+      if (t2_t0_norm > eps) {
+        residual(i) =
+            T(position_scale_) * (T(alpha_) - t1_t0_norm / t2_t0_norm);
+        // otherwise, use classic difference between speeds, so one can still
+        // drag away position if they're coincident
+      } else {
+        residual(i) = T(position_scale_) * (T(alpha_) * t2_t0(i) - t1_t0(i));
+      }
+    }
 
     // Rotation residual : op is rotation
     const Vec3<T> R2_R0t = T(alpha_) * MultRotations(R2.eval(), (-R0).eval());
     const Vec3<T> R0_R1t = MultRotations(R0.eval(), (-R1).eval());
     residual.segment(3, 3) =
-        T(position_scale_) * MultRotations(R2_R0t.eval(), R0_R1t);
+        T(orientation_scale_) * MultRotations(R2_R0t.eval(), R0_R1t);
     return true;
   }
   const double alpha_;
diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index f4c7343a9..daecddb52 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -165,10 +165,6 @@ def generate_exifs(
     causal_gps_noise: bool = False,
 ) -> Dict[str, Any]:
     """Generate fake exif metadata from the reconstruction."""
-    speed_ms = 10.0
-    previous_pose = None
-    previous_time = 0
-    exifs = {}
 
     def _gps_dop(shot: pymap.Shot) -> float:
         gps_dop = 15.0
@@ -178,6 +174,7 @@ def _gps_dop(shot: pymap.Shot) -> float:
             gps_dop = gps_noise[shot.camera.id]
         return gps_dop
 
+    exifs = {}
     per_sequence = defaultdict(list)
     for shot_name in sorted(reconstruction.shots.keys()):
         shot = reconstruction.shots[shot_name]
@@ -193,13 +190,20 @@ def _gps_dop(shot: pymap.Shot) -> float:
         if shot.camera.projection_type in ["perspective", "fisheye"]:
             exif["focal_ratio"] = shot.camera.focal
 
-        pose = shot.pose.get_origin()
+        exifs[shot_name] = exif
+
+    speed_ms = 10.0
+    previous_pose = None
+    previous_time = 0
+    for rig_instance in sorted(
+        reconstruction.rig_instances.values(), key=lambda x: x.id
+    ):
+        pose = rig_instance.pose.get_origin()
         if previous_pose is not None:
             previous_time += np.linalg.norm(pose - previous_pose) / speed_ms
         previous_pose = pose
-        exif["capture_time"] = previous_time
-
-        exifs[shot_name] = exif
+        for shot_id in rig_instance.shots:
+            exifs[shot_id]["capture_time"] = previous_time
 
     for sequence_images in per_sequence.values():
         if causal_gps_noise:

From 7152fc7bf21d9439e9a9e9adb34eef1615a93bea Mon Sep 17 00:00:00 2001
From: Ihor Ivlev <ivlev.igor@gmail.com>
Date: Mon, 4 Jul 2022 08:07:11 -0700
Subject: [PATCH 010/235] Update using.rst (#922)

Summary:
Fix typo

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/922

Reviewed By: YanNoun

Differential Revision: D37601783

Pulled By: fabianschenk

fbshipit-source-id: df6ae866e1660238c6d41ff06025f6f38ff3eae7
---
 doc/source/using.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/using.rst b/doc/source/using.rst
index 2dfb8e80d..36de1ebd6 100644
--- a/doc/source/using.rst
+++ b/doc/source/using.rst
@@ -8,7 +8,7 @@ Using
 Quickstart
 ----------
 
-An example dataset is available at ``data/berlin``.  You can reconstruct it using by running::
+An example dataset is available at ``data/berlin``.  You can reconstruct it by running::
 
     bin/opensfm_run_all data/berlin
 

From 3d576f06e1bb502ef6fa3a917980ef4796238a0d Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@fb.com>
Date: Mon, 4 Jul 2022 08:18:34 -0700
Subject: [PATCH 011/235] Remove unused altitude

Summary: The `altitude` is always set to `0`, thus can be safely removed from the `invent_reference_from_gps_and_gcp` computation.

Reviewed By: YanNoun

Differential Revision: D37453036

fbshipit-source-id: cb561dfb49505e7a2bb45799e88dbbb3f26012bd
---
 opensfm/dataset.py | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 60fdd3d2e..90aaf9b37 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -985,8 +985,12 @@ def save_undistorted_reconstruction(
 def invent_reference_from_gps_and_gcp(
     data: DataSetBase, images: Optional[List[str]] = None
 ) -> geo.TopocentricConverter:
-    lat, lon, alt = 0.0, 0.0, 0.0
-    wlat, wlon, walt = 0.0, 0.0, 0.0
+    """ Invent the reference from the weighted average of lat/lon measurements.
+    Most of the time the altitude provided in the metadata is inaccurate, thus
+    the reference altitude is set equal to 0 regardless of the altitude measurements.
+    """
+    lat, lon = 0.0, 0.0
+    wlat, wlon = 0.0, 0.0
     if images is None:
         images = data.images()
     for image in images:
@@ -997,27 +1001,18 @@ def invent_reference_from_gps_and_gcp(
             lon += w * d["gps"]["longitude"]
             wlat += w
             wlon += w
-            if "altitude" in d["gps"]:
-                alt += w * d["gps"]["altitude"]
-                walt += w
 
     if not wlat and not wlon:
         for gcp in data.load_ground_control_points():
             if gcp.lla:
                 lat += gcp.lla["latitude"]
                 lon += gcp.lla["longitude"]
-                wlat += 1
-                wlon += 1
-
-                if gcp.has_altitude:
-                    alt += gcp.lla["altitude"]
-                    walt += 1
+                wlat += 1.0
+                wlon += 1.0
 
     if wlat:
         lat /= wlat
     if wlon:
         lon /= wlon
-    if walt:
-        alt /= walt
 
-    return geo.TopocentricConverter(lat, lon, 0)  # Set altitude manually.
+    return geo.TopocentricConverter(lat, lon, 0)

From a1a253f148d6e5daf6f2247e43e7d3fd306def53 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@fb.com>
Date: Mon, 4 Jul 2022 08:21:42 -0700
Subject: [PATCH 012/235] Default use_altitude_tag to True

Summary: Set `use_altitude_tag = True` by default in the `config.py`. This should also solve problems like this [github issue](https://github.com/mapillary/OpenSfM/issues/918), where images are taken several meters above ground, e.g. by a drone, and points actually on the floor are then at a negative distance.

Reviewed By: YanNoun

Differential Revision: D37481946

fbshipit-source-id: 10247e1afca8c8f0aa31d693f2e14115cf238f89
---
 opensfm/config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 55bf4a34f..4ef433a17 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -281,7 +281,7 @@ class OpenSfMConfig:
     # Params for GPS alignment
     ##################################
     # Use or ignore EXIF altitude tag
-    use_altitude_tag: bool = False
+    use_altitude_tag: bool = True
     # orientation_prior or naive
     align_method: str = "auto"
     # horizontal, vertical or no_roll

From f3a059b5db681201dae9823c12da5275aed8bd86 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Mon, 11 Jul 2022 07:43:20 -0700
Subject: [PATCH 013/235] feat: synthetic log for bundle

Summary: This Diff adds a synthetic logging for OpenSfM bundle which summarizes if it was GLOBAL or LOCAL and the number of optimized entities (points and shots), as well as the actual running time.

Reviewed By: Ahmed-Salama

Differential Revision: D37717627

fbshipit-source-id: f51f55c03fc83f99c6f290f22eecce51199c4fd9
---
 opensfm/reconstruction.py         | 21 +++++++++++++++++----
 opensfm/src/sfm/src/ba_helpers.cc | 17 +++++++++++++++--
 2 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 117816dc5..3de7ebe89 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -4,11 +4,11 @@
 import enum
 import logging
 import math
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 from collections import defaultdict
 from itertools import combinations
 from timeit import default_timer as timer
-from typing import Dict, Any, List, Tuple, Set, Optional, Union
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import cv2
 import numpy as np
@@ -20,10 +20,10 @@
     pygeometry,
     pymap,
     pysfm,
+    reconstruction_helpers as helpers,
     rig,
     tracking,
     types,
-    reconstruction_helpers as helpers,
 )
 from opensfm.align import align_reconstruction, apply_similarity
 from opensfm.context import current_memory_usage, parallel_map
@@ -47,6 +47,18 @@ def _get_camera_from_bundle(
         camera.set_parameter_value(k, v)
 
 
+def log_bundle_stats(bundle_type: str, bundle_report: Dict[str, Any]) -> None:
+    times = bundle_report["wall_times"]
+    time_secs = times["run"] + times["setup"] + times["teardown"]
+    num_images, num_points, num_reprojections = bundle_report["num_images"], bundle_report["num_points"], bundle_report["num_reprojections"]
+
+    msg = f"Ran {bundle_type} bundle in {time_secs:.2f} secs."
+    if num_points > 0 :
+        msg += f"with {num_images}/{num_points}/{num_reprojections} ({num_reprojections/num_points:.2f}) "
+        msg += "shots/points/proj. (avg. length)"
+
+    logger.info(msg)
+
 def bundle(
     reconstruction: types.Reconstruction,
     camera_priors: Dict[str, pygeometry.Camera],
@@ -62,7 +74,7 @@ def bundle(
         gcp if gcp is not None else [],
         config,
     )
-
+    log_bundle_stats("GLOBAL", report)
     logger.debug(report["brief_report"])
     return report
 
@@ -102,6 +114,7 @@ def bundle_local(
         central_shot_id,
         config,
     )
+    log_bundle_stats("LOCAL", report)
     logger.debug(report["brief_report"])
     return pt_ids, report
 
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 4e15575a2..abdd55c56 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -215,6 +215,8 @@ py::tuple BAHelpers::BundleLocal(
     }
   }
 
+  size_t added_landmarks = 0;
+  size_t added_reprojections = 0;
   for (auto* shot : interior) {
     // Add all points of the shots that are in the interior
     for (const auto& lm_obs : shot->GetLandmarkObservations()) {
@@ -223,10 +225,12 @@ py::tuple BAHelpers::BundleLocal(
         points.insert(lm);
         pt_ids.append(lm->id_);
         ba.AddPoint(lm->id_, lm->GetGlobalPos(), point_constant);
+        ++added_landmarks;
       }
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_, obs.point,
                                        obs.scale);
+      ++added_reprojections;
     }
   }
   for (auto* shot : boundary) {
@@ -236,6 +240,7 @@ py::tuple BAHelpers::BundleLocal(
         const auto& obs = lm_obs.second;
         ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_,
                                          obs.point, obs.scale);
+        ++added_reprojections;
       }
     }
   }
@@ -298,10 +303,13 @@ py::tuple BAHelpers::BundleLocal(
                                                             timer_run)
           .count() /
       1000000.0;
+  report["num_images"] = interior.size();
   report["num_interior_images"] = interior.size();
   report["num_boundary_images"] = boundary.size();
   report["num_other_images"] =
       map.NumberOfShots() - interior.size() - boundary.size();
+  report["num_points"] = added_landmarks;
+  report["num_reprojections"] = added_reprojections;
   return py::make_tuple(pt_ids, report);
 }
 
@@ -332,8 +340,8 @@ bool BAHelpers::TriangulateGCP(
   os.conservativeResize(added, Eigen::NoChange);
   if (added >= 2) {
     const std::vector<double> thresholds(added, reproj_threshold);
-    const auto& res = geometry::TriangulateBearingsMidpoint(os, bs, thresholds,
-                                                            min_ray_angle, max_ray_angle);
+    const auto& res = geometry::TriangulateBearingsMidpoint(
+        os, bs, thresholds, min_ray_angle, max_ray_angle);
     coordinates = res.second;
     return res.first;
   }
@@ -672,6 +680,7 @@ py::dict BAHelpers::Bundle(
     }
   }
 
+  size_t added_reprojections = 0;
   for (const auto& shot_pair : map.GetShots()) {
     const auto& shot = shot_pair.second;
 
@@ -686,6 +695,7 @@ py::dict BAHelpers::Bundle(
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot.id_, lm_obs.first->id_, obs.point,
                                        obs.scale);
+      ++added_reprojections;
     }
   }
 
@@ -746,6 +756,9 @@ py::dict BAHelpers::Bundle(
                                                             timer_run)
           .count() /
       1000000.0;
+  report["num_images"] = map.GetShots().size();
+  report["num_points"] = map.GetLandmarks().size();
+  report["num_reprojections"] = added_reprojections;
   return report;
 }
 

From 1653772e08a65d6301a7252f22ab482f14564fdf Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Mon, 11 Jul 2022 07:43:20 -0700
Subject: [PATCH 014/235] fix: fix camera instanciation in global bundle

Summary:
This Diff fix an edge case in global bundle :
 - We were constructing the camera from the shots, because for > 1 rig instances (with > 1 rig camera), we usually have all the cameras in any of the instance.
 - In the edge case of individual rig cameras (each instance has a different rig camera), this is not the case during the initial pair bootstrap, as we ignore one of the two shots (we adjust each shot in turn).

we fixed that by collecting all the cameras, similarly to the rig cameras collection, and instanciate them at once.

Reviewed By: Ahmed-Salama

Differential Revision: D37717624

fbshipit-source-id: 9841a4e6538b5a1f75a15756c4eeb15eac01eae7
---
 opensfm/src/sfm/src/ba_helpers.cc | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index abdd55c56..5e7cc5c40 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -432,10 +432,16 @@ py::dict BAHelpers::BundleShotPoses(
     rig_instances_ids.insert(shot.GetRigInstanceId());
   }
   std::unordered_set<map::RigCameraId> rig_cameras_ids;
+  std::unordered_set<map::CameraId> cameras_ids;
   for (const auto& rig_instance_id : rig_instances_ids) {
     auto& instance = map.GetRigInstance(rig_instance_id);
     for (const auto& shot_n_rig_camera : instance.GetRigCameras()) {
-      rig_cameras_ids.insert(shot_n_rig_camera.second->id);
+      const auto rig_camera_id = shot_n_rig_camera.second->id;
+      rig_cameras_ids.insert(rig_camera_id);
+
+      const auto shot_id = shot_n_rig_camera.first;
+      const auto camera_id = map.GetShot(shot_id).GetCamera()->id;
+      cameras_ids.insert(camera_id);
     }
   }
 
@@ -446,16 +452,10 @@ py::dict BAHelpers::BundleShotPoses(
                     rig_camera_priors.at(rig_camera_id).pose, fix_rig_camera);
   }
 
-  std::unordered_set<map::CameraId> added_cameras;
-  for (const auto& shot_id : shot_ids) {
-    const auto& shot = map.GetShot(shot_id);
-    const auto& cam = *shot.GetCamera();
-    if (added_cameras.find(cam.id) != added_cameras.end()) {
-      continue;
-    }
-    const auto& cam_prior = camera_priors.at(cam.id);
-    ba.AddCamera(cam.id, cam, cam_prior, fix_cameras);
-    added_cameras.insert(cam.id);
+  for (const auto& camera_id : cameras_ids) {
+    const auto& cam = map.GetCamera(camera_id);
+    const auto& cam_prior = camera_priors.at(camera_id);
+    ba.AddCamera(camera_id, cam, cam_prior, fix_cameras);
   }
 
   std::unordered_set<map::Landmark*> landmarks;

From d1ec1d0590f9d6014e65f545741489224098e8d4 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Mon, 11 Jul 2022 07:43:20 -0700
Subject: [PATCH 015/235] fix: use rig instances per rig camera

Summary: This Diff strengthen the # of rig instances requirements for unleashing rig camera poses. In the Aria case, all rig instances have different cameras, which is over parametrized in that case.

Reviewed By: Ahmed-Salama

Differential Revision: D37717628

fbshipit-source-id: a24e7a1666af9711b131455864699c8cb7c2494e
---
 opensfm/src/sfm/src/ba_helpers.cc | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 5e7cc5c40..835883eb6 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -629,8 +629,13 @@ py::dict BAHelpers::Bundle(
 
   // setup rig cameras
   constexpr size_t kMinRigInstanceForAdjust{10};
+  const size_t shots_per_rig_cameras =
+      map.GetRigCameras().size() > 0
+          ? static_cast<size_t>(map.GetShots().size() /
+                                map.GetRigCameras().size())
+          : 1;
   const auto lock_rig_camera =
-      map.GetRigInstances().size() <= kMinRigInstanceForAdjust;
+      shots_per_rig_cameras <= kMinRigInstanceForAdjust;
   for (const auto& camera_pair : map.GetRigCameras()) {
     // could be set to false (not locked) the day we expose leverarm adjustment
     const bool is_leverarm =

From d1165f9d522aee41f825be464a7e232286f529f1 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Mon, 11 Jul 2022 07:43:20 -0700
Subject: [PATCH 016/235] fix: typo in stats

Summary: This Diff fixes a typo in stats which was also causing failure in rig camera stats computation.

Reviewed By: fabianschenk

Differential Revision: D37717626

fbshipit-source-id: b0a1ef809f4733e8351238ae91bb7bc22b8b1ffc
---
 opensfm/stats.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/stats.py b/opensfm/stats.py
index f4339bb31..5cc3a5151 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -424,7 +424,7 @@ def rig_statistics(
             }
 
     for rig_camera_id in rig_cameras:
-        if rig_camera.id not in stats:
+        if rig_camera_id not in stats:
             continue
         if "optimized_values" not in stats[rig_camera_id]:
             del stats[rig_camera_id]

From cb1fdeeac280f4b32e52f7300506b4831f23ce8f Mon Sep 17 00:00:00 2001
From: Digvijayad <digvijayad@gmail.com>
Date: Mon, 18 Jul 2022 03:23:12 -0700
Subject: [PATCH 017/235] fixed ply generation to support official ply headers
 (#932)

Summary:
This PR is in regards to the issue https://github.com/mapillary/OpenSfM/issues/741.

As open3D does not currently support user-defined headers, the following command fails to load colors from the ply file because OpenSfM generates ply file with `diffuse_` prefix to the color headers.
```
import open3d as o3d
pcd = o3d.io.read_point_cloud('merged.ply')
print(pcd.colors)

>>pcd.colors => std::vector<Eigen::Vector3d> with 0 elements.
```

To support [official ply headers](http://paulbourke.net/dataformats/ply/), `point_cloud_to_ply` and `ply_header` functions have been modified in the `OpenSfM/opensfm/io.py`.
```
def point_cloud_to_ply(
    points: np.ndarray,
    normals: np.ndarray,
    colors: np.ndarray,
    labels: np.ndarray,
    fp: TextIO,
) -> None:
    ...
    fp.write("property uchar red\n")       # Changed from diffuse_red
    fp.write("property uchar green\n")     # Changed from diffuse_green
    fp.write("property uchar blue\n")      # Changed from diffuse_blue
    fp.write("property uchar class\n")
    fp.write("end_header\n")
    ...
```

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/932

Reviewed By: YanNoun

Differential Revision: D37817489

Pulled By: fabianschenk

fbshipit-source-id: cde2a8172a2bf2f8256c9772a6bad4decaa9de78
---
 opensfm/io.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/opensfm/io.py b/opensfm/io.py
index 7eb0ac3cb..95eaedfa3 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1033,9 +1033,9 @@ def ply_header(
             "property float nx",
             "property float ny",
             "property float nz",
-            "property uchar diffuse_red",
-            "property uchar diffuse_green",
-            "property uchar diffuse_blue",
+            "property uchar red",      
+            "property uchar green",     
+            "property uchar blue",      
         ]
     else:
         header = [
@@ -1045,9 +1045,9 @@ def ply_header(
             "property float x",
             "property float y",
             "property float z",
-            "property uchar diffuse_red",
-            "property uchar diffuse_green",
-            "property uchar diffuse_blue",
+            "property uchar red",    
+            "property uchar green",   
+            "property uchar blue", 
         ]
 
     if point_num_views:
@@ -1146,9 +1146,9 @@ def point_cloud_to_ply(
     fp.write("property float nx\n")
     fp.write("property float ny\n")
     fp.write("property float nz\n")
-    fp.write("property uchar diffuse_red\n")
-    fp.write("property uchar diffuse_green\n")
-    fp.write("property uchar diffuse_blue\n")
+    fp.write("property uchar red\n")
+    fp.write("property uchar green\n")
+    fp.write("property uchar blue\n")
     fp.write("property uchar class\n")
     fp.write("end_header\n")
 

From f6c616b52cc26c817c484f5edbc8651a85860820 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@fb.com>
Date: Mon, 18 Jul 2022 03:43:19 -0700
Subject: [PATCH 018/235] Update documentation

Summary:
Update wrong documentation:
- OpenCV Fisheye has 4 radial distortion parameters instead of the 3 mentioned in the doc
- Fisheye62 should have `theta^2`

Follow-up on two github issues:
- https://github.com/mapillary/OpenSfM/issues/930
- https://github.com/mapillary/OpenSfM/issues/929

See Fisheye62 discussion in the [github issue](https://github.com/mapillary/OpenSfM/issues/930). The distortion computation is the same as for OpenCV fisheye just with more parameters.

Reviewed By: YanNoun

Differential Revision: D37814244

fbshipit-source-id: fe999ef52b6da0865ec410175329c910dd78e331
---
 doc/source/geometry.rst | 42 ++++++++++++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/doc/source/geometry.rst b/doc/source/geometry.rst
index b209bef01..199672d2e 100644
--- a/doc/source/geometry.rst
+++ b/doc/source/geometry.rst
@@ -163,34 +163,50 @@ Identifier `fisheye`
     v = f\ d\ \theta\ \frac{y}{r}
     \end{array}
 
+Fisheye OpenCV
+~~~~~~~~~~~~~~
+Identifier `fisheye_opencv`
+
+.. math::
+    \begin{array}{l}
+    r = \sqrt(x^2 + y^2) \\
+    \theta = \arctan(r / z) \\
+    d_r = 1 + k_1\theta^2 + k_2\theta^4 + k_3\theta^6 + k_4\theta^8\\
+    u = f\ (d\ \theta\ \frac{x}{r}) + c_x \\
+    v = f\ (d\ \theta\ \frac{y}{r}) + c_y
+    \end{array}
+
+
 Fisheye 62
 ~~~~~~~~~~~
 Identifier `fisheye62`
 
 .. math::
     \begin{array}{l}
-    r^2 = x^2 + y^2 \\
+    r = \sqrt(x^2 + y^2) \\
     \theta = \arctan(r / z) \\
-    d_r = 1 + k_1\theta + k_2\theta^2 + k_3\theta^3 + k_4\theta^4 + k_5\theta^5 + k_6\theta^6\\
-    d^t_x = 2p_1\ x_n\ y_n + p_2\ (r^2 + 2x)\\
-    d^t_y = 2p_2\ x_n\ y_n + p_1\ (r^2 + 2y)\\
+    d_r = 1 + k_1\theta^2 + k_2\theta^4 + k_3\theta^6 + k_4\theta^8 + k_5\theta^10 + k_6\theta^12\\
+    d^t_x = 2p_1\ x_n\ y_n + p_2\ (\theta^2 + 2\ x_n^2)\\
+    d^t_y = 2p_2\ x_n\ y_n + p_1\ (\theta^2 + 2\ y_n^2)\\
     u = f\ (d_r\ \theta\ \frac{x}{r} + d^t_x) + c_x \\
     v = f\ (d_r\ \theta\ \frac{y}{r} + d^t_y) + c_y
     \end{array}
 
-Fisheye OpenCV
-~~~~~~~~~~~~~~
-Identifier `fisheye_opencv`
+Fisheye 624
+~~~~~~~~~~~
+Identifier `fisheye624`
 
 .. math::
     \begin{array}{l}
-    r^2 = x^2 + y^2 \\
+    r = \sqrt(x^2 + y^2) \\
     \theta = \arctan(r / z) \\
-    d_r = 1 + k_1\theta^2 + k_2\theta^4 + k_3\theta^6\\
-    d^t_x = 2p_1\ x_n\ y_n + p_2\ (r^2 + 2x)\\
-    d^t_y = 2p_2\ x_n\ y_n + p_1\ (r^2 + 2y)\\
-    u = f\ (d\ \theta\ \frac{x}{r} + d^t_x) + c_x \\
-    v = f\ (d\ \theta\ \frac{y}{r} + d^t_y) + c_y
+    d_r = 1 + k_1\theta^2 + k_2\theta^4 + k_3\theta^6 + k_4\theta^8 + k_5\theta^10 + k_6\theta^12\\
+    d^t_x = 2p_1\ x_n\ y_n + p_2\ (\theta^2 + 2\ x_n^2)\\
+    d^t_y = 2p_2\ x_n\ y_n + p_1\ (\theta^2 + 2\ y_n^2)\\
+    d^s_x = s_0 * theta^2 + s_1 * theta^4\\
+    d^s_y = s_2 * theta^2 + s_3 * theta^4\\
+    u = f\ (d_r\ \theta\ \frac{x}{r} + d^t_x + d^p_x) + c_x \\
+    v = f\ (d_r\ \theta\ \frac{y}{r} + d^t_y + d^p_y) + c_y
     \end{array}
 
 Spherical Camera

From c81a19d143cc009aea3a3930575eac54152b7a74 Mon Sep 17 00:00:00 2001
From: Tobias Ollmann <tollmann@fb.com>
Date: Tue, 19 Jul 2022 02:35:04 -0700
Subject: [PATCH 019/235] increase feature timeout

Reviewed By: YanNoun

Differential Revision: D37609433

fbshipit-source-id: fc642902417c5e7ee9469edbb96303be0a24e471
---
 opensfm/features_processing.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 78c757408..72513df3e 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -4,10 +4,10 @@
 import queue
 import threading
 from timeit import default_timer as timer
-from typing import Optional, List, Dict, Any, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
-from opensfm import bow, features, io, log, pygeometry, upright, masking
+from opensfm import bow, features, io, log, masking, pygeometry, upright
 from opensfm.context import parallel_map
 from opensfm.dataset_base import DataSetBase
 
@@ -124,7 +124,7 @@ class Counter(object):
     some reason, joblib doesn't like a good old threading.Lock (everything is stuck)
     """
 
-    def __init__(self) ->None:
+    def __init__(self) -> None:
         self.number_of_read = 0
         self.counter = itertools.count()
         self.read_lock = threading.Lock()
@@ -157,7 +157,7 @@ def read_images(
     expected: int,
     force: bool,
 ) -> None:
-    full_queue_timeout = 120
+    full_queue_timeout = 600
     for image in images:
         logger.info(f"Reading data for image {image} (queue-size={queue.qsize()}")
         image_array = data.load_image(image)

From c011295ed15edb673115058b69a61ee2b75439c6 Mon Sep 17 00:00:00 2001
From: Tobias Ollmann <tollmann@fb.com>
Date: Wed, 27 Jul 2022 05:03:07 -0700
Subject: [PATCH 020/235] set default orientation if not set

Reviewed By: YanNoun

Differential Revision: D38146475

fbshipit-source-id: e9073bf4b237fbc0908ae40f65c224e5b8a21900
---
 opensfm/features_processing.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 72513df3e..ca8e4efa9 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -214,7 +214,7 @@ def bake_segmentation(
             points[:, :2],
             width,
             height,
-            exif["orientation"],
+            exif_orientation,
             new_width=new_width,
             new_height=new_height,
         ).astype(int)

From e4ee1901abc21e27ec0427deb17dd71bb88c3ac8 Mon Sep 17 00:00:00 2001
From: Tobias Ollmann <tollmann@fb.com>
Date: Wed, 27 Jul 2022 05:03:07 -0700
Subject: [PATCH 021/235] make robust_match work with already filtered matches

Summary:
Fix robust_match on matches which are already filtered.
Masking feature points again would cause out of bounds errors when resolving matches to features

Reviewed By: YanNoun

Differential Revision: D38146504

fbshipit-source-id: 444b21a959e4eca85b641d02ab59c03e752eb327
---
 opensfm/matching.py | 32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/opensfm/matching.py b/opensfm/matching.py
index e85c6979e..55bf8ec6f 100644
--- a/opensfm/matching.py
+++ b/opensfm/matching.py
@@ -1,6 +1,6 @@
 import logging
 from timeit import default_timer as timer
-from typing import Sized, Optional, Dict, Any, Tuple, List, Generator
+from typing import Any, Dict, Generator, List, Optional, Sized, Tuple
 
 import cv2
 import numpy as np
@@ -472,6 +472,7 @@ def match_robust(
     camera2: pygeometry.Camera,
     data: DataSetBase,
     config_override: Dict[str, Any],
+    input_is_masked: bool = True,
 ) -> np.ndarray:
     """Perform robust geometry matching on a set of matched descriptors indexes."""
     # Override parameters
@@ -483,10 +484,16 @@ def match_robust(
         "matching_use_segmentation"
     ]  # unused but keep using the same cache
     features_data1 = feature_loader.instance.load_all_data(
-        data, im1, masked=True, segmentation_in_descriptor=segmentation_in_descriptor
+        data,
+        im1,
+        masked=input_is_masked,
+        segmentation_in_descriptor=segmentation_in_descriptor,
     )
     features_data2 = feature_loader.instance.load_all_data(
-        data, im2, masked=True, segmentation_in_descriptor=segmentation_in_descriptor
+        data,
+        im2,
+        masked=input_is_masked,
+        segmentation_in_descriptor=segmentation_in_descriptor,
     )
     if (
         features_data1 is None
@@ -516,8 +523,10 @@ def match_robust(
     rmatches_unfiltered = []
     m1 = feature_loader.instance.load_mask(data, im1)
     m2 = feature_loader.instance.load_mask(data, im2)
-    if m1 is not None and m2 is not None:
+    if m1 is not None and m2 is not None and input_is_masked:
         rmatches_unfiltered = unfilter_matches(rmatches, m1, m2)
+    else:
+        rmatches_unfiltered = rmatches
 
     robust_matching_min_match = overriden_config["robust_matching_min_match"]
     logger.debug(
@@ -797,7 +806,11 @@ def robust_match_fundamental(
 
 
 def compute_inliers_bearings(
-    b1: np.ndarray, b2: np.ndarray, R: np.ndarray, t: np.ndarray, threshold: float=0.01
+    b1: np.ndarray,
+    b2: np.ndarray,
+    R: np.ndarray,
+    t: np.ndarray,
+    threshold: float = 0.01,
 ) -> List[bool]:
     """Compute points that can be triangulated.
 
@@ -956,7 +969,7 @@ def _non_static_matches(
     res = []
     for match in matches:
         d = p1[match[0]] - p2[match[1]]
-        if d[0] ** 2 + d[1] ** 2 >= threshold ** 2:
+        if d[0] ** 2 + d[1] ** 2 >= threshold**2:
             res.append(match)
 
     static_ratio_threshold = 0.85
@@ -1023,7 +1036,12 @@ def _vermont_valid_mask(p: np.ndarray) -> bool:
 
 
 def _not_on_blackvue_watermark(
-    p1: np.ndarray, p2: np.ndarray, matches: List[Tuple[int, int]], im1: str, im2: str, data: DataSetBase
+    p1: np.ndarray,
+    p2: np.ndarray,
+    matches: List[Tuple[int, int]],
+    im1: str,
+    im2: str,
+    data: DataSetBase,
 ) -> List[Tuple[int, int]]:
     """Filter Blackvue's watermark."""
     meta1 = data.load_exif(im1)

From b69eb5f8b916a347f2cdf6ca924603e01c8dc365 Mon Sep 17 00:00:00 2001
From: Pyre Bot Jr <>
Date: Thu, 4 Aug 2022 21:38:22 -0700
Subject: [PATCH 022/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D38448211

fbshipit-source-id: 4da716a8adcd2455c71d946fb2d0d62ffe35782a
---
 opensfm/io.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/opensfm/io.py b/opensfm/io.py
index 95eaedfa3..1b1172d81 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1352,7 +1352,6 @@ def __init__(self) -> None:
 
     @classmethod
     def exists(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.exists(path)
 
     @classmethod
@@ -1361,12 +1360,10 @@ def ls(cls, path: str) -> List[str]:
 
     @classmethod
     def isfile(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.isfile(path)
 
     @classmethod
     def isdir(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.isdir(path)
 
     @classmethod
@@ -1422,5 +1419,4 @@ def image_size(cls, path: str) -> Tuple[int, int]:
 
     @classmethod
     def timestamp(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `float`.
         return os.path.getmtime(path)

From 36ab87b11a98000af53f11aa3b78f01c33b8ab39 Mon Sep 17 00:00:00 2001
From: GaryStebbins <71356237+GaryStebbins@users.noreply.github.com>
Date: Mon, 15 Aug 2022 06:09:37 -0700
Subject: [PATCH 023/235] Update features_processing.py (#940)

Summary:
Add missing parenthesis in log statement

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/940

Reviewed By: YanNoun

Differential Revision: D38703078

Pulled By: fabianschenk

fbshipit-source-id: 54fe5655e724908e951bf289ae3bce9b71aad8e6
---
 opensfm/features_processing.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index ca8e4efa9..b48f2aac2 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -159,7 +159,7 @@ def read_images(
 ) -> None:
     full_queue_timeout = 600
     for image in images:
-        logger.info(f"Reading data for image {image} (queue-size={queue.qsize()}")
+        logger.info(f"Reading data for image {image} (queue-size={queue.qsize()})")
         image_array = data.load_image(image)
         if data.config["features_bake_segmentation"]:
             segmentation_array = data.load_segmentation(image)

From 9838a39729b56fb32a8191e277724fb54232fec8 Mon Sep 17 00:00:00 2001
From: Tobias Ollmann <tollmann@fb.com>
Date: Mon, 15 Aug 2022 08:21:09 -0700
Subject: [PATCH 024/235] Don't crash if compass accuracy is given as none

Summary: `metadata.compass_accuracy.value` is required to be float. If accuracy is set to `None`, the if condition passes, but an error is thrown at runtime

Reviewed By: fabianschenk

Differential Revision: D38703925

fbshipit-source-id: 932a3022912b0de640e04102bcd36f5a4070b320
---
 opensfm/reconstruction_helpers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/reconstruction_helpers.py b/opensfm/reconstruction_helpers.py
index 7c2ac892a..0b8787801 100644
--- a/opensfm/reconstruction_helpers.py
+++ b/opensfm/reconstruction_helpers.py
@@ -160,7 +160,7 @@ def exif_to_metadata(
 
     if "compass" in exif:
         metadata.compass_angle.value = exif["compass"]["angle"]
-        if "accuracy" in exif["compass"]:
+        if exif["compass"].get("accuracy") is not None:
             metadata.compass_accuracy.value = exif["compass"]["accuracy"]
 
     if "capture_time" in exif:

From 7bb45cf6482d1018733b306a2cc3992071a44d3a Mon Sep 17 00:00:00 2001
From: AfaqSaeed <45476864+AfaqSaeed@users.noreply.github.com>
Date: Thu, 25 Aug 2022 07:32:21 -0700
Subject: [PATCH 025/235] Update using.rst (#938)

Summary:
Added data format for the tracks.csv file in order to help other people using that file

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/938

Reviewed By: YanNoun

Differential Revision: D38908516

Pulled By: fabianschenk

fbshipit-source-id: 307207958b36f87290695503d73199e1fab8506f
---
 doc/source/using.rst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/doc/source/using.rst b/doc/source/using.rst
index 36de1ebd6..bcd3aeee4 100644
--- a/doc/source/using.rst
+++ b/doc/source/using.rst
@@ -248,6 +248,20 @@ create_tracks
 ~~~~~~~~~~~~~
 This command links the matches between pairs of images to build feature point tracks.  The tracks are stored in the `tracks.csv` file.  A track is a set of feature points from different images that have been recognized to correspond to the same pysical point.
 
+Format of the data in the genrated tracks.csv file is as follows:
+
+image_name track_id feature_index normalized_x normalized_y size       R   G   B
+02.jpg	   1479	    2594	      0.0379803	   -0.0481853	0.00155505	155	145	143
+
+image_name -- name of the image file from which the data was extracted
+track_id -- id to keep 'track' of the tracks
+feature_index -- index of the keypoint from which this track is associated
+normalized_x -- x coordinate of the normalized images coordinate system
+normalized_y -- y coordinate of the normalized images coordinate system
+size -- size value according to the normalized images coordinate system
+R -- pixel value for Red channel
+G -- pixel value for Green channel
+B -- pixel value for Blue channel
 
 reconstruct
 ~~~~~~~~~~~

From ce3054beec8a193eb3d7119745d8e26a91cb3242 Mon Sep 17 00:00:00 2001
From: summitbri <36425892+summitbri@users.noreply.github.com>
Date: Thu, 25 Aug 2022 07:33:39 -0700
Subject: [PATCH 026/235] Update sensor_data_detailed.json (#943)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/943

Reviewed By: YanNoun

Differential Revision: D38908510

Pulled By: fabianschenk

fbshipit-source-id: d9db92186064bbfab7cd32d363d2f440343465a0
---
 opensfm/data/sensor_data_detailed.json | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/opensfm/data/sensor_data_detailed.json b/opensfm/data/sensor_data_detailed.json
index d07082830..daf8928cd 100644
--- a/opensfm/data/sensor_data_detailed.json
+++ b/opensfm/data/sensor_data_detailed.json
@@ -4779,6 +4779,13 @@
         "Sensor res. (width)": 6016.0, 
         "Sensor res. (height)": 3376.0
     }, 
+    "DJI ZENMUSEP1": {
+        "Sensor height (mm)": 24, 
+        "Sensor width (mm)": 35.9, 
+        "Sensor res. (width)": 8192.0, 
+        "Sensor": "35.9 x 24 mm", 
+        "Sensor res. (height)": 5460.0
+    }, 
     "Epson L-500V": {
         "Sensor height (mm)": 4.32, 
         "Sensor width (mm)": 5.75, 

From 82459698d665510e595cb1161ff70e2a4fd1c073 Mon Sep 17 00:00:00 2001
From: summitbri <36425892+summitbri@users.noreply.github.com>
Date: Thu, 25 Aug 2022 07:59:59 -0700
Subject: [PATCH 027/235] Update sensor_data.json for Zenmuse P1 (#944)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/944

Reviewed By: YanNoun

Differential Revision: D38908509

Pulled By: fabianschenk

fbshipit-source-id: 94d9c79a615bc518564e6bc6a9ea1457ebd52859
---
 opensfm/data/sensor_data.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opensfm/data/sensor_data.json b/opensfm/data/sensor_data.json
index 0c90df8c2..4378842e8 100644
--- a/opensfm/data/sensor_data.json
+++ b/opensfm/data/sensor_data.json
@@ -3705,5 +3705,6 @@
     "SONY SLT-A77V": 23.5,
     "GITUP GIT2": 6.216,
     "DJI ZH20T": 7.68,
-    "DJI XT2": 10.88
+    "DJI XT2": 10.88,
+    "DJI ZENMUSEP1": 35.9
 }

From 28d2adde75eb3d36137adf60ba7f34f17f2a7f09 Mon Sep 17 00:00:00 2001
From: summitbri <36425892+summitbri@users.noreply.github.com>
Date: Mon, 12 Sep 2022 06:37:09 -0700
Subject: [PATCH 028/235] Update camera_calibration.yaml (#945)

Summary:
added zenmuse p1 (mapillary#933)

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/945

Reviewed By: paulinus

Differential Revision: D38908505

Pulled By: fabianschenk

fbshipit-source-id: e50a16f6a6c1886207ea5598a70701964b2c0ac8
---
 opensfm/data/camera_calibration.yaml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/opensfm/data/camera_calibration.yaml b/opensfm/data/camera_calibration.yaml
index 2cf333d99..934394deb 100644
--- a/opensfm/data/camera_calibration.yaml
+++ b/opensfm/data/camera_calibration.yaml
@@ -67,6 +67,18 @@
                 "focal": 0.5930666527479901,
                 "k1": -0.012137318698010527,
                 "k2": 0.016199087342953698
+            },
+            "zenmusep1": {
+                "projection_type": "brown",
+                "focal_x": 0.993855582350662,
+                "focal_y": 0.993855582350662,
+                "c_x": -0.000890260610982073,
+                "c_y": 0.0017658361729384116,
+                "k1": -0.04734574598470396,
+                "k2": 0.00875629525446153,
+                "p1": 0.002032062604630639,
+                "p2": -0.0007921675594001833,
+                "k3": -0.06874708730325006
             }
         }
     },

From bfa02497513fac5b70c518cb745e83a28a9ffb59 Mon Sep 17 00:00:00 2001
From: kielnino <kielnino@users.noreply.github.com>
Date: Tue, 29 Nov 2022 08:22:17 -0800
Subject: [PATCH 029/235] Added fisheye62 projection_type to undistort (#957)

Summary:
The projection_type for the Fisheye62 cameras was missing in the switch-statements.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/957

Reviewed By: YanNoun

Differential Revision: D41580786

Pulled By: fabianschenk

fbshipit-source-id: 2bf5cf758fadd1643f289bf77e3c770de1c84691
---
 opensfm/undistort.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/opensfm/undistort.py b/opensfm/undistort.py
index 010752041..63bae4de6 100644
--- a/opensfm/undistort.py
+++ b/opensfm/undistort.py
@@ -47,9 +47,15 @@ def undistort_reconstruction(
         elif shot.camera.projection_type == "brown":
             urec.add_camera(perspective_camera_from_brown(shot.camera))
             subshots = [get_shot_with_different_camera(urec, shot, image_format)]
-        elif shot.camera.projection_type in ["fisheye", "fisheye_opencv"]:
+        elif shot.camera.projection_type == "fisheye":
             urec.add_camera(perspective_camera_from_fisheye(shot.camera))
             subshots = [get_shot_with_different_camera(urec, shot, image_format)]
+        elif shot.camera.projection_type == "fisheye_opencv":
+            urec.add_camera(perspective_camera_from_fisheye_opencv(shot.camera))
+            subshots = [get_shot_with_different_camera(urec, shot, image_format)]
+        elif shot.camera.projection_type == "fisheye62":
+            urec.add_camera(perspective_camera_from_fisheye62(shot.camera))
+            subshots = [get_shot_with_different_camera(urec, shot, image_format)]
         elif pygeometry.Camera.is_panorama(shot.camera.projection_type):
             subshot_width = int(data.config["depthmap_resolution"])
             subshots = perspective_views_of_a_panorama(
@@ -173,7 +179,7 @@ def undistort_image(
         return {}
 
     projection_type = shot.camera.projection_type
-    if projection_type in ["perspective", "brown", "fisheye", "fisheye_opencv"]:
+    if projection_type in ["perspective", "brown", "fisheye", "fisheye_opencv", "fisheye62"]:
         [undistorted_shot] = undistorted_shots
         new_camera = undistorted_shot.camera
         height, width = original.shape[:2]

From 5375df1a1038c22219f64acb5e2d2c35c4fcafe2 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@meta.com>
Date: Mon, 23 Jan 2023 06:06:45 -0800
Subject: [PATCH 030/235] Update numpy and scipy requirements (#976)

Summary:
Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/976

This is an extension to https://github.com/mapillary/OpenSfM/pull/972

- Update NUMPY, scipy requirements to make docker run again

- A few things were removed in the most recent numpy version, so minor fixes

Reviewed By: YanNoun

Differential Revision: D42605541

fbshipit-source-id: 4061bd1c705c2625c99a6b1cf2829a8ef93e3802
---
 opensfm/features.py                       | 4 ++--
 opensfm/synthetic_data/synthetic_scene.py | 2 +-
 requirements.txt                          | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/opensfm/features.py b/opensfm/features.py
index c6bcf048e..c48fdcc76 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -2,7 +2,7 @@
 
 import logging
 import time
-from typing import Tuple, Dict, Any, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -119,7 +119,7 @@ def save(self, fileobject: Any, config: Dict[str, Any]):
                 colors=self.colors,
                 segmentations=semantic.segmentation.astype(np.uint8),
                 instances=instances.astype(np.int16) if instances is not None else [],
-                segmentation_labels=np.array(semantic.labels).astype(np.str),
+                segmentation_labels=np.array(semantic.labels).astype(str),
                 OPENSFM_FEATURES_VERSION=self.FEATURES_VERSION,
             )
         else:
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 3c572d802..81b2c6d5d 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -395,7 +395,7 @@ def get_reconstruction(self) -> types.Reconstruction:
         wall_color = [10, 90, 130]
 
         return sg.create_reconstruction(
-            points=np.asarray([self.floor_points, self.wall_points]),
+            points=np.asarray([self.floor_points, self.wall_points], dtype=object),
             colors=np.asarray([floor_color, wall_color]),
             cameras=self.cameras,
             shot_ids=self.shot_ids,
diff --git a/requirements.txt b/requirements.txt
index 947c3ec9b..5b937b629 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,13 +5,13 @@ fpdf2==2.4.6
 joblib==0.14.1
 matplotlib
 networkx==2.5
-numpy
+numpy>=1.19
 Pillow>=8.1.1
 pyproj>=1.9.5.1
 pytest==3.0.7
 python-dateutil>=2.7
 pyyaml==5.4
-scipy
+scipy>=1.10.0
 Sphinx==4.2.0
 six
 xmltodict==0.10.2

From 1a69f7c89b4518976b251f53a4ace8895c40c92e Mon Sep 17 00:00:00 2001
From: kielnino <kielnino@users.noreply.github.com>
Date: Wed, 25 Jan 2023 02:53:45 -0800
Subject: [PATCH 031/235] fix setting config parameter on the wrong dataset
 (#975)

Summary:
Here the `interactive` flag is set on the DataSet but `compute_depthmaps` is called with the `UndistortedDataSet`. So I think the flag need to be set there.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/975

Reviewed By: YanNoun

Differential Revision: D42736827

Pulled By: fabianschenk

fbshipit-source-id: 0da4f4eaf5abe07469bc6d9d52693be2c20d9f58
---
 opensfm/actions/compute_depthmaps.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/actions/compute_depthmaps.py b/opensfm/actions/compute_depthmaps.py
index 3d1a7e7a1..d16f06e59 100644
--- a/opensfm/actions/compute_depthmaps.py
+++ b/opensfm/actions/compute_depthmaps.py
@@ -16,7 +16,7 @@ def run_dataset(data: DataSet, subfolder, interactive) -> None:
 
     udata_path = os.path.join(data.data_path, subfolder)
     udataset = dataset.UndistortedDataSet(data, udata_path, io_handler=data.io_handler)
-    data.config["interactive"] = interactive
+    udataset.config["interactive"] = interactive
     reconstructions = udataset.load_undistorted_reconstruction()
     tracks_manager = udataset.load_undistorted_tracks_manager()
     dense.compute_depthmaps(udataset, tracks_manager, reconstructions[0])

From 8b97fa780af100db1096fb31404b22e2476b241d Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016 <generatedunixname89002005307016@fb.com>
Date: Thu, 2 Feb 2023 00:29:28 -0800
Subject: [PATCH 032/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D42946608

fbshipit-source-id: 81f76766e35948ed37d84dca79420b68b23b3c3a
---
 opensfm/io.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/opensfm/io.py b/opensfm/io.py
index 1b1172d81..95eaedfa3 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1352,6 +1352,7 @@ def __init__(self) -> None:
 
     @classmethod
     def exists(cls, path: str) -> str:
+        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.exists(path)
 
     @classmethod
@@ -1360,10 +1361,12 @@ def ls(cls, path: str) -> List[str]:
 
     @classmethod
     def isfile(cls, path: str) -> str:
+        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.isfile(path)
 
     @classmethod
     def isdir(cls, path: str) -> str:
+        # pyre-fixme[7]: Expected `str` but got `bool`.
         return os.path.isdir(path)
 
     @classmethod
@@ -1419,4 +1422,5 @@ def image_size(cls, path: str) -> Tuple[int, int]:
 
     @classmethod
     def timestamp(cls, path: str) -> str:
+        # pyre-fixme[7]: Expected `str` but got `float`.
         return os.path.getmtime(path)

From 44f4774a531ba185287061c5b99902743ab05636 Mon Sep 17 00:00:00 2001
From: Piero Toffanin <pt@masseranolabs.com>
Date: Mon, 20 Feb 2023 01:11:25 -0800
Subject: [PATCH 033/235] Adds Mavic 3 Pro camera CCD width (#966)

Summary:
Adds information for the Mavic 3 Pro camera.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/966

Reviewed By: YanNoun

Differential Revision: D43357430

Pulled By: fabianschenk

fbshipit-source-id: 2a08923f71abc3cc979819346f0225f31cdb2af9
---
 opensfm/data/sensor_data.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/opensfm/data/sensor_data.json b/opensfm/data/sensor_data.json
index 4378842e8..ca6a23922 100644
--- a/opensfm/data/sensor_data.json
+++ b/opensfm/data/sensor_data.json
@@ -1144,6 +1144,7 @@
     "GE X500": 6.16,
     "GE X550": 6.16,
     "GE X600": 6.16,
+    "Hasselblad L2D-20c": 17.5,
     "HP CA350": 6.16,
     "HP CB350": 6.16,
     "HP CW450": 6.16,

From 0e67e22ca14db034c87fe80ede0081dc83f728a2 Mon Sep 17 00:00:00 2001
From: Piero Toffanin <pt@masseranolabs.com>
Date: Mon, 20 Feb 2023 01:22:21 -0800
Subject: [PATCH 034/235] Fix match_candidates_by_graph when initial simplex is
 flat (#969)

Summary:
Hello :wave:.

in certain datasets (e.g. https://hub.dronedb.app/r/saijinnaib/roofer_gaming-13268) the Delaunay triangulation call for `match_candidates_by_graph` fails.

![image](https://user-images.githubusercontent.com/1951843/207391509-c0448204-bac2-4ce6-b01c-1fd927442432.png)

We can get around this problem by passing "QbB" (http://www.qhull.org/html/qh-optq.htm#QbB) to the function call, which may reduce some precision, but does not change the topology, which should suffice for the purposes here.

First reported on https://github.com/OpenDroneMap/ODM/issues/1564#issuecomment-1347753001

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/969

Reviewed By: YanNoun

Differential Revision: D43357417

Pulled By: fabianschenk

fbshipit-source-id: 53e57df8f7d98e9f6e940bb6865c3a4801f895e4
---
 opensfm/pairs_selection.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 8174c742c..191ab030e 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -250,7 +250,13 @@ def produce_edges(triangles):
 
     # first round compute scale based on edges (and push delaunay edges)
     edge_distances = []
-    triangles = spatial.Delaunay(points).simplices
+    try:
+        triangles = spatial.Delaunay(points).simplices
+    except spatial.QhullError:
+        # Initial simplex is flat
+        # Scale the input to fit the unit cube ("QbB")
+        triangles = spatial.Delaunay(points, qhull_options="Qbb Qc Qz Q12 QbB").simplices
+
     for (image1, image2), (vertex1, vertex2) in produce_edges(triangles):
         pairs.add((image1, image2))
         edge_distances.append(norm_2d(points[vertex1] - points[vertex2]))

From b760b21f5d23a2872e89fc708ac44645623e605a Mon Sep 17 00:00:00 2001
From: Karry Wong <karrywong@meta.com>
Date: Tue, 21 Feb 2023 10:59:27 -0800
Subject: [PATCH 035/235] Add GroundControlPoint Role (#983)

Summary:
Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/983

A GCP can have two different roles, either OPTIMIZATION or METRICS_ONLY:
1. OPTIMIZATION: CP is used in optimization and logging metrics
2. METRICS_ONLY: CP is only used in logging metrics

Reviewed By: chi3x10, mlopezantequera

Differential Revision: D43289380

fbshipit-source-id: d4faa53dcd5a80b3c9bbef64d1358b244e71f03c
---
 opensfm/src/map/ground_control_points.h | 14 ++++++++++++++
 opensfm/src/map/pymap.pyi               | 15 +++++++++++++++
 opensfm/src/map/python/pybind.cc        |  6 ++++++
 3 files changed, 35 insertions(+)

diff --git a/opensfm/src/map/ground_control_points.h b/opensfm/src/map/ground_control_points.h
index c22c1f82c..bab86d74a 100644
--- a/opensfm/src/map/ground_control_points.h
+++ b/opensfm/src/map/ground_control_points.h
@@ -3,6 +3,17 @@
 #include <map/defines.h>
 #include <map/map.h>
 namespace map {
+enum GroundControlPointRole {
+  /*    A ground control point role in SfM cluster merge and bundle adjuster
+
+       Attributes:
+           OPTIMIZATION: used in the optimization of map chunks and logging metrics
+           METRICS_ONLY: only used in logging metrics
+
+  **/
+  OPTIMIZATION = 0,
+  METRICS_ONLY = 1
+};
 struct GroundControlPointObservation {
   /*    A ground control point observation.
 
@@ -27,6 +38,8 @@ struct GroundControlPoint {
          observations: list of observations of the point on images
          id: a unique id for this point group (survey point + image observations)
          survey_point_id: a unique id for the point on the ground
+         role: OPTIMIZATION if gcp is used in SfM optimization, METRICS_ONLY if the
+         ground control point is used for computing map merging metrics
      */
   GroundControlPoint() = default;
   LandmarkId id_ = "";
@@ -34,6 +47,7 @@ struct GroundControlPoint {
   bool has_altitude_ = false;
   AlignedVector<GroundControlPointObservation> observations_;
   std::map<std::string, double> lla_;
+  GroundControlPointRole role_;
 
   Vec3d GetLlaVec3d() const {
     return {
diff --git a/opensfm/src/map/pymap.pyi b/opensfm/src/map/pymap.pyi
index 2c2305924..9af9c042f 100644
--- a/opensfm/src/map/pymap.pyi
+++ b/opensfm/src/map/pymap.pyi
@@ -20,6 +20,7 @@ __all__  = [
 "ErrorType",
 "GroundControlPoint",
 "GroundControlPointObservation",
+"GroundControlPointRole",
 "Landmark",
 "LandmarkView",
 "Map",
@@ -39,7 +40,9 @@ __all__  = [
 "ShotView",
 "TracksManager",
 "Angular",
+"METRICS_ONLY",
 "Normalized",
+"OPTIMIZATION",
 "Pixel"
 ]
 class BiasView:
@@ -93,6 +96,10 @@ class GroundControlPoint:
     @observations.setter
     def observations(self, arg1: List[GroundControlPointObservation]) -> None:...
     @property
+    def role(self) -> GroundControlPointRole:...
+    @role.setter
+    def role(self, arg0: GroundControlPointRole) -> None:...
+    @property
     def survey_point_id(self) -> int:...
     @survey_point_id.setter
     def survey_point_id(self, arg0: int) -> None:...
@@ -113,6 +120,12 @@ class GroundControlPointObservation:
     def uid(self) -> int:...
     @uid.setter
     def uid(self, arg0: int) -> None:...
+class GroundControlPointRole:
+    OPTIMIZATION: "GroundControlPointRole"
+    METRICS_ONLY: "GroundControlPointRole"
+    __members__: Dict[str, "GroundControlPointRole"]
+    @property
+    def name(self) -> str: ...
 class Landmark:
     def __init__(self, arg0: str, arg1: numpy.ndarray) -> None: ...
     def get_observations(self) -> Dict[Shot, int]: ...
@@ -470,5 +483,7 @@ class TracksManager:
     def remove_observation(self, arg0: str, arg1: str) -> None: ...
     def write_to_file(self, arg0: str) -> None: ...
 Angular = ...
+METRICS_ONLY = ...
 Normalized = ...
+OPTIMIZATION = ...
 Pixel = ...
\ No newline at end of file
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index b914cbc8e..207fa4066 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -251,6 +251,11 @@ PYBIND11_MODULE(pymap, m) {
       .def_readwrite("projection",
                      &map::GroundControlPointObservation::projection_);
 
+  py::enum_<map::GroundControlPointRole>(m, "GroundControlPointRole")
+      .value("OPTIMIZATION", map::GroundControlPointRole::OPTIMIZATION)
+      .value("METRICS_ONLY", map::GroundControlPointRole::METRICS_ONLY)
+      .export_values();
+
   py::class_<map::GroundControlPoint>(m, "GroundControlPoint")
       .def(py::init())
       .def_readwrite("id", &map::GroundControlPoint::id_)
@@ -259,6 +264,7 @@ PYBIND11_MODULE(pymap, m) {
       .def_readwrite("lla", &map::GroundControlPoint::lla_)
       .def_property("lla_vec", &map::GroundControlPoint::GetLlaVec3d,
                     &map::GroundControlPoint::SetLla)
+      .def_readwrite("role", &map::GroundControlPoint::role_)
       .def_property("observations", &map::GroundControlPoint::GetObservations,
                     &map::GroundControlPoint::SetObservations)
       .def("add_observation", &map::GroundControlPoint::AddObservation);

From 8887d336cdc305427d59d02a96ef9396aa197ad3 Mon Sep 17 00:00:00 2001
From: Piero Toffanin <pt@masseranolabs.com>
Date: Fri, 21 Apr 2023 04:56:37 -0700
Subject: [PATCH 036/235] FLANN LSH Indexing for binary descriptors (#996)

Summary:
Hello :wave:,

this PR adds support for using the FLANN index while using binary descriptors (e.g. `orb`).

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/996

Reviewed By: YanNoun

Differential Revision: D45175480

Pulled By: fabianschenk

fbshipit-source-id: 7807ba37ee9c0b6ce98d1724e7699cd9650823f7
---
 opensfm/features.py | 10 +++++++++-
 opensfm/matching.py |  8 --------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/opensfm/features.py b/opensfm/features.py
index c48fdcc76..bf07b7973 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -630,6 +630,7 @@ def build_flann_index(descriptors: np.ndarray, config: Dict[str, Any]) -> Any:
     # FLANN_INDEX_COMPOSITE = 3
     # FLANN_INDEX_KDTREE_SINGLE = 4
     # FLANN_INDEX_HIERARCHICAL = 5
+    FLANN_INDEX_LSH = 6
 
     if descriptors.dtype.type is np.float32:
         algorithm_type = config["flann_algorithm"].upper()
@@ -645,9 +646,16 @@ def build_flann_index(descriptors: np.ndarray, config: Dict[str, Any]) -> Any:
             "iterations": config["flann_iterations"],
             "tree": config["flann_tree"],
         }
+    elif descriptors.dtype.type is np.uint8:
+        flann_params = {
+            "algorithm": FLANN_INDEX_LSH,
+            "table_number": 10,
+            "key_size": 24,
+            "multi_probe_level": 1,
+        }
     else:
         raise ValueError(
-            "FLANN isn't supported for binary features because of poor-performance. Use BRUTEFORCE instead."
+            f"FLANN isn't supported for feature type {descriptors.dtype.type}."
         )
 
     return context.flann_Index(descriptors, flann_params)
diff --git a/opensfm/matching.py b/opensfm/matching.py
index 55bf8ec6f..068d126e9 100644
--- a/opensfm/matching.py
+++ b/opensfm/matching.py
@@ -369,14 +369,6 @@ def _match_descriptors_impl(
     if d1 is None or d2 is None:
         return dummy_ret
 
-    # Prevent using FLANN + Binary (np.uint8)
-    binary_matcher_override = "BRUTEFORCE"
-    if matcher_type == "FLANN" and d1.dtype == np.uint8:
-        logger.warning(
-            f"{matcher_type} for binary descriptors offers poor performance. Switching to {binary_matcher_override}."
-        )
-        matcher_type = binary_matcher_override
-
     symmetric_matching = overriden_config["symmetric_matching"]
     if matcher_type == "WORDS":
         words1 = feature_loader.instance.load_words(data, im1, masked=True)

From 5213d0f1e4cb88db7d638f4b24bbb9be777768bb Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@meta.com>
Date: Fri, 5 May 2023 07:27:18 -0700
Subject: [PATCH 037/235] Fix runtime with less iterations and more threads

Summary:
This Diff fixes ceres 2.0 update in dev/mode which is noticeably slower.

Unfortunately, in the short-term, we found no other issues than brute-forcing the threads # and the reducing the maximum number of iterations.

Differential Revision:
D45604439

Privacy Context Container: L1124100

fbshipit-source-id: 9c27fbb6ba8f3b0de09b2f7994164248be38fc57
---
 opensfm/test/test_reconstruction_incremental.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index 4ad885943..e1513dab5 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -16,6 +16,8 @@ def test_reconstruction_incremental(
 
     dataset.config["bundle_compensate_gps_bias"] = True
     dataset.config["bundle_use_gcp"] = True
+    dataset.config["bundle_max_iterations"] = 20
+    dataset.config["processes"] = 4
     _, reconstructed_scene = reconstruction.incremental_reconstruction(
         dataset, scene_synthetic.tracks_manager
     )

From 69f16bf851601b9c50add970834f1e44fc5e3b56 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016 <generatedunixname89002005307016@fb.com>
Date: Tue, 23 May 2023 20:47:14 -0700
Subject: [PATCH 038/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D46120702

fbshipit-source-id: bc82165733a63e53a01ac924ded4ba78e4193d3e
---
 opensfm/synthetic_data/synthetic_generator.py | 6 ++++++
 opensfm/synthetic_data/synthetic_scene.py     | 4 ++++
 2 files changed, 10 insertions(+)

diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index daecddb52..6037761fa 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -327,8 +327,14 @@ def create_reconstruction(
         s_cameras,
     ) in enumerate(zip(rig_shots, rig_positions, rig_rotations, rig_cameras, cameras)):
         add_shots_to_reconstruction(
+            # pyre-fixme[6]: For 1st argument expected `List[List[str]]` but got
+            #  `List[List[Tuple[str, str]]]`.
             s_rig_shots,
+            # pyre-fixme[6]: For 2nd argument expected `List[ndarray]` but got
+            #  `ndarray`.
             s_rig_positions,
+            # pyre-fixme[6]: For 3rd argument expected `List[ndarray]` but got
+            #  `ndarray`.
             s_rig_rotations,
             s_rig_cameras,
             s_cameras,
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 81b2c6d5d..688717981 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -344,7 +344,9 @@ def add_rig_camera_sequence(
         for j, (rig_camera_p, rig_camera_r) in enumerate(
             zip(relative_positions, relative_rotations)
         ):
+            # pyre-fixme[6]: For 1st argument expected `ndarray` but got `List[float]`.
             pose_rig_camera = pygeometry.Pose(rig_camera_r)
+            # pyre-fixme[6]: For 1st argument expected `ndarray` but got `List[float]`.
             pose_rig_camera.set_origin(rig_camera_p)
 
             rotations = []
@@ -370,7 +372,9 @@ def add_rig_camera_sequence(
         for i, (rig_camera_p, rig_camera_r) in enumerate(
             zip(relative_positions, relative_rotations)
         ):
+            # pyre-fixme[6]: For 1st argument expected `ndarray` but got `List[float]`.
             pose_rig_camera = pygeometry.Pose(rig_camera_r)
+            # pyre-fixme[6]: For 1st argument expected `ndarray` but got `List[float]`.
             pose_rig_camera.set_origin(rig_camera_p)
             rig_camera_id = f"RigCamera {rig_camera_id_shift + i}"
             rig_camera = pymap.RigCamera(pose_rig_camera, rig_camera_id)

From 5cdc3cee41f3117ec218bbff80662eeb461fbaf6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 24 May 2023 04:51:11 -0700
Subject: [PATCH 039/235] build(deps): Bump flask from 2.1.2 to 2.3.2 (#999)

Summary:
Bumps [flask](https://github.com/pallets/flask) from 2.1.2 to 2.3.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/pallets/flask/releases">flask's releases</a>.</em></p>
<blockquote>
<h2>2.3.2</h2>
<p>This is a security fix release for the 2.3.x release branch.</p>
<ul>
<li>Security advisory: <a href="https://github.com/pallets/flask/security/advisories/GHSA-m2qf-hxjv-5gpq">https://github.com/pallets/flask/security/advisories/GHSA-m2qf-hxjv-5gpq</a>, CVE-2023-30861</li>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-2">https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-2</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/29?closed=1">https://github.com/pallets/flask/milestone/29?closed=1</a></li>
</ul>
<h2>2.3.1</h2>
<p>This is a fix release for the 2.3.x release branch.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-1">https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-1</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/28?closed=1">https://github.com/pallets/flask/milestone/28?closed=1</a></li>
</ul>
<h2>2.3.0</h2>
<p>This is a feature release, which includes new features, removes previously deprecated code, and adds new deprecations. The 2.3.x branch is now the supported fix branch, the 2.2.x branch will become a tag marking the end of support for that branch. We encourage everyone to upgrade, and to use a tool such as <a href="https://pypi.org/project/pip-tools/">pip-tools</a> to pin all dependencies and control upgrades. Test with warnings treated as errors to be able to adapt to deprecation warnings early.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-0">https://flask.palletsprojects.com/en/2.3.x/changes/#version-2-3-0</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/24?closed=1">https://github.com/pallets/flask/milestone/24?closed=1</a></li>
</ul>
<h2>2.2.4</h2>
<p>This is a fix release for the 2.2.x release branch.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-4">https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-4</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/27?closed=1">https://github.com/pallets/flask/milestone/27?closed=1</a></li>
</ul>
<h2>2.2.3</h2>
<p>This is a fix release for the 2.2.x release branch.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-3">https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-3</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/26?closed=1">https://github.com/pallets/flask/milestone/26?closed=1</a></li>
</ul>
<h2>2.2.2</h2>
<p>This is a fix release for the <a href="https://github.com/pallets/flask/releases/tag/2.2.0">2.2.0</a> feature release.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-2">https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-2</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/25?closed=1">https://github.com/pallets/flask/milestone/25?closed=1</a></li>
</ul>
<h2>2.2.1</h2>
<p>This is a fix release for the <a href="https://github.com/pallets/flask/releases/tag/2.2.0">2.2.0</a> feature release.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-1">https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-1</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/23?closed=1">https://github.com/pallets/flask/milestone/23?closed=1</a></li>
</ul>
<h2>2.2.0</h2>
<p>This is a feature release, which includes new features and removes previously deprecated code. The 2.2.x branch is now the supported bug fix branch, the 2.1.x branch will become a tag marking the end of support for that branch. We encourage everyone to upgrade, and to use a tool such as <a href="https://pypi.org/project/pip-tools/">pip-tools</a> to pin all dependencies and control upgrades.</p>
<ul>
<li>Changes: <a href="https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-0">https://flask.palletsprojects.com/en/2.2.x/changes/#version-2-2-0</a></li>
<li>Milestone: <a href="https://github.com/pallets/flask/milestone/19?closed=1">https://github.com/pallets/flask/milestone/19?closed=1</a></li>
</ul>
<h2>2.1.3</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/pallets/flask/blob/main/CHANGES.rst">flask's changelog</a>.</em></p>
<blockquote>
<h2>Version 2.3.2</h2>
<p>Released 2023-05-01</p>
<ul>
<li>Set <code>Vary: Cookie</code> header when the session is accessed, modified, or refreshed.</li>
<li>Update Werkzeug requirement to &gt;=2.3.3 to apply recent bug fixes.</li>
</ul>
<h2>Version 2.3.1</h2>
<p>Released 2023-04-25</p>
<ul>
<li>Restore deprecated <code>from flask import Markup</code>. :issue:<code>5084</code></li>
</ul>
<h2>Version 2.3.0</h2>
<p>Released 2023-04-25</p>
<ul>
<li>
<p>Drop support for Python 3.7. :pr:<code>5072</code></p>
</li>
<li>
<p>Update minimum requirements to the latest versions: Werkzeug&gt;=2.3.0, Jinja2&gt;3.1.2,
itsdangerous&gt;=2.1.2, click&gt;=8.1.3.</p>
</li>
<li>
<p>Remove previously deprecated code. :pr:<code>4995</code></p>
<ul>
<li>The <code>push</code> and <code>pop</code> methods of the deprecated <code>_app_ctx_stack</code> and
<code>_request_ctx_stack</code> objects are removed. <code>top</code> still exists to give
extensions more time to update, but it will be removed.</li>
<li>The <code>FLASK_ENV</code> environment variable, <code>ENV</code> config key, and <code>app.env</code>
property are removed.</li>
<li>The <code>session_cookie_name</code>, <code>send_file_max_age_default</code>, <code>use_x_sendfile</code>,
<code>propagate_exceptions</code>, and <code>templates_auto_reload</code> properties on <code>app</code>
are removed.</li>
<li>The <code>JSON_AS_ASCII</code>, <code>JSON_SORT_KEYS</code>, <code>JSONIFY_MIMETYPE</code>, and
<code>JSONIFY_PRETTYPRINT_REGULAR</code> config keys are removed.</li>
<li>The <code>app.before_first_request</code> and <code>bp.before_app_first_request</code> decorators
are removed.</li>
<li><code>json_encoder</code> and <code>json_decoder</code> attributes on app and blueprint, and the
corresponding <code>json.JSONEncoder</code> and <code>JSONDecoder</code> classes, are removed.</li>
<li>The <code>json.htmlsafe_dumps</code> and <code>htmlsafe_dump</code> functions are removed.</li>
<li>Calling setup methods on blueprints after registration is an error instead of a
warning. :pr:<code>4997</code></li>
</ul>
</li>
<li>
<p>Importing <code>escape</code> and <code>Markup</code> from <code>flask</code> is deprecated. Import them
directly from <code>markupsafe</code> instead. :pr:<code>4996</code></p>
</li>
<li>
<p>The <code>app.got_first_request</code> property is deprecated. :pr:<code>4997</code></p>
</li>
<li>
<p>The <code>locked_cached_property</code> decorator is deprecated. Use a lock inside the
decorated function if locking is needed. :issue:<code>4993</code></p>
</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/pallets/flask/commit/f3b8f570545200c87465d18386f3fc9f2258307a"><code>f3b8f57</code></a> release version 2.3.2</li>
<li><a href="https://github.com/pallets/flask/commit/c990bba94ab9bc81adf2d33e83c9a9628a2098f2"><code>c990bba</code></a> update min test env</li>
<li><a href="https://github.com/pallets/flask/commit/adedb2a64ea7703369bc89021710b439ee79f8dc"><code>adedb2a</code></a> Merge pull request <a href="https://redirect.github.com/pallets/flask/issues/5101">#5101</a> from pallets/update-werkzeug</li>
<li><a href="https://github.com/pallets/flask/commit/e1aedecdc689cc9a79131851dbdabf6c3bc49c9e"><code>e1aedec</code></a> update werkzeug</li>
<li><a href="https://github.com/pallets/flask/commit/37badc3ce8b0665e3454547839196a676729309f"><code>37badc3</code></a> update changelog</li>
<li><a href="https://github.com/pallets/flask/commit/70f906c51ce49c485f1d355703e9cc3386b1cc2b"><code>70f906c</code></a> Merge pull request from GHSA-m2qf-hxjv-5gpq</li>
<li><a href="https://github.com/pallets/flask/commit/8705dd39c4fa563ea0fe0bf84c85da8fcc98b88d"><code>8705dd3</code></a> set <code>Vary: Cookie</code> header consistently for session</li>
<li><a href="https://github.com/pallets/flask/commit/9532cba45d2339e90ebf04f178b1e4f2064e7328"><code>9532cba</code></a> fix mypy finding</li>
<li><a href="https://github.com/pallets/flask/commit/0bc7356ce1ae11e633426902aba76d525f4523da"><code>0bc7356</code></a> start version 2.3.2</li>
<li><a href="https://github.com/pallets/flask/commit/f07fb2b607c1eaa724ca9bfe43e2dc20d97d34de"><code>f07fb2b</code></a> Merge pull request <a href="https://redirect.github.com/pallets/flask/issues/5086">#5086</a> from pallets/release-2.3.1</li>
<li>Additional commits viewable in <a href="https://github.com/pallets/flask/compare/2.1.2...2.3.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=flask&package-manager=pip&previous-version=2.1.2&new-version=2.3.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

 ---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `dependabot rebase` will rebase this PR
- `dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `dependabot merge` will merge this PR after your CI passes on it
- `dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `dependabot cancel merge` will cancel a previously requested merge and block automerging
- `dependabot reopen` will reopen this PR if it is closed
- `dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/mapillary/OpenSfM/network/alerts).

</details>

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/999

Reviewed By: YanNoun

Differential Revision: D46141368

Pulled By: fabianschenk

fbshipit-source-id: 5fc816689e8107ecb91579a1e6f6fa81b30801f3
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 5b937b629..0d50b21ef 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,6 @@
 cloudpickle==0.4.0
 exifread==2.1.2
-flask==2.1.2
+flask==2.3.2
 fpdf2==2.4.6
 joblib==0.14.1
 matplotlib

From a1f1959806039d1dfbd9436a95b1837360a7f9f1 Mon Sep 17 00:00:00 2001
From: kielnino <kielnino@users.noreply.github.com>
Date: Wed, 24 May 2023 05:12:43 -0700
Subject: [PATCH 040/235] Plot_inliers / File adapted to changes in the whole
 project (#1001)

Summary:
The project was further developed without following the changes to the interfaces in this file. This PR now handles this.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1001

Reviewed By: YanNoun

Differential Revision: D46141342

Pulled By: fabianschenk

fbshipit-source-id: a5db12aa4fe9abff8ae8ebcfa422572fc9e5f4da
---
 bin/plot_inliers | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/bin/plot_inliers b/bin/plot_inliers
index b970318c7..3c6112e7e 100755
--- a/bin/plot_inliers
+++ b/bin/plot_inliers
@@ -128,7 +128,7 @@ def create_subplot(figure, rows, columns, index, title, x_lim, y_lim, font_size=
         subplot.set_aspect(aspect)
 
     if grid:
-        pl.grid(b=True, which='major', color='0.3')
+        pl.grid(visible=True, which='major', color='0.3')
 
     return subplot
 
@@ -231,21 +231,21 @@ def reprojection_errors(reprojections, observations, scale):
     return errors, mean, std, min_norm, max_norm, corr
 
 
-def triangulate_tracks(tracks, reconstruction, graph, min_ray_angle):
+def triangulate_tracks(tracks, reconstruction, tracks_manager, min_ray_angle):
     """ Triangulates a list of tracks.
 
     :param tracks: The array of tracks.
     :param reconstruction: The reconstruction.
-    :param: graph, The tracks graph.
+    :param: tracks_manager, The tracks manager.
     :param: min_ray_angle: The minimum ray angle difference for a triangulation to be considered valid.
     :return: An array of booleans determining if each track was successfully triangulated or not.
     """
     succeeded = []
-    triangulator = reconstruct.TrackTriangulator(reconstruction, reconstruct.TrackHandlerTrackManager(graph, reconstruction)
+    triangulator = reconstruct.TrackTriangulator(reconstruction, reconstruct.TrackHandlerTrackManager(tracks_manager, reconstruction))
 
     for track in tracks:
         # Triangulate with 1 as reprojection threshold to avoid excluding tracks because of error.
-        triangulator.triangulate(str(track), 1, min_ray_angle)
+        triangulator.triangulate(str(track), 1, min_ray_angle, iterations=10)
         succeeded.append(True) if str(track) in reconstruction.points else succeeded.append(False)
 
     return np.array(succeeded) if len(succeeded) else np.empty((0,), bool)
@@ -319,8 +319,8 @@ def load_common_tracks(im1, im2, tracks_manager):
     :param tracks_manager: The track manager.
     :return: An array with rows containing a track id and the corresponding feature id for the first and second image.
     """
-    t1 = tracks_manager.get_shot_observations(im1).items()
-    t2 = tracks_manager.get_shot_observations(im2).items()
+    t1 = tracks_manager.get_shot_observations(im1)
+    t2 = tracks_manager.get_shot_observations(im2)
     tc, p1, p2 = tracking.common_tracks(tracks_manager, im1, im2)
 
     common_tracks = []
@@ -417,7 +417,7 @@ def create_matches_figure(im1, im2, data, save_figs=False, single_column=False):
     p1 = features_data1.points
     p2 = features_data2.points
 
-    symmetric_matches = matching.match_brute_force_symmetric(f1, f2, data.config)
+    symmetric_matches = matching.match_brute_force_symmetric(p1, p2, data.config)
     symmetric_matches = np.array(symmetric_matches)
 
     if symmetric_matches.shape[0] < 8:
@@ -519,7 +519,7 @@ def plot_opencv_find_homography(fw, ip, index, tracks, track_points1, track_poin
     threshold, pixels1, pixels2 = thresholds(ip.im1_array, ip.im2_array, 'homography_threshold', 0.004, data)
     H, inliers = cv2.findHomography(track_points1, track_points2, cv2.RANSAC, threshold)
 
-    inliers = np.array(np.squeeze(inliers), np.bool)
+    inliers = np.array(np.squeeze(inliers), bool)
 
     inliers1 = track_points1[inliers, :]
     inliers2 = track_points2[inliers, :]
@@ -554,7 +554,7 @@ def plot_two_view_reconstruction(fw, ip, index, track_points1, track_points2, da
 
     threshold, pixels1, pixels2 = thresholds(ip.im1_array, ip.im2_array, 'five_point_algo_threshold', 0.006, data)
     iterations = data.config['five_point_refine_rec_iterations']
-    R, t, inliers = reconstruct.two_view_reconstruction(track_points1, track_points2, camera1, camera2, threshold, iterations)
+    R, t, inliers, _ = reconstruct.two_view_reconstruction_general(track_points1, track_points2, camera1, camera2, threshold, iterations)
 
     inliers1 = track_points1[inliers, :]
     inliers2 = track_points2[inliers, :]
@@ -573,7 +573,7 @@ def plot_two_view_reconstruction(fw, ip, index, track_points1, track_points2, da
     plot_matches(subplot, ip.im1_array, ip.im2_array, outliers1, outliers2, 'r', 'om')
 
 
-def plot_bootstrapped_reconstruction(fw, ip, index, p1, p2, robust_tracks, linked_tracks, graph, data):
+def plot_bootstrapped_reconstruction(fw, ip, index, p1, p2, robust_tracks, linked_tracks, tracks_manager, data):
     """ Plot successfully reconstructed and failed 3D points by bootstrapping a reconstruction.
 
     :param fw: Figure wrapper.
@@ -583,13 +583,13 @@ def plot_bootstrapped_reconstruction(fw, ip, index, p1, p2, robust_tracks, linke
     :param p2: Feature points for the second image.
     :param robust_tracks: Tracks corresponding to robust matches.
     :param linked_tracks: Common tracks linked by other image correspondences.
-    :param graph: Tracks graph.
+    :param tracks_manager: The tracks manager.
     :param data: Data set.
     """
 
     print_reset = redirect_print()
-    _, pm1, pm2 = tracking.common_tracks(graph, ip.im1, ip.im2)
-    reconstruction, _, _ = reconstruct.bootstrap_reconstruction(data, graph, ip.im1, ip.im2, pm1, pm2)
+    _, pm1, pm2 = tracking.common_tracks(tracks_manager, ip.im1, ip.im2)
+    reconstruction, _ = reconstruct.bootstrap_reconstruction(data, tracks_manager, ip.im1, ip.im2, pm1, pm2)
     reset_print(print_reset)
 
     threshold, pixels1, pixels2 = thresholds(ip.im1_array, ip.im2_array, 'triangulation_threshold', 0.004, data)
@@ -667,7 +667,7 @@ def create_tracks_figure(im1, im2, data, save_figs=False, single_column=False):
     plot_common_tracks(fw, ip, 1, p1, p2, tracks, robust_tracks, linked_tracks, robust_matches)
     plot_opencv_find_homography(fw, ip, 2, tracks, track_points1, track_points2, data)
     plot_two_view_reconstruction(fw, ip, 3, track_points1, track_points2, data)
-    plot_bootstrapped_reconstruction(fw, ip, 4, p1, p2, robust_tracks, linked_tracks, graph, data)
+    plot_bootstrapped_reconstruction(fw, ip, 4, p1, p2, robust_tracks, linked_tracks, tracks_manager, data)
 
     display_figure(fig, save_figs, data, '{0}_{1}_{2}_tracks.jpg'.format(im1, im2, data.feature_type()))
 
@@ -704,7 +704,7 @@ def plot_reconstructed_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec
     plot_matches(subplot, ip.im1_array, ip.im2_array, non_rec_track_points1, non_rec_track_points2, 'r', 'om')
 
 
-def plot_reprojected_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec_tracks, reconstruction, graph, data):
+def plot_reprojected_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec_tracks, reconstruction, tracks_manager, data):
     """ Reprojects tracks included in and excluded from reconstruction and plots reprojections on top of observations.
 
     :param fw: Figure wrapper.
@@ -716,7 +716,7 @@ def plot_reprojected_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec_t
     :param rec_tracks: Common tracks included in the reconstruction.
     :param non_rec_tracks: Common tracks not included in the reconstruction.
     :param reconstruction: Reconstruction.
-    :param graph: Tracks graph.
+    :param tracks_manager: The tracks manager.
     :param data: Data set
     """
 
@@ -727,7 +727,7 @@ def plot_reprojected_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec_t
     rp2 = reproject_tracks(ip.im2, rec_tracks[:, 0], reconstruction)
 
     min_ray_angle = data.config['triangulation_min_ray_angle']
-    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, graph, min_ray_angle)
+    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, tracks_manager, min_ray_angle)
     reprojected1 = reproject_tracks(ip.im1, non_rec_tracks[succeeded, 0], reconstruction)
     reprojected2 = reproject_tracks(ip.im2, non_rec_tracks[succeeded, 0], reconstruction)
 
@@ -786,7 +786,7 @@ def create_reconstruction_matches_figure(im1, im2, data, save_figs=False):
     rec_tracks, non_rec_tracks = reconstruction_tracks(tracks, reconstruction)
 
     plot_reconstructed_tracks(fw, ip, 1, p1, p2, tracks, rec_tracks, non_rec_tracks)
-    plot_reprojected_tracks(fw, ip, 2, p1, p2, tracks, rec_tracks, non_rec_tracks, reconstruction, graph, data)
+    plot_reprojected_tracks(fw, ip, 2, p1, p2, tracks, rec_tracks, non_rec_tracks, reconstruction, tracks_manager, data)
 
     display_figure(fig, save_figs, data, '{0}_{1}_{2}_reconstruction.jpg'.format(im1, im2, data.feature_type()))
 
@@ -833,7 +833,7 @@ def create_complete_reconstruction_figure(im, data, save_figs=False, single_colu
     plot_points(rec_plot, im_array, rp, '+w')
 
     min_ray_angle = data.config['triangulation_min_ray_angle']
-    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, graph, min_ray_angle)
+    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, tracks_manager, min_ray_angle)
     reprojected = reproject_tracks(im, non_rec_tracks[succeeded, 0], reconstruction)
 
     triangulated_points = p[non_rec_tracks[succeeded, 1]]
@@ -887,7 +887,7 @@ def create_reprojection_error_figure(im, data, save_figs=False, single_column=Fa
     reproj_rec = reproject_tracks(im, rec_tracks[:, 0], reconstruction)
 
     min_ray_angle = data.config['triangulation_min_ray_angle']
-    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, graph, min_ray_angle)
+    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, tracks_manager, min_ray_angle)
     reproj_non = reproject_tracks(im, non_rec_tracks[succeeded, 0], reconstruction)
 
     triang_non = p[non_rec_tracks[succeeded, 1]]
@@ -897,7 +897,7 @@ def create_reprojection_error_figure(im, data, save_figs=False, single_column=Fa
     non_errors, non_mean, non_std, non_min, non_max, non_corr = reprojection_errors(reproj_non, triang_non, scale)
 
     triang_thld = data.config['triangulation_threshold']
-    bundle_thld = data.config['bundle_outlier_threshold']
+    bundle_thld = data.config['bundle_outlier_fixed_threshold']
     axis_max = np.max(np.abs(np.vstack((rec_errors, non_errors))))
     axis_max = 1.05 * np.max([axis_max, scale * triang_thld, scale * bundle_thld])
 

From f2df6febb4994c81c2d7fe5db0deb48e7c0d6a67 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@meta.com>
Date: Tue, 18 Jul 2023 09:10:33 -0700
Subject: [PATCH 041/235] Update jquery version

Summary: TSIA

Reviewed By: oscarlorentzon

Differential Revision: D47542023

fbshipit-source-id: 04f01aa9c76a234e6d4712d8a48050804c477d97
---
 viewer/legacy/js/jquery.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/viewer/legacy/js/jquery.js b/viewer/legacy/js/jquery.js
index 45477c0b6..c4c6022f2 100644
--- a/viewer/legacy/js/jquery.js
+++ b/viewer/legacy/js/jquery.js
@@ -1,2 +1,2 @@
-/*! jQuery v1.8.3 jquery.com | jquery.org/license */
-(function(e,t){function _(e){var t=M[e]={};return v.each(e.split(y),function(e,n){t[n]=!0}),t}function H(e,n,r){if(r===t&&e.nodeType===1){var i="data-"+n.replace(P,"-$1").toLowerCase();r=e.getAttribute(i);if(typeof r=="string"){try{r=r==="true"?!0:r==="false"?!1:r==="null"?null:+r+""===r?+r:D.test(r)?v.parseJSON(r):r}catch(s){}v.data(e,n,r)}else r=t}return r}function B(e){var t;for(t in e){if(t==="data"&&v.isEmptyObject(e[t]))continue;if(t!=="toJSON")return!1}return!0}function et(){return!1}function tt(){return!0}function ut(e){return!e||!e.parentNode||e.parentNode.nodeType===11}function at(e,t){do e=e[t];while(e&&e.nodeType!==1);return e}function ft(e,t,n){t=t||0;if(v.isFunction(t))return v.grep(e,function(e,r){var i=!!t.call(e,r,e);return i===n});if(t.nodeType)return v.grep(e,function(e,r){return e===t===n});if(typeof t=="string"){var r=v.grep(e,function(e){return e.nodeType===1});if(it.test(t))return v.filter(t,r,!n);t=v.filter(t,r)}return v.grep(e,function(e,r){return v.inArray(e,t)>=0===n})}function lt(e){var t=ct.split("|"),n=e.createDocumentFragment();if(n.createElement)while(t.length)n.createElement(t.pop());return n}function Lt(e,t){return e.getElementsByTagName(t)[0]||e.appendChild(e.ownerDocument.createElement(t))}function At(e,t){if(t.nodeType!==1||!v.hasData(e))return;var n,r,i,s=v._data(e),o=v._data(t,s),u=s.events;if(u){delete o.handle,o.events={};for(n in u)for(r=0,i=u[n].length;r<i;r++)v.event.add(t,n,u[n][r])}o.data&&(o.data=v.extend({},o.data))}function Ot(e,t){var n;if(t.nodeType!==1)return;t.clearAttributes&&t.clearAttributes(),t.mergeAttributes&&t.mergeAttributes(e),n=t.nodeName.toLowerCase(),n==="object"?(t.parentNode&&(t.outerHTML=e.outerHTML),v.support.html5Clone&&e.innerHTML&&!v.trim(t.innerHTML)&&(t.innerHTML=e.innerHTML)):n==="input"&&Et.test(e.type)?(t.defaultChecked=t.checked=e.checked,t.value!==e.value&&(t.value=e.value)):n==="option"?t.selected=e.defaultSelected:n==="input"||n==="textarea"?t.defaultValue=e.defaultValue:n==="script"&&t.text!==e.text&&(t.text=e.text),t.removeAttribute(v.expando)}function Mt(e){return typeof e.getElementsByTagName!="undefined"?e.getElementsByTagName("*"):typeof e.querySelectorAll!="undefined"?e.querySelectorAll("*"):[]}function _t(e){Et.test(e.type)&&(e.defaultChecked=e.checked)}function Qt(e,t){if(t in e)return t;var n=t.charAt(0).toUpperCase()+t.slice(1),r=t,i=Jt.length;while(i--){t=Jt[i]+n;if(t in e)return t}return r}function Gt(e,t){return e=t||e,v.css(e,"display")==="none"||!v.contains(e.ownerDocument,e)}function Yt(e,t){var n,r,i=[],s=0,o=e.length;for(;s<o;s++){n=e[s];if(!n.style)continue;i[s]=v._data(n,"olddisplay"),t?(!i[s]&&n.style.display==="none"&&(n.style.display=""),n.style.display===""&&Gt(n)&&(i[s]=v._data(n,"olddisplay",nn(n.nodeName)))):(r=Dt(n,"display"),!i[s]&&r!=="none"&&v._data(n,"olddisplay",r))}for(s=0;s<o;s++){n=e[s];if(!n.style)continue;if(!t||n.style.display==="none"||n.style.display==="")n.style.display=t?i[s]||"":"none"}return e}function Zt(e,t,n){var r=Rt.exec(t);return r?Math.max(0,r[1]-(n||0))+(r[2]||"px"):t}function en(e,t,n,r){var i=n===(r?"border":"content")?4:t==="width"?1:0,s=0;for(;i<4;i+=2)n==="margin"&&(s+=v.css(e,n+$t[i],!0)),r?(n==="content"&&(s-=parseFloat(Dt(e,"padding"+$t[i]))||0),n!=="margin"&&(s-=parseFloat(Dt(e,"border"+$t[i]+"Width"))||0)):(s+=parseFloat(Dt(e,"padding"+$t[i]))||0,n!=="padding"&&(s+=parseFloat(Dt(e,"border"+$t[i]+"Width"))||0));return s}function tn(e,t,n){var r=t==="width"?e.offsetWidth:e.offsetHeight,i=!0,s=v.support.boxSizing&&v.css(e,"boxSizing")==="border-box";if(r<=0||r==null){r=Dt(e,t);if(r<0||r==null)r=e.style[t];if(Ut.test(r))return r;i=s&&(v.support.boxSizingReliable||r===e.style[t]),r=parseFloat(r)||0}return r+en(e,t,n||(s?"border":"content"),i)+"px"}function nn(e){if(Wt[e])return Wt[e];var t=v("<"+e+">").appendTo(i.body),n=t.css("display");t.remove();if(n==="none"||n===""){Pt=i.body.appendChild(Pt||v.extend(i.createElement("iframe"),{frameBorder:0,width:0,height:0}));if(!Ht||!Pt.createElement)Ht=(Pt.contentWindow||Pt.contentDocument).document,Ht.write("<!doctype html><html><body>"),Ht.close();t=Ht.body.appendChild(Ht.createElement(e)),n=Dt(t,"display"),i.body.removeChild(Pt)}return Wt[e]=n,n}function fn(e,t,n,r){var i;if(v.isArray(t))v.each(t,function(t,i){n||sn.test(e)?r(e,i):fn(e+"["+(typeof i=="object"?t:"")+"]",i,n,r)});else if(!n&&v.type(t)==="object")for(i in t)fn(e+"["+i+"]",t[i],n,r);else r(e,t)}function Cn(e){return function(t,n){typeof t!="string"&&(n=t,t="*");var r,i,s,o=t.toLowerCase().split(y),u=0,a=o.length;if(v.isFunction(n))for(;u<a;u++)r=o[u],s=/^\+/.test(r),s&&(r=r.substr(1)||"*"),i=e[r]=e[r]||[],i[s?"unshift":"push"](n)}}function kn(e,n,r,i,s,o){s=s||n.dataTypes[0],o=o||{},o[s]=!0;var u,a=e[s],f=0,l=a?a.length:0,c=e===Sn;for(;f<l&&(c||!u);f++)u=a[f](n,r,i),typeof u=="string"&&(!c||o[u]?u=t:(n.dataTypes.unshift(u),u=kn(e,n,r,i,u,o)));return(c||!u)&&!o["*"]&&(u=kn(e,n,r,i,"*",o)),u}function Ln(e,n){var r,i,s=v.ajaxSettings.flatOptions||{};for(r in n)n[r]!==t&&((s[r]?e:i||(i={}))[r]=n[r]);i&&v.extend(!0,e,i)}function An(e,n,r){var i,s,o,u,a=e.contents,f=e.dataTypes,l=e.responseFields;for(s in l)s in r&&(n[l[s]]=r[s]);while(f[0]==="*")f.shift(),i===t&&(i=e.mimeType||n.getResponseHeader("content-type"));if(i)for(s in a)if(a[s]&&a[s].test(i)){f.unshift(s);break}if(f[0]in r)o=f[0];else{for(s in r){if(!f[0]||e.converters[s+" "+f[0]]){o=s;break}u||(u=s)}o=o||u}if(o)return o!==f[0]&&f.unshift(o),r[o]}function On(e,t){var n,r,i,s,o=e.dataTypes.slice(),u=o[0],a={},f=0;e.dataFilter&&(t=e.dataFilter(t,e.dataType));if(o[1])for(n in e.converters)a[n.toLowerCase()]=e.converters[n];for(;i=o[++f];)if(i!=="*"){if(u!=="*"&&u!==i){n=a[u+" "+i]||a["* "+i];if(!n)for(r in a){s=r.split(" ");if(s[1]===i){n=a[u+" "+s[0]]||a["* "+s[0]];if(n){n===!0?n=a[r]:a[r]!==!0&&(i=s[0],o.splice(f--,0,i));break}}}if(n!==!0)if(n&&e["throws"])t=n(t);else try{t=n(t)}catch(l){return{state:"parsererror",error:n?l:"No conversion from "+u+" to "+i}}}u=i}return{state:"success",data:t}}function Fn(){try{return new e.XMLHttpRequest}catch(t){}}function In(){try{return new e.ActiveXObject("Microsoft.XMLHTTP")}catch(t){}}function $n(){return setTimeout(function(){qn=t},0),qn=v.now()}function Jn(e,t){v.each(t,function(t,n){var r=(Vn[t]||[]).concat(Vn["*"]),i=0,s=r.length;for(;i<s;i++)if(r[i].call(e,t,n))return})}function Kn(e,t,n){var r,i=0,s=0,o=Xn.length,u=v.Deferred().always(function(){delete a.elem}),a=function(){var t=qn||$n(),n=Math.max(0,f.startTime+f.duration-t),r=n/f.duration||0,i=1-r,s=0,o=f.tweens.length;for(;s<o;s++)f.tweens[s].run(i);return u.notifyWith(e,[f,i,n]),i<1&&o?n:(u.resolveWith(e,[f]),!1)},f=u.promise({elem:e,props:v.extend({},t),opts:v.extend(!0,{specialEasing:{}},n),originalProperties:t,originalOptions:n,startTime:qn||$n(),duration:n.duration,tweens:[],createTween:function(t,n,r){var i=v.Tween(e,f.opts,t,n,f.opts.specialEasing[t]||f.opts.easing);return f.tweens.push(i),i},stop:function(t){var n=0,r=t?f.tweens.length:0;for(;n<r;n++)f.tweens[n].run(1);return t?u.resolveWith(e,[f,t]):u.rejectWith(e,[f,t]),this}}),l=f.props;Qn(l,f.opts.specialEasing);for(;i<o;i++){r=Xn[i].call(f,e,l,f.opts);if(r)return r}return Jn(f,l),v.isFunction(f.opts.start)&&f.opts.start.call(e,f),v.fx.timer(v.extend(a,{anim:f,queue:f.opts.queue,elem:e})),f.progress(f.opts.progress).done(f.opts.done,f.opts.complete).fail(f.opts.fail).always(f.opts.always)}function Qn(e,t){var n,r,i,s,o;for(n in e){r=v.camelCase(n),i=t[r],s=e[n],v.isArray(s)&&(i=s[1],s=e[n]=s[0]),n!==r&&(e[r]=s,delete e[n]),o=v.cssHooks[r];if(o&&"expand"in o){s=o.expand(s),delete e[r];for(n in s)n in e||(e[n]=s[n],t[n]=i)}else t[r]=i}}function Gn(e,t,n){var r,i,s,o,u,a,f,l,c,h=this,p=e.style,d={},m=[],g=e.nodeType&&Gt(e);n.queue||(l=v._queueHooks(e,"fx"),l.unqueued==null&&(l.unqueued=0,c=l.empty.fire,l.empty.fire=function(){l.unqueued||c()}),l.unqueued++,h.always(function(){h.always(function(){l.unqueued--,v.queue(e,"fx").length||l.empty.fire()})})),e.nodeType===1&&("height"in t||"width"in t)&&(n.overflow=[p.overflow,p.overflowX,p.overflowY],v.css(e,"display")==="inline"&&v.css(e,"float")==="none"&&(!v.support.inlineBlockNeedsLayout||nn(e.nodeName)==="inline"?p.display="inline-block":p.zoom=1)),n.overflow&&(p.overflow="hidden",v.support.shrinkWrapBlocks||h.done(function(){p.overflow=n.overflow[0],p.overflowX=n.overflow[1],p.overflowY=n.overflow[2]}));for(r in t){s=t[r];if(Un.exec(s)){delete t[r],a=a||s==="toggle";if(s===(g?"hide":"show"))continue;m.push(r)}}o=m.length;if(o){u=v._data(e,"fxshow")||v._data(e,"fxshow",{}),"hidden"in u&&(g=u.hidden),a&&(u.hidden=!g),g?v(e).show():h.done(function(){v(e).hide()}),h.done(function(){var t;v.removeData(e,"fxshow",!0);for(t in d)v.style(e,t,d[t])});for(r=0;r<o;r++)i=m[r],f=h.createTween(i,g?u[i]:0),d[i]=u[i]||v.style(e,i),i in u||(u[i]=f.start,g&&(f.end=f.start,f.start=i==="width"||i==="height"?1:0))}}function Yn(e,t,n,r,i){return new Yn.prototype.init(e,t,n,r,i)}function Zn(e,t){var n,r={height:e},i=0;t=t?1:0;for(;i<4;i+=2-t)n=$t[i],r["margin"+n]=r["padding"+n]=e;return t&&(r.opacity=r.width=e),r}function tr(e){return v.isWindow(e)?e:e.nodeType===9?e.defaultView||e.parentWindow:!1}var n,r,i=e.document,s=e.location,o=e.navigator,u=e.jQuery,a=e.$,f=Array.prototype.push,l=Array.prototype.slice,c=Array.prototype.indexOf,h=Object.prototype.toString,p=Object.prototype.hasOwnProperty,d=String.prototype.trim,v=function(e,t){return new v.fn.init(e,t,n)},m=/[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,g=/\S/,y=/\s+/,b=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,w=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,E=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,S=/^[\],:{}\s]*$/,x=/(?:^|:|,)(?:\s*\[)+/g,T=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,N=/"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,C=/^-ms-/,k=/-([\da-z])/gi,L=function(e,t){return(t+"").toUpperCase()},A=function(){i.addEventListener?(i.removeEventListener("DOMContentLoaded",A,!1),v.ready()):i.readyState==="complete"&&(i.detachEvent("onreadystatechange",A),v.ready())},O={};v.fn=v.prototype={constructor:v,init:function(e,n,r){var s,o,u,a;if(!e)return this;if(e.nodeType)return this.context=this[0]=e,this.length=1,this;if(typeof e=="string"){e.charAt(0)==="<"&&e.charAt(e.length-1)===">"&&e.length>=3?s=[null,e,null]:s=w.exec(e);if(s&&(s[1]||!n)){if(s[1])return n=n instanceof v?n[0]:n,a=n&&n.nodeType?n.ownerDocument||n:i,e=v.parseHTML(s[1],a,!0),E.test(s[1])&&v.isPlainObject(n)&&this.attr.call(e,n,!0),v.merge(this,e);o=i.getElementById(s[2]);if(o&&o.parentNode){if(o.id!==s[2])return r.find(e);this.length=1,this[0]=o}return this.context=i,this.selector=e,this}return!n||n.jquery?(n||r).find(e):this.constructor(n).find(e)}return v.isFunction(e)?r.ready(e):(e.selector!==t&&(this.selector=e.selector,this.context=e.context),v.makeArray(e,this))},selector:"",jquery:"1.8.3",length:0,size:function(){return this.length},toArray:function(){return l.call(this)},get:function(e){return e==null?this.toArray():e<0?this[this.length+e]:this[e]},pushStack:function(e,t,n){var r=v.merge(this.constructor(),e);return r.prevObject=this,r.context=this.context,t==="find"?r.selector=this.selector+(this.selector?" ":"")+n:t&&(r.selector=this.selector+"."+t+"("+n+")"),r},each:function(e,t){return v.each(this,e,t)},ready:function(e){return v.ready.promise().done(e),this},eq:function(e){return e=+e,e===-1?this.slice(e):this.slice(e,e+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(l.apply(this,arguments),"slice",l.call(arguments).join(","))},map:function(e){return this.pushStack(v.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:[].sort,splice:[].splice},v.fn.init.prototype=v.fn,v.extend=v.fn.extend=function(){var e,n,r,i,s,o,u=arguments[0]||{},a=1,f=arguments.length,l=!1;typeof u=="boolean"&&(l=u,u=arguments[1]||{},a=2),typeof u!="object"&&!v.isFunction(u)&&(u={}),f===a&&(u=this,--a);for(;a<f;a++)if((e=arguments[a])!=null)for(n in e){r=u[n],i=e[n];if(u===i)continue;l&&i&&(v.isPlainObject(i)||(s=v.isArray(i)))?(s?(s=!1,o=r&&v.isArray(r)?r:[]):o=r&&v.isPlainObject(r)?r:{},u[n]=v.extend(l,o,i)):i!==t&&(u[n]=i)}return u},v.extend({noConflict:function(t){return e.$===v&&(e.$=a),t&&e.jQuery===v&&(e.jQuery=u),v},isReady:!1,readyWait:1,holdReady:function(e){e?v.readyWait++:v.ready(!0)},ready:function(e){if(e===!0?--v.readyWait:v.isReady)return;if(!i.body)return setTimeout(v.ready,1);v.isReady=!0;if(e!==!0&&--v.readyWait>0)return;r.resolveWith(i,[v]),v.fn.trigger&&v(i).trigger("ready").off("ready")},isFunction:function(e){return v.type(e)==="function"},isArray:Array.isArray||function(e){return v.type(e)==="array"},isWindow:function(e){return e!=null&&e==e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return e==null?String(e):O[h.call(e)]||"object"},isPlainObject:function(e){if(!e||v.type(e)!=="object"||e.nodeType||v.isWindow(e))return!1;try{if(e.constructor&&!p.call(e,"constructor")&&!p.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(n){return!1}var r;for(r in e);return r===t||p.call(e,r)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw new Error(e)},parseHTML:function(e,t,n){var r;return!e||typeof e!="string"?null:(typeof t=="boolean"&&(n=t,t=0),t=t||i,(r=E.exec(e))?[t.createElement(r[1])]:(r=v.buildFragment([e],t,n?null:[]),v.merge([],(r.cacheable?v.clone(r.fragment):r.fragment).childNodes)))},parseJSON:function(t){if(!t||typeof t!="string")return null;t=v.trim(t);if(e.JSON&&e.JSON.parse)return e.JSON.parse(t);if(S.test(t.replace(T,"@").replace(N,"]").replace(x,"")))return(new Function("return "+t))();v.error("Invalid JSON: "+t)},parseXML:function(n){var r,i;if(!n||typeof n!="string")return null;try{e.DOMParser?(i=new DOMParser,r=i.parseFromString(n,"text/xml")):(r=new ActiveXObject("Microsoft.XMLDOM"),r.async="false",r.loadXML(n))}catch(s){r=t}return(!r||!r.documentElement||r.getElementsByTagName("parsererror").length)&&v.error("Invalid XML: "+n),r},noop:function(){},globalEval:function(t){t&&g.test(t)&&(e.execScript||function(t){e.eval.call(e,t)})(t)},camelCase:function(e){return e.replace(C,"ms-").replace(k,L)},nodeName:function(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()},each:function(e,n,r){var i,s=0,o=e.length,u=o===t||v.isFunction(e);if(r){if(u){for(i in e)if(n.apply(e[i],r)===!1)break}else for(;s<o;)if(n.apply(e[s++],r)===!1)break}else if(u){for(i in e)if(n.call(e[i],i,e[i])===!1)break}else for(;s<o;)if(n.call(e[s],s,e[s++])===!1)break;return e},trim:d&&!d.call("\ufeff\u00a0")?function(e){return e==null?"":d.call(e)}:function(e){return e==null?"":(e+"").replace(b,"")},makeArray:function(e,t){var n,r=t||[];return e!=null&&(n=v.type(e),e.length==null||n==="string"||n==="function"||n==="regexp"||v.isWindow(e)?f.call(r,e):v.merge(r,e)),r},inArray:function(e,t,n){var r;if(t){if(c)return c.call(t,e,n);r=t.length,n=n?n<0?Math.max(0,r+n):n:0;for(;n<r;n++)if(n in t&&t[n]===e)return n}return-1},merge:function(e,n){var r=n.length,i=e.length,s=0;if(typeof r=="number")for(;s<r;s++)e[i++]=n[s];else while(n[s]!==t)e[i++]=n[s++];return e.length=i,e},grep:function(e,t,n){var r,i=[],s=0,o=e.length;n=!!n;for(;s<o;s++)r=!!t(e[s],s),n!==r&&i.push(e[s]);return i},map:function(e,n,r){var i,s,o=[],u=0,a=e.length,f=e instanceof v||a!==t&&typeof a=="number"&&(a>0&&e[0]&&e[a-1]||a===0||v.isArray(e));if(f)for(;u<a;u++)i=n(e[u],u,r),i!=null&&(o[o.length]=i);else for(s in e)i=n(e[s],s,r),i!=null&&(o[o.length]=i);return o.concat.apply([],o)},guid:1,proxy:function(e,n){var r,i,s;return typeof n=="string"&&(r=e[n],n=e,e=r),v.isFunction(e)?(i=l.call(arguments,2),s=function(){return e.apply(n,i.concat(l.call(arguments)))},s.guid=e.guid=e.guid||v.guid++,s):t},access:function(e,n,r,i,s,o,u){var a,f=r==null,l=0,c=e.length;if(r&&typeof r=="object"){for(l in r)v.access(e,n,l,r[l],1,o,i);s=1}else if(i!==t){a=u===t&&v.isFunction(i),f&&(a?(a=n,n=function(e,t,n){return a.call(v(e),n)}):(n.call(e,i),n=null));if(n)for(;l<c;l++)n(e[l],r,a?i.call(e[l],l,n(e[l],r)):i,u);s=1}return s?e:f?n.call(e):c?n(e[0],r):o},now:function(){return(new Date).getTime()}}),v.ready.promise=function(t){if(!r){r=v.Deferred();if(i.readyState==="complete")setTimeout(v.ready,1);else if(i.addEventListener)i.addEventListener("DOMContentLoaded",A,!1),e.addEventListener("load",v.ready,!1);else{i.attachEvent("onreadystatechange",A),e.attachEvent("onload",v.ready);var n=!1;try{n=e.frameElement==null&&i.documentElement}catch(s){}n&&n.doScroll&&function o(){if(!v.isReady){try{n.doScroll("left")}catch(e){return setTimeout(o,50)}v.ready()}}()}}return r.promise(t)},v.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(e,t){O["[object "+t+"]"]=t.toLowerCase()}),n=v(i);var M={};v.Callbacks=function(e){e=typeof e=="string"?M[e]||_(e):v.extend({},e);var n,r,i,s,o,u,a=[],f=!e.once&&[],l=function(t){n=e.memory&&t,r=!0,u=s||0,s=0,o=a.length,i=!0;for(;a&&u<o;u++)if(a[u].apply(t[0],t[1])===!1&&e.stopOnFalse){n=!1;break}i=!1,a&&(f?f.length&&l(f.shift()):n?a=[]:c.disable())},c={add:function(){if(a){var t=a.length;(function r(t){v.each(t,function(t,n){var i=v.type(n);i==="function"?(!e.unique||!c.has(n))&&a.push(n):n&&n.length&&i!=="string"&&r(n)})})(arguments),i?o=a.length:n&&(s=t,l(n))}return this},remove:function(){return a&&v.each(arguments,function(e,t){var n;while((n=v.inArray(t,a,n))>-1)a.splice(n,1),i&&(n<=o&&o--,n<=u&&u--)}),this},has:function(e){return v.inArray(e,a)>-1},empty:function(){return a=[],this},disable:function(){return a=f=n=t,this},disabled:function(){return!a},lock:function(){return f=t,n||c.disable(),this},locked:function(){return!f},fireWith:function(e,t){return t=t||[],t=[e,t.slice?t.slice():t],a&&(!r||f)&&(i?f.push(t):l(t)),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!r}};return c},v.extend({Deferred:function(e){var t=[["resolve","done",v.Callbacks("once memory"),"resolved"],["reject","fail",v.Callbacks("once memory"),"rejected"],["notify","progress",v.Callbacks("memory")]],n="pending",r={state:function(){return n},always:function(){return i.done(arguments).fail(arguments),this},then:function(){var e=arguments;return v.Deferred(function(n){v.each(t,function(t,r){var s=r[0],o=e[t];i[r[1]](v.isFunction(o)?function(){var e=o.apply(this,arguments);e&&v.isFunction(e.promise)?e.promise().done(n.resolve).fail(n.reject).progress(n.notify):n[s+"With"](this===i?n:this,[e])}:n[s])}),e=null}).promise()},promise:function(e){return e!=null?v.extend(e,r):r}},i={};return r.pipe=r.then,v.each(t,function(e,s){var o=s[2],u=s[3];r[s[1]]=o.add,u&&o.add(function(){n=u},t[e^1][2].disable,t[2][2].lock),i[s[0]]=o.fire,i[s[0]+"With"]=o.fireWith}),r.promise(i),e&&e.call(i,i),i},when:function(e){var t=0,n=l.call(arguments),r=n.length,i=r!==1||e&&v.isFunction(e.promise)?r:0,s=i===1?e:v.Deferred(),o=function(e,t,n){return function(r){t[e]=this,n[e]=arguments.length>1?l.call(arguments):r,n===u?s.notifyWith(t,n):--i||s.resolveWith(t,n)}},u,a,f;if(r>1){u=new Array(r),a=new Array(r),f=new Array(r);for(;t<r;t++)n[t]&&v.isFunction(n[t].promise)?n[t].promise().done(o(t,f,n)).fail(s.reject).progress(o(t,a,u)):--i}return i||s.resolveWith(f,n),s.promise()}}),v.support=function(){var t,n,r,s,o,u,a,f,l,c,h,p=i.createElement("div");p.setAttribute("className","t"),p.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",n=p.getElementsByTagName("*"),r=p.getElementsByTagName("a")[0];if(!n||!r||!n.length)return{};s=i.createElement("select"),o=s.appendChild(i.createElement("option")),u=p.getElementsByTagName("input")[0],r.style.cssText="top:1px;float:left;opacity:.5",t={leadingWhitespace:p.firstChild.nodeType===3,tbody:!p.getElementsByTagName("tbody").length,htmlSerialize:!!p.getElementsByTagName("link").length,style:/top/.test(r.getAttribute("style")),hrefNormalized:r.getAttribute("href")==="/a",opacity:/^0.5/.test(r.style.opacity),cssFloat:!!r.style.cssFloat,checkOn:u.value==="on",optSelected:o.selected,getSetAttribute:p.className!=="t",enctype:!!i.createElement("form").enctype,html5Clone:i.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",boxModel:i.compatMode==="CSS1Compat",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,boxSizingReliable:!0,pixelPosition:!1},u.checked=!0,t.noCloneChecked=u.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!o.disabled;try{delete p.test}catch(d){t.deleteExpando=!1}!p.addEventListener&&p.attachEvent&&p.fireEvent&&(p.attachEvent("onclick",h=function(){t.noCloneEvent=!1}),p.cloneNode(!0).fireEvent("onclick"),p.detachEvent("onclick",h)),u=i.createElement("input"),u.value="t",u.setAttribute("type","radio"),t.radioValue=u.value==="t",u.setAttribute("checked","checked"),u.setAttribute("name","t"),p.appendChild(u),a=i.createDocumentFragment(),a.appendChild(p.lastChild),t.checkClone=a.cloneNode(!0).cloneNode(!0).lastChild.checked,t.appendChecked=u.checked,a.removeChild(u),a.appendChild(p);if(p.attachEvent)for(l in{submit:!0,change:!0,focusin:!0})f="on"+l,c=f in p,c||(p.setAttribute(f,"return;"),c=typeof p[f]=="function"),t[l+"Bubbles"]=c;return v(function(){var n,r,s,o,u="padding:0;margin:0;border:0;display:block;overflow:hidden;",a=i.getElementsByTagName("body")[0];if(!a)return;n=i.createElement("div"),n.style.cssText="visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px",a.insertBefore(n,a.firstChild),r=i.createElement("div"),n.appendChild(r),r.innerHTML="<table><tr><td></td><td>t</td></tr></table>",s=r.getElementsByTagName("td"),s[0].style.cssText="padding:0;margin:0;border:0;display:none",c=s[0].offsetHeight===0,s[0].style.display="",s[1].style.display="none",t.reliableHiddenOffsets=c&&s[0].offsetHeight===0,r.innerHTML="",r.style.cssText="box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;",t.boxSizing=r.offsetWidth===4,t.doesNotIncludeMarginInBodyOffset=a.offsetTop!==1,e.getComputedStyle&&(t.pixelPosition=(e.getComputedStyle(r,null)||{}).top!=="1%",t.boxSizingReliable=(e.getComputedStyle(r,null)||{width:"4px"}).width==="4px",o=i.createElement("div"),o.style.cssText=r.style.cssText=u,o.style.marginRight=o.style.width="0",r.style.width="1px",r.appendChild(o),t.reliableMarginRight=!parseFloat((e.getComputedStyle(o,null)||{}).marginRight)),typeof r.style.zoom!="undefined"&&(r.innerHTML="",r.style.cssText=u+"width:1px;padding:1px;display:inline;zoom:1",t.inlineBlockNeedsLayout=r.offsetWidth===3,r.style.display="block",r.style.overflow="visible",r.innerHTML="<div></div>",r.firstChild.style.width="5px",t.shrinkWrapBlocks=r.offsetWidth!==3,n.style.zoom=1),a.removeChild(n),n=r=s=o=null}),a.removeChild(p),n=r=s=o=u=a=p=null,t}();var D=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,P=/([A-Z])/g;v.extend({cache:{},deletedIds:[],uuid:0,expando:"jQuery"+(v.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(e){return e=e.nodeType?v.cache[e[v.expando]]:e[v.expando],!!e&&!B(e)},data:function(e,n,r,i){if(!v.acceptData(e))return;var s,o,u=v.expando,a=typeof n=="string",f=e.nodeType,l=f?v.cache:e,c=f?e[u]:e[u]&&u;if((!c||!l[c]||!i&&!l[c].data)&&a&&r===t)return;c||(f?e[u]=c=v.deletedIds.pop()||v.guid++:c=u),l[c]||(l[c]={},f||(l[c].toJSON=v.noop));if(typeof n=="object"||typeof n=="function")i?l[c]=v.extend(l[c],n):l[c].data=v.extend(l[c].data,n);return s=l[c],i||(s.data||(s.data={}),s=s.data),r!==t&&(s[v.camelCase(n)]=r),a?(o=s[n],o==null&&(o=s[v.camelCase(n)])):o=s,o},removeData:function(e,t,n){if(!v.acceptData(e))return;var r,i,s,o=e.nodeType,u=o?v.cache:e,a=o?e[v.expando]:v.expando;if(!u[a])return;if(t){r=n?u[a]:u[a].data;if(r){v.isArray(t)||(t in r?t=[t]:(t=v.camelCase(t),t in r?t=[t]:t=t.split(" ")));for(i=0,s=t.length;i<s;i++)delete r[t[i]];if(!(n?B:v.isEmptyObject)(r))return}}if(!n){delete u[a].data;if(!B(u[a]))return}o?v.cleanData([e],!0):v.support.deleteExpando||u!=u.window?delete u[a]:u[a]=null},_data:function(e,t,n){return v.data(e,t,n,!0)},acceptData:function(e){var t=e.nodeName&&v.noData[e.nodeName.toLowerCase()];return!t||t!==!0&&e.getAttribute("classid")===t}}),v.fn.extend({data:function(e,n){var r,i,s,o,u,a=this[0],f=0,l=null;if(e===t){if(this.length){l=v.data(a);if(a.nodeType===1&&!v._data(a,"parsedAttrs")){s=a.attributes;for(u=s.length;f<u;f++)o=s[f].name,o.indexOf("data-")||(o=v.camelCase(o.substring(5)),H(a,o,l[o]));v._data(a,"parsedAttrs",!0)}}return l}return typeof e=="object"?this.each(function(){v.data(this,e)}):(r=e.split(".",2),r[1]=r[1]?"."+r[1]:"",i=r[1]+"!",v.access(this,function(n){if(n===t)return l=this.triggerHandler("getData"+i,[r[0]]),l===t&&a&&(l=v.data(a,e),l=H(a,e,l)),l===t&&r[1]?this.data(r[0]):l;r[1]=n,this.each(function(){var t=v(this);t.triggerHandler("setData"+i,r),v.data(this,e,n),t.triggerHandler("changeData"+i,r)})},null,n,arguments.length>1,null,!1))},removeData:function(e){return this.each(function(){v.removeData(this,e)})}}),v.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=v._data(e,t),n&&(!r||v.isArray(n)?r=v._data(e,t,v.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=v.queue(e,t),r=n.length,i=n.shift(),s=v._queueHooks(e,t),o=function(){v.dequeue(e,t)};i==="inprogress"&&(i=n.shift(),r--),i&&(t==="fx"&&n.unshift("inprogress"),delete s.stop,i.call(e,o,s)),!r&&s&&s.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return v._data(e,n)||v._data(e,n,{empty:v.Callbacks("once memory").add(function(){v.removeData(e,t+"queue",!0),v.removeData(e,n,!0)})})}}),v.fn.extend({queue:function(e,n){var r=2;return typeof e!="string"&&(n=e,e="fx",r--),arguments.length<r?v.queue(this[0],e):n===t?this:this.each(function(){var t=v.queue(this,e,n);v._queueHooks(this,e),e==="fx"&&t[0]!=="inprogress"&&v.dequeue(this,e)})},dequeue:function(e){return this.each(function(){v.dequeue(this,e)})},delay:function(e,t){return e=v.fx?v.fx.speeds[e]||e:e,t=t||"fx",this.queue(t,function(t,n){var r=setTimeout(t,e);n.stop=function(){clearTimeout(r)}})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,n){var r,i=1,s=v.Deferred(),o=this,u=this.length,a=function(){--i||s.resolveWith(o,[o])};typeof e!="string"&&(n=e,e=t),e=e||"fx";while(u--)r=v._data(o[u],e+"queueHooks"),r&&r.empty&&(i++,r.empty.add(a));return a(),s.promise(n)}});var j,F,I,q=/[\t\r\n]/g,R=/\r/g,U=/^(?:button|input)$/i,z=/^(?:button|input|object|select|textarea)$/i,W=/^a(?:rea|)$/i,X=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,V=v.support.getSetAttribute;v.fn.extend({attr:function(e,t){return v.access(this,v.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each(function(){v.removeAttr(this,e)})},prop:function(e,t){return v.access(this,v.prop,e,t,arguments.length>1)},removeProp:function(e){return e=v.propFix[e]||e,this.each(function(){try{this[e]=t,delete this[e]}catch(n){}})},addClass:function(e){var t,n,r,i,s,o,u;if(v.isFunction(e))return this.each(function(t){v(this).addClass(e.call(this,t,this.className))});if(e&&typeof e=="string"){t=e.split(y);for(n=0,r=this.length;n<r;n++){i=this[n];if(i.nodeType===1)if(!i.className&&t.length===1)i.className=e;else{s=" "+i.className+" ";for(o=0,u=t.length;o<u;o++)s.indexOf(" "+t[o]+" ")<0&&(s+=t[o]+" ");i.className=v.trim(s)}}}return this},removeClass:function(e){var n,r,i,s,o,u,a;if(v.isFunction(e))return this.each(function(t){v(this).removeClass(e.call(this,t,this.className))});if(e&&typeof e=="string"||e===t){n=(e||"").split(y);for(u=0,a=this.length;u<a;u++){i=this[u];if(i.nodeType===1&&i.className){r=(" "+i.className+" ").replace(q," ");for(s=0,o=n.length;s<o;s++)while(r.indexOf(" "+n[s]+" ")>=0)r=r.replace(" "+n[s]+" "," ");i.className=e?v.trim(r):""}}}return this},toggleClass:function(e,t){var n=typeof e,r=typeof t=="boolean";return v.isFunction(e)?this.each(function(n){v(this).toggleClass(e.call(this,n,this.className,t),t)}):this.each(function(){if(n==="string"){var i,s=0,o=v(this),u=t,a=e.split(y);while(i=a[s++])u=r?u:!o.hasClass(i),o[u?"addClass":"removeClass"](i)}else if(n==="undefined"||n==="boolean")this.className&&v._data(this,"__className__",this.className),this.className=this.className||e===!1?"":v._data(this,"__className__")||""})},hasClass:function(e){var t=" "+e+" ",n=0,r=this.length;for(;n<r;n++)if(this[n].nodeType===1&&(" "+this[n].className+" ").replace(q," ").indexOf(t)>=0)return!0;return!1},val:function(e){var n,r,i,s=this[0];if(!arguments.length){if(s)return n=v.valHooks[s.type]||v.valHooks[s.nodeName.toLowerCase()],n&&"get"in n&&(r=n.get(s,"value"))!==t?r:(r=s.value,typeof r=="string"?r.replace(R,""):r==null?"":r);return}return i=v.isFunction(e),this.each(function(r){var s,o=v(this);if(this.nodeType!==1)return;i?s=e.call(this,r,o.val()):s=e,s==null?s="":typeof s=="number"?s+="":v.isArray(s)&&(s=v.map(s,function(e){return e==null?"":e+""})),n=v.valHooks[this.type]||v.valHooks[this.nodeName.toLowerCase()];if(!n||!("set"in n)||n.set(this,s,"value")===t)this.value=s})}}),v.extend({valHooks:{option:{get:function(e){var t=e.attributes.value;return!t||t.specified?e.value:e.text}},select:{get:function(e){var t,n,r=e.options,i=e.selectedIndex,s=e.type==="select-one"||i<0,o=s?null:[],u=s?i+1:r.length,a=i<0?u:s?i:0;for(;a<u;a++){n=r[a];if((n.selected||a===i)&&(v.support.optDisabled?!n.disabled:n.getAttribute("disabled")===null)&&(!n.parentNode.disabled||!v.nodeName(n.parentNode,"optgroup"))){t=v(n).val();if(s)return t;o.push(t)}}return o},set:function(e,t){var n=v.makeArray(t);return v(e).find("option").each(function(){this.selected=v.inArray(v(this).val(),n)>=0}),n.length||(e.selectedIndex=-1),n}}},attrFn:{},attr:function(e,n,r,i){var s,o,u,a=e.nodeType;if(!e||a===3||a===8||a===2)return;if(i&&v.isFunction(v.fn[n]))return v(e)[n](r);if(typeof e.getAttribute=="undefined")return v.prop(e,n,r);u=a!==1||!v.isXMLDoc(e),u&&(n=n.toLowerCase(),o=v.attrHooks[n]||(X.test(n)?F:j));if(r!==t){if(r===null){v.removeAttr(e,n);return}return o&&"set"in o&&u&&(s=o.set(e,r,n))!==t?s:(e.setAttribute(n,r+""),r)}return o&&"get"in o&&u&&(s=o.get(e,n))!==null?s:(s=e.getAttribute(n),s===null?t:s)},removeAttr:function(e,t){var n,r,i,s,o=0;if(t&&e.nodeType===1){r=t.split(y);for(;o<r.length;o++)i=r[o],i&&(n=v.propFix[i]||i,s=X.test(i),s||v.attr(e,i,""),e.removeAttribute(V?i:n),s&&n in e&&(e[n]=!1))}},attrHooks:{type:{set:function(e,t){if(U.test(e.nodeName)&&e.parentNode)v.error("type property can't be changed");else if(!v.support.radioValue&&t==="radio"&&v.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}},value:{get:function(e,t){return j&&v.nodeName(e,"button")?j.get(e,t):t in e?e.value:null},set:function(e,t,n){if(j&&v.nodeName(e,"button"))return j.set(e,t,n);e.value=t}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(e,n,r){var i,s,o,u=e.nodeType;if(!e||u===3||u===8||u===2)return;return o=u!==1||!v.isXMLDoc(e),o&&(n=v.propFix[n]||n,s=v.propHooks[n]),r!==t?s&&"set"in s&&(i=s.set(e,r,n))!==t?i:e[n]=r:s&&"get"in s&&(i=s.get(e,n))!==null?i:e[n]},propHooks:{tabIndex:{get:function(e){var n=e.getAttributeNode("tabindex");return n&&n.specified?parseInt(n.value,10):z.test(e.nodeName)||W.test(e.nodeName)&&e.href?0:t}}}}),F={get:function(e,n){var r,i=v.prop(e,n);return i===!0||typeof i!="boolean"&&(r=e.getAttributeNode(n))&&r.nodeValue!==!1?n.toLowerCase():t},set:function(e,t,n){var r;return t===!1?v.removeAttr(e,n):(r=v.propFix[n]||n,r in e&&(e[r]=!0),e.setAttribute(n,n.toLowerCase())),n}},V||(I={name:!0,id:!0,coords:!0},j=v.valHooks.button={get:function(e,n){var r;return r=e.getAttributeNode(n),r&&(I[n]?r.value!=="":r.specified)?r.value:t},set:function(e,t,n){var r=e.getAttributeNode(n);return r||(r=i.createAttribute(n),e.setAttributeNode(r)),r.value=t+""}},v.each(["width","height"],function(e,t){v.attrHooks[t]=v.extend(v.attrHooks[t],{set:function(e,n){if(n==="")return e.setAttribute(t,"auto"),n}})}),v.attrHooks.contenteditable={get:j.get,set:function(e,t,n){t===""&&(t="false"),j.set(e,t,n)}}),v.support.hrefNormalized||v.each(["href","src","width","height"],function(e,n){v.attrHooks[n]=v.extend(v.attrHooks[n],{get:function(e){var r=e.getAttribute(n,2);return r===null?t:r}})}),v.support.style||(v.attrHooks.style={get:function(e){return e.style.cssText.toLowerCase()||t},set:function(e,t){return e.style.cssText=t+""}}),v.support.optSelected||(v.propHooks.selected=v.extend(v.propHooks.selected,{get:function(e){var t=e.parentNode;return t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex),null}})),v.support.enctype||(v.propFix.enctype="encoding"),v.support.checkOn||v.each(["radio","checkbox"],function(){v.valHooks[this]={get:function(e){return e.getAttribute("value")===null?"on":e.value}}}),v.each(["radio","checkbox"],function(){v.valHooks[this]=v.extend(v.valHooks[this],{set:function(e,t){if(v.isArray(t))return e.checked=v.inArray(v(e).val(),t)>=0}})});var $=/^(?:textarea|input|select)$/i,J=/^([^\.]*|)(?:\.(.+)|)$/,K=/(?:^|\s)hover(\.\S+|)\b/,Q=/^key/,G=/^(?:mouse|contextmenu)|click/,Y=/^(?:focusinfocus|focusoutblur)$/,Z=function(e){return v.event.special.hover?e:e.replace(K,"mouseenter$1 mouseleave$1")};v.event={add:function(e,n,r,i,s){var o,u,a,f,l,c,h,p,d,m,g;if(e.nodeType===3||e.nodeType===8||!n||!r||!(o=v._data(e)))return;r.handler&&(d=r,r=d.handler,s=d.selector),r.guid||(r.guid=v.guid++),a=o.events,a||(o.events=a={}),u=o.handle,u||(o.handle=u=function(e){return typeof v=="undefined"||!!e&&v.event.triggered===e.type?t:v.event.dispatch.apply(u.elem,arguments)},u.elem=e),n=v.trim(Z(n)).split(" ");for(f=0;f<n.length;f++){l=J.exec(n[f])||[],c=l[1],h=(l[2]||"").split(".").sort(),g=v.event.special[c]||{},c=(s?g.delegateType:g.bindType)||c,g=v.event.special[c]||{},p=v.extend({type:c,origType:l[1],data:i,handler:r,guid:r.guid,selector:s,needsContext:s&&v.expr.match.needsContext.test(s),namespace:h.join(".")},d),m=a[c];if(!m){m=a[c]=[],m.delegateCount=0;if(!g.setup||g.setup.call(e,i,h,u)===!1)e.addEventListener?e.addEventListener(c,u,!1):e.attachEvent&&e.attachEvent("on"+c,u)}g.add&&(g.add.call(e,p),p.handler.guid||(p.handler.guid=r.guid)),s?m.splice(m.delegateCount++,0,p):m.push(p),v.event.global[c]=!0}e=null},global:{},remove:function(e,t,n,r,i){var s,o,u,a,f,l,c,h,p,d,m,g=v.hasData(e)&&v._data(e);if(!g||!(h=g.events))return;t=v.trim(Z(t||"")).split(" ");for(s=0;s<t.length;s++){o=J.exec(t[s])||[],u=a=o[1],f=o[2];if(!u){for(u in h)v.event.remove(e,u+t[s],n,r,!0);continue}p=v.event.special[u]||{},u=(r?p.delegateType:p.bindType)||u,d=h[u]||[],l=d.length,f=f?new RegExp("(^|\\.)"+f.split(".").sort().join("\\.(?:.*\\.|)")+"(\\.|$)"):null;for(c=0;c<d.length;c++)m=d[c],(i||a===m.origType)&&(!n||n.guid===m.guid)&&(!f||f.test(m.namespace))&&(!r||r===m.selector||r==="**"&&m.selector)&&(d.splice(c--,1),m.selector&&d.delegateCount--,p.remove&&p.remove.call(e,m));d.length===0&&l!==d.length&&((!p.teardown||p.teardown.call(e,f,g.handle)===!1)&&v.removeEvent(e,u,g.handle),delete h[u])}v.isEmptyObject(h)&&(delete g.handle,v.removeData(e,"events",!0))},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(n,r,s,o){if(!s||s.nodeType!==3&&s.nodeType!==8){var u,a,f,l,c,h,p,d,m,g,y=n.type||n,b=[];if(Y.test(y+v.event.triggered))return;y.indexOf("!")>=0&&(y=y.slice(0,-1),a=!0),y.indexOf(".")>=0&&(b=y.split("."),y=b.shift(),b.sort());if((!s||v.event.customEvent[y])&&!v.event.global[y])return;n=typeof n=="object"?n[v.expando]?n:new v.Event(y,n):new v.Event(y),n.type=y,n.isTrigger=!0,n.exclusive=a,n.namespace=b.join("."),n.namespace_re=n.namespace?new RegExp("(^|\\.)"+b.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,h=y.indexOf(":")<0?"on"+y:"";if(!s){u=v.cache;for(f in u)u[f].events&&u[f].events[y]&&v.event.trigger(n,r,u[f].handle.elem,!0);return}n.result=t,n.target||(n.target=s),r=r!=null?v.makeArray(r):[],r.unshift(n),p=v.event.special[y]||{};if(p.trigger&&p.trigger.apply(s,r)===!1)return;m=[[s,p.bindType||y]];if(!o&&!p.noBubble&&!v.isWindow(s)){g=p.delegateType||y,l=Y.test(g+y)?s:s.parentNode;for(c=s;l;l=l.parentNode)m.push([l,g]),c=l;c===(s.ownerDocument||i)&&m.push([c.defaultView||c.parentWindow||e,g])}for(f=0;f<m.length&&!n.isPropagationStopped();f++)l=m[f][0],n.type=m[f][1],d=(v._data(l,"events")||{})[n.type]&&v._data(l,"handle"),d&&d.apply(l,r),d=h&&l[h],d&&v.acceptData(l)&&d.apply&&d.apply(l,r)===!1&&n.preventDefault();return n.type=y,!o&&!n.isDefaultPrevented()&&(!p._default||p._default.apply(s.ownerDocument,r)===!1)&&(y!=="click"||!v.nodeName(s,"a"))&&v.acceptData(s)&&h&&s[y]&&(y!=="focus"&&y!=="blur"||n.target.offsetWidth!==0)&&!v.isWindow(s)&&(c=s[h],c&&(s[h]=null),v.event.triggered=y,s[y](),v.event.triggered=t,c&&(s[h]=c)),n.result}return},dispatch:function(n){n=v.event.fix(n||e.event);var r,i,s,o,u,a,f,c,h,p,d=(v._data(this,"events")||{})[n.type]||[],m=d.delegateCount,g=l.call(arguments),y=!n.exclusive&&!n.namespace,b=v.event.special[n.type]||{},w=[];g[0]=n,n.delegateTarget=this;if(b.preDispatch&&b.preDispatch.call(this,n)===!1)return;if(m&&(!n.button||n.type!=="click"))for(s=n.target;s!=this;s=s.parentNode||this)if(s.disabled!==!0||n.type!=="click"){u={},f=[];for(r=0;r<m;r++)c=d[r],h=c.selector,u[h]===t&&(u[h]=c.needsContext?v(h,this).index(s)>=0:v.find(h,this,null,[s]).length),u[h]&&f.push(c);f.length&&w.push({elem:s,matches:f})}d.length>m&&w.push({elem:this,matches:d.slice(m)});for(r=0;r<w.length&&!n.isPropagationStopped();r++){a=w[r],n.currentTarget=a.elem;for(i=0;i<a.matches.length&&!n.isImmediatePropagationStopped();i++){c=a.matches[i];if(y||!n.namespace&&!c.namespace||n.namespace_re&&n.namespace_re.test(c.namespace))n.data=c.data,n.handleObj=c,o=((v.event.special[c.origType]||{}).handle||c.handler).apply(a.elem,g),o!==t&&(n.result=o,o===!1&&(n.preventDefault(),n.stopPropagation()))}}return b.postDispatch&&b.postDispatch.call(this,n),n.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(e,t){return e.which==null&&(e.which=t.charCode!=null?t.charCode:t.keyCode),e}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(e,n){var r,s,o,u=n.button,a=n.fromElement;return e.pageX==null&&n.clientX!=null&&(r=e.target.ownerDocument||i,s=r.documentElement,o=r.body,e.pageX=n.clientX+(s&&s.scrollLeft||o&&o.scrollLeft||0)-(s&&s.clientLeft||o&&o.clientLeft||0),e.pageY=n.clientY+(s&&s.scrollTop||o&&o.scrollTop||0)-(s&&s.clientTop||o&&o.clientTop||0)),!e.relatedTarget&&a&&(e.relatedTarget=a===e.target?n.toElement:a),!e.which&&u!==t&&(e.which=u&1?1:u&2?3:u&4?2:0),e}},fix:function(e){if(e[v.expando])return e;var t,n,r=e,s=v.event.fixHooks[e.type]||{},o=s.props?this.props.concat(s.props):this.props;e=v.Event(r);for(t=o.length;t;)n=o[--t],e[n]=r[n];return e.target||(e.target=r.srcElement||i),e.target.nodeType===3&&(e.target=e.target.parentNode),e.metaKey=!!e.metaKey,s.filter?s.filter(e,r):e},special:{load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(e,t,n){v.isWindow(this)&&(this.onbeforeunload=n)},teardown:function(e,t){this.onbeforeunload===t&&(this.onbeforeunload=null)}}},simulate:function(e,t,n,r){var i=v.extend(new v.Event,n,{type:e,isSimulated:!0,originalEvent:{}});r?v.event.trigger(i,null,t):v.event.dispatch.call(t,i),i.isDefaultPrevented()&&n.preventDefault()}},v.event.handle=v.event.dispatch,v.removeEvent=i.removeEventListener?function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n,!1)}:function(e,t,n){var r="on"+t;e.detachEvent&&(typeof e[r]=="undefined"&&(e[r]=null),e.detachEvent(r,n))},v.Event=function(e,t){if(!(this instanceof v.Event))return new v.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||e.returnValue===!1||e.getPreventDefault&&e.getPreventDefault()?tt:et):this.type=e,t&&v.extend(this,t),this.timeStamp=e&&e.timeStamp||v.now(),this[v.expando]=!0},v.Event.prototype={preventDefault:function(){this.isDefaultPrevented=tt;var e=this.originalEvent;if(!e)return;e.preventDefault?e.preventDefault():e.returnValue=!1},stopPropagation:function(){this.isPropagationStopped=tt;var e=this.originalEvent;if(!e)return;e.stopPropagation&&e.stopPropagation(),e.cancelBubble=!0},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=tt,this.stopPropagation()},isDefaultPrevented:et,isPropagationStopped:et,isImmediatePropagationStopped:et},v.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(e,t){v.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,s=e.handleObj,o=s.selector;if(!i||i!==r&&!v.contains(r,i))e.type=s.origType,n=s.handler.apply(this,arguments),e.type=t;return n}}}),v.support.submitBubbles||(v.event.special.submit={setup:function(){if(v.nodeName(this,"form"))return!1;v.event.add(this,"click._submit keypress._submit",function(e){var n=e.target,r=v.nodeName(n,"input")||v.nodeName(n,"button")?n.form:t;r&&!v._data(r,"_submit_attached")&&(v.event.add(r,"submit._submit",function(e){e._submit_bubble=!0}),v._data(r,"_submit_attached",!0))})},postDispatch:function(e){e._submit_bubble&&(delete e._submit_bubble,this.parentNode&&!e.isTrigger&&v.event.simulate("submit",this.parentNode,e,!0))},teardown:function(){if(v.nodeName(this,"form"))return!1;v.event.remove(this,"._submit")}}),v.support.changeBubbles||(v.event.special.change={setup:function(){if($.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")v.event.add(this,"propertychange._change",function(e){e.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),v.event.add(this,"click._change",function(e){this._just_changed&&!e.isTrigger&&(this._just_changed=!1),v.event.simulate("change",this,e,!0)});return!1}v.event.add(this,"beforeactivate._change",function(e){var t=e.target;$.test(t.nodeName)&&!v._data(t,"_change_attached")&&(v.event.add(t,"change._change",function(e){this.parentNode&&!e.isSimulated&&!e.isTrigger&&v.event.simulate("change",this.parentNode,e,!0)}),v._data(t,"_change_attached",!0))})},handle:function(e){var t=e.target;if(this!==t||e.isSimulated||e.isTrigger||t.type!=="radio"&&t.type!=="checkbox")return e.handleObj.handler.apply(this,arguments)},teardown:function(){return v.event.remove(this,"._change"),!$.test(this.nodeName)}}),v.support.focusinBubbles||v.each({focus:"focusin",blur:"focusout"},function(e,t){var n=0,r=function(e){v.event.simulate(t,e.target,v.event.fix(e),!0)};v.event.special[t]={setup:function(){n++===0&&i.addEventListener(e,r,!0)},teardown:function(){--n===0&&i.removeEventListener(e,r,!0)}}}),v.fn.extend({on:function(e,n,r,i,s){var o,u;if(typeof e=="object"){typeof n!="string"&&(r=r||n,n=t);for(u in e)this.on(u,n,r,e[u],s);return this}r==null&&i==null?(i=n,r=n=t):i==null&&(typeof n=="string"?(i=r,r=t):(i=r,r=n,n=t));if(i===!1)i=et;else if(!i)return this;return s===1&&(o=i,i=function(e){return v().off(e),o.apply(this,arguments)},i.guid=o.guid||(o.guid=v.guid++)),this.each(function(){v.event.add(this,e,i,r,n)})},one:function(e,t,n,r){return this.on(e,t,n,r,1)},off:function(e,n,r){var i,s;if(e&&e.preventDefault&&e.handleObj)return i=e.handleObj,v(e.delegateTarget).off(i.namespace?i.origType+"."+i.namespace:i.origType,i.selector,i.handler),this;if(typeof e=="object"){for(s in e)this.off(s,n,e[s]);return this}if(n===!1||typeof n=="function")r=n,n=t;return r===!1&&(r=et),this.each(function(){v.event.remove(this,e,r,n)})},bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},live:function(e,t,n){return v(this.context).on(e,this.selector,t,n),this},die:function(e,t){return v(this.context).off(e,this.selector||"**",t),this},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return arguments.length===1?this.off(e,"**"):this.off(t,e||"**",n)},trigger:function(e,t){return this.each(function(){v.event.trigger(e,t,this)})},triggerHandler:function(e,t){if(this[0])return v.event.trigger(e,t,this[0],!0)},toggle:function(e){var t=arguments,n=e.guid||v.guid++,r=0,i=function(n){var i=(v._data(this,"lastToggle"+e.guid)||0)%r;return v._data(this,"lastToggle"+e.guid,i+1),n.preventDefault(),t[i].apply(this,arguments)||!1};i.guid=n;while(r<t.length)t[r++].guid=n;return this.click(i)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),v.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(e,t){v.fn[t]=function(e,n){return n==null&&(n=e,e=null),arguments.length>0?this.on(t,null,e,n):this.trigger(t)},Q.test(t)&&(v.event.fixHooks[t]=v.event.keyHooks),G.test(t)&&(v.event.fixHooks[t]=v.event.mouseHooks)}),function(e,t){function nt(e,t,n,r){n=n||[],t=t||g;var i,s,a,f,l=t.nodeType;if(!e||typeof e!="string")return n;if(l!==1&&l!==9)return[];a=o(t);if(!a&&!r)if(i=R.exec(e))if(f=i[1]){if(l===9){s=t.getElementById(f);if(!s||!s.parentNode)return n;if(s.id===f)return n.push(s),n}else if(t.ownerDocument&&(s=t.ownerDocument.getElementById(f))&&u(t,s)&&s.id===f)return n.push(s),n}else{if(i[2])return S.apply(n,x.call(t.getElementsByTagName(e),0)),n;if((f=i[3])&&Z&&t.getElementsByClassName)return S.apply(n,x.call(t.getElementsByClassName(f),0)),n}return vt(e.replace(j,"$1"),t,n,r,a)}function rt(e){return function(t){var n=t.nodeName.toLowerCase();return n==="input"&&t.type===e}}function it(e){return function(t){var n=t.nodeName.toLowerCase();return(n==="input"||n==="button")&&t.type===e}}function st(e){return N(function(t){return t=+t,N(function(n,r){var i,s=e([],n.length,t),o=s.length;while(o--)n[i=s[o]]&&(n[i]=!(r[i]=n[i]))})})}function ot(e,t,n){if(e===t)return n;var r=e.nextSibling;while(r){if(r===t)return-1;r=r.nextSibling}return 1}function ut(e,t){var n,r,s,o,u,a,f,l=L[d][e+" "];if(l)return t?0:l.slice(0);u=e,a=[],f=i.preFilter;while(u){if(!n||(r=F.exec(u)))r&&(u=u.slice(r[0].length)||u),a.push(s=[]);n=!1;if(r=I.exec(u))s.push(n=new m(r.shift())),u=u.slice(n.length),n.type=r[0].replace(j," ");for(o in i.filter)(r=J[o].exec(u))&&(!f[o]||(r=f[o](r)))&&(s.push(n=new m(r.shift())),u=u.slice(n.length),n.type=o,n.matches=r);if(!n)break}return t?u.length:u?nt.error(e):L(e,a).slice(0)}function at(e,t,r){var i=t.dir,s=r&&t.dir==="parentNode",o=w++;return t.first?function(t,n,r){while(t=t[i])if(s||t.nodeType===1)return e(t,n,r)}:function(t,r,u){if(!u){var a,f=b+" "+o+" ",l=f+n;while(t=t[i])if(s||t.nodeType===1){if((a=t[d])===l)return t.sizset;if(typeof a=="string"&&a.indexOf(f)===0){if(t.sizset)return t}else{t[d]=l;if(e(t,r,u))return t.sizset=!0,t;t.sizset=!1}}}else while(t=t[i])if(s||t.nodeType===1)if(e(t,r,u))return t}}function ft(e){return e.length>1?function(t,n,r){var i=e.length;while(i--)if(!e[i](t,n,r))return!1;return!0}:e[0]}function lt(e,t,n,r,i){var s,o=[],u=0,a=e.length,f=t!=null;for(;u<a;u++)if(s=e[u])if(!n||n(s,r,i))o.push(s),f&&t.push(u);return o}function ct(e,t,n,r,i,s){return r&&!r[d]&&(r=ct(r)),i&&!i[d]&&(i=ct(i,s)),N(function(s,o,u,a){var f,l,c,h=[],p=[],d=o.length,v=s||dt(t||"*",u.nodeType?[u]:u,[]),m=e&&(s||!t)?lt(v,h,e,u,a):v,g=n?i||(s?e:d||r)?[]:o:m;n&&n(m,g,u,a);if(r){f=lt(g,p),r(f,[],u,a),l=f.length;while(l--)if(c=f[l])g[p[l]]=!(m[p[l]]=c)}if(s){if(i||e){if(i){f=[],l=g.length;while(l--)(c=g[l])&&f.push(m[l]=c);i(null,g=[],f,a)}l=g.length;while(l--)(c=g[l])&&(f=i?T.call(s,c):h[l])>-1&&(s[f]=!(o[f]=c))}}else g=lt(g===o?g.splice(d,g.length):g),i?i(null,o,g,a):S.apply(o,g)})}function ht(e){var t,n,r,s=e.length,o=i.relative[e[0].type],u=o||i.relative[" "],a=o?1:0,f=at(function(e){return e===t},u,!0),l=at(function(e){return T.call(t,e)>-1},u,!0),h=[function(e,n,r){return!o&&(r||n!==c)||((t=n).nodeType?f(e,n,r):l(e,n,r))}];for(;a<s;a++)if(n=i.relative[e[a].type])h=[at(ft(h),n)];else{n=i.filter[e[a].type].apply(null,e[a].matches);if(n[d]){r=++a;for(;r<s;r++)if(i.relative[e[r].type])break;return ct(a>1&&ft(h),a>1&&e.slice(0,a-1).join("").replace(j,"$1"),n,a<r&&ht(e.slice(a,r)),r<s&&ht(e=e.slice(r)),r<s&&e.join(""))}h.push(n)}return ft(h)}function pt(e,t){var r=t.length>0,s=e.length>0,o=function(u,a,f,l,h){var p,d,v,m=[],y=0,w="0",x=u&&[],T=h!=null,N=c,C=u||s&&i.find.TAG("*",h&&a.parentNode||a),k=b+=N==null?1:Math.E;T&&(c=a!==g&&a,n=o.el);for(;(p=C[w])!=null;w++){if(s&&p){for(d=0;v=e[d];d++)if(v(p,a,f)){l.push(p);break}T&&(b=k,n=++o.el)}r&&((p=!v&&p)&&y--,u&&x.push(p))}y+=w;if(r&&w!==y){for(d=0;v=t[d];d++)v(x,m,a,f);if(u){if(y>0)while(w--)!x[w]&&!m[w]&&(m[w]=E.call(l));m=lt(m)}S.apply(l,m),T&&!u&&m.length>0&&y+t.length>1&&nt.uniqueSort(l)}return T&&(b=k,c=N),x};return o.el=0,r?N(o):o}function dt(e,t,n){var r=0,i=t.length;for(;r<i;r++)nt(e,t[r],n);return n}function vt(e,t,n,r,s){var o,u,f,l,c,h=ut(e),p=h.length;if(!r&&h.length===1){u=h[0]=h[0].slice(0);if(u.length>2&&(f=u[0]).type==="ID"&&t.nodeType===9&&!s&&i.relative[u[1].type]){t=i.find.ID(f.matches[0].replace($,""),t,s)[0];if(!t)return n;e=e.slice(u.shift().length)}for(o=J.POS.test(e)?-1:u.length-1;o>=0;o--){f=u[o];if(i.relative[l=f.type])break;if(c=i.find[l])if(r=c(f.matches[0].replace($,""),z.test(u[0].type)&&t.parentNode||t,s)){u.splice(o,1),e=r.length&&u.join("");if(!e)return S.apply(n,x.call(r,0)),n;break}}}return a(e,h)(r,t,s,n,z.test(e)),n}function mt(){}var n,r,i,s,o,u,a,f,l,c,h=!0,p="undefined",d=("sizcache"+Math.random()).replace(".",""),m=String,g=e.document,y=g.documentElement,b=0,w=0,E=[].pop,S=[].push,x=[].slice,T=[].indexOf||function(e){var t=0,n=this.length;for(;t<n;t++)if(this[t]===e)return t;return-1},N=function(e,t){return e[d]=t==null||t,e},C=function(){var e={},t=[];return N(function(n,r){return t.push(n)>i.cacheLength&&delete e[t.shift()],e[n+" "]=r},e)},k=C(),L=C(),A=C(),O="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",_=M.replace("w","w#"),D="([*^$|!~]?=)",P="\\["+O+"*("+M+")"+O+"*(?:"+D+O+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+_+")|)|)"+O+"*\\]",H=":("+M+")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:"+P+")|[^:]|\\\\.)*|.*))\\)|)",B=":(even|odd|eq|gt|lt|nth|first|last)(?:\\("+O+"*((?:-\\d)?\\d*)"+O+"*\\)|)(?=[^-]|$)",j=new RegExp("^"+O+"+|((?:^|[^\\\\])(?:\\\\.)*)"+O+"+$","g"),F=new RegExp("^"+O+"*,"+O+"*"),I=new RegExp("^"+O+"*([\\x20\\t\\r\\n\\f>+~])"+O+"*"),q=new RegExp(H),R=/^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,U=/^:not/,z=/[\x20\t\r\n\f]*[+~]/,W=/:not\($/,X=/h\d/i,V=/input|select|textarea|button/i,$=/\\(?!\\)/g,J={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),NAME:new RegExp("^\\[name=['\"]?("+M+")['\"]?\\]"),TAG:new RegExp("^("+M.replace("w","w*")+")"),ATTR:new RegExp("^"+P),PSEUDO:new RegExp("^"+H),POS:new RegExp(B,"i"),CHILD:new RegExp("^:(only|nth|first|last)-child(?:\\("+O+"*(even|odd|(([+-]|)(\\d*)n|)"+O+"*(?:([+-]|)"+O+"*(\\d+)|))"+O+"*\\)|)","i"),needsContext:new RegExp("^"+O+"*[>+~]|"+B,"i")},K=function(e){var t=g.createElement("div");try{return e(t)}catch(n){return!1}finally{t=null}},Q=K(function(e){return e.appendChild(g.createComment("")),!e.getElementsByTagName("*").length}),G=K(function(e){return e.innerHTML="<a href='#'></a>",e.firstChild&&typeof e.firstChild.getAttribute!==p&&e.firstChild.getAttribute("href")==="#"}),Y=K(function(e){e.innerHTML="<select></select>";var t=typeof e.lastChild.getAttribute("multiple");return t!=="boolean"&&t!=="string"}),Z=K(function(e){return e.innerHTML="<div class='hidden e'></div><div class='hidden'></div>",!e.getElementsByClassName||!e.getElementsByClassName("e").length?!1:(e.lastChild.className="e",e.getElementsByClassName("e").length===2)}),et=K(function(e){e.id=d+0,e.innerHTML="<a name='"+d+"'></a><div name='"+d+"'></div>",y.insertBefore(e,y.firstChild);var t=g.getElementsByName&&g.getElementsByName(d).length===2+g.getElementsByName(d+0).length;return r=!g.getElementById(d),y.removeChild(e),t});try{x.call(y.childNodes,0)[0].nodeType}catch(tt){x=function(e){var t,n=[];for(;t=this[e];e++)n.push(t);return n}}nt.matches=function(e,t){return nt(e,null,null,t)},nt.matchesSelector=function(e,t){return nt(t,null,null,[e]).length>0},s=nt.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(i===1||i===9||i===11){if(typeof e.textContent=="string")return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=s(e)}else if(i===3||i===4)return e.nodeValue}else for(;t=e[r];r++)n+=s(t);return n},o=nt.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return t?t.nodeName!=="HTML":!1},u=nt.contains=y.contains?function(e,t){var n=e.nodeType===9?e.documentElement:e,r=t&&t.parentNode;return e===r||!!(r&&r.nodeType===1&&n.contains&&n.contains(r))}:y.compareDocumentPosition?function(e,t){return t&&!!(e.compareDocumentPosition(t)&16)}:function(e,t){while(t=t.parentNode)if(t===e)return!0;return!1},nt.attr=function(e,t){var n,r=o(e);return r||(t=t.toLowerCase()),(n=i.attrHandle[t])?n(e):r||Y?e.getAttribute(t):(n=e.getAttributeNode(t),n?typeof e[t]=="boolean"?e[t]?t:null:n.specified?n.value:null:null)},i=nt.selectors={cacheLength:50,createPseudo:N,match:J,attrHandle:G?{}:{href:function(e){return e.getAttribute("href",2)},type:function(e){return e.getAttribute("type")}},find:{ID:r?function(e,t,n){if(typeof t.getElementById!==p&&!n){var r=t.getElementById(e);return r&&r.parentNode?[r]:[]}}:function(e,n,r){if(typeof n.getElementById!==p&&!r){var i=n.getElementById(e);return i?i.id===e||typeof i.getAttributeNode!==p&&i.getAttributeNode("id").value===e?[i]:t:[]}},TAG:Q?function(e,t){if(typeof t.getElementsByTagName!==p)return t.getElementsByTagName(e)}:function(e,t){var n=t.getElementsByTagName(e);if(e==="*"){var r,i=[],s=0;for(;r=n[s];s++)r.nodeType===1&&i.push(r);return i}return n},NAME:et&&function(e,t){if(typeof t.getElementsByName!==p)return t.getElementsByName(name)},CLASS:Z&&function(e,t,n){if(typeof t.getElementsByClassName!==p&&!n)return t.getElementsByClassName(e)}},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace($,""),e[3]=(e[4]||e[5]||"").replace($,""),e[2]==="~="&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),e[1]==="nth"?(e[2]||nt.error(e[0]),e[3]=+(e[3]?e[4]+(e[5]||1):2*(e[2]==="even"||e[2]==="odd")),e[4]=+(e[6]+e[7]||e[2]==="odd")):e[2]&&nt.error(e[0]),e},PSEUDO:function(e){var t,n;if(J.CHILD.test(e[0]))return null;if(e[3])e[2]=e[3];else if(t=e[4])q.test(t)&&(n=ut(t,!0))&&(n=t.indexOf(")",t.length-n)-t.length)&&(t=t.slice(0,n),e[0]=e[0].slice(0,n)),e[2]=t;return e.slice(0,3)}},filter:{ID:r?function(e){return e=e.replace($,""),function(t){return t.getAttribute("id")===e}}:function(e){return e=e.replace($,""),function(t){var n=typeof t.getAttributeNode!==p&&t.getAttributeNode("id");return n&&n.value===e}},TAG:function(e){return e==="*"?function(){return!0}:(e=e.replace($,"").toLowerCase(),function(t){return t.nodeName&&t.nodeName.toLowerCase()===e})},CLASS:function(e){var t=k[d][e+" "];return t||(t=new RegExp("(^|"+O+")"+e+"("+O+"|$)"))&&k(e,function(e){return t.test(e.className||typeof e.getAttribute!==p&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r,i){var s=nt.attr(r,e);return s==null?t==="!=":t?(s+="",t==="="?s===n:t==="!="?s!==n:t==="^="?n&&s.indexOf(n)===0:t==="*="?n&&s.indexOf(n)>-1:t==="$="?n&&s.substr(s.length-n.length)===n:t==="~="?(" "+s+" ").indexOf(n)>-1:t==="|="?s===n||s.substr(0,n.length+1)===n+"-":!1):!0}},CHILD:function(e,t,n,r){return e==="nth"?function(e){var t,i,s=e.parentNode;if(n===1&&r===0)return!0;if(s){i=0;for(t=s.firstChild;t;t=t.nextSibling)if(t.nodeType===1){i++;if(e===t)break}}return i-=r,i===n||i%n===0&&i/n>=0}:function(t){var n=t;switch(e){case"only":case"first":while(n=n.previousSibling)if(n.nodeType===1)return!1;if(e==="first")return!0;n=t;case"last":while(n=n.nextSibling)if(n.nodeType===1)return!1;return!0}}},PSEUDO:function(e,t){var n,r=i.pseudos[e]||i.setFilters[e.toLowerCase()]||nt.error("unsupported pseudo: "+e);return r[d]?r(t):r.length>1?(n=[e,e,"",t],i.setFilters.hasOwnProperty(e.toLowerCase())?N(function(e,n){var i,s=r(e,t),o=s.length;while(o--)i=T.call(e,s[o]),e[i]=!(n[i]=s[o])}):function(e){return r(e,0,n)}):r}},pseudos:{not:N(function(e){var t=[],n=[],r=a(e.replace(j,"$1"));return r[d]?N(function(e,t,n,i){var s,o=r(e,null,i,[]),u=e.length;while(u--)if(s=o[u])e[u]=!(t[u]=s)}):function(e,i,s){return t[0]=e,r(t,null,s,n),!n.pop()}}),has:N(function(e){return function(t){return nt(e,t).length>0}}),contains:N(function(e){return function(t){return(t.textContent||t.innerText||s(t)).indexOf(e)>-1}}),enabled:function(e){return e.disabled===!1},disabled:function(e){return e.disabled===!0},checked:function(e){var t=e.nodeName.toLowerCase();return t==="input"&&!!e.checked||t==="option"&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},parent:function(e){return!i.pseudos.empty(e)},empty:function(e){var t;e=e.firstChild;while(e){if(e.nodeName>"@"||(t=e.nodeType)===3||t===4)return!1;e=e.nextSibling}return!0},header:function(e){return X.test(e.nodeName)},text:function(e){var t,n;return e.nodeName.toLowerCase()==="input"&&(t=e.type)==="text"&&((n=e.getAttribute("type"))==null||n.toLowerCase()===t)},radio:rt("radio"),checkbox:rt("checkbox"),file:rt("file"),password:rt("password"),image:rt("image"),submit:it("submit"),reset:it("reset"),button:function(e){var t=e.nodeName.toLowerCase();return t==="input"&&e.type==="button"||t==="button"},input:function(e){return V.test(e.nodeName)},focus:function(e){var t=e.ownerDocument;return e===t.activeElement&&(!t.hasFocus||t.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},active:function(e){return e===e.ownerDocument.activeElement},first:st(function(){return[0]}),last:st(function(e,t){return[t-1]}),eq:st(function(e,t,n){return[n<0?n+t:n]}),even:st(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:st(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:st(function(e,t,n){for(var r=n<0?n+t:n;--r>=0;)e.push(r);return e}),gt:st(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}},f=y.compareDocumentPosition?function(e,t){return e===t?(l=!0,0):(!e.compareDocumentPosition||!t.compareDocumentPosition?e.compareDocumentPosition:e.compareDocumentPosition(t)&4)?-1:1}:function(e,t){if(e===t)return l=!0,0;if(e.sourceIndex&&t.sourceIndex)return e.sourceIndex-t.sourceIndex;var n,r,i=[],s=[],o=e.parentNode,u=t.parentNode,a=o;if(o===u)return ot(e,t);if(!o)return-1;if(!u)return 1;while(a)i.unshift(a),a=a.parentNode;a=u;while(a)s.unshift(a),a=a.parentNode;n=i.length,r=s.length;for(var f=0;f<n&&f<r;f++)if(i[f]!==s[f])return ot(i[f],s[f]);return f===n?ot(e,s[f],-1):ot(i[f],t,1)},[0,0].sort(f),h=!l,nt.uniqueSort=function(e){var t,n=[],r=1,i=0;l=h,e.sort(f);if(l){for(;t=e[r];r++)t===e[r-1]&&(i=n.push(r));while(i--)e.splice(n[i],1)}return e},nt.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},a=nt.compile=function(e,t){var n,r=[],i=[],s=A[d][e+" "];if(!s){t||(t=ut(e)),n=t.length;while(n--)s=ht(t[n]),s[d]?r.push(s):i.push(s);s=A(e,pt(i,r))}return s},g.querySelectorAll&&function(){var e,t=vt,n=/'|\\/g,r=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,i=[":focus"],s=[":active"],u=y.matchesSelector||y.mozMatchesSelector||y.webkitMatchesSelector||y.oMatchesSelector||y.msMatchesSelector;K(function(e){e.innerHTML="<select><option selected=''></option></select>",e.querySelectorAll("[selected]").length||i.push("\\["+O+"*(?:checked|disabled|ismap|multiple|readonly|selected|value)"),e.querySelectorAll(":checked").length||i.push(":checked")}),K(function(e){e.innerHTML="<p test=''></p>",e.querySelectorAll("[test^='']").length&&i.push("[*^$]="+O+"*(?:\"\"|'')"),e.innerHTML="<input type='hidden'/>",e.querySelectorAll(":enabled").length||i.push(":enabled",":disabled")}),i=new RegExp(i.join("|")),vt=function(e,r,s,o,u){if(!o&&!u&&!i.test(e)){var a,f,l=!0,c=d,h=r,p=r.nodeType===9&&e;if(r.nodeType===1&&r.nodeName.toLowerCase()!=="object"){a=ut(e),(l=r.getAttribute("id"))?c=l.replace(n,"\\$&"):r.setAttribute("id",c),c="[id='"+c+"'] ",f=a.length;while(f--)a[f]=c+a[f].join("");h=z.test(e)&&r.parentNode||r,p=a.join(",")}if(p)try{return S.apply(s,x.call(h.querySelectorAll(p),0)),s}catch(v){}finally{l||r.removeAttribute("id")}}return t(e,r,s,o,u)},u&&(K(function(t){e=u.call(t,"div");try{u.call(t,"[test!='']:sizzle"),s.push("!=",H)}catch(n){}}),s=new RegExp(s.join("|")),nt.matchesSelector=function(t,n){n=n.replace(r,"='$1']");if(!o(t)&&!s.test(n)&&!i.test(n))try{var a=u.call(t,n);if(a||e||t.document&&t.document.nodeType!==11)return a}catch(f){}return nt(n,null,null,[t]).length>0})}(),i.pseudos.nth=i.pseudos.eq,i.filters=mt.prototype=i.pseudos,i.setFilters=new mt,nt.attr=v.attr,v.find=nt,v.expr=nt.selectors,v.expr[":"]=v.expr.pseudos,v.unique=nt.uniqueSort,v.text=nt.getText,v.isXMLDoc=nt.isXML,v.contains=nt.contains}(e);var nt=/Until$/,rt=/^(?:parents|prev(?:Until|All))/,it=/^.[^:#\[\.,]*$/,st=v.expr.match.needsContext,ot={children:!0,contents:!0,next:!0,prev:!0};v.fn.extend({find:function(e){var t,n,r,i,s,o,u=this;if(typeof e!="string")return v(e).filter(function(){for(t=0,n=u.length;t<n;t++)if(v.contains(u[t],this))return!0});o=this.pushStack("","find",e);for(t=0,n=this.length;t<n;t++){r=o.length,v.find(e,this[t],o);if(t>0)for(i=r;i<o.length;i++)for(s=0;s<r;s++)if(o[s]===o[i]){o.splice(i--,1);break}}return o},has:function(e){var t,n=v(e,this),r=n.length;return this.filter(function(){for(t=0;t<r;t++)if(v.contains(this,n[t]))return!0})},not:function(e){return this.pushStack(ft(this,e,!1),"not",e)},filter:function(e){return this.pushStack(ft(this,e,!0),"filter",e)},is:function(e){return!!e&&(typeof e=="string"?st.test(e)?v(e,this.context).index(this[0])>=0:v.filter(e,this).length>0:this.filter(e).length>0)},closest:function(e,t){var n,r=0,i=this.length,s=[],o=st.test(e)||typeof e!="string"?v(e,t||this.context):0;for(;r<i;r++){n=this[r];while(n&&n.ownerDocument&&n!==t&&n.nodeType!==11){if(o?o.index(n)>-1:v.find.matchesSelector(n,e)){s.push(n);break}n=n.parentNode}}return s=s.length>1?v.unique(s):s,this.pushStack(s,"closest",e)},index:function(e){return e?typeof e=="string"?v.inArray(this[0],v(e)):v.inArray(e.jquery?e[0]:e,this):this[0]&&this[0].parentNode?this.prevAll().length:-1},add:function(e,t){var n=typeof e=="string"?v(e,t):v.makeArray(e&&e.nodeType?[e]:e),r=v.merge(this.get(),n);return this.pushStack(ut(n[0])||ut(r[0])?r:v.unique(r))},addBack:function(e){return this.add(e==null?this.prevObject:this.prevObject.filter(e))}}),v.fn.andSelf=v.fn.addBack,v.each({parent:function(e){var t=e.parentNode;return t&&t.nodeType!==11?t:null},parents:function(e){return v.dir(e,"parentNode")},parentsUntil:function(e,t,n){return v.dir(e,"parentNode",n)},next:function(e){return at(e,"nextSibling")},prev:function(e){return at(e,"previousSibling")},nextAll:function(e){return v.dir(e,"nextSibling")},prevAll:function(e){return v.dir(e,"previousSibling")},nextUntil:function(e,t,n){return v.dir(e,"nextSibling",n)},prevUntil:function(e,t,n){return v.dir(e,"previousSibling",n)},siblings:function(e){return v.sibling((e.parentNode||{}).firstChild,e)},children:function(e){return v.sibling(e.firstChild)},contents:function(e){return v.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:v.merge([],e.childNodes)}},function(e,t){v.fn[e]=function(n,r){var i=v.map(this,t,n);return nt.test(e)||(r=n),r&&typeof r=="string"&&(i=v.filter(r,i)),i=this.length>1&&!ot[e]?v.unique(i):i,this.length>1&&rt.test(e)&&(i=i.reverse()),this.pushStack(i,e,l.call(arguments).join(","))}}),v.extend({filter:function(e,t,n){return n&&(e=":not("+e+")"),t.length===1?v.find.matchesSelector(t[0],e)?[t[0]]:[]:v.find.matches(e,t)},dir:function(e,n,r){var i=[],s=e[n];while(s&&s.nodeType!==9&&(r===t||s.nodeType!==1||!v(s).is(r)))s.nodeType===1&&i.push(s),s=s[n];return i},sibling:function(e,t){var n=[];for(;e;e=e.nextSibling)e.nodeType===1&&e!==t&&n.push(e);return n}});var ct="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",ht=/ jQuery\d+="(?:null|\d+)"/g,pt=/^\s+/,dt=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,vt=/<([\w:]+)/,mt=/<tbody/i,gt=/<|&#?\w+;/,yt=/<(?:script|style|link)/i,bt=/<(?:script|object|embed|option|style)/i,wt=new RegExp("<(?:"+ct+")[\\s/>]","i"),Et=/^(?:checkbox|radio)$/,St=/checked\s*(?:[^=]|=\s*.checked.)/i,xt=/\/(java|ecma)script/i,Tt=/^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,Nt={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},Ct=lt(i),kt=Ct.appendChild(i.createElement("div"));Nt.optgroup=Nt.option,Nt.tbody=Nt.tfoot=Nt.colgroup=Nt.caption=Nt.thead,Nt.th=Nt.td,v.support.htmlSerialize||(Nt._default=[1,"X<div>","</div>"]),v.fn.extend({text:function(e){return v.access(this,function(e){return e===t?v.text(this):this.empty().append((this[0]&&this[0].ownerDocument||i).createTextNode(e))},null,e,arguments.length)},wrapAll:function(e){if(v.isFunction(e))return this.each(function(t){v(this).wrapAll(e.call(this,t))});if(this[0]){var t=v(e,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstChild&&e.firstChild.nodeType===1)e=e.firstChild;return e}).append(this)}return this},wrapInner:function(e){return v.isFunction(e)?this.each(function(t){v(this).wrapInner(e.call(this,t))}):this.each(function(){var t=v(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=v.isFunction(e);return this.each(function(n){v(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(){return this.parent().each(function(){v.nodeName(this,"body")||v(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(e){(this.nodeType===1||this.nodeType===11)&&this.appendChild(e)})},prepend:function(){return this.domManip(arguments,!0,function(e){(this.nodeType===1||this.nodeType===11)&&this.insertBefore(e,this.firstChild)})},before:function(){if(!ut(this[0]))return this.domManip(arguments,!1,function(e){this.parentNode.insertBefore(e,this)});if(arguments.length){var e=v.clean(arguments);return this.pushStack(v.merge(e,this),"before",this.selector)}},after:function(){if(!ut(this[0]))return this.domManip(arguments,!1,function(e){this.parentNode.insertBefore(e,this.nextSibling)});if(arguments.length){var e=v.clean(arguments);return this.pushStack(v.merge(this,e),"after",this.selector)}},remove:function(e,t){var n,r=0;for(;(n=this[r])!=null;r++)if(!e||v.filter(e,[n]).length)!t&&n.nodeType===1&&(v.cleanData(n.getElementsByTagName("*")),v.cleanData([n])),n.parentNode&&n.parentNode.removeChild(n);return this},empty:function(){var e,t=0;for(;(e=this[t])!=null;t++){e.nodeType===1&&v.cleanData(e.getElementsByTagName("*"));while(e.firstChild)e.removeChild(e.firstChild)}return this},clone:function(e,t){return e=e==null?!1:e,t=t==null?e:t,this.map(function(){return v.clone(this,e,t)})},html:function(e){return v.access(this,function(e){var n=this[0]||{},r=0,i=this.length;if(e===t)return n.nodeType===1?n.innerHTML.replace(ht,""):t;if(typeof e=="string"&&!yt.test(e)&&(v.support.htmlSerialize||!wt.test(e))&&(v.support.leadingWhitespace||!pt.test(e))&&!Nt[(vt.exec(e)||["",""])[1].toLowerCase()]){e=e.replace(dt,"<$1></$2>");try{for(;r<i;r++)n=this[r]||{},n.nodeType===1&&(v.cleanData(n.getElementsByTagName("*")),n.innerHTML=e);n=0}catch(s){}}n&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(e){return ut(this[0])?this.length?this.pushStack(v(v.isFunction(e)?e():e),"replaceWith",e):this:v.isFunction(e)?this.each(function(t){var n=v(this),r=n.html();n.replaceWith(e.call(this,t,r))}):(typeof e!="string"&&(e=v(e).detach()),this.each(function(){var t=this.nextSibling,n=this.parentNode;v(this).remove(),t?v(t).before(e):v(n).append(e)}))},detach:function(e){return this.remove(e,!0)},domManip:function(e,n,r){e=[].concat.apply([],e);var i,s,o,u,a=0,f=e[0],l=[],c=this.length;if(!v.support.checkClone&&c>1&&typeof f=="string"&&St.test(f))return this.each(function(){v(this).domManip(e,n,r)});if(v.isFunction(f))return this.each(function(i){var s=v(this);e[0]=f.call(this,i,n?s.html():t),s.domManip(e,n,r)});if(this[0]){i=v.buildFragment(e,this,l),o=i.fragment,s=o.firstChild,o.childNodes.length===1&&(o=s);if(s){n=n&&v.nodeName(s,"tr");for(u=i.cacheable||c-1;a<c;a++)r.call(n&&v.nodeName(this[a],"table")?Lt(this[a],"tbody"):this[a],a===u?o:v.clone(o,!0,!0))}o=s=null,l.length&&v.each(l,function(e,t){t.src?v.ajax?v.ajax({url:t.src,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0}):v.error("no ajax"):v.globalEval((t.text||t.textContent||t.innerHTML||"").replace(Tt,"")),t.parentNode&&t.parentNode.removeChild(t)})}return this}}),v.buildFragment=function(e,n,r){var s,o,u,a=e[0];return n=n||i,n=!n.nodeType&&n[0]||n,n=n.ownerDocument||n,e.length===1&&typeof a=="string"&&a.length<512&&n===i&&a.charAt(0)==="<"&&!bt.test(a)&&(v.support.checkClone||!St.test(a))&&(v.support.html5Clone||!wt.test(a))&&(o=!0,s=v.fragments[a],u=s!==t),s||(s=n.createDocumentFragment(),v.clean(e,n,s,r),o&&(v.fragments[a]=u&&s)),{fragment:s,cacheable:o}},v.fragments={},v.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,t){v.fn[e]=function(n){var r,i=0,s=[],o=v(n),u=o.length,a=this.length===1&&this[0].parentNode;if((a==null||a&&a.nodeType===11&&a.childNodes.length===1)&&u===1)return o[t](this[0]),this;for(;i<u;i++)r=(i>0?this.clone(!0):this).get(),v(o[i])[t](r),s=s.concat(r);return this.pushStack(s,e,o.selector)}}),v.extend({clone:function(e,t,n){var r,i,s,o;v.support.html5Clone||v.isXMLDoc(e)||!wt.test("<"+e.nodeName+">")?o=e.cloneNode(!0):(kt.innerHTML=e.outerHTML,kt.removeChild(o=kt.firstChild));if((!v.support.noCloneEvent||!v.support.noCloneChecked)&&(e.nodeType===1||e.nodeType===11)&&!v.isXMLDoc(e)){Ot(e,o),r=Mt(e),i=Mt(o);for(s=0;r[s];++s)i[s]&&Ot(r[s],i[s])}if(t){At(e,o);if(n){r=Mt(e),i=Mt(o);for(s=0;r[s];++s)At(r[s],i[s])}}return r=i=null,o},clean:function(e,t,n,r){var s,o,u,a,f,l,c,h,p,d,m,g,y=t===i&&Ct,b=[];if(!t||typeof t.createDocumentFragment=="undefined")t=i;for(s=0;(u=e[s])!=null;s++){typeof u=="number"&&(u+="");if(!u)continue;if(typeof u=="string")if(!gt.test(u))u=t.createTextNode(u);else{y=y||lt(t),c=t.createElement("div"),y.appendChild(c),u=u.replace(dt,"<$1></$2>"),a=(vt.exec(u)||["",""])[1].toLowerCase(),f=Nt[a]||Nt._default,l=f[0],c.innerHTML=f[1]+u+f[2];while(l--)c=c.lastChild;if(!v.support.tbody){h=mt.test(u),p=a==="table"&&!h?c.firstChild&&c.firstChild.childNodes:f[1]==="<table>"&&!h?c.childNodes:[];for(o=p.length-1;o>=0;--o)v.nodeName(p[o],"tbody")&&!p[o].childNodes.length&&p[o].parentNode.removeChild(p[o])}!v.support.leadingWhitespace&&pt.test(u)&&c.insertBefore(t.createTextNode(pt.exec(u)[0]),c.firstChild),u=c.childNodes,c.parentNode.removeChild(c)}u.nodeType?b.push(u):v.merge(b,u)}c&&(u=c=y=null);if(!v.support.appendChecked)for(s=0;(u=b[s])!=null;s++)v.nodeName(u,"input")?_t(u):typeof u.getElementsByTagName!="undefined"&&v.grep(u.getElementsByTagName("input"),_t);if(n){m=function(e){if(!e.type||xt.test(e.type))return r?r.push(e.parentNode?e.parentNode.removeChild(e):e):n.appendChild(e)};for(s=0;(u=b[s])!=null;s++)if(!v.nodeName(u,"script")||!m(u))n.appendChild(u),typeof u.getElementsByTagName!="undefined"&&(g=v.grep(v.merge([],u.getElementsByTagName("script")),m),b.splice.apply(b,[s+1,0].concat(g)),s+=g.length)}return b},cleanData:function(e,t){var n,r,i,s,o=0,u=v.expando,a=v.cache,f=v.support.deleteExpando,l=v.event.special;for(;(i=e[o])!=null;o++)if(t||v.acceptData(i)){r=i[u],n=r&&a[r];if(n){if(n.events)for(s in n.events)l[s]?v.event.remove(i,s):v.removeEvent(i,s,n.handle);a[r]&&(delete a[r],f?delete i[u]:i.removeAttribute?i.removeAttribute(u):i[u]=null,v.deletedIds.push(r))}}}}),function(){var e,t;v.uaMatch=function(e){e=e.toLowerCase();var t=/(chrome)[ \/]([\w.]+)/.exec(e)||/(webkit)[ \/]([\w.]+)/.exec(e)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(e)||/(msie) ([\w.]+)/.exec(e)||e.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(e)||[];return{browser:t[1]||"",version:t[2]||"0"}},e=v.uaMatch(o.userAgent),t={},e.browser&&(t[e.browser]=!0,t.version=e.version),t.chrome?t.webkit=!0:t.webkit&&(t.safari=!0),v.browser=t,v.sub=function(){function e(t,n){return new e.fn.init(t,n)}v.extend(!0,e,this),e.superclass=this,e.fn=e.prototype=this(),e.fn.constructor=e,e.sub=this.sub,e.fn.init=function(r,i){return i&&i instanceof v&&!(i instanceof e)&&(i=e(i)),v.fn.init.call(this,r,i,t)},e.fn.init.prototype=e.fn;var t=e(i);return e}}();var Dt,Pt,Ht,Bt=/alpha\([^)]*\)/i,jt=/opacity=([^)]*)/,Ft=/^(top|right|bottom|left)$/,It=/^(none|table(?!-c[ea]).+)/,qt=/^margin/,Rt=new RegExp("^("+m+")(.*)$","i"),Ut=new RegExp("^("+m+")(?!px)[a-z%]+$","i"),zt=new RegExp("^([-+])=("+m+")","i"),Wt={BODY:"block"},Xt={position:"absolute",visibility:"hidden",display:"block"},Vt={letterSpacing:0,fontWeight:400},$t=["Top","Right","Bottom","Left"],Jt=["Webkit","O","Moz","ms"],Kt=v.fn.toggle;v.fn.extend({css:function(e,n){return v.access(this,function(e,n,r){return r!==t?v.style(e,n,r):v.css(e,n)},e,n,arguments.length>1)},show:function(){return Yt(this,!0)},hide:function(){return Yt(this)},toggle:function(e,t){var n=typeof e=="boolean";return v.isFunction(e)&&v.isFunction(t)?Kt.apply(this,arguments):this.each(function(){(n?e:Gt(this))?v(this).show():v(this).hide()})}}),v.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Dt(e,"opacity");return n===""?"1":n}}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":v.support.cssFloat?"cssFloat":"styleFloat"},style:function(e,n,r,i){if(!e||e.nodeType===3||e.nodeType===8||!e.style)return;var s,o,u,a=v.camelCase(n),f=e.style;n=v.cssProps[a]||(v.cssProps[a]=Qt(f,a)),u=v.cssHooks[n]||v.cssHooks[a];if(r===t)return u&&"get"in u&&(s=u.get(e,!1,i))!==t?s:f[n];o=typeof r,o==="string"&&(s=zt.exec(r))&&(r=(s[1]+1)*s[2]+parseFloat(v.css(e,n)),o="number");if(r==null||o==="number"&&isNaN(r))return;o==="number"&&!v.cssNumber[a]&&(r+="px");if(!u||!("set"in u)||(r=u.set(e,r,i))!==t)try{f[n]=r}catch(l){}},css:function(e,n,r,i){var s,o,u,a=v.camelCase(n);return n=v.cssProps[a]||(v.cssProps[a]=Qt(e.style,a)),u=v.cssHooks[n]||v.cssHooks[a],u&&"get"in u&&(s=u.get(e,!0,i)),s===t&&(s=Dt(e,n)),s==="normal"&&n in Vt&&(s=Vt[n]),r||i!==t?(o=parseFloat(s),r||v.isNumeric(o)?o||0:s):s},swap:function(e,t,n){var r,i,s={};for(i in t)s[i]=e.style[i],e.style[i]=t[i];r=n.call(e);for(i in t)e.style[i]=s[i];return r}}),e.getComputedStyle?Dt=function(t,n){var r,i,s,o,u=e.getComputedStyle(t,null),a=t.style;return u&&(r=u.getPropertyValue(n)||u[n],r===""&&!v.contains(t.ownerDocument,t)&&(r=v.style(t,n)),Ut.test(r)&&qt.test(n)&&(i=a.width,s=a.minWidth,o=a.maxWidth,a.minWidth=a.maxWidth=a.width=r,r=u.width,a.width=i,a.minWidth=s,a.maxWidth=o)),r}:i.documentElement.currentStyle&&(Dt=function(e,t){var n,r,i=e.currentStyle&&e.currentStyle[t],s=e.style;return i==null&&s&&s[t]&&(i=s[t]),Ut.test(i)&&!Ft.test(t)&&(n=s.left,r=e.runtimeStyle&&e.runtimeStyle.left,r&&(e.runtimeStyle.left=e.currentStyle.left),s.left=t==="fontSize"?"1em":i,i=s.pixelLeft+"px",s.left=n,r&&(e.runtimeStyle.left=r)),i===""?"auto":i}),v.each(["height","width"],function(e,t){v.cssHooks[t]={get:function(e,n,r){if(n)return e.offsetWidth===0&&It.test(Dt(e,"display"))?v.swap(e,Xt,function(){return tn(e,t,r)}):tn(e,t,r)},set:function(e,n,r){return Zt(e,n,r?en(e,t,r,v.support.boxSizing&&v.css(e,"boxSizing")==="border-box"):0)}}}),v.support.opacity||(v.cssHooks.opacity={get:function(e,t){return jt.test((t&&e.currentStyle?e.currentStyle.filter:e.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":t?"1":""},set:function(e,t){var n=e.style,r=e.currentStyle,i=v.isNumeric(t)?"alpha(opacity="+t*100+")":"",s=r&&r.filter||n.filter||"";n.zoom=1;if(t>=1&&v.trim(s.replace(Bt,""))===""&&n.removeAttribute){n.removeAttribute("filter");if(r&&!r.filter)return}n.filter=Bt.test(s)?s.replace(Bt,i):s+" "+i}}),v(function(){v.support.reliableMarginRight||(v.cssHooks.marginRight={get:function(e,t){return v.swap(e,{display:"inline-block"},function(){if(t)return Dt(e,"marginRight")})}}),!v.support.pixelPosition&&v.fn.position&&v.each(["top","left"],function(e,t){v.cssHooks[t]={get:function(e,n){if(n){var r=Dt(e,t);return Ut.test(r)?v(e).position()[t]+"px":r}}}})}),v.expr&&v.expr.filters&&(v.expr.filters.hidden=function(e){return e.offsetWidth===0&&e.offsetHeight===0||!v.support.reliableHiddenOffsets&&(e.style&&e.style.display||Dt(e,"display"))==="none"},v.expr.filters.visible=function(e){return!v.expr.filters.hidden(e)}),v.each({margin:"",padding:"",border:"Width"},function(e,t){v.cssHooks[e+t]={expand:function(n){var r,i=typeof n=="string"?n.split(" "):[n],s={};for(r=0;r<4;r++)s[e+$t[r]+t]=i[r]||i[r-2]||i[0];return s}},qt.test(e)||(v.cssHooks[e+t].set=Zt)});var rn=/%20/g,sn=/\[\]$/,on=/\r?\n/g,un=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,an=/^(?:select|textarea)/i;v.fn.extend({serialize:function(){return v.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?v.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||an.test(this.nodeName)||un.test(this.type))}).map(function(e,t){var n=v(this).val();return n==null?null:v.isArray(n)?v.map(n,function(e,n){return{name:t.name,value:e.replace(on,"\r\n")}}):{name:t.name,value:n.replace(on,"\r\n")}}).get()}}),v.param=function(e,n){var r,i=[],s=function(e,t){t=v.isFunction(t)?t():t==null?"":t,i[i.length]=encodeURIComponent(e)+"="+encodeURIComponent(t)};n===t&&(n=v.ajaxSettings&&v.ajaxSettings.traditional);if(v.isArray(e)||e.jquery&&!v.isPlainObject(e))v.each(e,function(){s(this.name,this.value)});else for(r in e)fn(r,e[r],n,s);return i.join("&").replace(rn,"+")};var ln,cn,hn=/#.*$/,pn=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,dn=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,vn=/^(?:GET|HEAD)$/,mn=/^\/\//,gn=/\?/,yn=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,bn=/([?&])_=[^&]*/,wn=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,En=v.fn.load,Sn={},xn={},Tn=["*/"]+["*"];try{cn=s.href}catch(Nn){cn=i.createElement("a"),cn.href="",cn=cn.href}ln=wn.exec(cn.toLowerCase())||[],v.fn.load=function(e,n,r){if(typeof e!="string"&&En)return En.apply(this,arguments);if(!this.length)return this;var i,s,o,u=this,a=e.indexOf(" ");return a>=0&&(i=e.slice(a,e.length),e=e.slice(0,a)),v.isFunction(n)?(r=n,n=t):n&&typeof n=="object"&&(s="POST"),v.ajax({url:e,type:s,dataType:"html",data:n,complete:function(e,t){r&&u.each(r,o||[e.responseText,t,e])}}).done(function(e){o=arguments,u.html(i?v("<div>").append(e.replace(yn,"")).find(i):e)}),this},v.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(e,t){v.fn[t]=function(e){return this.on(t,e)}}),v.each(["get","post"],function(e,n){v[n]=function(e,r,i,s){return v.isFunction(r)&&(s=s||i,i=r,r=t),v.ajax({type:n,url:e,data:r,success:i,dataType:s})}}),v.extend({getScript:function(e,n){return v.get(e,t,n,"script")},getJSON:function(e,t,n){return v.get(e,t,n,"json")},ajaxSetup:function(e,t){return t?Ln(e,v.ajaxSettings):(t=e,e=v.ajaxSettings),Ln(e,t),e},ajaxSettings:{url:cn,isLocal:dn.test(ln[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":Tn},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":e.String,"text html":!0,"text json":v.parseJSON,"text xml":v.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:Cn(Sn),ajaxTransport:Cn(xn),ajax:function(e,n){function T(e,n,s,a){var l,y,b,w,S,T=n;if(E===2)return;E=2,u&&clearTimeout(u),o=t,i=a||"",x.readyState=e>0?4:0,s&&(w=An(c,x,s));if(e>=200&&e<300||e===304)c.ifModified&&(S=x.getResponseHeader("Last-Modified"),S&&(v.lastModified[r]=S),S=x.getResponseHeader("Etag"),S&&(v.etag[r]=S)),e===304?(T="notmodified",l=!0):(l=On(c,w),T=l.state,y=l.data,b=l.error,l=!b);else{b=T;if(!T||e)T="error",e<0&&(e=0)}x.status=e,x.statusText=(n||T)+"",l?d.resolveWith(h,[y,T,x]):d.rejectWith(h,[x,T,b]),x.statusCode(g),g=t,f&&p.trigger("ajax"+(l?"Success":"Error"),[x,c,l?y:b]),m.fireWith(h,[x,T]),f&&(p.trigger("ajaxComplete",[x,c]),--v.active||v.event.trigger("ajaxStop"))}typeof e=="object"&&(n=e,e=t),n=n||{};var r,i,s,o,u,a,f,l,c=v.ajaxSetup({},n),h=c.context||c,p=h!==c&&(h.nodeType||h instanceof v)?v(h):v.event,d=v.Deferred(),m=v.Callbacks("once memory"),g=c.statusCode||{},b={},w={},E=0,S="canceled",x={readyState:0,setRequestHeader:function(e,t){if(!E){var n=e.toLowerCase();e=w[n]=w[n]||e,b[e]=t}return this},getAllResponseHeaders:function(){return E===2?i:null},getResponseHeader:function(e){var n;if(E===2){if(!s){s={};while(n=pn.exec(i))s[n[1].toLowerCase()]=n[2]}n=s[e.toLowerCase()]}return n===t?null:n},overrideMimeType:function(e){return E||(c.mimeType=e),this},abort:function(e){return e=e||S,o&&o.abort(e),T(0,e),this}};d.promise(x),x.success=x.done,x.error=x.fail,x.complete=m.add,x.statusCode=function(e){if(e){var t;if(E<2)for(t in e)g[t]=[g[t],e[t]];else t=e[x.status],x.always(t)}return this},c.url=((e||c.url)+"").replace(hn,"").replace(mn,ln[1]+"//"),c.dataTypes=v.trim(c.dataType||"*").toLowerCase().split(y),c.crossDomain==null&&(a=wn.exec(c.url.toLowerCase()),c.crossDomain=!(!a||a[1]===ln[1]&&a[2]===ln[2]&&(a[3]||(a[1]==="http:"?80:443))==(ln[3]||(ln[1]==="http:"?80:443)))),c.data&&c.processData&&typeof c.data!="string"&&(c.data=v.param(c.data,c.traditional)),kn(Sn,c,n,x);if(E===2)return x;f=c.global,c.type=c.type.toUpperCase(),c.hasContent=!vn.test(c.type),f&&v.active++===0&&v.event.trigger("ajaxStart");if(!c.hasContent){c.data&&(c.url+=(gn.test(c.url)?"&":"?")+c.data,delete c.data),r=c.url;if(c.cache===!1){var N=v.now(),C=c.url.replace(bn,"$1_="+N);c.url=C+(C===c.url?(gn.test(c.url)?"&":"?")+"_="+N:"")}}(c.data&&c.hasContent&&c.contentType!==!1||n.contentType)&&x.setRequestHeader("Content-Type",c.contentType),c.ifModified&&(r=r||c.url,v.lastModified[r]&&x.setRequestHeader("If-Modified-Since",v.lastModified[r]),v.etag[r]&&x.setRequestHeader("If-None-Match",v.etag[r])),x.setRequestHeader("Accept",c.dataTypes[0]&&c.accepts[c.dataTypes[0]]?c.accepts[c.dataTypes[0]]+(c.dataTypes[0]!=="*"?", "+Tn+"; q=0.01":""):c.accepts["*"]);for(l in c.headers)x.setRequestHeader(l,c.headers[l]);if(!c.beforeSend||c.beforeSend.call(h,x,c)!==!1&&E!==2){S="abort";for(l in{success:1,error:1,complete:1})x[l](c[l]);o=kn(xn,c,n,x);if(!o)T(-1,"No Transport");else{x.readyState=1,f&&p.trigger("ajaxSend",[x,c]),c.async&&c.timeout>0&&(u=setTimeout(function(){x.abort("timeout")},c.timeout));try{E=1,o.send(b,T)}catch(k){if(!(E<2))throw k;T(-1,k)}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var Mn=[],_n=/\?/,Dn=/(=)\?(?=&|$)|\?\?/,Pn=v.now();v.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Mn.pop()||v.expando+"_"+Pn++;return this[e]=!0,e}}),v.ajaxPrefilter("json jsonp",function(n,r,i){var s,o,u,a=n.data,f=n.url,l=n.jsonp!==!1,c=l&&Dn.test(f),h=l&&!c&&typeof a=="string"&&!(n.contentType||"").indexOf("application/x-www-form-urlencoded")&&Dn.test(a);if(n.dataTypes[0]==="jsonp"||c||h)return s=n.jsonpCallback=v.isFunction(n.jsonpCallback)?n.jsonpCallback():n.jsonpCallback,o=e[s],c?n.url=f.replace(Dn,"$1"+s):h?n.data=a.replace(Dn,"$1"+s):l&&(n.url+=(_n.test(f)?"&":"?")+n.jsonp+"="+s),n.converters["script json"]=function(){return u||v.error(s+" was not called"),u[0]},n.dataTypes[0]="json",e[s]=function(){u=arguments},i.always(function(){e[s]=o,n[s]&&(n.jsonpCallback=r.jsonpCallback,Mn.push(s)),u&&v.isFunction(o)&&o(u[0]),u=o=t}),"script"}),v.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(e){return v.globalEval(e),e}}}),v.ajaxPrefilter("script",function(e){e.cache===t&&(e.cache=!1),e.crossDomain&&(e.type="GET",e.global=!1)}),v.ajaxTransport("script",function(e){if(e.crossDomain){var n,r=i.head||i.getElementsByTagName("head")[0]||i.documentElement;return{send:function(s,o){n=i.createElement("script"),n.async="async",e.scriptCharset&&(n.charset=e.scriptCharset),n.src=e.url,n.onload=n.onreadystatechange=function(e,i){if(i||!n.readyState||/loaded|complete/.test(n.readyState))n.onload=n.onreadystatechange=null,r&&n.parentNode&&r.removeChild(n),n=t,i||o(200,"success")},r.insertBefore(n,r.firstChild)},abort:function(){n&&n.onload(0,1)}}}});var Hn,Bn=e.ActiveXObject?function(){for(var e in Hn)Hn[e](0,1)}:!1,jn=0;v.ajaxSettings.xhr=e.ActiveXObject?function(){return!this.isLocal&&Fn()||In()}:Fn,function(e){v.extend(v.support,{ajax:!!e,cors:!!e&&"withCredentials"in e})}(v.ajaxSettings.xhr()),v.support.ajax&&v.ajaxTransport(function(n){if(!n.crossDomain||v.support.cors){var r;return{send:function(i,s){var o,u,a=n.xhr();n.username?a.open(n.type,n.url,n.async,n.username,n.password):a.open(n.type,n.url,n.async);if(n.xhrFields)for(u in n.xhrFields)a[u]=n.xhrFields[u];n.mimeType&&a.overrideMimeType&&a.overrideMimeType(n.mimeType),!n.crossDomain&&!i["X-Requested-With"]&&(i["X-Requested-With"]="XMLHttpRequest");try{for(u in i)a.setRequestHeader(u,i[u])}catch(f){}a.send(n.hasContent&&n.data||null),r=function(e,i){var u,f,l,c,h;try{if(r&&(i||a.readyState===4)){r=t,o&&(a.onreadystatechange=v.noop,Bn&&delete Hn[o]);if(i)a.readyState!==4&&a.abort();else{u=a.status,l=a.getAllResponseHeaders(),c={},h=a.responseXML,h&&h.documentElement&&(c.xml=h);try{c.text=a.responseText}catch(p){}try{f=a.statusText}catch(p){f=""}!u&&n.isLocal&&!n.crossDomain?u=c.text?200:404:u===1223&&(u=204)}}}catch(d){i||s(-1,d)}c&&s(u,f,c,l)},n.async?a.readyState===4?setTimeout(r,0):(o=++jn,Bn&&(Hn||(Hn={},v(e).unload(Bn)),Hn[o]=r),a.onreadystatechange=r):r()},abort:function(){r&&r(0,1)}}}});var qn,Rn,Un=/^(?:toggle|show|hide)$/,zn=new RegExp("^(?:([-+])=|)("+m+")([a-z%]*)$","i"),Wn=/queueHooks$/,Xn=[Gn],Vn={"*":[function(e,t){var n,r,i=this.createTween(e,t),s=zn.exec(t),o=i.cur(),u=+o||0,a=1,f=20;if(s){n=+s[2],r=s[3]||(v.cssNumber[e]?"":"px");if(r!=="px"&&u){u=v.css(i.elem,e,!0)||n||1;do a=a||".5",u/=a,v.style(i.elem,e,u+r);while(a!==(a=i.cur()/o)&&a!==1&&--f)}i.unit=r,i.start=u,i.end=s[1]?u+(s[1]+1)*n:n}return i}]};v.Animation=v.extend(Kn,{tweener:function(e,t){v.isFunction(e)?(t=e,e=["*"]):e=e.split(" ");var n,r=0,i=e.length;for(;r<i;r++)n=e[r],Vn[n]=Vn[n]||[],Vn[n].unshift(t)},prefilter:function(e,t){t?Xn.unshift(e):Xn.push(e)}}),v.Tween=Yn,Yn.prototype={constructor:Yn,init:function(e,t,n,r,i,s){this.elem=e,this.prop=n,this.easing=i||"swing",this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=s||(v.cssNumber[n]?"":"px")},cur:function(){var e=Yn.propHooks[this.prop];return e&&e.get?e.get(this):Yn.propHooks._default.get(this)},run:function(e){var t,n=Yn.propHooks[this.prop];return this.options.duration?this.pos=t=v.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Yn.propHooks._default.set(this),this}},Yn.prototype.init.prototype=Yn.prototype,Yn.propHooks={_default:{get:function(e){var t;return e.elem[e.prop]==null||!!e.elem.style&&e.elem.style[e.prop]!=null?(t=v.css(e.elem,e.prop,!1,""),!t||t==="auto"?0:t):e.elem[e.prop]},set:function(e){v.fx.step[e.prop]?v.fx.step[e.prop](e):e.elem.style&&(e.elem.style[v.cssProps[e.prop]]!=null||v.cssHooks[e.prop])?v.style(e.elem,e.prop,e.now+e.unit):e.elem[e.prop]=e.now}}},Yn.propHooks.scrollTop=Yn.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},v.each(["toggle","show","hide"],function(e,t){var n=v.fn[t];v.fn[t]=function(r,i,s){return r==null||typeof r=="boolean"||!e&&v.isFunction(r)&&v.isFunction(i)?n.apply(this,arguments):this.animate(Zn(t,!0),r,i,s)}}),v.fn.extend({fadeTo:function(e,t,n,r){return this.filter(Gt).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=v.isEmptyObject(e),s=v.speed(t,n,r),o=function(){var t=Kn(this,v.extend({},e),s);i&&t.stop(!0)};return i||s.queue===!1?this.each(o):this.queue(s.queue,o)},stop:function(e,n,r){var i=function(e){var t=e.stop;delete e.stop,t(r)};return typeof e!="string"&&(r=n,n=e,e=t),n&&e!==!1&&this.queue(e||"fx",[]),this.each(function(){var t=!0,n=e!=null&&e+"queueHooks",s=v.timers,o=v._data(this);if(n)o[n]&&o[n].stop&&i(o[n]);else for(n in o)o[n]&&o[n].stop&&Wn.test(n)&&i(o[n]);for(n=s.length;n--;)s[n].elem===this&&(e==null||s[n].queue===e)&&(s[n].anim.stop(r),t=!1,s.splice(n,1));(t||!r)&&v.dequeue(this,e)})}}),v.each({slideDown:Zn("show"),slideUp:Zn("hide"),slideToggle:Zn("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,t){v.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}}),v.speed=function(e,t,n){var r=e&&typeof e=="object"?v.extend({},e):{complete:n||!n&&t||v.isFunction(e)&&e,duration:e,easing:n&&t||t&&!v.isFunction(t)&&t};r.duration=v.fx.off?0:typeof r.duration=="number"?r.duration:r.duration in v.fx.speeds?v.fx.speeds[r.duration]:v.fx.speeds._default;if(r.queue==null||r.queue===!0)r.queue="fx";return r.old=r.complete,r.complete=function(){v.isFunction(r.old)&&r.old.call(this),r.queue&&v.dequeue(this,r.queue)},r},v.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2}},v.timers=[],v.fx=Yn.prototype.init,v.fx.tick=function(){var e,n=v.timers,r=0;qn=v.now();for(;r<n.length;r++)e=n[r],!e()&&n[r]===e&&n.splice(r--,1);n.length||v.fx.stop(),qn=t},v.fx.timer=function(e){e()&&v.timers.push(e)&&!Rn&&(Rn=setInterval(v.fx.tick,v.fx.interval))},v.fx.interval=13,v.fx.stop=function(){clearInterval(Rn),Rn=null},v.fx.speeds={slow:600,fast:200,_default:400},v.fx.step={},v.expr&&v.expr.filters&&(v.expr.filters.animated=function(e){return v.grep(v.timers,function(t){return e===t.elem}).length});var er=/^(?:body|html)$/i;v.fn.offset=function(e){if(arguments.length)return e===t?this:this.each(function(t){v.offset.setOffset(this,e,t)});var n,r,i,s,o,u,a,f={top:0,left:0},l=this[0],c=l&&l.ownerDocument;if(!c)return;return(r=c.body)===l?v.offset.bodyOffset(l):(n=c.documentElement,v.contains(n,l)?(typeof l.getBoundingClientRect!="undefined"&&(f=l.getBoundingClientRect()),i=tr(c),s=n.clientTop||r.clientTop||0,o=n.clientLeft||r.clientLeft||0,u=i.pageYOffset||n.scrollTop,a=i.pageXOffset||n.scrollLeft,{top:f.top+u-s,left:f.left+a-o}):f)},v.offset={bodyOffset:function(e){var t=e.offsetTop,n=e.offsetLeft;return v.support.doesNotIncludeMarginInBodyOffset&&(t+=parseFloat(v.css(e,"marginTop"))||0,n+=parseFloat(v.css(e,"marginLeft"))||0),{top:t,left:n}},setOffset:function(e,t,n){var r=v.css(e,"position");r==="static"&&(e.style.position="relative");var i=v(e),s=i.offset(),o=v.css(e,"top"),u=v.css(e,"left"),a=(r==="absolute"||r==="fixed")&&v.inArray("auto",[o,u])>-1,f={},l={},c,h;a?(l=i.position(),c=l.top,h=l.left):(c=parseFloat(o)||0,h=parseFloat(u)||0),v.isFunction(t)&&(t=t.call(e,n,s)),t.top!=null&&(f.top=t.top-s.top+c),t.left!=null&&(f.left=t.left-s.left+h),"using"in t?t.using.call(e,f):i.css(f)}},v.fn.extend({position:function(){if(!this[0])return;var e=this[0],t=this.offsetParent(),n=this.offset(),r=er.test(t[0].nodeName)?{top:0,left:0}:t.offset();return n.top-=parseFloat(v.css(e,"marginTop"))||0,n.left-=parseFloat(v.css(e,"marginLeft"))||0,r.top+=parseFloat(v.css(t[0],"borderTopWidth"))||0,r.left+=parseFloat(v.css(t[0],"borderLeftWidth"))||0,{top:n.top-r.top,left:n.left-r.left}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||i.body;while(e&&!er.test(e.nodeName)&&v.css(e,"position")==="static")e=e.offsetParent;return e||i.body})}}),v.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(e,n){var r=/Y/.test(n);v.fn[e]=function(i){return v.access(this,function(e,i,s){var o=tr(e);if(s===t)return o?n in o?o[n]:o.document.documentElement[i]:e[i];o?o.scrollTo(r?v(o).scrollLeft():s,r?s:v(o).scrollTop()):e[i]=s},e,i,arguments.length,null)}}),v.each({Height:"height",Width:"width"},function(e,n){v.each({padding:"inner"+e,content:n,"":"outer"+e},function(r,i){v.fn[i]=function(i,s){var o=arguments.length&&(r||typeof i!="boolean"),u=r||(i===!0||s===!0?"margin":"border");return v.access(this,function(n,r,i){var s;return v.isWindow(n)?n.document.documentElement["client"+e]:n.nodeType===9?(s=n.documentElement,Math.max(n.body["scroll"+e],s["scroll"+e],n.body["offset"+e],s["offset"+e],s["client"+e])):i===t?v.css(n,r,i,u):v.style(n,r,i,u)},n,o?i:t,o,null)}})}),e.jQuery=e.$=v,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return v})})(window);
+/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),j=function(e,t){return e===t&&(l=!0),0},D={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&D.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(j),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(j).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var D,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^([^.]*)(?:\.(.+)|)/;function we(){return!0}function Te(){return!1}function Ce(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ee(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ee(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Te;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Se(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n&&n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,we)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=be.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=be.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click",we),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?we:Te,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Te,isPropagationStopped:Te,isImmediatePropagationStopped:Te,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=we,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=we,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=we,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Se(this,e,Ce),!1},trigger:function(){return Se(this,e),!0},_default:function(){return!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return Ee(this,e,t,n,r)},one:function(e,t,n,r){return Ee(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Te),this.each(function(){S.event.remove(this,e,n,t)})}});var ke=/<script|<style|<link/i,Ae=/checked\s*(?:[^=]|=\s*.checked.)/i,Ne=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function He(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Ae.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),He(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),De)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,qe),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(Ne,""),u,l))}return n}function Oe(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Le(o[r],a[r]);else Le(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Oe(this,e,!0)},remove:function(e){return Oe(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return He(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||je(this,e).appendChild(e)})},prepend:function(){return He(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=je(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!ke.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return He(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Pe=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Re=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Me=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Ie=new RegExp(ne.join("|"),"i");function We(e,t,n){var r,i,o,a,s=e.style;return(n=n||Re(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Pe.test(a)&&Ie.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function Fe(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="border:1px solid",t.style.height="1px",n.style.height="9px",n.style.display="block",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=parseInt(r.height,10)+parseInt(r.borderTopWidth,10)+parseInt(r.borderBottomWidth,10)===t.offsetHeight,re.removeChild(e)),a}}))}();var Be=["Webkit","Moz","ms"],$e=E.createElement("div").style,_e={};function ze(e){var t=S.cssProps[e]||_e[e];return t||(e in $e?e:_e[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Be.length;while(n--)if((e=Be[n]+t)in $e)return e}(e)||e)}var Ue=/^(none|table(?!-c[ea]).+)/,Xe=/^--/,Ve={position:"absolute",visibility:"hidden",display:"block"},Ge={letterSpacing:"0",fontWeight:"400"};function Ye(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Qe(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Je(e,t,n){var r=Re(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=We(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Pe.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Qe(e,t,n||(i?"border":"content"),o,r,a)+"px"}function Ke(e,t,n,r,i){return new Ke.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=We(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Xe.test(t),l=e.style;if(u||(t=ze(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Xe.test(t)||(t=ze(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=We(e,t,r)),"normal"===i&&t in Ge&&(i=Ge[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ue.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Je(e,u,n):Me(e,Ve,function(){return Je(e,u,n)})},set:function(e,t,n){var r,i=Re(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Qe(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Qe(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Ye(0,t,s)}}}),S.cssHooks.marginLeft=Fe(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(We(e,"marginLeft"))||e.getBoundingClientRect().left-Me(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Ye)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Re(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=Ke).prototype={constructor:Ke,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=Ke.propHooks[this.prop];return e&&e.get?e.get(this):Ke.propHooks._default.get(this)},run:function(e){var t,n=Ke.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Ke.propHooks._default.set(this),this}}).init.prototype=Ke.prototype,(Ke.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[ze(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=Ke.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=Ke.prototype.init,S.fx.step={};var Ze,et,tt,nt,rt=/^(?:toggle|show|hide)$/,it=/queueHooks$/;function ot(){et&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(ot):C.setTimeout(ot,S.fx.interval),S.fx.tick())}function at(){return C.setTimeout(function(){Ze=void 0}),Ze=Date.now()}function st(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ut(e,t,n){for(var r,i=(lt.tweeners[t]||[]).concat(lt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function lt(o,e,t){var n,a,r=0,i=lt.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=Ze||at(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:Ze||at(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=lt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ut,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(lt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],lt.tweeners[n]=lt.tweeners[n]||[],lt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],rt.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ut(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?lt.prefilters.unshift(e):lt.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=lt(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&it.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(st(r,!0),e,t,n)}}),S.each({slideDown:st("show"),slideUp:st("hide"),slideToggle:st("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(Ze=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),Ze=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){et||(et=!0,ot())},S.fx.stop=function(){et=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},tt=E.createElement("input"),nt=E.createElement("select").appendChild(E.createElement("option")),tt.type="checkbox",y.checkOn=""!==tt.value,y.optSelected=nt.selected,(tt=E.createElement("input")).value="t",tt.type="radio",y.radioValue="t"===tt.value;var ct,ft=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?ct:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ct={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=ft[t]||S.find.attr;ft[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=ft[o],ft[o]=r,r=null!=a(e,t,n)?o:null,ft[o]=i),r}});var pt=/^(?:input|select|textarea|button)$/i,dt=/^(?:a|area)$/i;function ht(e){return(e.match(P)||[]).join(" ")}function gt(e){return e.getAttribute&&e.getAttribute("class")||""}function vt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):pt.test(e.nodeName)||dt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,gt(this)))});if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,gt(this)))});if(!arguments.length)return this.attr("class","");if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,gt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=vt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=gt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+ht(gt(n))+" ").indexOf(t))return!0;return!1}});var yt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(yt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:ht(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var mt=/^(?:focusinfocus|focusoutblur)$/,xt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!mt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,mt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,xt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,xt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var bt=C.location,wt={guid:Date.now()},Tt=/\?/;S.parseXML=function(e){var t,n;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){}return n=t&&t.getElementsByTagName("parsererror")[0],t&&!n||S.error("Invalid XML: "+(n?S.map(n.childNodes,function(e){return e.textContent}).join("\n"):e)),t};var Ct=/\[\]$/,Et=/\r?\n/g,St=/^(?:submit|button|image|reset|file)$/i,kt=/^(?:input|select|textarea|keygen)/i;function At(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||Ct.test(n)?i(n,t):At(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)At(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)At(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&kt.test(this.nodeName)&&!St.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(Et,"\r\n")}}):{name:t.name,value:n.replace(Et,"\r\n")}}).get()}});var Nt=/%20/g,jt=/#.*$/,Dt=/([?&])_=[^&]*/,qt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Lt=/^(?:GET|HEAD)$/,Ht=/^\/\//,Ot={},Pt={},Rt="*/".concat("*"),Mt=E.createElement("a");function It(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Wt(t,i,o,a){var s={},u=t===Pt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function Ft(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Mt.href=bt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:bt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(bt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Rt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Ft(Ft(e,S.ajaxSettings),t):Ft(S.ajaxSettings,e)},ajaxPrefilter:It(Ot),ajaxTransport:It(Pt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=qt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||bt.href)+"").replace(Ht,bt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Mt.protocol+"//"+Mt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Wt(Ot,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Lt.test(v.type),f=v.url.replace(jt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Nt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Tt.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Dt,"$1"),o=(Tt.test(f)?"&":"?")+"_="+wt.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+Rt+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Wt(Pt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&S.inArray("json",v.dataTypes)<0&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Bt={0:200,1223:204},$t=S.ajaxSettings.xhr();y.cors=!!$t&&"withCredentials"in $t,y.ajax=$t=!!$t,S.ajaxTransport(function(i){var o,a;if(y.cors||$t&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Bt[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=ht(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Xt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Xt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Vt=C.jQuery,Gt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Gt),e&&C.jQuery===S&&(C.jQuery=Vt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});

From cdd38545b0192bd7bf23c928116d0411c1b5c237 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Mon, 24 Jul 2023 14:36:51 -0700
Subject: [PATCH 042/235] suppress errors in `mapillary/opensfm`

Differential Revision: D47734393

fbshipit-source-id: 60c404337afddf2eb20c9b0df27fb6bd009eba61
---
 viewer/server.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/viewer/server.py b/viewer/server.py
index bddd1ba13..536c0fc2e 100644
--- a/viewer/server.py
+++ b/viewer/server.py
@@ -23,6 +23,8 @@
 
 @app.route("/")
 def index() -> Response:
+    # pyre-fixme[6]: For 1st argument expected `typing_extensions.LiteralString` but
+    #  got `Optional[str]`.
     return send_file(os.path.join(app.static_folder, "index.html"))
 
 
@@ -83,7 +85,6 @@ def verified_send(file) -> Response:
     if os.path.isfile(file):
         return send_file(file)
     else:
-        # pyre-fixme[7]: Expected `Response` but got implicit return value of `None`.
         abort(404)
 
 

From 5fe4115896d994bf31e8856bd04a5063aafccfd9 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Mon, 24 Jul 2023 18:16:27 -0700
Subject: [PATCH 043/235] suppress errors in `mapillary/opensfm`

Differential Revision: D47743328

fbshipit-source-id: 8c1f719db79817730bf0aabf03899082fcca9a6c
---
 viewer/server.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/viewer/server.py b/viewer/server.py
index 536c0fc2e..bddd1ba13 100644
--- a/viewer/server.py
+++ b/viewer/server.py
@@ -23,8 +23,6 @@
 
 @app.route("/")
 def index() -> Response:
-    # pyre-fixme[6]: For 1st argument expected `typing_extensions.LiteralString` but
-    #  got `Optional[str]`.
     return send_file(os.path.join(app.static_folder, "index.html"))
 
 
@@ -85,6 +83,7 @@ def verified_send(file) -> Response:
     if os.path.isfile(file):
         return send_file(file)
     else:
+        # pyre-fixme[7]: Expected `Response` but got implicit return value of `None`.
         abort(404)
 
 

From 193818dcd274fbc5763c654b0446df0aca696544 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Mon, 31 Jul 2023 18:13:07 -0700
Subject: [PATCH 044/235] suppress errors in `mapillary/opensfm`

Differential Revision: D47940244

fbshipit-source-id: dd8961029435e5c43816cbe63b6a01cdc1b52986
---
 viewer/server.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/viewer/server.py b/viewer/server.py
index bddd1ba13..536c0fc2e 100644
--- a/viewer/server.py
+++ b/viewer/server.py
@@ -23,6 +23,8 @@
 
 @app.route("/")
 def index() -> Response:
+    # pyre-fixme[6]: For 1st argument expected `typing_extensions.LiteralString` but
+    #  got `Optional[str]`.
     return send_file(os.path.join(app.static_folder, "index.html"))
 
 
@@ -83,7 +85,6 @@ def verified_send(file) -> Response:
     if os.path.isfile(file):
         return send_file(file)
     else:
-        # pyre-fixme[7]: Expected `Response` but got implicit return value of `None`.
         abort(404)
 
 

From 899575ae9633d24e497df52ed2eb93642d862422 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Sun, 27 Aug 2023 22:26:08 -0700
Subject: [PATCH 045/235] Del `(object)` from 50 inc
 manifold/cogwheel/lib/manifold_semaphore.py

Summary: Python3 makes the use of `(object)` in class inheritance unnecessary. Let's modernize our code by eliminating this.

Reviewed By: palmje

Differential Revision: D48718310

fbshipit-source-id: c6e6ad2889add16537c78353f3202ac924f00fae
---
 opensfm/dataset.py                        | 2 +-
 opensfm/feature_loading.py                | 2 +-
 opensfm/features_processing.py            | 2 +-
 opensfm/geo.py                            | 2 +-
 opensfm/synthetic_data/synthetic_scene.py | 2 +-
 opensfm/types.py                          | 4 ++--
 opensfm/vlad.py                           | 2 +-
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 90aaf9b37..ff825a272 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -702,7 +702,7 @@ def undistorted_dataset(self) -> "UndistortedDataSet":
         )
 
 
-class UndistortedDataSet(object):
+class UndistortedDataSet:
     """Accessors to the undistorted data of a dataset.
 
     Data include undistorted images, masks, and segmentation as well
diff --git a/opensfm/feature_loading.py b/opensfm/feature_loading.py
index bd8baa022..f985b6869 100644
--- a/opensfm/feature_loading.py
+++ b/opensfm/feature_loading.py
@@ -15,7 +15,7 @@
 )
 
 
-class FeatureLoader(object):
+class FeatureLoader:
     def clear_cache(self) -> None:
         self.load_mask.cache_clear()
         self.load_points_colors_segmentations_instances.cache_clear()
diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index b48f2aac2..52ce8c29c 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -118,7 +118,7 @@ def is_high_res_panorama(
     return w == 2 * h or exif_pano
 
 
-class Counter(object):
+class Counter:
     """Lock-less counter from https://julien.danjou.info/atomic-lock-free-counters-in-python/
     that relies on the CPython impl. of itertools.count() that is thread-safe. Used, as for
     some reason, joblib doesn't like a good old threading.Lock (everything is stuck)
diff --git a/opensfm/geo.py b/opensfm/geo.py
index a0324f9b9..90c3d3d9d 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -175,7 +175,7 @@ def gps_distance(latlon_1, latlon_2):
     return dis
 
 
-class TopocentricConverter(object):
+class TopocentricConverter:
     """Convert to and from a topocentric reference frame."""
 
     def __init__(self, reflat, reflon, refalt):
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 688717981..5a1e4f230 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -75,7 +75,7 @@ def normalized(x: np.ndarray) -> np.ndarray:
     return pose
 
 
-class SyntheticScene(object):
+class SyntheticScene:
     def get_reconstruction(self) -> types.Reconstruction:
         raise NotImplementedError()
 
diff --git a/opensfm/types.py b/opensfm/types.py
index 1d2a877d1..7e444b9c9 100644
--- a/opensfm/types.py
+++ b/opensfm/types.py
@@ -9,7 +9,7 @@
 PANOSHOT_RIG_PREFIX = "panoshot_"
 
 
-class ShotMesh(object):
+class ShotMesh:
     """Triangular mesh of points visible in a shot
 
     Attributes:
@@ -22,7 +22,7 @@ def __init__(self):
         self.faces = None
 
 
-class Reconstruction(object):
+class Reconstruction:
     """Defines the reconstructed scene.
 
     Attributes:
diff --git a/opensfm/vlad.py b/opensfm/vlad.py
index 3a472f054..5cf9b02b4 100644
--- a/opensfm/vlad.py
+++ b/opensfm/vlad.py
@@ -47,7 +47,7 @@ def vlad_distances(
     return image, distances, others
 
 
-class VladCache(object):
+class VladCache:
     def clear_cache(self) -> None:
         self.load_words.cache_clear()
         self.vlad_histogram.cache_clear()

From c798da16206aa52395eaef09ea4d7746028479d3 Mon Sep 17 00:00:00 2001
From: True Price <jtprice@meta.com>
Date: Wed, 30 Aug 2023 08:46:11 -0700
Subject: [PATCH 046/235] Use ASSERT_FLOAT_EQ in
 TestPixelNormalizedCoordinatesConversion

Reviewed By: mlopezantequera

Differential Revision: D48805944

fbshipit-source-id: 1c293ca367202740fc4e96011efb66bd8df0b119
---
 opensfm/src/geometry/test/camera_test.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/geometry/test/camera_test.cc b/opensfm/src/geometry/test/camera_test.cc
index 81d8a0032..881c19861 100644
--- a/opensfm/src/geometry/test/camera_test.cc
+++ b/opensfm/src/geometry/test/camera_test.cc
@@ -549,7 +549,8 @@ TEST(Camera, TestPixelNormalizedCoordinatesConversion) {
   ASSERT_EQ(norm_coord_comp[1],
             (px_coord_def[1] - (height - 1) / 2.0) * inv_normalizer);
   const Vec2d px_coord_comp = cam.NormalizedToPixelCoordinates(norm_coord_comp);
-  ASSERT_EQ(px_coord_comp, px_coord_def);
+  ASSERT_FLOAT_EQ(px_coord_comp[0], px_coord_def[0]);
+  ASSERT_FLOAT_EQ(px_coord_comp[1], px_coord_def[1]);
 
   const Vec2d norm_coord_static =
       geometry::Camera::PixelToNormalizedCoordinates(px_coord_def, width,

From c6b5acef9376a75b87414d900c258ef876a6413a Mon Sep 17 00:00:00 2001
From: michalmachura <michal.machura@pragmile.com>
Date: Fri, 15 Sep 2023 01:54:39 -0700
Subject: [PATCH 047/235] Image channels dimension and dtype check for feature
 extraction. (#1018)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1018

Reviewed By: paulinus

Differential Revision: D48945121

Pulled By: fabianschenk

fbshipit-source-id: b1b1b51640dd82d9de98e59de8d09c054641a6b7
---
 opensfm/features.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/opensfm/features.py b/opensfm/features.py
index bf07b7973..d4dbac37d 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -589,10 +589,14 @@ def extract_features(
         else config["feature_min_frames"]
     )
 
-    assert len(image.shape) == 3 or len(image.shape) == 2
+    assert image.ndim == 2 or image.ndim == 3 and image.shape[2] in [1, 3]
+    assert image.shape[0] > 2 and image.shape[1] > 2
+    assert np.issubdtype(image.dtype, np.uint8)
+
     image = resized_image(image, extraction_size)
-    if len(image.shape) == 2:  # convert (h, w) to (h, w, 1)
+    if image.ndim == 2:  # convert (h, w) to (h, w, 1)
         image = np.expand_dims(image, axis=2)
+
     # convert color to gray-scale if necessary
     if image.shape[2] == 3:
         image_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
@@ -610,9 +614,8 @@ def extract_features(
     elif feature_type == "ORB":
         points, desc = extract_features_orb(image_gray, config, features_count)
     else:
-        raise ValueError(
-            "Unknown feature type " "(must be SURF, SIFT, AKAZE, HAHOG or ORB)"
-        )
+        raise ValueError("Unknown feature type "
+                         + "(must be SURF, SIFT, AKAZE, HAHOG or ORB)")
 
     xs = points[:, 0].round().astype(int)
     ys = points[:, 1].round().astype(int)

From fb3dc964854a08d7cd6aa1c7ef98dd5fe419c4ce Mon Sep 17 00:00:00 2001
From: Ahmed Ahmed <ahmedahmed@meta.com>
Date: Mon, 6 Nov 2023 13:12:51 -0800
Subject: [PATCH 048/235] Add logs for number of GPS constraints in OpenSFM

Summary: Loggs to test Enable/Disable GPS in OpenSFM

Differential Revision: D50942543

fbshipit-source-id: ba2c001179a5d07d25917adf7b4abdb517f6d5a7
---
 opensfm/align.py                  | 6 +++---
 opensfm/src/sfm/src/ba_helpers.cc | 7 +++++++
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index 034799c96..383109564 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -123,13 +123,13 @@ def alignment_constraints(
     """Gather alignment constraints to be used by checking bundle_use_gcp and bundle_use_gps."""
 
     X, Xp = [], []
-
+    logger.info(f"Collecting alignment constraints - bundle_use_gps:{config['bundle_use_gps']} bundle_use_gcp: {config['bundle_use_gcp']}")
     # Get Ground Control Point correspondences
     if gcp and config["bundle_use_gcp"]:
         triangulated, measured = triangulate_all_gcp(reconstruction, gcp)
         X.extend(triangulated)
         Xp.extend(measured)
-
+    logger.info(f"GCP constraints X ({len(X)}) - Xp ({len(Xp)})")
     # Get camera center correspondences
     if use_gps and config["bundle_use_gps"]:
         for rig_instance in reconstruction.rig_instances.values():
@@ -141,7 +141,7 @@ def alignment_constraints(
             if len(gpses) > 0:
                 X.append(rig_instance.pose.get_origin())
                 Xp.append(np.average(gpses, axis=0))
-
+    logger.info(f"GPS constraints X ({len(X)}) - Xp ({len(Xp)})")
     return X, Xp
 
 
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 835883eb6..01b9dc10d 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -205,8 +205,15 @@ py::tuple BAHelpers::BundleLocal(
     ba.AddRigInstance(rig_instance_id, instance.GetPose(), shot_cameras,
                       shot_rig_cameras, fix_instance);
 
+    LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>();
     // only add averaged rig position constraints to moving instances
     if (!fix_instance && gps_count > 0) {
+      LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>()
+                << ", adding average GPS prior to rig instance " << rig_instance_id
+                << ", count: " << gps_count
+                << ", avg pos: " << average_position.transpose()
+                << ", avg std: " << average_std
+                << ", scale group: " << gps_scale_group;
       average_position /= gps_count;
       average_std /= gps_count;
       ba.AddRigInstancePositionPrior(rig_instance_id, average_position,

From 25c04c334001c2316d946c3c63ef5a1b4054ca90 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Fri, 10 Nov 2023 14:08:52 -0800
Subject: [PATCH 049/235] add gopro max fisheye to hardcoded_camera_calibration

Summary: with this we no longer need to manually set calibration in UVP

Differential Revision: D51165336

fbshipit-source-id: 85804043986ef9520694e9dd788efbc7223420d9
---
 opensfm/src/sfm/src/ba_helpers.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 01b9dc10d..e06692840 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -205,7 +205,6 @@ py::tuple BAHelpers::BundleLocal(
     ba.AddRigInstance(rig_instance_id, instance.GetPose(), shot_cameras,
                       shot_rig_cameras, fix_instance);
 
-    LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>();
     // only add averaged rig position constraints to moving instances
     if (!fix_instance && gps_count > 0) {
       LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>()

From 98939bf06a7a777415c97db380fd110cc36043b7 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Tue, 14 Nov 2023 06:36:42 -0800
Subject: [PATCH 050/235] mapillary

Reviewed By: zsol

Differential Revision: D51300169

fbshipit-source-id: 30cf2084197dbe6f30d499e06e0f09674d761bad
---
 annotation_gui_gcp/run_ba.py | 38 +++++++++++++++++++++++++++---------
 bin/opensfm_main.py          | 12 +++++++++---
 bin/plot_matches.py          | 21 +++++++++++++-------
 3 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index 5e4ad9f09..4e571f8aa 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -8,10 +8,16 @@
 
 import numpy as np
 import opensfm.reconstruction as orec
-from opensfm import dataset, log, multiview, pygeometry, pymap
-from opensfm import reconstruction_helpers as helpers
-from opensfm import transformations as tf
-from opensfm import types
+from opensfm import (
+    dataset,
+    log,
+    multiview,
+    pygeometry,
+    pymap,
+    reconstruction_helpers as helpers,
+    transformations as tf,
+    types,
+)
 from opensfm.align import apply_similarity
 
 logger = logging.getLogger(__name__)
@@ -81,7 +87,9 @@ def resplit_reconstruction(merged, original_reconstructions):
     return split
 
 
-def gcp_geopositional_error(gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction):
+def gcp_geopositional_error(
+    gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction
+):
     coords_reconstruction = triangulate_gcps(gcps, reconstruction)
     out = {}
     for ix, gcp in enumerate(gcps):
@@ -114,7 +122,9 @@ def gcp_geopositional_error(gcps: List[pymap.GroundControlPoint], reconstruction
     return out
 
 
-def triangulate_gcps(gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction):
+def triangulate_gcps(
+    gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction
+):
     coords = []
     for gcp in gcps:
         res = multiview.triangulate_gcp(
@@ -127,7 +137,11 @@ def triangulate_gcps(gcps: List[pymap.GroundControlPoint], reconstruction: types
     return coords
 
 
-def reproject_gcps(gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction, reproj_threshold):
+def reproject_gcps(
+    gcps: List[pymap.GroundControlPoint],
+    reconstruction: types.Reconstruction,
+    reproj_threshold,
+):
     output = {}
     for gcp in gcps:
         point = multiview.triangulate_gcp(
@@ -269,7 +283,9 @@ def bundle_with_fixed_images(
 
     for point in reconstruction.points.values():
         ba.add_point(point.id, point.coordinates, False)
-        ba.add_point_prior(point.id, point.coordinates, np.array([100.0, 100.0, 100.0]), False)
+        ba.add_point_prior(
+            point.id, point.coordinates, np.array([100.0, 100.0, 100.0]), False
+        )
 
     for shot_id in reconstruction.shots:
         shot = reconstruction.get_shot(shot_id)
@@ -866,7 +882,7 @@ def align(
             logger.info("No annotations with large reprojection errors")
 
 
-if __name__ == "__main__":
+def main() -> None:
     log.setup()
     args = parse_args()
     sys.exit(
@@ -880,3 +896,7 @@ def align(
             args.std_threshold,
         )
     )
+
+
+if __name__ == "__main__":
+    main()  # pragma: no cover
diff --git a/bin/opensfm_main.py b/bin/opensfm_main.py
index 31249e129..2041e163d 100755
--- a/bin/opensfm_main.py
+++ b/bin/opensfm_main.py
@@ -1,5 +1,5 @@
 import sys
-from os.path import abspath, join, dirname
+from os.path import abspath, dirname, join
 
 sys.path.insert(0, abspath(join(dirname(__file__), "..")))
 
@@ -21,7 +21,13 @@ def create_default_dataset_context(
         dataset.clean_up()
 
 
-if __name__ == "__main__":
+def main() -> None:
     commands.command_runner(
-        commands.opensfm_commands, create_default_dataset_context, dataset_choices=["opensfm"]
+        commands.opensfm_commands,
+        create_default_dataset_context,
+        dataset_choices=["opensfm"],
     )
+
+
+if __name__ == "__main__":
+    main()  # pragma: no cover
diff --git a/bin/plot_matches.py b/bin/plot_matches.py
index 94f9d7fbf..2fe59174b 100755
--- a/bin/plot_matches.py
+++ b/bin/plot_matches.py
@@ -3,15 +3,13 @@
 import argparse
 import os.path
 from itertools import combinations
+from typing import List
 
 import matplotlib.cm as cm
 import matplotlib.pyplot as pl
 import numpy as np
-from opensfm import dataset
-from opensfm import features
-from opensfm import io
 from numpy import ndarray
-from typing import List
+from opensfm import dataset, features, io
 
 
 def plot_matches(im1, im2, p1: ndarray, p2: ndarray) -> None:
@@ -113,7 +111,8 @@ def plot_matches_for_images(data, image, images) -> None:
         pl.show()
 
 
-if __name__ == "__main__":
+def main() -> None:
+    global args, images
     parser = argparse.ArgumentParser(description="Plot matches between images")
     parser.add_argument("dataset", help="path to the dataset to be processed")
     parser.add_argument("--image", help="show tracks for a specific")
@@ -124,12 +123,20 @@ def plot_matches_for_images(data, image, images) -> None:
     parser.add_argument(
         "--save_figs", help="save figures instead of showing them", action="store_true"
     )
-    args: argparse.Namespace = parser.parse_args()
+    args = parser.parse_args()
 
     data = dataset.DataSet(args.dataset)
-    images: List[str] = data.images()
+    images = data.images()
 
     if args.graph:
         plot_graph(data)
     else:
         plot_matches_for_images(data, args.image, args.images)
+
+
+args: argparse.Namespace
+images: List[str]
+
+
+if __name__ == "__main__":
+    main()  # pragma: no cover

From 925d7ffe327026d4afb0eb75134090f9f8c63a8d Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Wed, 6 Dec 2023 23:06:23 -0800
Subject: [PATCH 051/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D51900922

fbshipit-source-id: 4d2baa2ad4b8555fbe1ef33e2ebaedb64bdcac4b
---
 opensfm/report.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/report.py b/opensfm/report.py
index 31cb47186..b1bf5f859 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -39,7 +39,6 @@ def __init__(self, data: DataSet) -> None:
         self.stats = self._read_stats_file("stats.json")
 
     def save_report(self, filename: str) -> None:
-        # pyre-fixme[28]: Unexpected keyword argument `dest`.
         bytestring = self.pdf.output(dest="S")
         if isinstance(bytestring, str):
             bytestring = bytestring.encode("utf8")

From 6a1f95ec626f63668afe09af2b0c1cccde4c9700 Mon Sep 17 00:00:00 2001
From: Michael Waechter <nightwatch@meta.com>
Date: Fri, 8 Dec 2023 11:11:51 -0800
Subject: [PATCH 052/235] add progress plotting to correspondence copier and
 opensfm.reconstructor

Summary:
To make it easier to track reconstruction progress in larger jobs, this diff adds
- logging to the `opensfm.reconstructor` how many shots we already have in a map
- `tqdm` logging to the most expensive loops of the `copy_view_correspondences_between_pose_graph_and_component` module.

Differential Revision: D51964593

fbshipit-source-id: 08a4e81f6464329da01ba78e41d5142c7db0e848
---
 opensfm/reconstruction.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 3de7ebe89..eaa6a6a15 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1494,6 +1494,8 @@ def grow_reconstruction(
                 remove_outliers(reconstruction, config, bundled_points)
                 step["local_bundle"] = brep
 
+            logger.info(f"Reconstruction now has {len(reconstruction.shots)} shots.")
+
             break
         else:
             logger.info("Some images can not be added")

From d787a1811be3eda610090af3741c4a618e73f375 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Fri, 8 Dec 2023 15:40:48 -0800
Subject: [PATCH 053/235] Remove extra semi colon from
 mapillary/opensfm/opensfm/src/geo/geo.h

Summary:
`-Wextra-semi` or `-Wextra-semi-stmt`

If the code compiles, this is safe to land.

Reviewed By: palmje

Differential Revision: D51995097

fbshipit-source-id: 473fa063cd47983e6e99a85c112fb51af0ea6719
---
 opensfm/src/geo/geo.h      | 2 +-
 opensfm/src/geo/src/geo.cc | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/opensfm/src/geo/geo.h b/opensfm/src/geo/geo.h
index 053249d72..cf3c7e63e 100644
--- a/opensfm/src/geo/geo.h
+++ b/opensfm/src/geo/geo.h
@@ -47,4 +47,4 @@ struct TopocentricConverter {
   Vec3d ToLla(const Vec3d& xyz) const;
   Vec3d GetLlaRef() const;
 };
-};  // namespace geo
+}  // namespace geo
diff --git a/opensfm/src/geo/src/geo.cc b/opensfm/src/geo/src/geo.cc
index 2f07b4ad2..c80118901 100644
--- a/opensfm/src/geo/src/geo.cc
+++ b/opensfm/src/geo/src/geo.cc
@@ -165,7 +165,7 @@ TopocentricConverter::TopocentricConverter(const double lat,
     : lat_(lat), long_(longitude), alt_(alt) {}
 
 TopocentricConverter::TopocentricConverter(const Vec3d& lla)
-    : TopocentricConverter(lla[0], lla[1], lla[2]){};
+    : TopocentricConverter(lla[0], lla[1], lla[2]){}
 
 Vec3d TopocentricConverter::ToTopocentric(const double lat, const double lon,
                                           const double alt) const {

From 7f170d0dc352340295ff480378e3ac37d0179f8e Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Fri, 8 Dec 2023 18:20:27 -0800
Subject: [PATCH 054/235] Remove extra semi colon from
 luna/common/sampling/samplers/StatsWrapper.cpp

Summary:
`-Wextra-semi` or `-Wextra-semi-stmt`

If the code compiles, this is safe to land.

Reviewed By: palmje

Differential Revision: D51995049

fbshipit-source-id: 441e8695a7d4c68d715c87a7704fa54bda53f6ab
---
 opensfm/src/foundation/newton_raphson.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/src/foundation/newton_raphson.h b/opensfm/src/foundation/newton_raphson.h
index d418905f3..47db76d5f 100644
--- a/opensfm/src/foundation/newton_raphson.h
+++ b/opensfm/src/foundation/newton_raphson.h
@@ -65,7 +65,7 @@ typename TypeTraits<N, M>::Values SolveDecr(
     const typename TypeTraits<N, M>::Jacobian& d,
     const typename TypeTraits<N, M>::Values& f) {
   return (d.transpose() * d).inverse() * d.transpose() * f;
-};
+}
 
 template <>
 typename TypeTraits<1, 1>::Values SolveDecr<1, 1>(

From 569f6d3a287178872277d7adcae1f5cb6eba92e3 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@meta.com>
Date: Mon, 8 Jan 2024 02:59:21 -0800
Subject: [PATCH 055/235] Rename variable to avoid shadowing

Summary: This is a better renaming of what was proposed in D52582811.

Reviewed By: YanNoun

Differential Revision: D52596501

fbshipit-source-id: 17a4b2e3b17a2040908d16c007cea3556c7302bf
---
 opensfm/src/bundle/src/bundle_adjuster.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index dd999ac0d..18a6dd1ed 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -561,17 +561,17 @@ void BundleAdjuster::Run() {
   ceres::Problem problem;
 
   // Add cameras
-  for (auto &i : cameras_) {
-    auto &data = i.second.GetValueData();
+  for (auto &[_, cam] : cameras_) {
+    auto &data = cam.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
-    if (i.second.GetParametersToOptimize().empty()) {
+    if (cam.GetParametersToOptimize().empty()) {
       problem.SetParameterBlockConstant(data.data());
     }
 
     // Add a barrier for constraining transition of dual to stay in [0, 1]
-    const auto camera = i.second.GetValue();
+    const auto camera = cam.GetValue();
     if (camera.GetProjectionType() == geometry::ProjectionType::DUAL) {
       const auto types = camera.GetParametersTypes();
       int index = -1;

From a848b1f47a71da6c96dee666245ed9253ec69aa0 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Thu, 25 Jan 2024 19:15:07 -0800
Subject: [PATCH 056/235] suppress errors in `mapillary/opensfm`

Differential Revision: D53099888

fbshipit-source-id: 2dc5a3bf14b2e97958f394f87f8dc4fb8bc1a851
---
 opensfm/multiview.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 65dd3ea07..10d55dcfb 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -165,6 +165,7 @@ def ransac(kernel: Any, threshold: float) -> TRansacSolution:
         try:
             samples = kernel.sampling()
         except AttributeError:
+            # pyre-fixme[20]: Argument `k` expected.
             samples = random.sample(
                 range(kernel.num_samples()), kernel.required_samples
             )
@@ -238,13 +239,16 @@ def sampling(self) -> Dict[str, Any]:
         samples = {}
         if len(self.vectors) > 0:
             samples["points"] = self.points[
+                # pyre-fixme[20]: Argument `k` expected.
                 random.sample(range(len(self.points)), 2), :
             ]
             samples["vectors"] = [
+                # pyre-fixme[20]: Argument `k` expected.
                 self.vectors[i] for i in random.sample(range(len(self.vectors)), 1)
             ]
         else:
             samples["points"] = self.points[
+                # pyre-fixme[20]: Argument `k` expected.
                 :, random.sample(range(len(self.points)), 3)
             ]
             samples["vectors"] = None

From bec57f3075bb3f2ef0e7c2a29ad4d877cc1bd1d3 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Fri, 26 Jan 2024 19:07:33 -0800
Subject: [PATCH 057/235] suppress errors in `mapillary/opensfm`

Differential Revision: D53151206

fbshipit-source-id: 04c3b8f4766a2d749b2471038e3cb1cd9b877f5d
---
 opensfm/multiview.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 10d55dcfb..65dd3ea07 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -165,7 +165,6 @@ def ransac(kernel: Any, threshold: float) -> TRansacSolution:
         try:
             samples = kernel.sampling()
         except AttributeError:
-            # pyre-fixme[20]: Argument `k` expected.
             samples = random.sample(
                 range(kernel.num_samples()), kernel.required_samples
             )
@@ -239,16 +238,13 @@ def sampling(self) -> Dict[str, Any]:
         samples = {}
         if len(self.vectors) > 0:
             samples["points"] = self.points[
-                # pyre-fixme[20]: Argument `k` expected.
                 random.sample(range(len(self.points)), 2), :
             ]
             samples["vectors"] = [
-                # pyre-fixme[20]: Argument `k` expected.
                 self.vectors[i] for i in random.sample(range(len(self.vectors)), 1)
             ]
         else:
             samples["points"] = self.points[
-                # pyre-fixme[20]: Argument `k` expected.
                 :, random.sample(range(len(self.points)), 3)
             ]
             samples["vectors"] = None

From 013956c43ffb95605845ff1858e645a00ed66e98 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 14 Feb 2024 13:29:12 -0800
Subject: [PATCH 058/235] Remove semicolon(s) from 3 files inc
 loki/lacis/storage/rtree/liveindex/LokiShard.h

Summary:
`-Wextra-semi` or `-Wextra-semi-stmt` found an extra semi

If the code compiles, this is safe to land.

Reviewed By: palmje, dmm-fb

Differential Revision: D53776073

fbshipit-source-id: 99e769877dd17b6ddb51e82cf48d7605668cafb7
---
 opensfm/src/bundle/src/bundle_adjuster.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 18a6dd1ed..b727b6b70 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -18,7 +18,7 @@ bool IsRigCameraUseful(bundle::RigCamera &rig_camera) {
   return !(rig_camera.GetParametersToOptimize().empty() &&
            rig_camera.GetValueData().isConstant(0.));
 }
-};  // namespace
+}  // namespace
 
 namespace bundle {
 BundleAdjuster::BundleAdjuster() {
@@ -140,7 +140,7 @@ void BundleAdjuster::AddRigInstance(
                                          &rig_camera_exists->second,
                                          &rig_instances_.at(rig_instance_id)));
   }
-};
+}
 
 void BundleAdjuster::AddRigCamera(const std::string &rig_camera_id,
                                   const geometry::Pose &pose,
@@ -161,7 +161,7 @@ void BundleAdjuster::AddRigCamera(const std::string &rig_camera_id,
   if (fixed) {
     rig_camera.SetParametersToOptimize({});
   }
-};
+}
 
 void BundleAdjuster::AddRigInstancePositionPrior(
     const std::string &instance_id, const Vec3d &position,

From 2281fd434989b28ff5c7161c389c09a111956f8d Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 14 Feb 2024 13:44:22 -0800
Subject: [PATCH 059/235] Remove semicolon(s) from 3 files inc
 mapillary/opensfm/opensfm/src/geometry/camera.h

Summary:
`-Wextra-semi` or `-Wextra-semi-stmt` found an extra semi

If the code compiles, this is safe to land.

Reviewed By: palmje, dmm-fb

Differential Revision: D53776237

fbshipit-source-id: eb4d82dc16f32e4276887e025d29b701d3333811
---
 opensfm/src/geometry/camera.h           | 2 +-
 opensfm/src/geometry/camera_instances.h | 2 +-
 opensfm/src/geometry/functions.h        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/opensfm/src/geometry/camera.h b/opensfm/src/geometry/camera.h
index 348219599..e38867d99 100644
--- a/opensfm/src/geometry/camera.h
+++ b/opensfm/src/geometry/camera.h
@@ -118,4 +118,4 @@ class Camera {
 std::pair<MatXf, MatXf> ComputeCameraMapping(const Camera& from,
                                              const Camera& to, int width,
                                              int height);
-};  // namespace geometry
+}  // namespace geometry
diff --git a/opensfm/src/geometry/camera_instances.h b/opensfm/src/geometry/camera_instances.h
index e5acf475e..ba89e6407 100644
--- a/opensfm/src/geometry/camera_instances.h
+++ b/opensfm/src/geometry/camera_instances.h
@@ -232,5 +232,5 @@ void Dispatch(const ProjectionType& type, IN&&... args) {
     default:
       throw std::runtime_error("Invalid ProjectionType");
   }
-};
+}
 }  // namespace geometry
diff --git a/opensfm/src/geometry/functions.h b/opensfm/src/geometry/functions.h
index 4beb40784..58c8e8db1 100644
--- a/opensfm/src/geometry/functions.h
+++ b/opensfm/src/geometry/functions.h
@@ -109,4 +109,4 @@ static void ComposeFunctions(const T* in, const T* parameters, T* out) {
   constexpr int Index = ComposeIndex<FUNC2, FUNCS...>();
   FUNC1::template Apply<T>(&tmp[0], parameters + Index, out);
 }
-};  // namespace geometry
+}  // namespace geometry

From 072abf02f58b923d74736277c1e15af4de8c0162 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 14 Feb 2024 16:16:41 -0800
Subject: [PATCH 060/235] Remove unused variables in
 mapillary/opensfm/opensfm/src/geometry/pose.h

Summary:
LLVM-15 has a warning `-Wunused-but-set-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code, or (b) qualifies the variable with `[[maybe_unused]]`, mostly in cases where the variable _is_ used, but, eg, in an `assert` statement that isn't present in production code.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: palmje

Differential Revision: D53779585

fbshipit-source-id: d651d6b4cf4dbc777f924f936e9325005c80d2ba
---
 opensfm/src/geometry/pose.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/geometry/pose.h b/opensfm/src/geometry/pose.h
index c015e7b7f..736563b3d 100644
--- a/opensfm/src/geometry/pose.h
+++ b/opensfm/src/geometry/pose.h
@@ -17,7 +17,6 @@ class Pose {
   virtual ~Pose() = default;
 
   Pose(const Vec3d& R, const Vec3d& t = Vec3d::Zero()) {
-    Mat4d T_cw = Mat4d::Identity();
     SetFromWorldToCamera(R, t);
   }
   Pose(const Mat3d& R, const Vec3d& t = Vec3d::Zero()) {

From 68b18f309e743f8824c93616800ddaab64bba9e8 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 14 Feb 2024 16:26:06 -0800
Subject: [PATCH 061/235] Remove unused variables in
 mapillary/opensfm/opensfm/src/foundation/newton_raphson.h

Summary:
LLVM-15 has a warning `-Wunused-but-set-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code, or (b) qualifies the variable with `[[maybe_unused]]`, mostly in cases where the variable _is_ used, but, eg, in an `assert` statement that isn't present in production code.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: palmje

Differential Revision: D53779594

fbshipit-source-id: a22fbbc945140165686a74c9d0c921983ca54451
---
 opensfm/src/foundation/newton_raphson.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/opensfm/src/foundation/newton_raphson.h b/opensfm/src/foundation/newton_raphson.h
index 47db76d5f..63b44e976 100644
--- a/opensfm/src/foundation/newton_raphson.h
+++ b/opensfm/src/foundation/newton_raphson.h
@@ -44,7 +44,6 @@ template <class F>
 struct FiniteDiff<F, 1, 1> {
   static typename TypeTraits<1, 1>::Jacobian Derivative(
       const F& func, typename TypeTraits<1, 1>::Values& x) {
-    typename TypeTraits<1, 1>::Jacobian jacobian;
     constexpr auto eps = 1e-15;
     return (func(x + eps) - func(x)) / eps;
   }
@@ -77,7 +76,6 @@ template <class F, int N, int M, class D = FiniteDiff<F, N, M>>
 typename TypeTraits<N, M>::Values NewtonRaphson(
     const F& func, const typename TypeTraits<N, M>::Values& initial_value,
     int iterations, double tol = 1e-6) {
-  constexpr auto eps = std::numeric_limits<double>::epsilon();
   auto current_value = initial_value;
   for (int i = 0; i < iterations; ++i) {
     const auto at_current_value = func(current_value);

From 21ed668ed496c5b4f7477e7985579b5112099a6a Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 14 Feb 2024 16:48:58 -0800
Subject: [PATCH 062/235] Remove semicolon(s) from 3 files inc
 mapillary/opensfm/opensfm/src/geometry/pose.h

Summary:
`-Wextra-semi` or `-Wextra-semi-stmt` found an extra semi

If the code compiles, this is safe to land.

Reviewed By: palmje, dmm-fb

Differential Revision: D53776244

fbshipit-source-id: 83a21ed4c3a954d7389b084a68912fe229bff40e
---
 opensfm/src/geometry/pose.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/src/geometry/pose.h b/opensfm/src/geometry/pose.h
index 736563b3d..69f95488f 100644
--- a/opensfm/src/geometry/pose.h
+++ b/opensfm/src/geometry/pose.h
@@ -49,7 +49,7 @@ class Pose {
 
   Vec3d TranslationCameraToWorld() const {
     return cam_to_world_.block<3, 1>(0, 3);
-  };
+  }
 
   Vec3d GetOrigin() const { return TranslationCameraToWorld(); }
   virtual void SetOrigin(const Vec3d& origin) {

From 4a74bc3b1f4043079099100e969e558d559acbfa Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Wed, 28 Feb 2024 03:10:47 -0800
Subject: [PATCH 063/235] mapillary (463897787004193082)

Reviewed By: paulinus

Differential Revision: D54105414

fbshipit-source-id: a76d6dcd36c8d73a04ec93cfb8aabf2ca9eab2de
---
 opensfm/src/bundle/error/projection_errors.h  |  6 +--
 opensfm/src/bundle/reconstruction_alignment.h |  6 +--
 opensfm/src/bundle/src/bundle_adjuster.cc     | 10 ++--
 .../bundle/test/reprojection_errors_test.cc   | 18 +++----
 opensfm/src/dense/depthmap_bind.h             |  8 +--
 opensfm/src/features/src/hahog.cc             | 11 ++--
 opensfm/src/features/src/matching.cc          |  3 +-
 opensfm/src/foundation/numeric.h              |  5 +-
 opensfm/src/foundation/python_types.h         | 12 ++---
 opensfm/src/geometry/covariance.h             |  4 +-
 opensfm/src/geometry/src/covariance.cc        |  4 +-
 opensfm/src/geometry/src/triangulation.cc     |  7 +--
 .../geometry/test/camera_functions_test.cc    |  2 +-
 opensfm/src/geometry/test/covariance_test.cc  |  2 +-
 opensfm/src/map/ground_control_points.h       |  4 +-
 opensfm/src/map/pybind_utils.h                | 20 ++++---
 opensfm/src/map/src/map.cc                    |  6 +--
 opensfm/src/sfm/retriangulation.h             |  4 +-
 opensfm/src/sfm/src/ba_helpers.cc             |  3 +-
 opensfm/src/sfm/src/retriangulation.cc        |  4 +-
 opensfm/src/sfm/src/tracks_helpers.cc         |  4 +-
 opensfm/src/sfm/test/tracks_helpers_test.cc   |  8 +--
 opensfm/src/sfm/tracks_helpers.h              |  4 +-
 opensfm/src/third_party/akaze/lib/AKAZE.cpp   | 52 ++++++++++++-------
 opensfm/src/third_party/akaze/lib/fed.cpp     | 11 ++--
 .../akaze/lib/nldiffusion_functions.cpp       | 29 +++++++----
 opensfm/src/third_party/akaze/lib/utils.cpp   | 21 +++++---
 27 files changed, 148 insertions(+), 120 deletions(-)

diff --git a/opensfm/src/bundle/error/projection_errors.h b/opensfm/src/bundle/error/projection_errors.h
index c8bf8f239..20d6fdb87 100644
--- a/opensfm/src/bundle/error/projection_errors.h
+++ b/opensfm/src/bundle/error/projection_errors.h
@@ -261,10 +261,10 @@ class ReprojectionError3DAnalytic
     Vec3d transformed;
     /* Error only */
     if (!jacobians) {
-      geometry::PoseFunctor::Forward(point, rig_instance, &transformed[0]);
+      geometry::PoseFunctor::Forward(point, rig_instance, transformed.data());
       if (use_rig_camera_) {
-        geometry::PoseFunctor::Forward(&transformed[0], rig_camera,
-                                       &transformed[0]);
+        geometry::PoseFunctor::Forward(transformed.data(), rig_camera,
+                                       transformed.data());
       }
       transformed.normalize();
     } /* Jacobian + Error */
diff --git a/opensfm/src/bundle/reconstruction_alignment.h b/opensfm/src/bundle/reconstruction_alignment.h
index 8b108401a..a27073439 100644
--- a/opensfm/src/bundle/reconstruction_alignment.h
+++ b/opensfm/src/bundle/reconstruction_alignment.h
@@ -375,8 +375,8 @@ struct RACommonCameraError {
 
 class ReconstructionAlignment {
  public:
-  ReconstructionAlignment() {}
-  virtual ~ReconstructionAlignment() {}
+  ReconstructionAlignment() = default;
+  virtual ~ReconstructionAlignment() = default;
 
   RAShot GetShot(const std::string &id) { return shots_[id]; }
 
@@ -520,7 +520,7 @@ class ReconstructionAlignment {
           new ceres::AutoDiffCostFunction<RAAbsolutePositionError, 3, 6>(
               new RAAbsolutePositionError(a.position, a.std_deviation));
 
-      problem.AddResidualBlock(cost_function, NULL, a.shot->parameters);
+      problem.AddResidualBlock(cost_function, nullptr, a.shot->parameters);
     }
 
     // Add relative-absolute position errors
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index b727b6b70..40aac3347 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -424,7 +424,7 @@ ceres::LossFunction *CreateLossFunction(std::string name, double threshold) {
   } else if (name.compare("ArctanLoss") == 0) {
     return new ceres::ArctanLoss(threshold);
   }
-  return NULL;
+  return nullptr;
 }
 
 void BundleAdjuster::AddLinearMotion(const std::string &shot0_id,
@@ -1094,9 +1094,8 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
 
     std::vector<std::pair<const double *, const double *>> covariance_blocks;
     for (auto &i : shots_) {
-      covariance_blocks.push_back(
-          std::make_pair(i.second.GetRigInstance()->GetValueData().data(),
-                         i.second.GetRigInstance()->GetValueData().data()));
+      covariance_blocks.emplace_back(i.second.GetRigInstance()->GetValueData().data(),
+                         i.second.GetRigInstance()->GetValueData().data());
     }
 
     bool worked = covariance.Compute(covariance_blocks, problem);
@@ -1129,7 +1128,8 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
         break;
       }
       // stop after first Nan value
-      if (!computed) break;
+      if (!computed) { break;
+}
     }
   }
 
diff --git a/opensfm/src/bundle/test/reprojection_errors_test.cc b/opensfm/src/bundle/test/reprojection_errors_test.cc
index cfb9edb64..581296c03 100644
--- a/opensfm/src/bundle/test/reprojection_errors_test.cc
+++ b/opensfm/src/bundle/test/reprojection_errors_test.cc
@@ -7,7 +7,7 @@
 
 class ReprojectionError2DFixtureBase : public ::testing::Test {
  public:
-  typedef Eigen::AutoDiffScalar<Eigen::VectorXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<Eigen::VectorXd>;
   ReprojectionError2DFixtureBase() { observed << 0.5, 0.5; }
 
   constexpr static int size_residual = 2;
@@ -118,7 +118,7 @@ TEST_F(ReprojectionError2DFixture, BrownAnalyticErrorEvaluatesOK) {
   // focal, ar, cx, cy, k1, k2, k3, p1, p2
   constexpr std::array<double, size> camera{0.3,   1.0,   0.001,  -0.02, 0.1,
                                             -0.03, 0.001, -0.005, 0.001};
-  RunTest<size>(geometry::ProjectionType::BROWN, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::BROWN, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, PerspectiveAnalyticErrorEvaluatesOK) {
@@ -126,7 +126,7 @@ TEST_F(ReprojectionError2DFixture, PerspectiveAnalyticErrorEvaluatesOK) {
 
   // focal, k1, k2
   constexpr std::array<double, size> camera{0.3, 0.1, -0.03};
-  RunTest<size>(geometry::ProjectionType::PERSPECTIVE, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::PERSPECTIVE, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, FisheyeAnalyticErrorEvaluatesOK) {
@@ -134,7 +134,7 @@ TEST_F(ReprojectionError2DFixture, FisheyeAnalyticErrorEvaluatesOK) {
 
   // focal, k1, k2, k3
   constexpr std::array<double, size> camera{0.3, 0.1, -0.03};
-  RunTest<size>(geometry::ProjectionType::FISHEYE, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::FISHEYE, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, FisheyeOpencvAnalyticErrorEvaluatesOK) {
@@ -143,7 +143,7 @@ TEST_F(ReprojectionError2DFixture, FisheyeOpencvAnalyticErrorEvaluatesOK) {
   // focal, ar, cx, cy, k1, k2, k3, k4
   constexpr std::array<double, size> camera{0.3, 1.0,   0.001, -0.02,
                                             0.1, -0.03, 0.001, -0.005};
-  RunTest<size>(geometry::ProjectionType::FISHEYE_OPENCV, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::FISHEYE_OPENCV, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, Fisheye62AnalyticErrorEvaluatesOK) {
@@ -153,7 +153,7 @@ TEST_F(ReprojectionError2DFixture, Fisheye62AnalyticErrorEvaluatesOK) {
   constexpr std::array<double, size> camera{0.3,  1.0,   0.001, -0.02,
                                             0.1,  -0.03, 0.001, -0.005,
                                             0.01, 0.006, 0.02,  0.003};
-  RunTest<size>(geometry::ProjectionType::FISHEYE62, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::FISHEYE62, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, Fisheye624AnalyticErrorEvaluatesOK) {
@@ -163,7 +163,7 @@ TEST_F(ReprojectionError2DFixture, Fisheye624AnalyticErrorEvaluatesOK) {
   constexpr std::array<double, size> camera{
       0.3,  1.0,   0.001, -0.02, 0.1,   -0.03,  0.001, -0.005,
       0.01, 0.006, 0.02,  0.003, 0.001, -0.009, -0.01, 0.03};
-  RunTest<size>(geometry::ProjectionType::FISHEYE624, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::FISHEYE624, camera.data());
 }
 
 TEST_F(ReprojectionError2DFixture, DualAnalyticErrorEvaluatesOK) {
@@ -171,14 +171,14 @@ TEST_F(ReprojectionError2DFixture, DualAnalyticErrorEvaluatesOK) {
 
   // transition, focal, k1, k2
   constexpr std::array<double, size> camera{0.5, 0.3, 0.1, -0.03};
-  RunTest<size>(geometry::ProjectionType::DUAL, &camera[0]);
+  RunTest<size>(geometry::ProjectionType::DUAL, camera.data());
 }
 
 class ReprojectionError3DFixture : public ::testing::Test {
  public:
   static constexpr int size = 3;
 
-  typedef Eigen::AutoDiffScalar<Eigen::VectorXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<Eigen::VectorXd>;
   ReprojectionError3DFixture() { observed << 0.5, 0.5; }
 
   void SetupADiff() {
diff --git a/opensfm/src/dense/depthmap_bind.h b/opensfm/src/dense/depthmap_bind.h
index 2c62127fe..007178394 100644
--- a/opensfm/src/dense/depthmap_bind.h
+++ b/opensfm/src/dense/depthmap_bind.h
@@ -128,10 +128,10 @@ class DepthmapPrunerWrapper {
 
     py::list retn;
     int n = int(points.size()) / 3;
-    retn.append(py_array_from_data(&points[0], n, 3));
-    retn.append(py_array_from_data(&normals[0], n, 3));
-    retn.append(py_array_from_data(&colors[0], n, 3));
-    retn.append(py_array_from_data(&labels[0], n));
+    retn.append(py_array_from_data(points.data(), n, 3));
+    retn.append(py_array_from_data(normals.data(), n, 3));
+    retn.append(py_array_from_data(colors.data(), n, 3));
+    retn.append(py_array_from_data(labels.data(), n));
     return std::move(retn);
   }
 
diff --git a/opensfm/src/features/src/hahog.cc b/opensfm/src/features/src/hahog.cc
index 6f8002c64..3a6aace8f 100644
--- a/opensfm/src/features/src/hahog.cc
+++ b/opensfm/src/features/src/hahog.cc
@@ -49,7 +49,8 @@ vl_size run_non_maxima_suppression(VlCovDet *covdet, vl_size num_features,
       double dy_ = features[j].frame.y - y;
       double sigma_ = features[j].frame.a11;
       double score_ = features[j].peakScore;
-      if (score_ == 0) continue;
+      if (score_ == 0) { continue;
+}
       if (sigma < (1 + tol) * sigma_ && sigma_ < (1 + tol) * sigma &&
           vl_abs_d(dx_) < tol * sigma && vl_abs_d(dy_) < tol * sigma &&
           vl_abs_d(score) > vl_abs_d(score_)) {
@@ -178,15 +179,15 @@ py::tuple hahog(foundation::pyarray_f image, float peak_threshold,
       points[4 * i + 2] = size;
       points[4 * i + 3] = angle;
 
-      vl_covdet_extract_patch_for_frame(covdet, &patch[0], patchResolution,
+      vl_covdet_extract_patch_for_frame(covdet, patch.data(), patchResolution,
                                         patchRelativeExtent,
                                         patchRelativeSmoothing, frame);
 
-      vl_imgradient_polar_f(&patchXY[0], &patchXY[1], 2, 2 * patchSide,
-                            &patch[0], patchSide, patchSide, patchSide);
+      vl_imgradient_polar_f(patchXY.data(), &patchXY[1], 2, 2 * patchSide,
+                            patch.data(), patchSide, patchSide, patchSide);
 
       vl_sift_calc_raw_descriptor(
-          sift, &patchXY[0], &desc[dimension * i], (int)patchSide,
+          sift, patchXY.data(), &desc[dimension * i], (int)patchSide,
           (int)patchSide, (double)(patchSide - 1) / 2,
           (double)(patchSide - 1) / 2,
           (double)patchRelativeExtent / (3.0 * (4 + 1) / 2) / patchStep,
diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index d759b7647..0623cd452 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -66,7 +66,8 @@ void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
         }
         checks++;
       }
-      if (checks >= max_checks) break;
+      if (checks >= max_checks) { break;
+}
     }
     if (best_distance[i] < lowes_ratio * second_best_distance[i]) {
       tmp_match.at<int>(0, 0) = i;
diff --git a/opensfm/src/foundation/numeric.h b/opensfm/src/foundation/numeric.h
index 19cdb8bef..ba42e1c8b 100644
--- a/opensfm/src/foundation/numeric.h
+++ b/opensfm/src/foundation/numeric.h
@@ -35,11 +35,12 @@ bool SolveAX0(const MAT& A, VEC* solution) {
 
   // Some nullspace will make a solution
   const bool some_nullspace = ratio > minimum_ratio;
-  if (some_nullspace)
+  if (some_nullspace) {
     return true;
-  else
+  } else {
     return false;
 }
+}
 
 Eigen::Matrix3d SkewMatrix(const Eigen::Vector3d& v);
 template <class V, class M>
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index c56d71e88..35855cc28 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -10,12 +10,10 @@ namespace py = pybind11;
 
 namespace foundation {
 
-typedef py::array_t<float, py::array::c_style | py::array::forcecast> pyarray_f;
-typedef py::array_t<double, py::array::c_style | py::array::forcecast>
-    pyarray_d;
-typedef py::array_t<int, py::array::c_style | py::array::forcecast> pyarray_int;
-typedef py::array_t<unsigned char, py::array::c_style | py::array::forcecast>
-    pyarray_uint8;
+using pyarray_f = py::array_t<float, py::array::c_style | py::array::forcecast>;
+using pyarray_d = py::array_t<double, py::array::c_style | py::array::forcecast>;
+using pyarray_int = py::array_t<int, py::array::c_style | py::array::forcecast>;
+using pyarray_uint8 = py::array_t<unsigned char, py::array::c_style | py::array::forcecast>;
 
 template <typename T>
 py::array_t<T> py_array_from_data(const T *data, size_t shape0) {
@@ -41,7 +39,7 @@ py::array_t<T> py_array_from_data(const T *data, size_t shape0, size_t shape1,
 
 template <typename T>
 py::array_t<T> py_array_from_vector(const std::vector<T> &v) {
-  const T *data = v.size() ? &v[0] : NULL;
+  const T *data = v.size() ? v.data() : NULL;
   return py_array_from_data(data, v.size());
 }
 
diff --git a/opensfm/src/geometry/covariance.h b/opensfm/src/geometry/covariance.h
index 8c6a0b52f..af6d747b9 100644
--- a/opensfm/src/geometry/covariance.h
+++ b/opensfm/src/geometry/covariance.h
@@ -3,8 +3,7 @@
 #include <geometry/functions.h>
 #include <geometry/pose.h>
 
-namespace geometry {
-namespace covariance {
+namespace geometry::covariance {
 using PointJacobian = Eigen::Matrix<double, 2, 3, Eigen::RowMajor>;
 std::pair<PointJacobian, Vec2d> ComputeJacobianReprojectionError(
     const Camera& camera, const Pose& pose, const Vec2d& observation,
@@ -12,5 +11,4 @@ std::pair<PointJacobian, Vec2d> ComputeJacobianReprojectionError(
 std::pair<Mat3d, double> ComputePointInverseCovariance(
     const std::vector<Camera>& cameras, const std::vector<Pose>& poses,
     const std::vector<Vec2d>& observations, const Vec3d& point);
-}  // namespace covariance
 }  // namespace geometry
diff --git a/opensfm/src/geometry/src/covariance.cc b/opensfm/src/geometry/src/covariance.cc
index c88942b61..b86fabf3d 100644
--- a/opensfm/src/geometry/src/covariance.cc
+++ b/opensfm/src/geometry/src/covariance.cc
@@ -1,7 +1,6 @@
 #include <geometry/covariance.h>
 
-namespace geometry {
-namespace covariance {
+namespace geometry::covariance {
 using PointJacobian = Eigen::Matrix<double, 2, 3, Eigen::RowMajor>;
 std::pair<PointJacobian, Vec2d> ComputeJacobianReprojectionError(
     const Camera& camera, const Pose& pose, const Vec2d& observation,
@@ -39,5 +38,4 @@ std::pair<Mat3d, double> ComputePointInverseCovariance(
   return std::make_pair(covariance, sigma2);
 }
 
-}  // namespace covariance
 }  // namespace geometry
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 1723731fa..470ea71dd 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -5,15 +5,16 @@
 #include <foundation/types.h>
 #include <geometry/transformations_functions.h>
 #include <geometry/triangulation.h>
-#include <math.h>
+#include <cmath>
 
 double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v) {
   double c = (u.dot(v)) / sqrt(u.dot(u) * v.dot(v));
-  if (std::fabs(c) >= 1.0)
+  if (std::fabs(c) >= 1.0) {
     return 0.0;
-  else
+  } else {
     return acos(c);
 }
+}
 
 Eigen::Vector4d TriangulateBearingsDLTSolve(
     const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
diff --git a/opensfm/src/geometry/test/camera_functions_test.cc b/opensfm/src/geometry/test/camera_functions_test.cc
index d851c28dd..975ee9e9f 100644
--- a/opensfm/src/geometry/test/camera_functions_test.cc
+++ b/opensfm/src/geometry/test/camera_functions_test.cc
@@ -305,7 +305,7 @@ class CameraDerivativesFixture : public ::testing::Test {
   Vec2d principal_point;
 
   double point[3];
-  typedef Eigen::AutoDiffScalar<VecXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<VecXd>;
   AScalar point_adiff[3];
   VecX<AScalar> camera_adiff;
 
diff --git a/opensfm/src/geometry/test/covariance_test.cc b/opensfm/src/geometry/test/covariance_test.cc
index 9a235bfac..0049e27d9 100644
--- a/opensfm/src/geometry/test/covariance_test.cc
+++ b/opensfm/src/geometry/test/covariance_test.cc
@@ -70,7 +70,7 @@ class CovarianceFixture : public ::testing::Test {
 
   const double focal{1.0};
   double point[3];
-  typedef Eigen::AutoDiffScalar<VecXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<VecXd>;
   AScalar point_adiff[3];
   AScalar projection_expected[2];
   Vec2d observation;
diff --git a/opensfm/src/map/ground_control_points.h b/opensfm/src/map/ground_control_points.h
index bab86d74a..c14a07b6e 100644
--- a/opensfm/src/map/ground_control_points.h
+++ b/opensfm/src/map/ground_control_points.h
@@ -25,7 +25,7 @@ struct GroundControlPointObservation {
   GroundControlPointObservation() = default;
   GroundControlPointObservation(const ShotId& shot_id, const Vec2d& proj)
       : shot_id_(shot_id), projection_(proj) {}
-  ShotId shot_id_ = "";
+  ShotId shot_id_;
   Vec2d projection_ = Vec2d::Zero();
   LandmarkUniqueId uid_ = 0;
 };
@@ -42,7 +42,7 @@ struct GroundControlPoint {
          ground control point is used for computing map merging metrics
      */
   GroundControlPoint() = default;
-  LandmarkId id_ = "";
+  LandmarkId id_;
   LandmarkUniqueId survey_point_id_ = 0;
   bool has_altitude_ = false;
   AlignedVector<GroundControlPointObservation> observations_;
diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index 817d1a16a..414d9ca74 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -68,10 +68,11 @@ iterator make_value_iterator(Iterator first, Sentinel last, Extra &&... extra) {
         .def("__iter__", [](state &s) -> state & { return s; })
         .def("__next__",
              [](state &s) -> KeyType {
-               if (!s.first_or_done)
+               if (!s.first_or_done) {
                  ++s.it;
-               else
+               } else {
                  s.first_or_done = false;
+}
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -99,10 +100,11 @@ iterator make_ref_value_iterator(Iterator first, Sentinel last,
         .def("__iter__", [](state &s) -> state & { return s; })
         .def("__next__",
              [](state &s) -> KeyType {
-               if (!s.first_or_done)
+               if (!s.first_or_done) {
                  ++s.it;
-               else
+               } else {
                  s.first_or_done = false;
+}
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -131,10 +133,11 @@ iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&... extra) {
         .def("__iter__", [](state &s) -> state & { return s; })
         .def("__next__",
              [](state &s) -> KeyType {
-               if (!s.first_or_done)
+               if (!s.first_or_done) {
                  ++s.it;
-               else
+               } else {
                  s.first_or_done = false;
+}
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -160,10 +163,11 @@ iterator make_ptr_iterator(Iterator first, Sentinel last, Extra &&... extra) {
         .def("__iter__", [](state &s) -> state & { return s; })
         .def("__next__",
              [](state &s) -> ValueType {
-               if (!s.first_or_done)
+               if (!s.first_or_done) {
                  ++s.it;
-               else
+               } else {
                  s.first_or_done = false;
+}
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
diff --git a/opensfm/src/map/src/map.cc b/opensfm/src/map/src/map.cc
index cce614ffc..e8773ca2c 100644
--- a/opensfm/src/map/src/map.cc
+++ b/opensfm/src/map/src/map.cc
@@ -320,8 +320,8 @@ void Map::RemoveLandmark(const LandmarkId& lm_id) {
 }
 
 geometry::Camera& Map::CreateCamera(const geometry::Camera& cam) {
-  auto it = cameras_.emplace(std::make_pair(cam.id, cam));
-  bias_.emplace(std::make_pair(cam.id, geometry::Similarity()));
+  auto it = cameras_.emplace(cam.id, cam);
+  bias_.emplace(cam.id, geometry::Similarity());
   return it.first->second;
 }
 
@@ -413,7 +413,7 @@ RigCamera& Map::CreateRigCamera(const map::RigCamera& rig_camera) {
     throw std::runtime_error("RigCamera " + rig_camera.id + " already exists.");
   }
 
-  auto it = rig_cameras_.emplace(std::make_pair(rig_camera.id, rig_camera));
+  auto it = rig_cameras_.emplace(rig_camera.id, rig_camera);
   return it.first->second;
 }
 
diff --git a/opensfm/src/sfm/retriangulation.h b/opensfm/src/sfm/retriangulation.h
index 100a64ca0..c1e703ca2 100644
--- a/opensfm/src/sfm/retriangulation.h
+++ b/opensfm/src/sfm/retriangulation.h
@@ -2,9 +2,7 @@
 #include <map/map.h>
 #include <map/tracks_manager.h>
 
-namespace sfm {
-namespace retriangulation {
+namespace sfm::retriangulation {
 void RealignMaps(const map::Map& reference, map::Map& to_align,
                  bool update_points);
-}  // namespace retriangulation
 }  // namespace sfm
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index e06692840..d0aca260f 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -852,7 +852,8 @@ void BAHelpers::AlignmentConstraints(
   // Triangulated vs measured points
   if (!gcp.empty() && config["bundle_use_gcp"].cast<bool>()) {
     for (const auto& point : gcp) {
-      if (point.lla_.empty()) continue;
+      if (point.lla_.empty()) { continue;
+}
       Vec3d coordinates;
       if (TriangulateGCP(point, shots, coordinates)) {
         Xp.row(idx) = topocentricConverter.ToTopocentric(point.GetLlaVec3d());
diff --git a/opensfm/src/sfm/src/retriangulation.cc b/opensfm/src/sfm/src/retriangulation.cc
index 78c30c447..006189b32 100644
--- a/opensfm/src/sfm/src/retriangulation.cc
+++ b/opensfm/src/sfm/src/retriangulation.cc
@@ -5,8 +5,7 @@
 #include <limits>
 #include <unordered_set>
 
-namespace sfm {
-namespace retriangulation {
+namespace sfm::retriangulation {
 void RealignMaps(const map::Map& map_from, map::Map& map_to,
                  bool update_points) {
   const auto& map_from_shots = map_from.GetShots();
@@ -114,5 +113,4 @@ void RealignMaps(const map::Map& map_from, map::Map& map_to,
     map_to.RemoveShot(shot_id);
   }
 }
-}  // namespace retriangulation
 }  // namespace sfm
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index 27e4ff967..2346bcc94 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -3,8 +3,7 @@
 #include <unordered_map>
 #include <unordered_set>
 
-namespace sfm {
-namespace tracks_helpers {
+namespace sfm::tracks_helpers {
 std::unordered_map<map::ShotId, int> CountTracksPerShot(
     const map::TracksManager& manager, const std::vector<map::ShotId>& shots,
     const std::vector<map::TrackId>& tracks) {
@@ -43,5 +42,4 @@ void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
     manager.RemoveObservation(shot_id, connection);
   }
 }
-}  // namespace tracks_helpers
 }  // namespace sfm
diff --git a/opensfm/src/sfm/test/tracks_helpers_test.cc b/opensfm/src/sfm/test/tracks_helpers_test.cc
index 7420d08bb..baee75dd8 100644
--- a/opensfm/src/sfm/test/tracks_helpers_test.cc
+++ b/opensfm/src/sfm/test/tracks_helpers_test.cc
@@ -18,11 +18,11 @@ class TracksHelpersTest : public ::testing::Test {
     track["2"] = o2;
     track["3"] = o3;
 
-    connections_add.push_back("1");
-    connections_add.push_back("2");
-    connections_add.push_back("3");
+    connections_add.emplace_back("1");
+    connections_add.emplace_back("2");
+    connections_add.emplace_back("3");
 
-    connections_remove.push_back("1");
+    connections_remove.emplace_back("1");
   }
 
   map::TracksManager manager;
diff --git a/opensfm/src/sfm/tracks_helpers.h b/opensfm/src/sfm/tracks_helpers.h
index 42e7f5f00..cadc91ea0 100644
--- a/opensfm/src/sfm/tracks_helpers.h
+++ b/opensfm/src/sfm/tracks_helpers.h
@@ -9,8 +9,7 @@
 
 #include <string>
 
-namespace sfm {
-namespace tracks_helpers {
+namespace sfm::tracks_helpers {
 std::unordered_map<map::ShotId, int> CountTracksPerShot(
     const map::TracksManager& manager, const std::vector<map::ShotId>& shots,
     const std::vector<map::TrackId>& tracks);
@@ -18,5 +17,4 @@ void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                     const std::vector<map::TrackId>& connections);
 void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                        const std::vector<map::TrackId>& connections);
-}  // namespace tracks_helpers
 }  // namespace sfm
diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index 26472fea2..32f1b0ae8 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -165,8 +165,9 @@ int AKAZE::Create_Nonlinear_Scale_Space(const cv::Mat& img) {
     }
 
     // Perform FED n inner steps
-    for (int j = 0; j < nsteps_[i-1]; j++)
+    for (int j = 0; j < nsteps_[i-1]; j++) {
       nld_step_scalar(evolution_[i].Lt, evolution_[i].Lflow, evolution_[i].Lstep, tsteps_[i-1][j]);
+}
   }
 
   t2 = cv::getTickCount();
@@ -241,8 +242,9 @@ void AKAZE::Compute_Determinant_Hessian_Response() {
       const float* lxy = evolution_[i].Lxy.ptr<float>(ix);
       const float* lyy = evolution_[i].Lyy.ptr<float>(ix);
       float* ldet = evolution_[i].Ldet.ptr<float>(ix);
-      for (int jx = 0; jx < evolution_[i].Ldet.cols; jx++)
+      for (int jx = 0; jx < evolution_[i].Ldet.cols; jx++) {
         ldet[jx] = lxx[jx]*lyy[jx]-lxy[jx]*lxy[jx];
+}
     }
   }
 }
@@ -391,8 +393,9 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
       }
     }
 
-    if (is_repeated == false)
+    if (is_repeated == false) {
       kpts.push_back(point);
+}
   }
 
   // Keep only the k-best keypoints
@@ -583,10 +586,11 @@ void AKAZE::Compute_Descriptors(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc)
 #pragma omp parallel for
 #endif
       for (int i = 0; i < (int)(kpts.size()); i++) {
-        if (options_.descriptor_size == 0)
+        if (options_.descriptor_size == 0) {
           Get_Upright_MLDB_Full_Descriptor(kpts[i], desc.ptr<unsigned char>(i));
-        else
+        } else {
           Get_Upright_MLDB_Descriptor_Subset(kpts[i], desc.ptr<unsigned char>(i));
+}
       }
     }
     break;
@@ -597,10 +601,11 @@ void AKAZE::Compute_Descriptors(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc)
 #endif
       for (int i = 0; i < (int)(kpts.size()); i++) {
         Compute_Main_Orientation(kpts[i]);
-        if (options_.descriptor_size == 0)
+        if (options_.descriptor_size == 0) {
           Get_MLDB_Full_Descriptor(kpts[i], desc.ptr<unsigned char>(i));
-        else
+        } else {
           Get_MLDB_Descriptor_Subset(kpts[i], desc.ptr<unsigned char>(i));
+}
       }
     }
     break;
@@ -843,9 +848,10 @@ void AKAZE::Get_SURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const {
   // convert to unit vector
   len = sqrt(len);
 
-  for (int i = 0; i < dsize; i++)
+  for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
 }
+}
 
 /* ************************************************************************* */
 void AKAZE::Get_MSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const {
@@ -954,9 +960,10 @@ void AKAZE::Get_MSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float *desc
   // convert to unit vector
   len = sqrt(len);
 
-  for (int i = 0; i < dsize; i++)
+  for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
 }
+}
 
 /* ************************************************************************* */
 void AKAZE::Get_MSURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const {
@@ -1069,9 +1076,10 @@ void AKAZE::Get_MSURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const
   // convert to unit vector
   len = sqrt(len);
 
-  for (int i = 0; i < dsize; i++)
+  for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
 }
+}
 
 /* ************************************************************************* */
 void AKAZE::Get_MLDB_Full_Descriptor(const cv::KeyPoint& kpt, unsigned char* desc) const {
@@ -1170,11 +1178,13 @@ void AKAZE::MLDB_Fill_Values(float* values, int sample_step, int level,
 
       values[valpos] = di;
 
-      if (nr_channels > 1)
+      if (nr_channels > 1) {
         values[valpos + 1] = dx;
+}
 
-      if (nr_channels > 2)
+      if (nr_channels > 2) {
         values[valpos + 2] = dy;
+}
 
       valpos += nr_channels;
     }
@@ -1229,11 +1239,13 @@ void AKAZE::MLDB_Fill_Upright_Values(float* values, int sample_step, int level,
 
       values[valpos] = di;
 
-      if (nr_channels > 1)
+      if (nr_channels > 1) {
         values[valpos + 1] = dx;
+}
 
-      if (nr_channels > 2)
+      if (nr_channels > 2) {
         values[valpos + 2] = dy;
+}
 
       valpos += nr_channels;
     }
@@ -1569,16 +1581,20 @@ void libAKAZE::generateDescriptorSubsample(cv::Mat& sampleList, cv::Mat& compari
 /* ************************************************************************* */
 void libAKAZE::check_descriptor_limits(int &x, int &y, int width, int height) {
 
-  if (x < 0)
+  if (x < 0) {
     x = 0;
+}
 
-  if (y < 0)
+  if (y < 0) {
     y = 0;
+}
 
-  if (x > width-1)
+  if (x > width-1) {
     x = width-1;
+}
 
-  if (y > height-1)
+  if (y > height-1) {
     y = height-1;
 }
+}
 
diff --git a/opensfm/src/third_party/akaze/lib/fed.cpp b/opensfm/src/third_party/akaze/lib/fed.cpp
index 7973af6b8..ac67fa1c3 100644
--- a/opensfm/src/third_party/akaze/lib/fed.cpp
+++ b/opensfm/src/third_party/akaze/lib/fed.cpp
@@ -66,14 +66,16 @@ int fed_tau_internal(const int n, const float scale, const float tau_max,
   float c = 0.0, d = 0.0;     // Time savers
   vector<float> tauh;    // Helper vector for unsorted taus
 
-  if (n <= 0)
+  if (n <= 0) {
     return 0;
+}
 
   // Allocate memory for the time step size
   tau = vector<float>(n);
 
-  if (reordering)
+  if (reordering) {
     tauh = vector<float>(n);
+}
 
   // Compute time saver
   c = 1.0f / (4.0f * (float)n + 2.0f);
@@ -83,10 +85,11 @@ int fed_tau_internal(const int n, const float scale, const float tau_max,
   for (int k = 0; k < n; ++k) {
     float h = cos(M_PI * (2.0f * (float)k + 1.0f) * c);
 
-    if (reordering)
+    if (reordering) {
       tauh[k] = d / (h * h);
-    else
+    } else {
       tau[k] = d / (h * h);
+}
   }
 
   // Permute list of time steps according to chosen reordering function
diff --git a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
index 1fdab7b95..3981d455c 100644
--- a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
+++ b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
@@ -33,11 +33,13 @@ void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, size_t ksize_x,
   }
 
   // The kernel size must be and odd number
-  if ((ksize_x % 2) == 0)
+  if ((ksize_x % 2) == 0) {
     ksize_x += 1;
+}
 
-  if ((ksize_y % 2) == 0)
+  if ((ksize_y % 2) == 0) {
     ksize_y += 1;
+}
 
   // Perform the Gaussian Smoothing with border replication
   cv::GaussianBlur(src, dst, cv::Size(ksize_x, ksize_y), sigma, sigma, cv::BORDER_REPLICATE);
@@ -58,8 +60,9 @@ void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float k) {
     const float* Lx_row = Lx.ptr<float>(y);
     const float* Ly_row = Ly.ptr<float>(y);
     float* dst_row = dst.ptr<float>(y);
-    for (int x = 0; x < sz.width; x++)
+    for (int x = 0; x < sz.width; x++) {
       dst_row[x] = (-inv_k*(Lx_row[x]*Lx_row[x] + Ly_row[x]*Ly_row[x]));
+}
   }
 
   cv::exp(dst, dst);
@@ -74,8 +77,9 @@ void pm_g2(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float k) {
     const float* Lx_row = Lx.ptr<float>(y);
     const float* Ly_row = Ly.ptr<float>(y);
     float* dst_row = dst.ptr<float>(y);
-    for (int x = 0; x < sz.width; x++)
+    for (int x = 0; x < sz.width; x++) {
       dst_row[x] = 1.0 / (1.0+inv_k*(Lx_row[x]*Lx_row[x] + Ly_row[x]*Ly_row[x]));
+}
   }
 }
 
@@ -130,8 +134,9 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
   cv::Mat Ly = cv::Mat::zeros(img.rows, img.cols, CV_32F);
 
   // Set the histogram to zero
-  for (size_t i = 0; i < nbins; i++)
+  for (size_t i = 0; i < nbins; i++) {
     hist[i] = 0.0;
+}
 
   // Perform the Gaussian convolution
   gaussian_2D_convolution(img, gaussian, ksize_x, ksize_y, gscale);
@@ -151,8 +156,9 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
       modg = sqrt(Lx_row[x]*Lx_row[x] + Ly_row[x]*Ly_row[x]);
 
       // Get the maximum
-      if (modg > hmax)
+      if (modg > hmax) {
         hmax = modg;
+}
     }
   }
 
@@ -183,13 +189,15 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
   // Now find the perc of the histogram percentile
   nthreshold = (size_t)(npoints*perc);
 
-  for (k = 0; nelements < nthreshold && k < nbins; k++)
+  for (k = 0; nelements < nthreshold && k < nbins; k++) {
     nelements = nelements + hist[k];
+}
 
-  if (nelements < nthreshold)
+  if (nelements < nthreshold) {
     kperc = 0.03;
-  else
+  } else {
     kperc = hmax*((float)(k)/(float)nbins);
+}
 
   delete [] hist;
   return kperc;
@@ -343,8 +351,9 @@ void compute_derivative_kernels(cv::OutputArray kx_, cv::OutputArray ky_,
     int order = k == 0 ? dx : dy;
     float kerI[1000];
 
-    for (int t = 0; t<ksize; t++)
+    for (int t = 0; t<ksize; t++) {
       kerI[t] = 0;
+}
 
     if (order == 0) {
       kerI[0] = norm;
diff --git a/opensfm/src/third_party/akaze/lib/utils.cpp b/opensfm/src/third_party/akaze/lib/utils.cpp
index 737f5de54..5d2a674a3 100644
--- a/opensfm/src/third_party/akaze/lib/utils.cpp
+++ b/opensfm/src/third_party/akaze/lib/utils.cpp
@@ -36,8 +36,9 @@ void compute_min_32F(const cv::Mat &src, float& value) {
   float aux = 1000.0;
   for (int i = 0; i < src.rows; i++) {
     for (int j = 0; j < src.cols; j++) {
-      if (src.at<float>(i,j) < aux)
+      if (src.at<float>(i,j) < aux) {
         aux = src.at<float>(i,j);
+}
     }
   }
   value = aux;
@@ -49,8 +50,9 @@ void compute_max_32F(const cv::Mat &src, float& value) {
   float aux = 0.0;
   for (int i = 0; i < src.rows; i++) {
     for (int j = 0; j < src.cols; j++) {
-      if (src.at<float>(i,j) > aux)
+      if (src.at<float>(i,j) > aux) {
         aux = src.at<float>(i,j);
+}
     }
   }
   value = aux;
@@ -184,10 +186,11 @@ void compute_inliers_ransac(const std::vector<cv::Point2f>& matches,
   }
 
   if (npoints > 8) {
-    if (use_fund == true)
+    if (use_fund == true) {
       H = cv::findFundamentalMat(points1,points2,cv::FM_RANSAC,error,0.99,status);
-    else
+    } else {
       H = cv::findHomography(points1,points2,cv::RANSAC,error,status);
+}
 
     for (int i = 0; i < npoints; i++) {
       if (status.at<unsigned char>(i) == 1) {
@@ -326,12 +329,13 @@ void draw_inliers(const cv::Mat& img1, const cv::Mat& img2, cv::Mat& img_com,
     x2 = (int)(ptpairs[i+1].x*ufactor+img1.cols+.5);
     y2 = (int)(ptpairs[i+1].y*vfactor+.5);
 
-    if (color == 0)
+    if (color == 0) {
       cv::line(img_com, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(255,255,0), 2);
-    else if (color == 1)
+    } else if (color == 1) {
       cv::line(img_com, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(255,0,0), 2);
-    else if (color == 2)
+    } else if (color == 2) {
       cv::line(img_com, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(0,0,255), 2);
+}
   }
 }
 
@@ -351,8 +355,9 @@ bool read_homography(const string& hFile, cv::Mat& H1toN) {
   ifstream pf;
   pf.open(filename.c_str(), std::ifstream::in);
 
-  if (!pf.is_open())
+  if (!pf.is_open()) {
     return false;
+}
 
   pf.getline(tmp_buf,tmp_buf_size);
   sscanf(tmp_buf,"%f %f %f",&h11,&h12,&h13);

From 8f618a2baf99589064f6eebb1c5018cda4dbfd43 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Wed, 28 Feb 2024 04:53:27 -0800
Subject: [PATCH 064/235] fix some indentation messed up by a codemod

Summary: The previous diff failed to indent closing brackets.

Reviewed By: fabianschenk

Differential Revision: D54298641

fbshipit-source-id: fff4bb610fad7ee64375f7182b3e4c177556af95
---
 opensfm/src/bundle/src/bundle_adjuster.cc     |  5 +--
 opensfm/src/features/src/hahog.cc             |  5 +--
 opensfm/src/features/src/matching.cc          |  5 +--
 opensfm/src/foundation/numeric.h              |  2 +-
 opensfm/src/geometry/src/triangulation.cc     |  2 +-
 opensfm/src/map/pybind_utils.h                |  8 ++---
 opensfm/src/sfm/src/ba_helpers.cc             |  5 +--
 opensfm/src/third_party/akaze/lib/AKAZE.cpp   | 35 +++++++++----------
 opensfm/src/third_party/akaze/lib/fed.cpp     |  6 ++--
 .../akaze/lib/nldiffusion_functions.cpp       | 16 ++++-----
 opensfm/src/third_party/akaze/lib/utils.cpp   | 14 ++++----
 11 files changed, 53 insertions(+), 50 deletions(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 40aac3347..907a6691c 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -1128,8 +1128,9 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
         break;
       }
       // stop after first Nan value
-      if (!computed) { break;
-}
+      if (!computed) {
+        break;
+      }
     }
   }
 
diff --git a/opensfm/src/features/src/hahog.cc b/opensfm/src/features/src/hahog.cc
index 3a6aace8f..691a898fb 100644
--- a/opensfm/src/features/src/hahog.cc
+++ b/opensfm/src/features/src/hahog.cc
@@ -49,8 +49,9 @@ vl_size run_non_maxima_suppression(VlCovDet *covdet, vl_size num_features,
       double dy_ = features[j].frame.y - y;
       double sigma_ = features[j].frame.a11;
       double score_ = features[j].peakScore;
-      if (score_ == 0) { continue;
-}
+      if (score_ == 0) {
+        continue;
+      }
       if (sigma < (1 + tol) * sigma_ && sigma_ < (1 + tol) * sigma &&
           vl_abs_d(dx_) < tol * sigma && vl_abs_d(dy_) < tol * sigma &&
           vl_abs_d(score) > vl_abs_d(score_)) {
diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index 0623cd452..b25ed46ca 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -66,8 +66,9 @@ void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
         }
         checks++;
       }
-      if (checks >= max_checks) { break;
-}
+      if (checks >= max_checks) {
+        break;
+      }
     }
     if (best_distance[i] < lowes_ratio * second_best_distance[i]) {
       tmp_match.at<int>(0, 0) = i;
diff --git a/opensfm/src/foundation/numeric.h b/opensfm/src/foundation/numeric.h
index ba42e1c8b..dd1550791 100644
--- a/opensfm/src/foundation/numeric.h
+++ b/opensfm/src/foundation/numeric.h
@@ -39,7 +39,7 @@ bool SolveAX0(const MAT& A, VEC* solution) {
     return true;
   } else {
     return false;
-}
+  }
 }
 
 Eigen::Matrix3d SkewMatrix(const Eigen::Vector3d& v);
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 470ea71dd..be15dfd4b 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -13,7 +13,7 @@ double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v) {
     return 0.0;
   } else {
     return acos(c);
-}
+  }
 }
 
 Eigen::Vector4d TriangulateBearingsDLTSolve(
diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index 414d9ca74..e7f402eed 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -72,7 +72,7 @@ iterator make_value_iterator(Iterator first, Sentinel last, Extra &&... extra) {
                  ++s.it;
                } else {
                  s.first_or_done = false;
-}
+               }
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -104,7 +104,7 @@ iterator make_ref_value_iterator(Iterator first, Sentinel last,
                  ++s.it;
                } else {
                  s.first_or_done = false;
-}
+               }
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -137,7 +137,7 @@ iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&... extra) {
                  ++s.it;
                } else {
                  s.first_or_done = false;
-}
+               }
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
@@ -167,7 +167,7 @@ iterator make_ptr_iterator(Iterator first, Sentinel last, Extra &&... extra) {
                  ++s.it;
                } else {
                  s.first_or_done = false;
-}
+               }
                if (s.it == s.end) {
                  s.first_or_done = true;
                  throw stop_iteration();
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index d0aca260f..d0501aa84 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -852,8 +852,9 @@ void BAHelpers::AlignmentConstraints(
   // Triangulated vs measured points
   if (!gcp.empty() && config["bundle_use_gcp"].cast<bool>()) {
     for (const auto& point : gcp) {
-      if (point.lla_.empty()) { continue;
-}
+      if (point.lla_.empty()) {
+        continue;
+      }
       Vec3d coordinates;
       if (TriangulateGCP(point, shots, coordinates)) {
         Xp.row(idx) = topocentricConverter.ToTopocentric(point.GetLlaVec3d());
diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index 32f1b0ae8..5d42f251d 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -167,7 +167,7 @@ int AKAZE::Create_Nonlinear_Scale_Space(const cv::Mat& img) {
     // Perform FED n inner steps
     for (int j = 0; j < nsteps_[i-1]; j++) {
       nld_step_scalar(evolution_[i].Lt, evolution_[i].Lflow, evolution_[i].Lstep, tsteps_[i-1][j]);
-}
+    }
   }
 
   t2 = cv::getTickCount();
@@ -244,7 +244,7 @@ void AKAZE::Compute_Determinant_Hessian_Response() {
       float* ldet = evolution_[i].Ldet.ptr<float>(ix);
       for (int jx = 0; jx < evolution_[i].Ldet.cols; jx++) {
         ldet[jx] = lxx[jx]*lyy[jx]-lxy[jx]*lxy[jx];
-}
+      }
     }
   }
 }
@@ -395,7 +395,7 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
 
     if (is_repeated == false) {
       kpts.push_back(point);
-}
+    }
   }
 
   // Keep only the k-best keypoints
@@ -430,7 +430,7 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
     } else {
       // Non-adapting suppression: keep k best response.
       std::sort(kpts.begin(), kpts.end(), compareKeyPointResponse);
-      kpts.resize(options_.target_num_features);      
+      kpts.resize(options_.target_num_features);
     }
   }
   std::cout << "Keeping " << kpts.size() << " out of " << num_features_before << "\n";
@@ -590,7 +590,7 @@ void AKAZE::Compute_Descriptors(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc)
           Get_Upright_MLDB_Full_Descriptor(kpts[i], desc.ptr<unsigned char>(i));
         } else {
           Get_Upright_MLDB_Descriptor_Subset(kpts[i], desc.ptr<unsigned char>(i));
-}
+        }
       }
     }
     break;
@@ -605,7 +605,7 @@ void AKAZE::Compute_Descriptors(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc)
           Get_MLDB_Full_Descriptor(kpts[i], desc.ptr<unsigned char>(i));
         } else {
           Get_MLDB_Descriptor_Subset(kpts[i], desc.ptr<unsigned char>(i));
-}
+        }
       }
     }
     break;
@@ -850,7 +850,7 @@ void AKAZE::Get_SURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const {
 
   for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
-}
+  }
 }
 
 /* ************************************************************************* */
@@ -962,7 +962,7 @@ void AKAZE::Get_MSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float *desc
 
   for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
-}
+  }
 }
 
 /* ************************************************************************* */
@@ -1078,7 +1078,7 @@ void AKAZE::Get_MSURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const
 
   for (int i = 0; i < dsize; i++) {
     desc[i] /= len;
-}
+  }
 }
 
 /* ************************************************************************* */
@@ -1180,11 +1180,11 @@ void AKAZE::MLDB_Fill_Values(float* values, int sample_step, int level,
 
       if (nr_channels > 1) {
         values[valpos + 1] = dx;
-}
+      }
 
       if (nr_channels > 2) {
         values[valpos + 2] = dy;
-}
+      }
 
       valpos += nr_channels;
     }
@@ -1241,11 +1241,11 @@ void AKAZE::MLDB_Fill_Upright_Values(float* values, int sample_step, int level,
 
       if (nr_channels > 1) {
         values[valpos + 1] = dx;
-}
+      }
 
       if (nr_channels > 2) {
         values[valpos + 2] = dy;
-}
+      }
 
       valpos += nr_channels;
     }
@@ -1583,18 +1583,17 @@ void libAKAZE::check_descriptor_limits(int &x, int &y, int width, int height) {
 
   if (x < 0) {
     x = 0;
-}
+  }
 
   if (y < 0) {
     y = 0;
-}
+  }
 
   if (x > width-1) {
     x = width-1;
-}
+  }
 
   if (y > height-1) {
     y = height-1;
+  }
 }
-}
-
diff --git a/opensfm/src/third_party/akaze/lib/fed.cpp b/opensfm/src/third_party/akaze/lib/fed.cpp
index ac67fa1c3..8989c2463 100644
--- a/opensfm/src/third_party/akaze/lib/fed.cpp
+++ b/opensfm/src/third_party/akaze/lib/fed.cpp
@@ -68,14 +68,14 @@ int fed_tau_internal(const int n, const float scale, const float tau_max,
 
   if (n <= 0) {
     return 0;
-}
+  }
 
   // Allocate memory for the time step size
   tau = vector<float>(n);
 
   if (reordering) {
     tauh = vector<float>(n);
-}
+  }
 
   // Compute time saver
   c = 1.0f / (4.0f * (float)n + 2.0f);
@@ -89,7 +89,7 @@ int fed_tau_internal(const int n, const float scale, const float tau_max,
       tauh[k] = d / (h * h);
     } else {
       tau[k] = d / (h * h);
-}
+    }
   }
 
   // Permute list of time steps according to chosen reordering function
diff --git a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
index 3981d455c..b1e3567ef 100644
--- a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
+++ b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
@@ -35,11 +35,11 @@ void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, size_t ksize_x,
   // The kernel size must be and odd number
   if ((ksize_x % 2) == 0) {
     ksize_x += 1;
-}
+  }
 
   if ((ksize_y % 2) == 0) {
     ksize_y += 1;
-}
+  }
 
   // Perform the Gaussian Smoothing with border replication
   cv::GaussianBlur(src, dst, cv::Size(ksize_x, ksize_y), sigma, sigma, cv::BORDER_REPLICATE);
@@ -62,7 +62,7 @@ void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float k) {
     float* dst_row = dst.ptr<float>(y);
     for (int x = 0; x < sz.width; x++) {
       dst_row[x] = (-inv_k*(Lx_row[x]*Lx_row[x] + Ly_row[x]*Ly_row[x]));
-}
+    }
   }
 
   cv::exp(dst, dst);
@@ -79,7 +79,7 @@ void pm_g2(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float k) {
     float* dst_row = dst.ptr<float>(y);
     for (int x = 0; x < sz.width; x++) {
       dst_row[x] = 1.0 / (1.0+inv_k*(Lx_row[x]*Lx_row[x] + Ly_row[x]*Ly_row[x]));
-}
+    }
   }
 }
 
@@ -158,7 +158,7 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
       // Get the maximum
       if (modg > hmax) {
         hmax = modg;
-}
+     }
     }
   }
 
@@ -191,13 +191,13 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
 
   for (k = 0; nelements < nthreshold && k < nbins; k++) {
     nelements = nelements + hist[k];
-}
+  }
 
   if (nelements < nthreshold) {
     kperc = 0.03;
   } else {
     kperc = hmax*((float)(k)/(float)nbins);
-}
+  }
 
   delete [] hist;
   return kperc;
@@ -353,7 +353,7 @@ void compute_derivative_kernels(cv::OutputArray kx_, cv::OutputArray ky_,
 
     for (int t = 0; t<ksize; t++) {
       kerI[t] = 0;
-}
+    }
 
     if (order == 0) {
       kerI[0] = norm;
diff --git a/opensfm/src/third_party/akaze/lib/utils.cpp b/opensfm/src/third_party/akaze/lib/utils.cpp
index 5d2a674a3..ddd2a2f0f 100644
--- a/opensfm/src/third_party/akaze/lib/utils.cpp
+++ b/opensfm/src/third_party/akaze/lib/utils.cpp
@@ -38,7 +38,7 @@ void compute_min_32F(const cv::Mat &src, float& value) {
     for (int j = 0; j < src.cols; j++) {
       if (src.at<float>(i,j) < aux) {
         aux = src.at<float>(i,j);
-}
+      }
     }
   }
   value = aux;
@@ -52,7 +52,7 @@ void compute_max_32F(const cv::Mat &src, float& value) {
     for (int j = 0; j < src.cols; j++) {
       if (src.at<float>(i,j) > aux) {
         aux = src.at<float>(i,j);
-}
+      }
     }
   }
   value = aux;
@@ -190,7 +190,7 @@ void compute_inliers_ransac(const std::vector<cv::Point2f>& matches,
       H = cv::findFundamentalMat(points1,points2,cv::FM_RANSAC,error,0.99,status);
     } else {
       H = cv::findHomography(points1,points2,cv::RANSAC,error,status);
-}
+    }
 
     for (int i = 0; i < npoints; i++) {
       if (status.at<unsigned char>(i) == 1) {
@@ -335,7 +335,7 @@ void draw_inliers(const cv::Mat& img1, const cv::Mat& img2, cv::Mat& img_com,
       cv::line(img_com, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(255,0,0), 2);
     } else if (color == 2) {
       cv::line(img_com, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(0,0,255), 2);
-}
+    }
   }
 }
 
@@ -357,7 +357,7 @@ bool read_homography(const string& hFile, cv::Mat& H1toN) {
 
   if (!pf.is_open()) {
     return false;
-}
+  }
 
   pf.getline(tmp_buf,tmp_buf_size);
   sscanf(tmp_buf,"%f %f %f",&h11,&h12,&h13);
@@ -414,12 +414,12 @@ void show_input_options_help(int example) {
   else if (example == 2) {
     cout << "./akaze_compare img1.jpg img2.pgm [homography.txt] [options]" << endl;
   }
-  
+
   cout << endl;
   cout_help() << "homography.txt is optional. If the txt file is not provided a planar homography will be estimated using RANSAC" << endl;
 
   cout << endl;
-  cout_help() << "Options below are not mandatory. Unless specified, default arguments are used." << endl << endl;  
+  cout_help() << "Options below are not mandatory. Unless specified, default arguments are used." << endl << endl;
 
   // Justify on the left
   cout << left;

From 7ad733935e0c81942e03d8f994844084a925372c Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Sat, 2 Mar 2024 10:20:41 -0800
Subject: [PATCH 065/235] Pyre Configurationless migration for] [batch:26/112]
 [shard:6/N] (#1041)

Summary:
X-link: https://github.com/facebookincubator/metalos/pull/5

X-link: https://github.com/facebookresearch/fbpcp/pull/527

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1041

Reviewed By: connernilsen

Differential Revision: D54440273

fbshipit-source-id: 0742c4b76bbef07c68a729f65bc27f1a176b919f
---
 annotation_gui_gcp/lib/GUI.py                         | 1 +
 annotation_gui_gcp/lib/gcp_manager.py                 | 1 +
 annotation_gui_gcp/lib/geometry.py                    | 1 +
 annotation_gui_gcp/lib/image_manager.py               | 1 +
 annotation_gui_gcp/lib/views/cad_view.py              | 1 +
 annotation_gui_gcp/lib/views/cp_finder_view.py        | 1 +
 annotation_gui_gcp/lib/views/image_view.py            | 1 +
 annotation_gui_gcp/lib/views/tools_view.py            | 1 +
 annotation_gui_gcp/lib/views/web_view.py              | 1 +
 annotation_gui_gcp/main.py                            | 1 +
 annotation_gui_gcp/run_ba.py                          | 1 +
 bin/import_colmap.py                                  | 2 ++
 bin/opensfm_main.py                                   | 1 +
 bin/plot_matches.py                                   | 2 ++
 opensfm/__init__.py                                   | 1 +
 opensfm/actions/align_submodels.py                    | 1 +
 opensfm/actions/bundle.py                             | 1 +
 opensfm/actions/compute_depthmaps.py                  | 1 +
 opensfm/actions/compute_statistics.py                 | 1 +
 opensfm/actions/create_rig.py                         | 1 +
 opensfm/actions/create_submodels.py                   | 1 +
 opensfm/actions/create_tracks.py                      | 1 +
 opensfm/actions/detect_features.py                    | 1 +
 opensfm/actions/export_bundler.py                     | 1 +
 opensfm/actions/export_colmap.py                      | 2 ++
 opensfm/actions/export_geocoords.py                   | 1 +
 opensfm/actions/export_openmvs.py                     | 1 +
 opensfm/actions/export_ply.py                         | 1 +
 opensfm/actions/export_pmvs.py                        | 1 +
 opensfm/actions/export_report.py                      | 1 +
 opensfm/actions/export_visualsfm.py                   | 1 +
 opensfm/actions/extend_reconstruction.py              | 1 +
 opensfm/actions/extract_metadata.py                   | 1 +
 opensfm/actions/match_features.py                     | 1 +
 opensfm/actions/mesh.py                               | 1 +
 opensfm/actions/reconstruct.py                        | 1 +
 opensfm/actions/reconstruct_from_prior.py             | 1 +
 opensfm/actions/undistort.py                          | 1 +
 opensfm/align.py                                      | 1 +
 opensfm/bow.py                                        | 1 +
 opensfm/commands/__init__.py                          | 1 +
 opensfm/commands/align_submodels.py                   | 1 +
 opensfm/commands/bundle.py                            | 1 +
 opensfm/commands/command.py                           | 1 +
 opensfm/commands/command_runner.py                    | 1 +
 opensfm/commands/compute_depthmaps.py                 | 1 +
 opensfm/commands/compute_statistics.py                | 1 +
 opensfm/commands/create_rig.py                        | 1 +
 opensfm/commands/create_submodels.py                  | 1 +
 opensfm/commands/create_tracks.py                     | 1 +
 opensfm/commands/detect_features.py                   | 1 +
 opensfm/commands/export_bundler.py                    | 1 +
 opensfm/commands/export_colmap.py                     | 1 +
 opensfm/commands/export_geocoords.py                  | 1 +
 opensfm/commands/export_openmvs.py                    | 1 +
 opensfm/commands/export_ply.py                        | 1 +
 opensfm/commands/export_pmvs.py                       | 1 +
 opensfm/commands/export_report.py                     | 1 +
 opensfm/commands/export_visualsfm.py                  | 1 +
 opensfm/commands/extend_reconstruction.py             | 1 +
 opensfm/commands/extract_metadata.py                  | 1 +
 opensfm/commands/match_features.py                    | 1 +
 opensfm/commands/mesh.py                              | 1 +
 opensfm/commands/reconstruct.py                       | 1 +
 opensfm/commands/reconstruct_from_prior.py            | 1 +
 opensfm/commands/undistort.py                         | 1 +
 opensfm/config.py                                     | 1 +
 opensfm/context.py                                    | 1 +
 opensfm/dataset.py                                    | 1 +
 opensfm/dataset_base.py                               | 1 +
 opensfm/dense.py                                      | 1 +
 opensfm/exif.py                                       | 1 +
 opensfm/feature_loader.py                             | 1 +
 opensfm/feature_loading.py                            | 1 +
 opensfm/features.py                                   | 1 +
 opensfm/features_processing.py                        | 1 +
 opensfm/geo.py                                        | 1 +
 opensfm/geometry.py                                   | 1 +
 opensfm/geotag_from_gpx.py                            | 2 ++
 opensfm/io.py                                         | 1 +
 opensfm/large/metadataset.py                          | 1 +
 opensfm/large/tools.py                                | 1 +
 opensfm/log.py                                        | 1 +
 opensfm/masking.py                                    | 1 +
 opensfm/matching.py                                   | 1 +
 opensfm/mesh.py                                       | 2 ++
 opensfm/multiview.py                                  | 1 +
 opensfm/pairs_selection.py                            | 1 +
 opensfm/reconstruction.py                             | 1 +
 opensfm/reconstruction_helpers.py                     | 1 +
 opensfm/report.py                                     | 1 +
 opensfm/rig.py                                        | 1 +
 opensfm/sensors.py                                    | 1 +
 opensfm/stats.py                                      | 1 +
 opensfm/synthetic_data/synthetic_dataset.py           | 1 +
 opensfm/synthetic_data/synthetic_examples.py          | 1 +
 opensfm/synthetic_data/synthetic_generator.py         | 1 +
 opensfm/synthetic_data/synthetic_metrics.py           | 1 +
 opensfm/synthetic_data/synthetic_scene.py             | 1 +
 opensfm/test/conftest.py                              | 1 +
 opensfm/test/data_generation.py                       | 1 +
 opensfm/test/test_bundle.py                           | 1 +
 opensfm/test/test_commands.py                         | 1 +
 opensfm/test/test_dataset.py                          | 1 +
 opensfm/test/test_datastructures.py                   | 1 +
 opensfm/test/test_dense.py                            | 1 +
 opensfm/test/test_geo.py                              | 1 +
 opensfm/test/test_geometry.py                         | 1 +
 opensfm/test/test_io.py                               | 1 +
 opensfm/test/test_matching.py                         | 1 +
 opensfm/test/test_multiview.py                        | 1 +
 opensfm/test/test_pairs_selection.py                  | 1 +
 opensfm/test/test_reconstruction_alignment.py         | 1 +
 opensfm/test/test_reconstruction_incremental.py       | 1 +
 opensfm/test/test_reconstruction_resect.py            | 1 +
 opensfm/test/test_reconstruction_shot_neighborhood.py | 1 +
 opensfm/test/test_reconstruction_triangulation.py     | 1 +
 opensfm/test/test_rig.py                              | 1 +
 opensfm/test/test_robust.py                           | 1 +
 opensfm/test/test_stats.py                            | 1 +
 opensfm/test/test_triangulation.py                    | 1 +
 opensfm/test/test_types.py                            | 1 +
 opensfm/test/test_undistort.py                        | 1 +
 opensfm/test/test_vlad.py                             | 1 +
 opensfm/test/utils.py                                 | 2 ++
 opensfm/tracking.py                                   | 1 +
 opensfm/transformations.py                            | 2 ++
 opensfm/types.py                                      | 1 +
 opensfm/undistort.py                                  | 1 +
 opensfm/unionfind.py                                  | 2 ++
 opensfm/upright.py                                    | 1 +
 opensfm/video.py                                      | 1 +
 opensfm/vlad.py                                       | 1 +
 viewer/server.py                                      | 1 +
 134 files changed, 142 insertions(+)

diff --git a/annotation_gui_gcp/lib/GUI.py b/annotation_gui_gcp/lib/GUI.py
index f9953f4d8..44a999ec3 100644
--- a/annotation_gui_gcp/lib/GUI.py
+++ b/annotation_gui_gcp/lib/GUI.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 import random
 import subprocess
diff --git a/annotation_gui_gcp/lib/gcp_manager.py b/annotation_gui_gcp/lib/gcp_manager.py
index 1a22e1ae7..f5d2858e5 100644
--- a/annotation_gui_gcp/lib/gcp_manager.py
+++ b/annotation_gui_gcp/lib/gcp_manager.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import json
 import os
 import typing as t
diff --git a/annotation_gui_gcp/lib/geometry.py b/annotation_gui_gcp/lib/geometry.py
index c10b2daa5..1df053f3e 100644
--- a/annotation_gui_gcp/lib/geometry.py
+++ b/annotation_gui_gcp/lib/geometry.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import dataset
 from numpy import ndarray
 from typing import Dict, Tuple
diff --git a/annotation_gui_gcp/lib/image_manager.py b/annotation_gui_gcp/lib/image_manager.py
index bd4d63922..494eeda7a 100644
--- a/annotation_gui_gcp/lib/image_manager.py
+++ b/annotation_gui_gcp/lib/image_manager.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import typing as t
 from io import BytesIO
 
diff --git a/annotation_gui_gcp/lib/views/cad_view.py b/annotation_gui_gcp/lib/views/cad_view.py
index fb3e46c79..29d1320d3 100644
--- a/annotation_gui_gcp/lib/views/cad_view.py
+++ b/annotation_gui_gcp/lib/views/cad_view.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import json
 import logging
 from pathlib import Path
diff --git a/annotation_gui_gcp/lib/views/cp_finder_view.py b/annotation_gui_gcp/lib/views/cp_finder_view.py
index af6f3b0a6..b8b491402 100644
--- a/annotation_gui_gcp/lib/views/cp_finder_view.py
+++ b/annotation_gui_gcp/lib/views/cp_finder_view.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import typing as t
 
 from annotation_gui_gcp.lib.views.image_view import ImageView
diff --git a/annotation_gui_gcp/lib/views/image_view.py b/annotation_gui_gcp/lib/views/image_view.py
index 16dddbed8..efc1a1bdf 100644
--- a/annotation_gui_gcp/lib/views/image_view.py
+++ b/annotation_gui_gcp/lib/views/image_view.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Dict, Any
 
 from annotation_gui_gcp.lib.views.web_view import WebView, distinct_colors
diff --git a/annotation_gui_gcp/lib/views/tools_view.py b/annotation_gui_gcp/lib/views/tools_view.py
index 9a70b0482..22a5e9bca 100644
--- a/annotation_gui_gcp/lib/views/tools_view.py
+++ b/annotation_gui_gcp/lib/views/tools_view.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Dict, Any
 
 from annotation_gui_gcp.lib.views.web_view import WebView
diff --git a/annotation_gui_gcp/lib/views/web_view.py b/annotation_gui_gcp/lib/views/web_view.py
index a2f93107c..b41dd41e6 100644
--- a/annotation_gui_gcp/lib/views/web_view.py
+++ b/annotation_gui_gcp/lib/views/web_view.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import abc
 import json
 import time
diff --git a/annotation_gui_gcp/main.py b/annotation_gui_gcp/main.py
index aad365118..41388dbe5 100644
--- a/annotation_gui_gcp/main.py
+++ b/annotation_gui_gcp/main.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import argparse
 import json
 import typing as t
diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index 4e571f8aa..41d54ed59 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import argparse
 import json
 import logging
diff --git a/bin/import_colmap.py b/bin/import_colmap.py
index 9388883f4..95a6a2365 100755
--- a/bin/import_colmap.py
+++ b/bin/import_colmap.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 
+# pyre-unsafe
+
 # Snippets to read from the colmap database taken from:
 # https://github.com/colmap/colmap/blob/ad7bd93f1a27af7533121aa043a167fe1490688c /
 # scripts/python/export_to_bundler.py
diff --git a/bin/opensfm_main.py b/bin/opensfm_main.py
index 2041e163d..7709b7491 100755
--- a/bin/opensfm_main.py
+++ b/bin/opensfm_main.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import sys
 from os.path import abspath, dirname, join
 
diff --git a/bin/plot_matches.py b/bin/plot_matches.py
index 2fe59174b..ab94b2e94 100755
--- a/bin/plot_matches.py
+++ b/bin/plot_matches.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
 
+# pyre-unsafe
+
 import argparse
 import os.path
 from itertools import combinations
diff --git a/opensfm/__init__.py b/opensfm/__init__.py
index 011058c79..8cd78b225 100644
--- a/opensfm/__init__.py
+++ b/opensfm/__init__.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import pybundle
 from opensfm import pydense
 from opensfm import pyfeatures
diff --git a/opensfm/actions/align_submodels.py b/opensfm/actions/align_submodels.py
index 3e70501f4..28fc2a525 100644
--- a/opensfm/actions/align_submodels.py
+++ b/opensfm/actions/align_submodels.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.large import metadataset
 from opensfm.large import tools
 from opensfm.dataset import DataSet
diff --git a/opensfm/actions/bundle.py b/opensfm/actions/bundle.py
index fa4afdc48..28c08dd14 100644
--- a/opensfm/actions/bundle.py
+++ b/opensfm/actions/bundle.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import opensfm.reconstruction as orec
 from opensfm.dataset_base import DataSetBase
 from typing import Optional
diff --git a/opensfm/actions/compute_depthmaps.py b/opensfm/actions/compute_depthmaps.py
index d16f06e59..e7972c226 100644
--- a/opensfm/actions/compute_depthmaps.py
+++ b/opensfm/actions/compute_depthmaps.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 
 from opensfm import dataset
diff --git a/opensfm/actions/compute_statistics.py b/opensfm/actions/compute_statistics.py
index 736c11706..0b8eb057a 100644
--- a/opensfm/actions/compute_statistics.py
+++ b/opensfm/actions/compute_statistics.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 
diff --git a/opensfm/actions/create_rig.py b/opensfm/actions/create_rig.py
index 823f9f019..50b1608fb 100644
--- a/opensfm/actions/create_rig.py
+++ b/opensfm/actions/create_rig.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 
 from opensfm import pymap, rig, reconstruction_helpers as helpers, types
diff --git a/opensfm/actions/create_submodels.py b/opensfm/actions/create_submodels.py
index 08ef8e205..2716a0603 100644
--- a/opensfm/actions/create_submodels.py
+++ b/opensfm/actions/create_submodels.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from collections import defaultdict
 
diff --git a/opensfm/actions/create_tracks.py b/opensfm/actions/create_tracks.py
index e119eb07f..1a0db6e4f 100644
--- a/opensfm/actions/create_tracks.py
+++ b/opensfm/actions/create_tracks.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from timeit import default_timer as timer
 
 from opensfm import io
diff --git a/opensfm/actions/detect_features.py b/opensfm/actions/detect_features.py
index a84f6791b..9bf47cfed 100644
--- a/opensfm/actions/detect_features.py
+++ b/opensfm/actions/detect_features.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from timeit import default_timer as timer
 
diff --git a/opensfm/actions/export_bundler.py b/opensfm/actions/export_bundler.py
index 9a6002aa3..1535ff795 100644
--- a/opensfm/actions/export_bundler.py
+++ b/opensfm/actions/export_bundler.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 
 import numpy as np
diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index ab275e074..c86e38fa9 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -29,6 +29,8 @@
 #
 # Author: Johannes L. Schoenberger (jsch at inf.ethz.ch)
 
+# pyre-unsafe
+
 # This script is based on an original implementation by True Price.
 
 import math
diff --git a/opensfm/actions/export_geocoords.py b/opensfm/actions/export_geocoords.py
index 67b1f7233..aad9d7910 100644
--- a/opensfm/actions/export_geocoords.py
+++ b/opensfm/actions/export_geocoords.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 from opensfm import types
diff --git a/opensfm/actions/export_openmvs.py b/opensfm/actions/export_openmvs.py
index 7d3edc8ab..2020913d6 100644
--- a/opensfm/actions/export_openmvs.py
+++ b/opensfm/actions/export_openmvs.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 
 import numpy as np
diff --git a/opensfm/actions/export_ply.py b/opensfm/actions/export_ply.py
index 3e718c01b..69658ce4f 100644
--- a/opensfm/actions/export_ply.py
+++ b/opensfm/actions/export_ply.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 
 import numpy as np
diff --git a/opensfm/actions/export_pmvs.py b/opensfm/actions/export_pmvs.py
index 264fb2e4a..de11b4974 100644
--- a/opensfm/actions/export_pmvs.py
+++ b/opensfm/actions/export_pmvs.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 
diff --git a/opensfm/actions/export_report.py b/opensfm/actions/export_report.py
index 8b50e4f49..d20ac0a3a 100644
--- a/opensfm/actions/export_report.py
+++ b/opensfm/actions/export_report.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import report
 from opensfm.dataset import DataSet
 
diff --git a/opensfm/actions/export_visualsfm.py b/opensfm/actions/export_visualsfm.py
index 1b1ce0846..1f91b0811 100644
--- a/opensfm/actions/export_visualsfm.py
+++ b/opensfm/actions/export_visualsfm.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 import sys
diff --git a/opensfm/actions/extend_reconstruction.py b/opensfm/actions/extend_reconstruction.py
index 2d9bd303d..adc9ea78b 100644
--- a/opensfm/actions/extend_reconstruction.py
+++ b/opensfm/actions/extend_reconstruction.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 from typing import Optional
diff --git a/opensfm/actions/extract_metadata.py b/opensfm/actions/extract_metadata.py
index b7f5fcbae..6d58383d3 100644
--- a/opensfm/actions/extract_metadata.py
+++ b/opensfm/actions/extract_metadata.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 import logging
 from functools import partial
diff --git a/opensfm/actions/match_features.py b/opensfm/actions/match_features.py
index 84b1937a1..9cd8d8433 100644
--- a/opensfm/actions/match_features.py
+++ b/opensfm/actions/match_features.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from timeit import default_timer as timer
 
 from opensfm import io
diff --git a/opensfm/actions/mesh.py b/opensfm/actions/mesh.py
index d3a952c93..203e3bf86 100644
--- a/opensfm/actions/mesh.py
+++ b/opensfm/actions/mesh.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import mesh
 from opensfm.dataset_base import DataSetBase
 
diff --git a/opensfm/actions/reconstruct.py b/opensfm/actions/reconstruct.py
index 9c952fd7d..d5b30420d 100644
--- a/opensfm/actions/reconstruct.py
+++ b/opensfm/actions/reconstruct.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import io
 from opensfm import reconstruction
 from opensfm.dataset_base import DataSetBase
diff --git a/opensfm/actions/reconstruct_from_prior.py b/opensfm/actions/reconstruct_from_prior.py
index 067be1fa2..e5d86232e 100644
--- a/opensfm/actions/reconstruct_from_prior.py
+++ b/opensfm/actions/reconstruct_from_prior.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import io
 from opensfm import reconstruction
 from opensfm.dataset_base import DataSetBase
diff --git a/opensfm/actions/undistort.py b/opensfm/actions/undistort.py
index 1f1a129de..5d9bcd220 100644
--- a/opensfm/actions/undistort.py
+++ b/opensfm/actions/undistort.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 from typing import Optional
 
diff --git a/opensfm/align.py b/opensfm/align.py
index 383109564..48d7d60c3 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Tools to align a reconstruction to GPS and GCP data."""
 
 import logging
diff --git a/opensfm/bow.py b/opensfm/bow.py
index 544bcb079..f4746c469 100644
--- a/opensfm/bow.py
+++ b/opensfm/bow.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os.path
 
 import cv2
diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index 426afebd7..97a2f32fe 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from . import (
     align_submodels,
     bundle,
diff --git a/opensfm/commands/align_submodels.py b/opensfm/commands/align_submodels.py
index f3bc8c917..8055c45bd 100644
--- a/opensfm/commands/align_submodels.py
+++ b/opensfm/commands/align_submodels.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import align_submodels
 
 from . import command
diff --git a/opensfm/commands/bundle.py b/opensfm/commands/bundle.py
index b7e6f668a..767d73146 100644
--- a/opensfm/commands/bundle.py
+++ b/opensfm/commands/bundle.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import bundle
 
 from . import command
diff --git a/opensfm/commands/command.py b/opensfm/commands/command.py
index 077c7c811..2e7093e93 100644
--- a/opensfm/commands/command.py
+++ b/opensfm/commands/command.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from timeit import default_timer as timer
 import argparse
 from opensfm.dataset import DataSet
diff --git a/opensfm/commands/command_runner.py b/opensfm/commands/command_runner.py
index 6498a7ef6..55b556903 100644
--- a/opensfm/commands/command_runner.py
+++ b/opensfm/commands/command_runner.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Any, Callable, List
 import argparse
 
diff --git a/opensfm/commands/compute_depthmaps.py b/opensfm/commands/compute_depthmaps.py
index 57c647947..6265b6fd3 100644
--- a/opensfm/commands/compute_depthmaps.py
+++ b/opensfm/commands/compute_depthmaps.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import compute_depthmaps
 
 from . import command
diff --git a/opensfm/commands/compute_statistics.py b/opensfm/commands/compute_statistics.py
index a445fc7c4..8b6544a30 100644
--- a/opensfm/commands/compute_statistics.py
+++ b/opensfm/commands/compute_statistics.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from . import command
 import argparse
 from opensfm.dataset import DataSet
diff --git a/opensfm/commands/create_rig.py b/opensfm/commands/create_rig.py
index 120e471b9..82d191156 100644
--- a/opensfm/commands/create_rig.py
+++ b/opensfm/commands/create_rig.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import json
 
 from opensfm.actions import create_rig
diff --git a/opensfm/commands/create_submodels.py b/opensfm/commands/create_submodels.py
index bc76dcba8..a6d301103 100644
--- a/opensfm/commands/create_submodels.py
+++ b/opensfm/commands/create_submodels.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import create_submodels
 
 from . import command
diff --git a/opensfm/commands/create_tracks.py b/opensfm/commands/create_tracks.py
index d5ee6e6ac..408c67a53 100644
--- a/opensfm/commands/create_tracks.py
+++ b/opensfm/commands/create_tracks.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import create_tracks
 
 from . import command
diff --git a/opensfm/commands/detect_features.py b/opensfm/commands/detect_features.py
index b94f83289..466826e52 100644
--- a/opensfm/commands/detect_features.py
+++ b/opensfm/commands/detect_features.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import detect_features
 
 from . import command
diff --git a/opensfm/commands/export_bundler.py b/opensfm/commands/export_bundler.py
index 13bb1a241..83be840d3 100644
--- a/opensfm/commands/export_bundler.py
+++ b/opensfm/commands/export_bundler.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_bundler
 
 from . import command
diff --git a/opensfm/commands/export_colmap.py b/opensfm/commands/export_colmap.py
index b5fab0a00..79c4b86ac 100644
--- a/opensfm/commands/export_colmap.py
+++ b/opensfm/commands/export_colmap.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_colmap
 
 from . import command
diff --git a/opensfm/commands/export_geocoords.py b/opensfm/commands/export_geocoords.py
index 155a91bca..1f3b4e219 100644
--- a/opensfm/commands/export_geocoords.py
+++ b/opensfm/commands/export_geocoords.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_geocoords
 
 from . import command
diff --git a/opensfm/commands/export_openmvs.py b/opensfm/commands/export_openmvs.py
index 7476c6fad..91dbb595e 100644
--- a/opensfm/commands/export_openmvs.py
+++ b/opensfm/commands/export_openmvs.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_openmvs
 
 from . import command
diff --git a/opensfm/commands/export_ply.py b/opensfm/commands/export_ply.py
index 7e4892968..1d3be5f00 100644
--- a/opensfm/commands/export_ply.py
+++ b/opensfm/commands/export_ply.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_ply
 
 from . import command
diff --git a/opensfm/commands/export_pmvs.py b/opensfm/commands/export_pmvs.py
index 9a39d5ccd..84d67c656 100644
--- a/opensfm/commands/export_pmvs.py
+++ b/opensfm/commands/export_pmvs.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_pmvs
 
 from . import command
diff --git a/opensfm/commands/export_report.py b/opensfm/commands/export_report.py
index ab6722ee2..d9f084329 100644
--- a/opensfm/commands/export_report.py
+++ b/opensfm/commands/export_report.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from . import command
 import argparse
 from opensfm.dataset import DataSet
diff --git a/opensfm/commands/export_visualsfm.py b/opensfm/commands/export_visualsfm.py
index c0b65eead..37080add9 100644
--- a/opensfm/commands/export_visualsfm.py
+++ b/opensfm/commands/export_visualsfm.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import export_visualsfm
 
 from . import command
diff --git a/opensfm/commands/extend_reconstruction.py b/opensfm/commands/extend_reconstruction.py
index 2804c5382..6e72374e5 100644
--- a/opensfm/commands/extend_reconstruction.py
+++ b/opensfm/commands/extend_reconstruction.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import extend_reconstruction
 
 from . import command
diff --git a/opensfm/commands/extract_metadata.py b/opensfm/commands/extract_metadata.py
index c51879103..5bf0d62b1 100644
--- a/opensfm/commands/extract_metadata.py
+++ b/opensfm/commands/extract_metadata.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import extract_metadata
 
 from . import command
diff --git a/opensfm/commands/match_features.py b/opensfm/commands/match_features.py
index 5739c1801..74e88984f 100644
--- a/opensfm/commands/match_features.py
+++ b/opensfm/commands/match_features.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import match_features
 
 from . import command
diff --git a/opensfm/commands/mesh.py b/opensfm/commands/mesh.py
index c762d97c3..6a407cab4 100644
--- a/opensfm/commands/mesh.py
+++ b/opensfm/commands/mesh.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import mesh
 
 from . import command
diff --git a/opensfm/commands/reconstruct.py b/opensfm/commands/reconstruct.py
index bfccf9eba..5dcb002f2 100644
--- a/opensfm/commands/reconstruct.py
+++ b/opensfm/commands/reconstruct.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import reconstruction
 from opensfm.actions import reconstruct
 
diff --git a/opensfm/commands/reconstruct_from_prior.py b/opensfm/commands/reconstruct_from_prior.py
index f4271e98a..0aa7389ef 100644
--- a/opensfm/commands/reconstruct_from_prior.py
+++ b/opensfm/commands/reconstruct_from_prior.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import reconstruct_from_prior
 
 from . import command
diff --git a/opensfm/commands/undistort.py b/opensfm/commands/undistort.py
index d9f99eb62..d7eae5d6e 100644
--- a/opensfm/commands/undistort.py
+++ b/opensfm/commands/undistort.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm.actions import undistort
 
 from . import command
diff --git a/opensfm/config.py b/opensfm/config.py
index 4ef433a17..907e9c1ed 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 from dataclasses import dataclass, asdict
 from typing import Any, Dict, IO, Union
diff --git a/opensfm/context.py b/opensfm/context.py
index 58fa25296..00ea4074e 100644
--- a/opensfm/context.py
+++ b/opensfm/context.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index ff825a272..12af6a344 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import gzip
 import json
 import logging
diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index 9f3c64068..a049344e9 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from abc import ABC, abstractmethod
 from typing import Dict, List, Tuple, Optional, IO, Any
diff --git a/opensfm/dense.py b/opensfm/dense.py
index 49cd18365..14b4fc940 100644
--- a/opensfm/dense.py
+++ b/opensfm/dense.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import typing as t
 
diff --git a/opensfm/exif.py b/opensfm/exif.py
index d46ead2d8..6b4e76462 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import datetime
 import logging
 from codecs import encode, decode
diff --git a/opensfm/feature_loader.py b/opensfm/feature_loader.py
index eac0cb4cc..d9a3ad086 100644
--- a/opensfm/feature_loader.py
+++ b/opensfm/feature_loader.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import feature_loading
 
 
diff --git a/opensfm/feature_loading.py b/opensfm/feature_loading.py
index f985b6869..7ff3d4934 100644
--- a/opensfm/feature_loading.py
+++ b/opensfm/feature_loading.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from functools import lru_cache
 from typing import Optional, Tuple, Any
diff --git a/opensfm/features.py b/opensfm/features.py
index d4dbac37d..622c47ae2 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Tools to extract features."""
 
 import logging
diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 52ce8c29c..94889eac9 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import itertools
 import logging
 import math
diff --git a/opensfm/geo.py b/opensfm/geo.py
index 90c3d3d9d..335dad66f 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from numpy import ndarray
 from typing import Tuple
diff --git a/opensfm/geometry.py b/opensfm/geometry.py
index 654a17469..43cd52a12 100644
--- a/opensfm/geometry.py
+++ b/opensfm/geometry.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Tuple
 
 import cv2
diff --git a/opensfm/geotag_from_gpx.py b/opensfm/geotag_from_gpx.py
index a206f907d..9198b3398 100644
--- a/opensfm/geotag_from_gpx.py
+++ b/opensfm/geotag_from_gpx.py
@@ -1,5 +1,7 @@
 #!/usr/bin/python3
 
+# pyre-unsafe
+
 import datetime
 import math
 import os
diff --git a/opensfm/io.py b/opensfm/io.py
index 95eaedfa3..bf72ae9f3 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import json
 import logging
 import os
diff --git a/opensfm/large/metadataset.py b/opensfm/large/metadataset.py
index 81a016f6e..df5a27a7b 100644
--- a/opensfm/large/metadataset.py
+++ b/opensfm/large/metadataset.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 import os.path
 import shutil
diff --git a/opensfm/large/tools.py b/opensfm/large/tools.py
index e66c0d35e..fff5b6536 100644
--- a/opensfm/large/tools.py
+++ b/opensfm/large/tools.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import itertools
 import logging
 from collections import namedtuple
diff --git a/opensfm/log.py b/opensfm/log.py
index 379a3a53b..ecca50c12 100644
--- a/opensfm/log.py
+++ b/opensfm/log.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 from typing import Optional
diff --git a/opensfm/masking.py b/opensfm/masking.py
index 37bfe0ec8..3a20a86f7 100644
--- a/opensfm/masking.py
+++ b/opensfm/masking.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from typing import List, Tuple, Optional
 
diff --git a/opensfm/matching.py b/opensfm/matching.py
index 068d126e9..a96eee3f0 100644
--- a/opensfm/matching.py
+++ b/opensfm/matching.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 from timeit import default_timer as timer
 from typing import Any, Dict, Generator, List, Optional, Sized, Tuple
diff --git a/opensfm/mesh.py b/opensfm/mesh.py
index 47447c275..9080a0a74 100644
--- a/opensfm/mesh.py
+++ b/opensfm/mesh.py
@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+
+# pyre-unsafe
 import itertools
 import logging
 from typing import Any, Tuple, List
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 65dd3ea07..e6f37e9c0 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import math
 import random
 from typing import Any, Dict, List, Optional, Tuple
diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 191ab030e..214e251b3 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 import logging
 import math
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index eaa6a6a15..ad242f9ee 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Incremental reconstruction pipeline"""
 
 import datetime
diff --git a/opensfm/reconstruction_helpers.py b/opensfm/reconstruction_helpers.py
index 0b8787801..48aa4663b 100644
--- a/opensfm/reconstruction_helpers.py
+++ b/opensfm/reconstruction_helpers.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import math
 from typing import Any, Dict, Iterable, List, Optional
diff --git a/opensfm/report.py b/opensfm/report.py
index b1bf5f859..410f0a016 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import os
 import subprocess
diff --git a/opensfm/rig.py b/opensfm/rig.py
index e20003e42..d21380228 100644
--- a/opensfm/rig.py
+++ b/opensfm/rig.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Tool for handling rigs"""
 
 import logging
diff --git a/opensfm/sensors.py b/opensfm/sensors.py
index 7ff93f13c..9e2cc8796 100644
--- a/opensfm/sensors.py
+++ b/opensfm/sensors.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from functools import lru_cache
 from typing import Any, Dict, List
 import yaml
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 5cc3a5151..44dc31a05 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import datetime
 import math
 import os
diff --git a/opensfm/synthetic_data/synthetic_dataset.py b/opensfm/synthetic_data/synthetic_dataset.py
index a6023010d..b52cdfcd7 100644
--- a/opensfm/synthetic_data/synthetic_dataset.py
+++ b/opensfm/synthetic_data/synthetic_dataset.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import collections
 import logging
 import os
diff --git a/opensfm/synthetic_data/synthetic_examples.py b/opensfm/synthetic_data/synthetic_examples.py
index c17589395..2632854b5 100644
--- a/opensfm/synthetic_data/synthetic_examples.py
+++ b/opensfm/synthetic_data/synthetic_examples.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Optional
 
 import opensfm.synthetic_data.synthetic_scene as ss
diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index 6037761fa..90b3fc8da 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import math
 import time
diff --git a/opensfm/synthetic_data/synthetic_metrics.py b/opensfm/synthetic_data/synthetic_metrics.py
index baabb3853..762060aa8 100644
--- a/opensfm/synthetic_data/synthetic_metrics.py
+++ b/opensfm/synthetic_data/synthetic_metrics.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Tuple, List, Dict
 
 import cv2
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 5a1e4f230..f8fcc8140 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import functools
 import math
 from typing import Dict, Optional, List, Any, Union, Tuple, Callable
diff --git a/opensfm/test/conftest.py b/opensfm/test/conftest.py
index b8cc2ed9a..78331cd35 100644
--- a/opensfm/test/conftest.py
+++ b/opensfm/test/conftest.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from collections import defaultdict
 from distutils.version import LooseVersion
 from typing import Dict, List, Tuple
diff --git a/opensfm/test/data_generation.py b/opensfm/test/data_generation.py
index 097d53c09..821f3a8b1 100644
--- a/opensfm/test/data_generation.py
+++ b/opensfm/test/data_generation.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 
 import opensfm.dataset
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index a3e12afaf..54202da06 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 
 import numpy as np
diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index 2e30159b8..a5890bcd9 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import argparse
 from os.path import join
 
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 02202e45d..60022ae0a 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import features
 from opensfm.test import data_generation
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index 2e8d1a25e..5e9c5cd9a 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 from opensfm.pymap import RigCamera, RigInstance, Shot
 from opensfm.types import Reconstruction
diff --git a/opensfm/test/test_dense.py b/opensfm/test/test_dense.py
index 5f2bb9789..2c7bdd28e 100644
--- a/opensfm/test/test_dense.py
+++ b/opensfm/test/test_dense.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import dense
 from opensfm import pygeometry
diff --git a/opensfm/test/test_geo.py b/opensfm/test/test_geo.py
index a6d534be4..65c3b12bd 100644
--- a/opensfm/test/test_geo.py
+++ b/opensfm/test/test_geo.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import geo, pygeo
 
diff --git a/opensfm/test/test_geometry.py b/opensfm/test/test_geometry.py
index ccb5ec728..4d5890198 100644
--- a/opensfm/test/test_geometry.py
+++ b/opensfm/test/test_geometry.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import geometry
 
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 23c90c140..0b43af2c5 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import json
 import os.path
 from io import StringIO
diff --git a/opensfm/test/test_matching.py b/opensfm/test/test_matching.py
index c397b7ee1..c236de723 100644
--- a/opensfm/test/test_matching.py
+++ b/opensfm/test/test_matching.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from typing import Any, Dict, List, Set, Tuple
 
 import numpy as np
diff --git a/opensfm/test/test_multiview.py b/opensfm/test/test_multiview.py
index ab943fe41..a0e6f1376 100644
--- a/opensfm/test/test_multiview.py
+++ b/opensfm/test/test_multiview.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 
 import numpy as np
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index 3fdc04145..b16a2ce69 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import argparse
 import os.path
 from typing import Any, Dict, Generator
diff --git a/opensfm/test/test_reconstruction_alignment.py b/opensfm/test/test_reconstruction_alignment.py
index fb2f156c4..a077cca4a 100644
--- a/opensfm/test/test_reconstruction_alignment.py
+++ b/opensfm/test/test_reconstruction_alignment.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import pybundle
 from opensfm import pygeometry
diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index e1513dab5..1d3320e34 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import reconstruction
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_reconstruction_resect.py b/opensfm/test/test_reconstruction_resect.py
index 3a5e1f4dc..f55448d1a 100644
--- a/opensfm/test/test_reconstruction_resect.py
+++ b/opensfm/test/test_reconstruction_resect.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import config, multiview, pymap, reconstruction, types
 from typing import Tuple
diff --git a/opensfm/test/test_reconstruction_shot_neighborhood.py b/opensfm/test/test_reconstruction_shot_neighborhood.py
index d302a7fa7..f42f98603 100644
--- a/opensfm/test/test_reconstruction_shot_neighborhood.py
+++ b/opensfm/test/test_reconstruction_shot_neighborhood.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import networkx as nx
 from opensfm import pygeometry
 from opensfm import pymap
diff --git a/opensfm/test/test_reconstruction_triangulation.py b/opensfm/test/test_reconstruction_triangulation.py
index a05056681..9f631872a 100644
--- a/opensfm/test/test_reconstruction_triangulation.py
+++ b/opensfm/test/test_reconstruction_triangulation.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import reconstruction
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_rig.py b/opensfm/test/test_rig.py
index 56fd95161..50677f3cc 100644
--- a/opensfm/test/test_rig.py
+++ b/opensfm/test/test_rig.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Test the rig module."""
 import numpy as np
 from opensfm import pygeometry, rig, types
diff --git a/opensfm/test/test_robust.py b/opensfm/test/test_robust.py
index ed296dd4c..6c02d71a9 100644
--- a/opensfm/test/test_robust.py
+++ b/opensfm/test/test_robust.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 from typing import Tuple
 
diff --git a/opensfm/test/test_stats.py b/opensfm/test/test_stats.py
index b486794eb..2511fb255 100644
--- a/opensfm/test/test_stats.py
+++ b/opensfm/test/test_stats.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from opensfm import stats, types
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index 1620931c9..734be5d6c 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from opensfm import io
 from opensfm import pygeometry
diff --git a/opensfm/test/test_types.py b/opensfm/test/test_types.py
index 01a27f560..679c2ab02 100644
--- a/opensfm/test/test_types.py
+++ b/opensfm/test/test_types.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import copy
 import sys
 
diff --git a/opensfm/test/test_undistort.py b/opensfm/test/test_undistort.py
index 3ea656967..e5e8120f6 100644
--- a/opensfm/test/test_undistort.py
+++ b/opensfm/test/test_undistort.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import itertools
 
 import numpy as np
diff --git a/opensfm/test/test_vlad.py b/opensfm/test/test_vlad.py
index c406195c0..dee12fa08 100644
--- a/opensfm/test/test_vlad.py
+++ b/opensfm/test/test_vlad.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 import pytest
 from opensfm import vlad
diff --git a/opensfm/test/utils.py b/opensfm/test/utils.py
index 0531458d9..562bbd1fe 100644
--- a/opensfm/test/utils.py
+++ b/opensfm/test/utils.py
@@ -1,4 +1,6 @@
 # Test utils for python
+
+# pyre-unsafe
 import numpy as np
 from opensfm import pygeo, pygeometry, pymap
 
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index 4cb699ee4..c1b79798c 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import logging
 import typing as t
 
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index 96bcd6bdc..071915b64 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -1,5 +1,7 @@
 # transformations.py
 
+# pyre-unsafe
+
 # Copyright (c) 2006-2013, Christoph Gohlke
 # Copyright (c) 2006-2013, The Regents of the University of California
 # Produced at the Laboratory for Fluorescence Dynamics
diff --git a/opensfm/types.py b/opensfm/types.py
index 7e444b9c9..6492e8509 100644
--- a/opensfm/types.py
+++ b/opensfm/types.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 """Basic types for building a reconstruction."""
 from typing import Dict, Optional
 
diff --git a/opensfm/undistort.py b/opensfm/undistort.py
index 63bae4de6..f7e3f0803 100644
--- a/opensfm/undistort.py
+++ b/opensfm/undistort.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import itertools
 import logging
 from typing import Iterator, List, Dict, Optional
diff --git a/opensfm/unionfind.py b/opensfm/unionfind.py
index bf0345bf5..aca3e8951 100644
--- a/opensfm/unionfind.py
+++ b/opensfm/unionfind.py
@@ -1,6 +1,8 @@
 # Source: https://www.ics.uci.edu/~eppstein/PADS/UnionFind.py
 # Licence: MIT
 
+# pyre-unsafe
+
 
 # This is PADS, a library of Python Algorithms and Data Structures
 # implemented by David Eppstein of the University of California, Irvine.
diff --git a/opensfm/upright.py b/opensfm/upright.py
index bfa2a3df2..c06cc409a 100644
--- a/opensfm/upright.py
+++ b/opensfm/upright.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import numpy as np
 from typing import Optional
 
diff --git a/opensfm/video.py b/opensfm/video.py
index a951240c2..9e34b6e92 100644
--- a/opensfm/video.py
+++ b/opensfm/video.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import datetime
 import os
 from subprocess import Popen, PIPE
diff --git a/opensfm/vlad.py b/opensfm/vlad.py
index 5cf9b02b4..5c623e0f1 100644
--- a/opensfm/vlad.py
+++ b/opensfm/vlad.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 from functools import lru_cache
 from typing import List, Tuple, Iterable, Dict, Optional
 
diff --git a/viewer/server.py b/viewer/server.py
index 536c0fc2e..418791c79 100644
--- a/viewer/server.py
+++ b/viewer/server.py
@@ -1,3 +1,4 @@
+# pyre-unsafe
 import argparse
 import os
 from typing import List

From 938a3a169e66adb71949907fcf3ebca2089727a9 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 6 Mar 2024 07:58:20 -0800
Subject: [PATCH 066/235] Fix `-Wimplicit-const-int-float-conversion` violation
 in mapillary/opensfm/opensfm/src/features/src/matching.cc

Summary:
# Overview

LLVM has detected a bad _implicit constant integer to float conversion_ in mapillary/opensfm/opensfm/src/features/src/matching.cc. Almost all such cases lead to very subtle bugs, so we are making them a compiler error by default.

# Reproducer

The fix can be checked using:
```
buck2 build --config cxx.extra_cxxflags=-Wimplicit-const-int-float-conversion <TARGET>
```

# Description of the problem

What value do you think this produces?
```
static_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max()))
```
You'd hope it would produce UINT64_MAX (18446744073709551615), but it doesn't.

In debug mode it produces 9223372036854775808 (half of the above). In opt mode it produces "random" numbers such as 140726009322632 (which is 130,000x smaller than UINT64_MAX).

Comparisons between floats and maximum integer values are also scary:
```
constexpr double x = std::numeric_limits<uint64_t>::max();
constexpr auto kMax64 = std::numeric_limits<uint64_t>::max();
std::cout << (x > kMax64 ? kMax64 : static_cast<uint64_t>(x)) << std::endl;
```
produces garbage: 140731185888920

The reason this happens is because floating-point types can only represent integers sparsely in the regions of the maximum integers (generated with P1188399781):
```
delta = 128
2147483264 f
2147483392 f
2147483520 f
2147483647 <- Largest integer
2147483648 f
2147483904 f
2147484160 f

delta = 256
4294966528 f
4294966784 f
4294967040 f
4294967295 <- Largest integer
4294967296 f
4294967808 f
4294968320 f

delta = 1024
9223372036854772736 d
9223372036854773760 d
9223372036854774784 d
9223372036854775807 <- Largest integer
9223372036854775808 d
9223372036854777856 d
9223372036854779904 d

delta = 2048
18446744073709545472 d
18446744073709547520 d
18446744073709549568 d
18446744073709551615 <- Largest integer
18446744073709551616 d
18446744073709555712 d
18446744073709559808 d
```

# Fixing the Problem

See example fixes in D54119898, D54119901, D54119899.

## Careful Clamping

The fix will be situation dependent, `folly::constexpr_clamp_cast` is _very_ useful:
```
// Include the target `//folly:constexpr_math`
#include <folly/ConstexprMath.h>
#include <iostream>
#include <limits>

int main() {
  constexpr auto kMax32 = std::numeric_limits<int32_t>::max();
  std::cout << folly::constexpr_clamp_cast<int32_t>(static_cast<float>(kMax32)) << std::endl;
  return 0;
}
```

## Use infinity

In some cases we want want something like
```
double smallest_value = BIG_NUMBER;
for (const auto &x : values) {
    smallest_value = std::min(smallest_value, x);
}
```
If `BIG_NUMBER` is an integer this code could be incorrect!

Instead we use
```
double smallest_value = std::numeric_limits<double>::infinity();
```

## Make the conversion explicit

For situations in which we are dividing by a very large integer, we can use `static_cast<FLOAT_TYPE>(LARGE_INT)` to make the conversion from int to float explicit. The conversion is _not_ exact, but our hope is that the precision we've lost is small enough that it doesn't matter for the problem being solved.

Reviewed By: YanNoun

Differential Revision: D54586513

fbshipit-source-id: 87fba3097e3822eb68660e0f2ab947eaf6450698
---
 opensfm/src/features/src/matching.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index b25ed46ca..26e7e4339 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -41,8 +41,8 @@ void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
   }
 
   std::vector<int> best_match(f1.rows, -1), second_best_match(f1.rows, -1);
-  std::vector<float> best_distance(f1.rows, 99999999),
-      second_best_distance(f1.rows, 99999999);
+  std::vector<float> best_distance(f1.rows, std::numeric_limits<float>::infinity());
+  std::vector<float> second_best_distance(f1.rows, std::numeric_limits<float>::infinity());
   *matches = cv::Mat(0, 2, CV_32S);
   cv::Mat tmp_match(1, 2, CV_32S);
   for (unsigned int i = 0; i < w1.rows; ++i) {

From 424ecc210ee468c0eab46a019d484ceaf4893a21 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 6 Mar 2024 08:05:42 -0800
Subject: [PATCH 067/235] Fix `-Wimplicit-const-int-float-conversion` violation
 in mapillary/opensfm/opensfm/src/dense/src/depthmap.cc

Summary:
# Overview

LLVM has detected a bad _implicit constant integer to float conversion_ in mapillary/opensfm/opensfm/src/dense/src/depthmap.cc. Almost all such cases lead to very subtle bugs, so we are making them a compiler error by default.

# Reproducer

The fix can be checked using:
```
buck2 build --config cxx.extra_cxxflags=-Wimplicit-const-int-float-conversion <TARGET>
```

# Description of the problem

What value do you think this produces?
```
static_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max()))
```
You'd hope it would produce UINT64_MAX (18446744073709551615), but it doesn't.

In debug mode it produces 9223372036854775808 (half of the above). In opt mode it produces "random" numbers such as 140726009322632 (which is 130,000x smaller than UINT64_MAX).

Comparisons between floats and maximum integer values are also scary:
```
constexpr double x = std::numeric_limits<uint64_t>::max();
constexpr auto kMax64 = std::numeric_limits<uint64_t>::max();
std::cout << (x > kMax64 ? kMax64 : static_cast<uint64_t>(x)) << std::endl;
```
produces garbage: 140731185888920

The reason this happens is because floating-point types can only represent integers sparsely in the regions of the maximum integers (generated with P1188399781):
```
delta = 128
2147483264 f
2147483392 f
2147483520 f
2147483647 <- Largest integer
2147483648 f
2147483904 f
2147484160 f

delta = 256
4294966528 f
4294966784 f
4294967040 f
4294967295 <- Largest integer
4294967296 f
4294967808 f
4294968320 f

delta = 1024
9223372036854772736 d
9223372036854773760 d
9223372036854774784 d
9223372036854775807 <- Largest integer
9223372036854775808 d
9223372036854777856 d
9223372036854779904 d

delta = 2048
18446744073709545472 d
18446744073709547520 d
18446744073709549568 d
18446744073709551615 <- Largest integer
18446744073709551616 d
18446744073709555712 d
18446744073709559808 d
```

# Fixing the Problem

See example fixes in D54119898, D54119901, D54119899.

## Careful Clamping

The fix will be situation dependent, `folly::constexpr_clamp_cast` is _very_ useful:
```
// Include the target `//folly:constexpr_math`
#include <folly/ConstexprMath.h>
#include <iostream>
#include <limits>

int main() {
  constexpr auto kMax32 = std::numeric_limits<int32_t>::max();
  std::cout << folly::constexpr_clamp_cast<int32_t>(static_cast<float>(kMax32)) << std::endl;
  return 0;
}
```

## Use infinity

In some cases we want want something like
```
double smallest_value = BIG_NUMBER;
for (const auto &x : values) {
    smallest_value = std::min(smallest_value, x);
}
```
If `BIG_NUMBER` is an integer this code could be incorrect!

Instead we use
```
double smallest_value = std::numeric_limits<double>::infinity();
```

## Make the conversion explicit

For situations in which we are dividing by a very large integer, we can use `static_cast<FLOAT_TYPE>(LARGE_INT)` to make the conversion from int to float explicit. The conversion is _not_ exact, but our hope is that the precision we've lost is small enough that it doesn't matter for the problem being solved.

Reviewed By: YanNoun

Differential Revision: D54586527

fbshipit-source-id: 6ac8812158f204457e002f2c3ec15b55d8fcb538
---
 opensfm/src/dense/src/depthmap.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/dense/src/depthmap.cc b/opensfm/src/dense/src/depthmap.cc
index a665d9296..57ef85b6d 100644
--- a/opensfm/src/dense/src/depthmap.cc
+++ b/opensfm/src/dense/src/depthmap.cc
@@ -126,7 +126,8 @@ cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d &K,
 }
 
 float UniformRand(float a, float b) {
-  return a + (b - a) * float(rand()) / RAND_MAX;
+  // Note that float(RAND_MAX) cannot be exactly represented as a float. We ignore the small inaccuracy here; this is already a bad way to get random numbers.
+  return a + (b - a) * float(rand()) / static_cast<float>(RAND_MAX);
 }
 
 DepthmapEstimator::DepthmapEstimator()

From afb0c15beacbf68890c3ddcadbb33186cc03f379 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Thu, 7 Mar 2024 08:17:38 -0800
Subject: [PATCH 068/235] Fix `-Wimplicit-const-int-float-conversion` violation
 in mapillary/opensfm/opensfm/src/geometry/relative_pose.h

Summary:
# Overview

LLVM has detected a bad _implicit constant integer to float conversion_ in mapillary/opensfm/opensfm/src/geometry/relative_pose.h. Almost all such cases lead to very subtle bugs, so we are making them a compiler error by default.

# Reproducer

The fix can be checked using:
```
buck2 build --config cxx.extra_cxxflags=-Wimplicit-const-int-float-conversion <TARGET>
```

# Description of the problem

What value do you think this produces?
```
static_cast<uint64_t>(static_cast<double>(std::numeric_limits<uint64_t>::max()))
```
You'd hope it would produce UINT64_MAX (18446744073709551615), but it doesn't.

In debug mode it produces 9223372036854775808 (half of the above). In opt mode it produces "random" numbers such as 140726009322632 (which is 130,000x smaller than UINT64_MAX).

Comparisons between floats and maximum integer values are also scary:
```
constexpr double x = std::numeric_limits<uint64_t>::max();
constexpr auto kMax64 = std::numeric_limits<uint64_t>::max();
std::cout << (x > kMax64 ? kMax64 : static_cast<uint64_t>(x)) << std::endl;
```
produces garbage: 140731185888920

The reason this happens is because floating-point types can only represent integers sparsely in the regions of the maximum integers (generated with P1188399781):
```
delta = 128
2147483264 f
2147483392 f
2147483520 f
2147483647 <- Largest integer
2147483648 f
2147483904 f
2147484160 f

delta = 256
4294966528 f
4294966784 f
4294967040 f
4294967295 <- Largest integer
4294967296 f
4294967808 f
4294968320 f

delta = 1024
9223372036854772736 d
9223372036854773760 d
9223372036854774784 d
9223372036854775807 <- Largest integer
9223372036854775808 d
9223372036854777856 d
9223372036854779904 d

delta = 2048
18446744073709545472 d
18446744073709547520 d
18446744073709549568 d
18446744073709551615 <- Largest integer
18446744073709551616 d
18446744073709555712 d
18446744073709559808 d
```

# Fixing the Problem

See example fixes in D54119898, D54119901, D54119899.

## Careful Clamping

The fix will be situation dependent, `folly::constexpr_clamp_cast` is _very_ useful:
```
// Include the target `//folly:constexpr_math`
#include <folly/ConstexprMath.h>
#include <iostream>
#include <limits>

int main() {
  constexpr auto kMax32 = std::numeric_limits<int32_t>::max();
  std::cout << folly::constexpr_clamp_cast<int32_t>(static_cast<float>(kMax32)) << std::endl;
  return 0;
}
```

## Use infinity

In some cases we want want something like
```
double smallest_value = BIG_NUMBER;
for (const auto &x : values) {
    smallest_value = std::min(smallest_value, x);
}
```
If `BIG_NUMBER` is an integer this code could be incorrect!

Instead we use
```
double smallest_value = std::numeric_limits<double>::infinity();
```

## Make the conversion explicit

For situations in which we are dividing by a very large integer, we can use `static_cast<FLOAT_TYPE>(LARGE_INT)` to make the conversion from int to float explicit. The conversion is _not_ exact, but our hope is that the precision we've lost is small enough that it doesn't matter for the problem being solved.

Reviewed By: dmm-fb

Differential Revision: D54586517

fbshipit-source-id: b03d0e05edc5dccff17811e8419548cfb72759b0
---
 opensfm/src/geometry/relative_pose.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/geometry/relative_pose.h b/opensfm/src/geometry/relative_pose.h
index 997875764..7fb759fd9 100644
--- a/opensfm/src/geometry/relative_pose.h
+++ b/opensfm/src/geometry/relative_pose.h
@@ -87,7 +87,8 @@ struct RelativePoseCost {
     std::srand(42);
     const int count = end_ - begin_;
     for (int i = 0; i < MAX_ERRORS; ++i) {
-      const int index = (float(std::rand()) / RAND_MAX) * count;
+      // Note that float(RAND_MAX) cannot be exactly represented as a float. We ignore the small inaccuracy here; this is already a bad way to get random numbers.
+      const int index = (float(std::rand()) / static_cast<float>(RAND_MAX)) * count;
       picked_errors_.push_back(begin_ + index);
     }
   }

From 78b795c58a4684195c6c7ab5e7d531ee484f32c6 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Thu, 7 Mar 2024 10:57:56 -0800
Subject: [PATCH 069/235] Remove unused variables in
 mapillary/opensfm/opensfm/src/third_party/akaze/lib/AKAZE.cpp

Summary:
LLVM-15 has a warning `-Wunused-but-set-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code, or (b) qualifies the variable with `[[maybe_unused]]`, mostly in cases where the variable _is_ used, but, eg, in an `assert` statement that isn't present in production code.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: dmm-fb

Differential Revision: D54378379

fbshipit-source-id: 0a23b525ffbe0862e32609ce45af4c2cd7794551
---
 opensfm/src/third_party/akaze/lib/AKAZE.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index 5d42f251d..e49b6f1c2 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -269,7 +269,7 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
   double t1 = 0.0, t2 = 0.0;
   float value = 0.0;
   float dist = 0.0, ratio = 0.0, smax = 0.0;
-  int npoints = 0, id_repeated = 0;
+  int id_repeated = 0;
   int sigma_size_ = 0, left_x = 0, right_x = 0, up_y = 0, down_y = 0;
   bool is_extremum = false, is_repeated = false, is_out = false;
   cv::KeyPoint point;
@@ -357,7 +357,6 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
                 point.pt.x *= ratio;
                 point.pt.y *= ratio;
                 kpts_aux.push_back(point);
-                npoints++;
               }
               else {
                 point.pt.x *= ratio;

From 4b562c6ab178b60d1f167dc2ec24d6dad8bb7aa6 Mon Sep 17 00:00:00 2001
From: oafolabi <oaa3wf@virginia.edu>
Date: Mon, 18 Mar 2024 10:02:32 -0700
Subject: [PATCH 070/235] =?UTF-8?q?returning=20norm=5Fcoords=20instead=20o?=
 =?UTF-8?q?f=20px=5Fcoords=20in=20pixelToNormalizedCoordi=E2=80=A6=20(#103?=
 =?UTF-8?q?1)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Summary:
…natesMany

Attempting to fix issue create here: [https://github.com/mapillary/OpenSfM/issues/1030#issue-2046628484](https://github.com/mapillary/OpenSfM/issues/1030#issue-2046628484)

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1031

Reviewed By: paulinus

Differential Revision: D55006764

Pulled By: fabianschenk

fbshipit-source-id: 506078187c0f2387535521f0068c3322f2465b22
---
 opensfm/src/geometry/src/camera.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/src/geometry/src/camera.cc b/opensfm/src/geometry/src/camera.cc
index 45619f6cf..d864fa743 100644
--- a/opensfm/src/geometry/src/camera.cc
+++ b/opensfm/src/geometry/src/camera.cc
@@ -366,7 +366,7 @@ MatX2d Camera::PixelToNormalizedCoordinatesMany(const MatX2d& px_coords,
     norm_coords.row(i) =
         PixelToNormalizedCoordinates(px_coords.row(i), width, height);
   }
-  return px_coords;
+  return norm_coords;
 }
 
 Vec2d Camera::NormalizedToPixelCoordinates(const Vec2d& norm_coord) const {

From c72419228fb8c86f2c367989abd64f784ec684b3 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Thu, 21 Mar 2024 18:37:26 -0700
Subject: [PATCH 071/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D55201655

fbshipit-source-id: a1eb370d0b39457e3f59614a093a50022869eca9
---
 opensfm/commands/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index 97a2f32fe..da12e64dc 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -24,6 +24,7 @@
     reconstruct_from_prior,
     undistort,
 )
+# pyre-fixme[21]: Could not find module `opensfm.commands.command_runner`.
 from .command_runner import command_runner
 
 

From 5e854bb43f046ac9277dcfc7a891bab8587f070f Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Tue, 2 Apr 2024 17:49:18 -0700
Subject: [PATCH 072/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D55650790

fbshipit-source-id: e7eb7d1ee3f84943d28a1f893e75f58e9b4a67e1
---
 opensfm/commands/__init__.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index da12e64dc..97a2f32fe 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -24,7 +24,6 @@
     reconstruct_from_prior,
     undistort,
 )
-# pyre-fixme[21]: Could not find module `opensfm.commands.command_runner`.
 from .command_runner import command_runner
 
 

From 5b32e380a66e095894de82291087c674e0d6d3cd Mon Sep 17 00:00:00 2001
From: True Price <jtprice@meta.com>
Date: Thu, 18 Apr 2024 12:39:11 -0700
Subject: [PATCH 073/235] Remove unused pybind11 functions

Differential Revision: D56274720

fbshipit-source-id: bd23cac89ee6df6190e8b847591ba2a12d8b4c66
---
 opensfm/src/map/pybind_utils.h | 154 +++++++--------------------------
 1 file changed, 32 insertions(+), 122 deletions(-)

diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index e7f402eed..bcb878176 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -12,12 +12,10 @@
 #define PYBIND11_NAMESPACE_END_ NAMESPACE_END
 #endif
 
-
 PYBIND11_NAMESPACE_BEGIN_(PYBIND11_NAMESPACE)
 PYBIND11_NAMESPACE_BEGIN_(detail)
 
 // See https://github.com/pybind/pybind11/issues/637
-// Also fbsource/fbcode/caffe2/torch/csrc/jit/python/pybind.h
 
 using ListCasterBase =
     pybind11::detail::list_caster<std::vector<map::Landmark *>,
@@ -52,45 +50,12 @@ struct sfm_iterator_state {
 };
 PYBIND11_NAMESPACE_END_(detail)
 
-/// Makes an python iterator over the keys (`.first`) of a iterator over pairs
-/// from a first and past-the-end InputIterator.
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Iterator, typename Sentinel,
-          typename KeyType = decltype((*std::declval<Iterator>()).second),
-          typename... Extra>
-iterator make_value_iterator(Iterator first, Sentinel last, Extra &&... extra) {
-  typedef detail::sfm_iterator_state<Iterator, Sentinel, detail::RefIterator,
-                                     Policy>
-      state;
-
-  if (!detail::get_type_info(typeid(state), false)) {
-    class_<state>(handle(), "iterator", pybind11::module_local())
-        .def("__iter__", [](state &s) -> state & { return s; })
-        .def("__next__",
-             [](state &s) -> KeyType {
-               if (!s.first_or_done) {
-                 ++s.it;
-               } else {
-                 s.first_or_done = false;
-               }
-               if (s.it == s.end) {
-                 s.first_or_done = true;
-                 throw stop_iteration();
-               }
-               return (*s.it).second;
-             },
-             std::forward<Extra>(extra)..., Policy);
-  }
-
-  return cast(state{first, last, true});
-}
-
 template <return_value_policy Policy = return_value_policy::reference_internal,
           typename Iterator, typename Sentinel,
           typename KeyType = decltype(&((*std::declval<Iterator>()).second)),
           typename... Extra>
 iterator make_ref_value_iterator(Iterator first, Sentinel last,
-                                 Extra &&... extra) {
+                                 Extra &&...extra) {
   typedef detail::sfm_iterator_state<Iterator, Sentinel,
                                      detail::RefValueIterator, Policy>
       state;
@@ -98,20 +63,21 @@ iterator make_ref_value_iterator(Iterator first, Sentinel last,
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_value_iterator", pybind11::module_local())
         .def("__iter__", [](state &s) -> state & { return s; })
-        .def("__next__",
-             [](state &s) -> KeyType {
-               if (!s.first_or_done) {
-                 ++s.it;
-               } else {
-                 s.first_or_done = false;
-               }
-               if (s.it == s.end) {
-                 s.first_or_done = true;
-                 throw stop_iteration();
-               }
-               return &(s.it->second);
-             },
-             std::forward<Extra>(extra)..., Policy);
+        .def(
+            "__next__",
+            [](state &s) -> KeyType {
+              if (!s.first_or_done) {
+                ++s.it;
+              } else {
+                s.first_or_done = false;
+              }
+              if (s.it == s.end) {
+                s.first_or_done = true;
+                throw stop_iteration();
+              }
+              return &(s.it->second);
+            },
+            std::forward<Extra>(extra)..., Policy);
   }
 
   return cast(state{first, last, true});
@@ -123,7 +89,7 @@ template <
     typename KeyType =
         pybind11::tuple,  // decltype(&((*std::declval<Iterator>()).second)),
     typename... Extra>
-iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&... extra) {
+iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&...extra) {
   typedef detail::sfm_iterator_state<Iterator, Sentinel, detail::ValueIterator,
                                      Policy>
       state;
@@ -131,80 +97,24 @@ iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&... extra) {
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_iterator", pybind11::module_local())
         .def("__iter__", [](state &s) -> state & { return s; })
-        .def("__next__",
-             [](state &s) -> KeyType {
-               if (!s.first_or_done) {
-                 ++s.it;
-               } else {
-                 s.first_or_done = false;
-               }
-               if (s.it == s.end) {
-                 s.first_or_done = true;
-                 throw stop_iteration();
-               }
-               return pybind11::make_tuple(s.it->first, &(s.it->second));
-             },
-             std::forward<Extra>(extra)..., Policy);
-  }
-
-  return cast(state{first, last, true});
-}
-
-/// Makes a python iterator from a first and past-the-end C++ InputIterator.
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Iterator, typename Sentinel,
-          typename ValueType = decltype(std::declval<Iterator>()),
-          typename... Extra>
-iterator make_ptr_iterator(Iterator first, Sentinel last, Extra &&... extra) {
-  typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
-
-  if (!detail::get_type_info(typeid(state), false)) {
-    class_<state>(handle(), "iterator", pybind11::module_local())
-        .def("__iter__", [](state &s) -> state & { return s; })
-        .def("__next__",
-             [](state &s) -> ValueType {
-               if (!s.first_or_done) {
-                 ++s.it;
-               } else {
-                 s.first_or_done = false;
-               }
-               if (s.it == s.end) {
-                 s.first_or_done = true;
-                 throw stop_iteration();
-               }
-               return s.it;
-             },
-             std::forward<Extra>(extra)..., Policy);
+        .def(
+            "__next__",
+            [](state &s) -> KeyType {
+              if (!s.first_or_done) {
+                ++s.it;
+              } else {
+                s.first_or_done = false;
+              }
+              if (s.it == s.end) {
+                s.first_or_done = true;
+                throw stop_iteration();
+              }
+              return pybind11::make_tuple(s.it->first, &(s.it->second));
+            },
+            std::forward<Extra>(extra)..., Policy);
   }
 
   return cast(state{first, last, true});
 }
 
-/// Makes an iterator over the keys (`.first`) of a stl map-like container
-/// supporting `std::begin()`/`std::end()`
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Type, typename... Extra>
-iterator make_value_iterator(Type &value, Extra &&... extra) {
-  return make_value_iterator<Policy>(std::begin(value), std::end(value),
-                                     extra...);
-}
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Type, typename... Extra>
-iterator make_unique_ptr_value_iterator(Type &value, Extra &&... extra) {
-  return make_unique_ptr_value_iterator<Policy>(std::begin(value),
-                                                std::end(value), extra...);
-}
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Type, typename... Extra>
-iterator make_unique_ptr_iterator(Type &value, Extra &&... extra) {
-  return make_unique_ptr_iterator<Policy>(std::begin(value), std::end(value),
-                                          extra...);
-}
-
-template <return_value_policy Policy = return_value_policy::reference_internal,
-          typename Type, typename... Extra>
-iterator make_ref_value_iterator(Type &value, Extra &&... extra) {
-  return make_ref_value_iterator<Policy>(std::begin(value), std::end(value),
-                                         extra...);
-}
 PYBIND11_NAMESPACE_END_(PYBIND11_NAMESPACE)

From 40b73c08d4a7087a6d76033284eb6c66e1efe35f Mon Sep 17 00:00:00 2001
From: Sebastian Gassner <sepastian@users.noreply.github.com>
Date: Mon, 3 Jun 2024 01:02:22 -0700
Subject: [PATCH 074/235] describe how to build and use docker images (#1049)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1049

Reviewed By: paulinus

Differential Revision: D57765801

Pulled By: fabianschenk

fbshipit-source-id: 6aa8c2678ac0007d42baa410b43077d4cccdd9ad
---
 doc/source/building.rst | 12 +++++++++++-
 doc/source/using.rst    | 15 +++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/doc/source/building.rst b/doc/source/building.rst
index 591444af4..56a76ec96 100644
--- a/doc/source/building.rst
+++ b/doc/source/building.rst
@@ -108,6 +108,16 @@ Once the dependencies have been installed, you can build OpenSfM by running the
 
     python3 setup.py build
 
+Building Docker images
+----------------------
+
+Once dependencies have been installed, you can build OpenSfM Docker images by running the following command from the main folder::
+
+    docker build -t opensfm -f Dockerfile .
+
+To build an image using the Ceres 2 solver, use::
+
+  docker build -t opensfm:ceres2 -f Dockerfile.ceres2 .
 
 Building the documentation
 --------------------------
@@ -131,4 +141,4 @@ and browse `http://localhost:8000/ <http://localhost:8000/>`_
 .. _git: https://git-scm.com/
 .. _cmake: https://cmake.org/
 .. _Visual Studio 2019: https://visualstudio.microsoft.com/downloads/
-.. _Python 3.8: https://www.microsoft.com/en-us/p/python-38/9mssztt1n39l
\ No newline at end of file
+.. _Python 3.8: https://www.microsoft.com/en-us/p/python-38/9mssztt1n39l
diff --git a/doc/source/using.rst b/doc/source/using.rst
index bcd3aeee4..9cf364ead 100644
--- a/doc/source/using.rst
+++ b/doc/source/using.rst
@@ -14,6 +14,21 @@ An example dataset is available at ``data/berlin``.  You can reconstruct it by r
 
 This will run the entire SfM pipeline and produce the file ``data/berlin/reconstruction.meshed.json`` as output.
 
+Running in Docker
+'''''''''''''''''
+
+First, build the OpenSfM Docker image, as described under "building".
+
+
+Then, start a Docker container. The following command mounts the `data/` folder to `/data/` inside the Docker container::
+
+    docker run -it -p 8080:8080 -v ${PWD}/data/:/data/ opensfm:ceres2
+
+Once inside the running Docker container, start the reconstruction process with the usual command::
+
+    bin/opensfm_run_all /data/berlin/
+
+When done, exit the container by pressing Ctrl+d. The model generated will be available in the `data/` catalogue.
 
 Viewer setup
 ''''''''''''

From b18e63800126844b27c9d56d2da466c6a58c6d1f Mon Sep 17 00:00:00 2001
From: kielnino <kielnino@users.noreply.github.com>
Date: Mon, 3 Jun 2024 01:50:18 -0700
Subject: [PATCH 075/235] Remove dublicated SIFT-Dectector instance in feature
 matching (#1053)

Summary:
It seems to me that the SIFT detector is instantiated, but then not used, because the object is created again in the following while loop. This merge request removes the unnecessary code.
I have also made the missing parameters of the OpenCV-Sift implementation configurable.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1053

Reviewed By: paulinus

Differential Revision: D57765783

Pulled By: fabianschenk

fbshipit-source-id: 59a24bbbc60f55c1cb5e1f81a9896ec13f82e5d8
---
 opensfm/config.py   |  6 ++++++
 opensfm/features.py | 48 +++++++++++++++++++--------------------------
 2 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 907e9c1ed..d19591333 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -42,6 +42,12 @@ class OpenSfMConfig:
     sift_peak_threshold: float = 0.1
     # See OpenCV doc
     sift_edge_threshold: int = 10
+    # See OpenCV doc
+    sift_nfeatures: int = 0
+    # See OpenCV doc
+    sift_octave_layers: int = 3
+    # See OpenCV doc
+    sift_sigma: float = 1.6
 
     ##################################
     # Params for SURF
diff --git a/opensfm/features.py b/opensfm/features.py
index 622c47ae2..26eb0c05a 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -353,45 +353,36 @@ def extract_features_sift(
 ) -> Tuple[np.ndarray, np.ndarray]:
     sift_edge_threshold = config["sift_edge_threshold"]
     sift_peak_threshold = float(config["sift_peak_threshold"])
-    # SIFT support is in cv2 main from version 4.4.0
-    if context.OPENCV44 or context.OPENCV5:
-        # OpenCV versions concerned /** 3.4.11, >= 4.4.0 **/  ==> Sift became free since March 2020
-        detector = cv2.SIFT_create(
-            edgeThreshold=sift_edge_threshold, contrastThreshold=sift_peak_threshold
-        )
-        descriptor = detector
-    elif context.OPENCV3 or context.OPENCV4:
-        try:
-            # OpenCV versions concerned /** 3.2.x, 3.3.x, 3.4.0, 3.4.1, 3.4.2, 3.4.10, 4.3.0, 4.4.0 **/
-            detector = cv2.xfeatures2d.SIFT_create(
-                edgeThreshold=sift_edge_threshold, contrastThreshold=sift_peak_threshold
-            )
-        except AttributeError as ae:
-            # OpenCV versions concerned /** 3.4.3, 3.4.4, 3.4.5, 3.4.6, 3.4.7, 3.4.8, 3.4.9, 4.0.x, 4.1.x, 4.2.x **/
-            if "no attribute 'xfeatures2d'" in str(ae):
-                logger.error(
-                    "OpenCV Contrib modules are required to extract SIFT features"
-                )
-            raise
-        descriptor = detector
-    else:
-        detector = cv2.FeatureDetector_create("SIFT")
-        descriptor = cv2.DescriptorExtractor_create("SIFT")
-        detector.setDouble("edgeThreshold", sift_edge_threshold)
+    sift_nfeatures = config["sift_nfeatures"]
+    sift_octave_layers = config["sift_octave_layers"]
+    sift_sigma = float(config["sift_sigma"])
     while True:
         logger.debug("Computing sift with threshold {0}".format(sift_peak_threshold))
         t = time.time()
         # SIFT support is in cv2 main from version 4.4.0
         if context.OPENCV44 or context.OPENCV5:
             detector = cv2.SIFT_create(
-                edgeThreshold=sift_edge_threshold, contrastThreshold=sift_peak_threshold
+                nfeatures=sift_nfeatures,
+                nOctaveLayers=sift_octave_layers,
+                contrastThreshold=sift_peak_threshold,
+                edgeThreshold=sift_edge_threshold,
+                sigma=sift_sigma,
             )
+            descriptor = detector
         elif context.OPENCV3:
             detector = cv2.xfeatures2d.SIFT_create(
-                edgeThreshold=sift_edge_threshold, contrastThreshold=sift_peak_threshold
+                nfeatures=sift_nfeatures,
+                nOctaveLayers=sift_octave_layers,
+                contrastThreshold=sift_peak_threshold,
+                edgeThreshold=sift_edge_threshold,
+                sigma=sift_sigma,
             )
+            descriptor = detector
         else:
-            detector.setDouble("contrastThreshold", sift_peak_threshold)
+            detector = cv2.FeatureDetector_create("SIFT")
+            descriptor = cv2.DescriptorExtractor_create("SIFT")
+            detector.setDouble("edgeThreshold", sift_edge_threshold)
+        
         points = detector.detect(image)
         logger.debug("Found {0} points in {1}s".format(len(points), time.time() - t))
         if len(points) < features_count and sift_peak_threshold > 0.0001:
@@ -400,6 +391,7 @@ def extract_features_sift(
         else:
             logger.debug("done")
             break
+
     points, desc = descriptor.compute(image, points)
 
     if desc is not None:

From c9d7d98811568777d4ed35947ac040066c50782e Mon Sep 17 00:00:00 2001
From: Michael Waechter <nightwatch@meta.com>
Date: Tue, 11 Jun 2024 02:18:27 -0700
Subject: [PATCH 076/235] add check to opensfm BA that GPS accuracies are
 positive

Summary: For MLY internal we sometimes get -1 values for GPS accuracy. The new EXIF parser now prevents this from happening and sends None instead, but this diff adds an error message for this case so that we immediately notice if this ever happens again.

Reviewed By: DodgySpaniard

Differential Revision: D58373009

fbshipit-source-id: 526d92fbec49be7a9a8398648d722880ab138d54
---
 opensfm/src/sfm/src/ba_helpers.cc | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index d0501aa84..82d550e9f 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -8,6 +8,7 @@
 #include <chrono>
 #include <cmath>
 #include <stdexcept>
+#include <string>
 
 #include "geo/geo.h"
 #include "map/defines.h"
@@ -672,6 +673,11 @@ py::dict BAHelpers::Bundle(
         const auto pos = shot.GetShotMeasurements().gps_position_;
         const auto acc = shot.GetShotMeasurements().gps_accuracy_;
         if (pos.HasValue() && acc.HasValue()) {
+          if (acc.Value() <= 0) {
+            throw std::runtime_error("Shot " + shot.GetId() + " has an accuracy <= 0: "
+                                    + std::to_string(acc.Value()) + ". Try modifying "
+                                    "your input parser to filter such values.");
+          }
           average_position += pos.Value();
           average_std += acc.Value();
           ++gps_count;

From 7b531aecf708472b1eed928cdea1d7d4fc70028a Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 26 Jun 2024 07:24:14 -0700
Subject: [PATCH 077/235] Fix shadowed variable in
 mapillary/opensfm/opensfm/src/geometry/src/camera.cc

Summary:
Our upcoming compiler upgrade will require us not to have shadowed variables. Such variables have a _high_ bug rate and reduce readability, so we would like to avoid them even if the compiler was not forcing us to do so.

This codemod attempts to fix an instance of a shadowed variable. Please review with care: if it's failed the result will be a silent bug.

**What's a shadowed variable?**

Shadowed variables are variables in an inner scope with the same name as another variable in an outer scope. Having the same name for both variables might be semantically correct, but it can make the code confusing to read! It can also hide subtle bugs.

This diff fixes such an issue by renaming the variable.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: dmm-fb

Differential Revision: D59008872

fbshipit-source-id: bd67d6396265aefb077ab37ae343e67c31a16408
---
 opensfm/src/geometry/src/camera.cc            |  8 ++---
 opensfm/src/third_party/akaze/lib/AKAZE.cpp   | 22 ++++++-------
 .../akaze/lib/nldiffusion_functions.cpp       | 32 +++++++++----------
 3 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/opensfm/src/geometry/src/camera.cc b/opensfm/src/geometry/src/camera.cc
index d864fa743..58b4a50e2 100644
--- a/opensfm/src/geometry/src/camera.cc
+++ b/opensfm/src/geometry/src/camera.cc
@@ -276,15 +276,15 @@ Mat3d Camera::GetProjectionMatrix() const {
   return unnormalized;
 }
 
-Mat3d Camera::GetProjectionMatrixScaled(int width, int height) const {
-  const auto unnormalizer = std::max(width, height);
+Mat3d Camera::GetProjectionMatrixScaled(int width_2, int height_2) const {
+  const auto unnormalizer = std::max(width_2, height_2);
   Mat3d unnormalized = Mat3d::Zero();
 
   const auto projection_matrix = GetProjectionMatrix();
   unnormalized.block<2, 2>(0, 0)
       << unnormalizer * projection_matrix.block<2, 2>(0, 0);
-  unnormalized.col(2) << projection_matrix(0, 2) * unnormalizer + 0.5 * width,
-      projection_matrix(1, 2) * unnormalizer + 0.5 * height, 1.0;
+  unnormalized.col(2) << projection_matrix(0, 2) * unnormalizer + 0.5 * width_2,
+      projection_matrix(1, 2) * unnormalizer + 0.5 * height_2, 1.0;
   return unnormalized;
 }
 
diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index e49b6f1c2..d8356a066 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -374,17 +374,17 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
   for (size_t i = 0; i < kpts_aux.size(); i++) {
 
     is_repeated = false;
-    const cv::KeyPoint& point = kpts_aux[i];
+    const cv::KeyPoint& point_2 = kpts_aux[i];
     for (size_t j = i+1; j < kpts_aux.size(); j++) {
 
       // Compare response with the upper scale
-      if ((point.class_id+1) == kpts_aux[j].class_id) {
+      if ((point_2.class_id+1) == kpts_aux[j].class_id) {
 
-        dist = (point.pt.x-kpts_aux[j].pt.x)*(point.pt.x-kpts_aux[j].pt.x) +
-            (point.pt.y-kpts_aux[j].pt.y)*(point.pt.y-kpts_aux[j].pt.y);
+        dist = (point_2.pt.x-kpts_aux[j].pt.x)*(point_2.pt.x-kpts_aux[j].pt.x) +
+            (point_2.pt.y-kpts_aux[j].pt.y)*(point_2.pt.y-kpts_aux[j].pt.y);
 
-        if (dist <= point.size*point.size) {
-          if (point.response < kpts_aux[j].response) {
+        if (dist <= point_2.size*point_2.size) {
+          if (point_2.response < kpts_aux[j].response) {
             is_repeated = true;
             break;
           }
@@ -393,7 +393,7 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
     }
 
     if (is_repeated == false) {
-      kpts.push_back(point);
+      kpts.push_back(point_2);
     }
   }
 
@@ -959,8 +959,8 @@ void AKAZE::Get_MSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float *desc
   // convert to unit vector
   len = sqrt(len);
 
-  for (int i = 0; i < dsize; i++) {
-    desc[i] /= len;
+  for (int i_2 = 0; i_2 < dsize; i_2++) {
+    desc[i_2] /= len;
   }
 }
 
@@ -1075,8 +1075,8 @@ void AKAZE::Get_MSURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc) const
   // convert to unit vector
   len = sqrt(len);
 
-  for (int i = 0; i < dsize; i++) {
-    desc[i] /= len;
+  for (int i_2 = 0; i_2 < dsize; i_2++) {
+    desc[i_2] /= len;
   }
 }
 
diff --git a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
index b1e3567ef..9f50abd5a 100644
--- a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
+++ b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
@@ -271,11 +271,11 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, const float
   Ld_row_p = Ld.ptr<float>(Lstep.rows-2);
   Lstep_row = Lstep.ptr<float>(Lstep.rows-1);
 
-  for (int x = 1; x < Lstep.cols-1; x++) {
-    float xpos = (c_row[x]+c_row[x+1])*(Ld_row[x+1]-Ld_row[x]);
-    float xneg = (c_row[x-1]+c_row[x])*(Ld_row[x]-Ld_row[x-1]);
-    float ypos = (c_row[x]+c_row_p[x])*(Ld_row_p[x]-Ld_row[x]);
-    Lstep_row[x] = 0.5*stepsize*(xpos-xneg + ypos);
+  for (int x_2 = 1; x_2 < Lstep.cols-1; x_2++) {
+    float xpos_2 = (c_row[x_2]+c_row[x_2+1])*(Ld_row[x_2+1]-Ld_row[x_2]);
+    float xneg_2 = (c_row[x_2-1]+c_row[x_2])*(Ld_row[x_2]-Ld_row[x_2-1]);
+    float ypos_2 = (c_row[x_2]+c_row_p[x_2])*(Ld_row_p[x_2]-Ld_row[x_2]);
+    Lstep_row[x_2] = 0.5*stepsize*(xpos_2-xneg_2 + ypos_2);
   }
 
   xpos = (c_row[0]+c_row[1])*(Ld_row[1]-Ld_row[0]);
@@ -290,22 +290,22 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, const float
   // First and last columns
   for (int i = 1; i < Lstep.rows-1; i++) {
 
-    const float* c_row = c.ptr<float>(i);
+    const float* c_row_2 = c.ptr<float>(i);
     const float* c_row_m = c.ptr<float>(i-1);
-    const float* c_row_p = c.ptr<float>(i+1);
-    float* Ld_row = Ld.ptr<float>(i);
-    float* Ld_row_p = Ld.ptr<float>(i+1);
+    const float* c_row_p_2 = c.ptr<float>(i+1);
+    float* Ld_row_2 = Ld.ptr<float>(i);
+    float* Ld_row_p_2 = Ld.ptr<float>(i+1);
     float* Ld_row_m = Ld.ptr<float>(i-1);
     Lstep_row = Lstep.ptr<float>(i);
 
-    float xpos = (c_row[0]+c_row[1])*(Ld_row[1]-Ld_row[0]);
-    float ypos = (c_row[0]+c_row_p[0])*(Ld_row_p[0]-Ld_row[0]);
-    float yneg = (c_row_m[0]+c_row[0])*(Ld_row[0]-Ld_row_m[0]);
-    Lstep_row[0] = 0.5*stepsize*(xpos+ypos-yneg);
+    float xpos_2 = (c_row_2[0]+c_row_2[1])*(Ld_row_2[1]-Ld_row_2[0]);
+    float ypos = (c_row_2[0]+c_row_p_2[0])*(Ld_row_p_2[0]-Ld_row_2[0]);
+    float yneg = (c_row_m[0]+c_row_2[0])*(Ld_row_2[0]-Ld_row_m[0]);
+    Lstep_row[0] = 0.5*stepsize*(xpos_2+ypos-yneg);
 
-    float xneg = (c_row[Lstep.cols-2]+c_row[Lstep.cols-1])*(Ld_row[Lstep.cols-1]-Ld_row[Lstep.cols-2]);
-    ypos = (c_row[Lstep.cols-1]+c_row_p[Lstep.cols-1])*(Ld_row_p[Lstep.cols-1]-Ld_row[Lstep.cols-1]);
-    yneg = (c_row_m[Lstep.cols-1]+c_row[Lstep.cols-1])*(Ld_row[Lstep.cols-1]-Ld_row_m[Lstep.cols-1]);
+    float xneg = (c_row_2[Lstep.cols-2]+c_row_2[Lstep.cols-1])*(Ld_row_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-2]);
+    ypos = (c_row_2[Lstep.cols-1]+c_row_p_2[Lstep.cols-1])*(Ld_row_p_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-1]);
+    yneg = (c_row_m[Lstep.cols-1]+c_row_2[Lstep.cols-1])*(Ld_row_2[Lstep.cols-1]-Ld_row_m[Lstep.cols-1]);
     Lstep_row[Lstep.cols-1] = 0.5*stepsize*(-xneg+ypos-yneg);
   }
 

From da789737d4e97c2b47242742009824ba77eb853c Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Wed, 10 Jul 2024 08:41:35 -0700
Subject: [PATCH 078/235] Remove unused-variable in
 mapillary/opensfm/opensfm/src/geometry/absolute_pose.h

Summary:
LLVM-15 has a warning `-Wunused-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code or (b) qualifies the variable with `[[maybe_unused]]`.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: fabianschenk

Differential Revision: D59586421

fbshipit-source-id: 6a8eece4ed9e6015a73021a0ee3bba4d1a0c49b6
---
 opensfm/src/geometry/absolute_pose.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/opensfm/src/geometry/absolute_pose.h b/opensfm/src/geometry/absolute_pose.h
index faa7a2633..2de1894b2 100644
--- a/opensfm/src/geometry/absolute_pose.h
+++ b/opensfm/src/geometry/absolute_pose.h
@@ -28,7 +28,6 @@ std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(IT begin,
   // Compute k1, k2 and k3
   const Eigen::Vector3d k1 = (p1 - p2).normalized();
   const Eigen::Vector3d k3 = (b1.cross(b2)).normalized();
-  const Eigen::Vector3d k2 = (k1.cross(k3)).normalized();
 
   // Compute ui and vi for i = 1, 2
   const Eigen::Vector3d u1 = p1 - p3;
@@ -93,7 +92,6 @@ std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(IT begin,
   e1 << 1, 0, 0;
   e2 << 0, 1, 0;
 
-  constexpr double eps = 1e-20;
   for (const auto &root : roots) {
     const auto cos_theta_1 = root;
     const auto sin_theta_1 =

From 1106198c79a0417fe59df68293c59ba7688533c0 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Fri, 12 Jul 2024 07:38:50 -0700
Subject: [PATCH 079/235] Remove unused function from
 mapillary/opensfm/opensfm/src/third_party/akaze/lib/utils.cpp

Summary: `-Wunused-function` has identified an unused function. This diff removes it. In many cases these functions have existed for years in an unused state.

Reviewed By: dmm-fb

Differential Revision: D59644696

fbshipit-source-id: 1e7f68d125820c9a969db26df91e0fe269fbddd5
---
 opensfm/src/third_party/akaze/lib/utils.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/opensfm/src/third_party/akaze/lib/utils.cpp b/opensfm/src/third_party/akaze/lib/utils.cpp
index ddd2a2f0f..d77168908 100644
--- a/opensfm/src/third_party/akaze/lib/utils.cpp
+++ b/opensfm/src/third_party/akaze/lib/utils.cpp
@@ -392,12 +392,6 @@ static inline std::ostream& cout_help() {
   return cout;
 }
 
-/* ************************************************************************* */
-static inline std::string toUpper(std::string s) {
-  std::transform(s.begin(), s.end(), s.begin(), ::toupper);
-  return s;
-}
-
 /* ************************************************************************* */
 void show_input_options_help(int example) {
 

From 670d53e64ccebbdc4234d8c0be76c9bb6c71f476 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Thu, 25 Jul 2024 13:46:04 -0700
Subject: [PATCH 080/235] Del using namespace
 mapillary/opensfm/opensfm/src/dense/depthmap_bind.h

Summary:
Removes a `using namespace` from the global namespace in pursuit of enabling `-Wheader-hygiene`.
Qualifies instances that relied on the `using namespace`.

Reviewed By: dmm-fb

Differential Revision: D60114516

fbshipit-source-id: d8741cc8a56bf07fb9e596bd219e4ef42468451e
---
 opensfm/src/dense/depthmap_bind.h    | 29 ++++++++++++++--------------
 opensfm/src/dense/openmvs_exporter.h |  6 +++---
 2 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/opensfm/src/dense/depthmap_bind.h b/opensfm/src/dense/depthmap_bind.h
index 007178394..d24ff80a3 100644
--- a/opensfm/src/dense/depthmap_bind.h
+++ b/opensfm/src/dense/depthmap_bind.h
@@ -3,14 +3,13 @@
 #include <dense/depthmap.h>
 #include <foundation/python_types.h>
 
-using namespace foundation;
 
 namespace dense {
 
 class DepthmapEstimatorWrapper {
  public:
-  void AddView(pyarray_d K, pyarray_d R, pyarray_d t, pyarray_uint8 image,
-               pyarray_uint8 mask) {
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_uint8 image,
+               foundation::pyarray_uint8 mask) {
     if ((image.shape(0) != mask.shape(0)) || (image.shape(1) != mask.shape(1))){
       throw std::invalid_argument("image and mask must have matching shapes.");
     }
@@ -57,13 +56,13 @@ class DepthmapEstimatorWrapper {
 
   py::object ComputeReturnValues(const DepthmapEstimatorResult &result) {
     py::list retn;
-    retn.append(py_array_from_data(result.depth.ptr<float>(0),
+    retn.append(foundation::py_array_from_data(result.depth.ptr<float>(0),
                                    result.depth.rows, result.depth.cols));
-    retn.append(py_array_from_data(result.plane.ptr<float>(0),
+    retn.append(foundation::py_array_from_data(result.plane.ptr<float>(0),
                                    result.plane.rows, result.plane.cols, 3));
-    retn.append(py_array_from_data(result.score.ptr<float>(0),
+    retn.append(foundation::py_array_from_data(result.score.ptr<float>(0),
                                    result.score.rows, result.score.cols));
-    retn.append(py_array_from_data(result.nghbr.ptr<int>(0), result.nghbr.rows,
+    retn.append(foundation::py_array_from_data(result.nghbr.ptr<int>(0), result.nghbr.rows,
                                    result.nghbr.cols));
     return std::move(retn);
   }
@@ -78,7 +77,7 @@ class DepthmapCleanerWrapper {
 
   void SetMinConsistentViews(int n) { dc_.SetMinConsistentViews(n); }
 
-  void AddView(pyarray_d K, pyarray_d R, pyarray_d t, pyarray_f depth) {
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_f depth) {
     dc_.AddView(K.data(), R.data(), t.data(), depth.data(), depth.shape(1),
                 depth.shape(0));
   }
@@ -89,7 +88,7 @@ class DepthmapCleanerWrapper {
       py::gil_scoped_release release;
       dc_.Clean(&depth);
     }
-    return py_array_from_data(depth.ptr<float>(0), depth.rows, depth.cols);
+    return foundation::py_array_from_data(depth.ptr<float>(0), depth.rows, depth.cols);
   }
 
  private:
@@ -100,8 +99,8 @@ class DepthmapPrunerWrapper {
  public:
   void SetSameDepthThreshold(float t) { dp_.SetSameDepthThreshold(t); }
 
-  void AddView(pyarray_d K, pyarray_d R, pyarray_d t, pyarray_f depth,
-               pyarray_f plane, pyarray_uint8 color, pyarray_uint8 label) {
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_f depth,
+               foundation::pyarray_f plane, foundation::pyarray_uint8 color, foundation::pyarray_uint8 label) {
     if ((depth.shape(0) != plane.shape(0)) || (depth.shape(1) != plane.shape(1))){
       throw std::invalid_argument("depth and plane must have matching shapes.");
     }
@@ -128,10 +127,10 @@ class DepthmapPrunerWrapper {
 
     py::list retn;
     int n = int(points.size()) / 3;
-    retn.append(py_array_from_data(points.data(), n, 3));
-    retn.append(py_array_from_data(normals.data(), n, 3));
-    retn.append(py_array_from_data(colors.data(), n, 3));
-    retn.append(py_array_from_data(labels.data(), n));
+    retn.append(foundation::py_array_from_data(points.data(), n, 3));
+    retn.append(foundation::py_array_from_data(normals.data(), n, 3));
+    retn.append(foundation::py_array_from_data(colors.data(), n, 3));
+    retn.append(foundation::py_array_from_data(labels.data(), n));
     return std::move(retn);
   }
 
diff --git a/opensfm/src/dense/openmvs_exporter.h b/opensfm/src/dense/openmvs_exporter.h
index 088223f7b..ba055f76e 100644
--- a/opensfm/src/dense/openmvs_exporter.h
+++ b/opensfm/src/dense/openmvs_exporter.h
@@ -6,7 +6,7 @@ namespace dense {
 
 class OpenMVSExporter {
  public:
-  void AddCamera(const std::string &camera_id, pyarray_d K, uint32_t width, uint32_t height) {
+  void AddCamera(const std::string &camera_id, foundation::pyarray_d K, uint32_t width, uint32_t height) {
     MVS::Interface::Platform platform;
     platform.name = camera_id;
     MVS::Interface::Platform::Camera camera;
@@ -22,7 +22,7 @@ class OpenMVSExporter {
   }
 
   void AddShot(const std::string &path, const std::string &maskPath, const std::string &shot_id,
-               const std::string &camera_id, pyarray_d R, pyarray_d C) {
+               const std::string &camera_id, foundation::pyarray_d R, foundation::pyarray_d C) {
     const double *C_data = C.data();
 
     int platform_id = platform_ids_[camera_id];
@@ -45,7 +45,7 @@ class OpenMVSExporter {
     scene_.images.push_back(image);
   }
 
-  void AddPoint(pyarray_d coordinates, py::list shot_ids) {
+  void AddPoint(foundation::pyarray_d coordinates, py::list shot_ids) {
     const double *x = coordinates.data();
 
     MVS::Interface::Vertex vertex;

From f953531fdea6b7ab2631e9910a5466be447107a9 Mon Sep 17 00:00:00 2001
From: Fabian Schenk <fschenk@meta.com>
Date: Tue, 6 Aug 2024 00:10:02 -0700
Subject: [PATCH 081/235] Migrate "mapillary/opensfm/PACKAGE" from LLVM-15 to
 LLVM-17

Differential Revision: D60359203

fbshipit-source-id: 5064b2fdb68276edd6408fd4f0fe87424be4bb4f
---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index a739a68fd..8843455c0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,5 @@ data/berlin/*
 
 # Ignore virtualenv files
 env/*
+
+PACKAGE

From ef872b2399cf1cc036d91e950f210a7be33c2745 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Thu, 8 Aug 2024 23:08:12 -0700
Subject: [PATCH 082/235] upgrade pyre version in `fbcode/mapillary` - batch 1

Differential Revision: D60994471

fbshipit-source-id: 9fdcfea8f07fc6b2c711a03ec1c919d37623d852
---
 opensfm/features.py                           |  1 +
 opensfm/io.py                                 |  1 +
 opensfm/multiview.py                          |  1 +
 opensfm/synthetic_data/synthetic_generator.py |  2 ++
 opensfm/test/test_bundle.py                   | 13 +++++++++++++
 opensfm/test/test_multiview.py                |  3 +++
 opensfm/test/test_robust.py                   |  1 +
 7 files changed, 22 insertions(+)

diff --git a/opensfm/features.py b/opensfm/features.py
index 26eb0c05a..15af8700f 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -516,6 +516,7 @@ def extract_features_hahog(
         uchar_scaling = 512
 
     if config["hahog_normalize_to_uchar"]:
+        # pyre-fixme[16]: `int` has no attribute `clip`.
         desc = (uchar_scaling * desc).clip(0, 255).round()
 
     logger.debug("Found {0} points in {1}s".format(len(points), time.time() - t))
diff --git a/opensfm/io.py b/opensfm/io.py
index bf72ae9f3..79119e892 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1098,6 +1098,7 @@ def reconstruction_to_ply(
                 for depth in np.linspace(0, 2, 10):
                     p = o + depth * R[axis]
                     s = "{} {} {} {} {} {}".format(
+                        # pyre-fixme[16]: `int` has no attribute `__getitem__`.
                         p[0], p[1], p[2], int(c[0]), int(c[1]), int(c[2])
                     )
                     if point_num_views:
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index e6f37e9c0..e164fd1f0 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -464,6 +464,7 @@ def R_from_homography(
 def project_to_rotation_matrix(A: np.ndarray) -> Optional[np.ndarray]:
     try:
         u, d, vt = np.linalg.svd(A)
+    # pyre-fixme[16]: Module `linalg` has no attribute `LinAlgError`.
     except np.linalg.linalg.LinAlgError:
         return None
     return u.dot(vt)
diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index 90b3fc8da..0dd20c840 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -219,6 +219,8 @@ def _gps_dop(shot: pymap.Shot) -> float:
             origin = shot.pose.get_origin()
 
             if causal_gps_noise:
+                # pyre-fixme[61]: `perturbations_2d` is undefined, or not always
+                #  defined.
                 gps_perturbation = [perturbations_2d[j][i] for j in range(2)] + [0]
             else:
                 gps_noise = _gps_dop(shot)
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index 54202da06..d3d499560 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -108,14 +108,27 @@ def test_bundle_projection_fixed_internals(scene_synthetic) -> None:
                 color = g_obs["feature_color"]
                 pt = g_obs["feature"]
                 obs = pymap.Observation(
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[0],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[1],
+                    # pyre-fixme[6]: For 3rd argument expected `float` but got
+                    #  `Dict[str, typing.Any]`.
                     g_obs["feature_scale"],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[0],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[1],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[2],
+                    # pyre-fixme[6]: For 7th argument expected `int` but got
+                    #  `Dict[str, typing.Any]`.
                     g_obs["feature_id"],
+                    # pyre-fixme[6]: For 8th argument expected `int` but got
+                    #  `Dict[str, typing.Any]`.
                     g_obs["feature_segmentation"],
+                    # pyre-fixme[6]: For 9th argument expected `int` but got
+                    #  `Dict[str, typing.Any]`.
                     g_obs["feature_instance"],
                 )
                 reference.map.add_observation(shot_id, point_id, obs)
diff --git a/opensfm/test/test_multiview.py b/opensfm/test/test_multiview.py
index a0e6f1376..8edc8cc8b 100644
--- a/opensfm/test/test_multiview.py
+++ b/opensfm/test/test_multiview.py
@@ -13,12 +13,15 @@ def normalized(x: np.ndarray) -> np.ndarray:
 
 def test_motion_from_plane_homography() -> None:
     R = tf.random_rotation_matrix()[:3, :3]
+    # pyre-fixme[6]: For 1st argument expected `ndarray` but got `int`.
     t = normalized(2 * np.random.rand(3) - 1)
+    # pyre-fixme[6]: For 1st argument expected `ndarray` but got `int`.
     n = normalized(2 * np.random.rand(3) - 1)
     d = 2 * np.random.rand() - 1
     scale = 2 * np.random.rand() - 1
     H = scale * (d * R - np.outer(t, n))
 
+    # pyre-fixme[6]: For 1st argument expected `ndarray` but got `int`.
     motions = multiview.motion_from_plane_homography(H)
     assert motions is not None
     goodness = []
diff --git a/opensfm/test/test_robust.py b/opensfm/test/test_robust.py
index 6c02d71a9..1f4330b6f 100644
--- a/opensfm/test/test_robust.py
+++ b/opensfm/test/test_robust.py
@@ -261,6 +261,7 @@ def test_outliers_relative_pose_ransac(pairs_and_their_E) -> None:
         inliers_count = (1 - ratio_outliers) * len(points)
         assert np.isclose(len(result.inliers_indices), inliers_count, rtol=tolerance)
 
+    # pyre-fixme[61]: `expected` is undefined, or not always defined.
     assert np.linalg.norm(expected - result.lo_model, ord="fro") < 16e-2
 
 

From d1727b0673a70120ad1db8e81fac46fbd55adec5 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Thu, 15 Aug 2024 02:34:52 -0700
Subject: [PATCH 083/235] removing base_module]
 fbcode/mapillary/opensfm/opensfm/test/TARGETS

Reviewed By: fabianschenk

Differential Revision: D61262745

fbshipit-source-id: ecf3ab7b8e3e37e9a5bc9da01a33b2bda62882d5
---
 opensfm/test/test_commands.py        | 2 +-
 opensfm/test/test_dataset.py         | 2 +-
 opensfm/test/test_datastructures.py  | 6 +-----
 opensfm/test/test_io.py              | 2 +-
 opensfm/test/test_pairs_selection.py | 2 +-
 5 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index a5890bcd9..ac04e8602 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -3,7 +3,7 @@
 from os.path import join
 
 from opensfm import commands, dataset
-from opensfm.test import data_generation, utils
+from mapillary.opensfm.opensfm.test import data_generation, utils
 
 
 def run_command(command, args) -> None:
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 60022ae0a..142887c82 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,7 +1,7 @@
 # pyre-unsafe
 import numpy as np
 from opensfm import features
-from opensfm.test import data_generation
+from mapillary.opensfm.opensfm.test import data_generation
 
 
 def test_dataset_load_features_sift(tmpdir) -> None:
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index 5e9c5cd9a..cbf5116be 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -11,11 +11,7 @@
 from opensfm import pygeometry
 from opensfm import pymap
 from opensfm import types
-from opensfm.test.utils import (
-    assert_maps_equal, assert_metadata_equal,
-    assert_cameras_equal,
-    assert_shots_equal,
-)
+from mapillary.opensfm.opensfm.test.utils import assert_maps_equal, assert_metadata_equal, assert_cameras_equal, assert_shots_equal
 
 
 def _create_reconstruction(
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 0b43af2c5..39e46890d 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -5,7 +5,7 @@
 
 import numpy as np
 from opensfm import io, pygeometry, types
-from opensfm.test import data_generation, utils
+from mapillary.opensfm.opensfm.test import data_generation, utils
 
 
 filename = os.path.join(
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index b16a2ce69..303f334ff 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -6,7 +6,7 @@
 import numpy as np
 import pytest
 from opensfm import commands, dataset, feature_loader, pairs_selection, geo
-from opensfm.test import data_generation
+from mapillary.opensfm.opensfm.test import data_generation
 from opensfm.dataset_base import DataSetBase
 
 

From 7514c2107fa8fe3ae757968a3ec14926ddba721f Mon Sep 17 00:00:00 2001
From: generatedunixname89002005307016
 <generatedunixname89002005307016@meta.com>
Date: Mon, 30 Sep 2024 15:54:51 -0700
Subject: [PATCH 084/235] Convert .pyre_configuration.local to fast by default
 architecture] [batch:44/100] [shard:2/N] [A]

Reviewed By: MaggieMoss

Differential Revision: D63644535

fbshipit-source-id: f4118078d10c24b1fd5c400659c5f3c70ae2c781
---
 opensfm/actions/export_colmap.py              |  2 ++
 opensfm/actions/export_geocoords.py           |  2 ++
 opensfm/align.py                              |  4 ++++
 opensfm/dataset.py                            |  2 ++
 opensfm/feature_loading.py                    |  1 +
 opensfm/features_processing.py                |  2 ++
 opensfm/multiview.py                          | 11 ++++++++++-
 opensfm/pairs_selection.py                    |  2 ++
 opensfm/reconstruction.py                     |  7 +++++++
 opensfm/synthetic_data/synthetic_generator.py |  2 ++
 opensfm/synthetic_data/synthetic_scene.py     |  6 ++++++
 opensfm/test/test_bundle.py                   |  5 -----
 opensfm/test/test_dataset.py                  |  2 ++
 opensfm/test/test_multiview.py                |  1 -
 opensfm/test/test_triangulation.py            |  1 +
 opensfm/tracking.py                           |  4 ++++
 opensfm/transformations.py                    | 10 ++++++++++
 17 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index c86e38fa9..a8b7a5ccb 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -185,11 +185,13 @@ def array_to_blob(array) -> bytes:
     if IS_PYTHON3:
         return array.tobytes()
     else:
+        # pyre-fixme[16]: Module `numpy` has no attribute `getbuffer`.
         return np.getbuffer(array)
 
 
 def blob_to_array(blob, dtype, shape: Tuple[int] = (-1,)):
     if IS_PYTHON3:
+        # pyre-fixme[20]: Argument `sep` expected.
         return np.fromstring(blob, dtype=dtype).reshape(*shape)
     else:
         return np.frombuffer(blob, dtype=dtype).reshape(*shape)
diff --git a/opensfm/actions/export_geocoords.py b/opensfm/actions/export_geocoords.py
index aad9d7910..42ab9df76 100644
--- a/opensfm/actions/export_geocoords.py
+++ b/opensfm/actions/export_geocoords.py
@@ -146,7 +146,9 @@ def _transform_dense_point_cloud(
                     fout.write(line)
                 else:
                     x, y, z, nx, ny, nz, red, green, blue = line.split()
+                    # pyre-fixme[6]: For 2nd argument expected `Union[Sequence[Sequen...
                     x, y, z = np.dot(A, map(float, [x, y, z])) + b
+                    # pyre-fixme[6]: For 2nd argument expected `Union[Sequence[Sequen...
                     nx, ny, nz = np.dot(A, map(float, [nx, ny, nz]))
                     fout.write(
                         "{} {} {} {} {} {} {} {} {}\n".format(
diff --git a/opensfm/align.py b/opensfm/align.py
index 48d7d60c3..f07aa004f 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -282,7 +282,11 @@ def compute_orientation_prior_similarity(
         max_scale = 1000
         current_scale = np.linalg.norm(b)
         if two_shots and current_scale > max_scale:
+            # pyre-fixme[58]: `/` is not supported for operand types `int` and
+            #  `floating[typing.Any]`.
             b = max_scale * b / current_scale
+            # pyre-fixme[58]: `/` is not supported for operand types `int` and
+            #  `floating[typing.Any]`.
             s = max_scale / current_scale
     else:
         try:
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 12af6a344..fa96fc6fb 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -334,6 +334,8 @@ def load_words(self, image: str) -> np.ndarray:
 
     def save_words(self, image: str, words: np.ndarray) -> None:
         with self.io_handler.open(self._words_file(image), "wb") as f:
+            # pyre-fixme[6]: For 1st argument expected `Union[_SupportsWrite[bytes],
+            #  PathLike[str], str]` but got `IO[typing.Any]`.
             np.savez_compressed(f, words=words.astype(np.uint16))
 
     def _matches_path(self) -> str:
diff --git a/opensfm/feature_loading.py b/opensfm/feature_loading.py
index 7ff3d4934..1f3c63a69 100644
--- a/opensfm/feature_loading.py
+++ b/opensfm/feature_loading.py
@@ -133,6 +133,7 @@ def _add_segmentation_in_descriptor(
             return features
 
         desc_augmented = np.concatenate(
+            # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[ty...
             (
                 features.descriptors,
                 (np.array([segmentation]).T).astype(np.float32),
diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 94889eac9..671facfde 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -219,6 +219,8 @@ def bake_segmentation(
             new_width=new_width,
             new_height=new_height,
         ).astype(int)
+        # pyre-fixme[6]: For 2nd argument expected `None` but got
+        #  `ndarray[typing.Any, typing.Any]`.
         panoptic_data[i] = p_data[ps[:, 1], ps[:, 0]]
     return tuple(panoptic_data)
 
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index e164fd1f0..97b7e2b18 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -182,6 +182,9 @@ def ransac(kernel: Any, threshold: float) -> TRansacSolution:
                     max_iterations, ransac_max_iterations(kernel, best_inliers, 0.01)
                 )
         i += 1
+    # pyre-fixme[7]: Expected `Tuple[ndarray[typing.Any, typing.Any],
+    #  ndarray[typing.Any, typing.Any], float]` but got `Tuple[typing.Any,
+    #  Union[List[typing.Any], ndarray[typing.Any, dtype[typing.Any]]], typing.Any]`.
     return best_model, best_inliers, best_error
 
 
@@ -211,6 +214,8 @@ def num_samples(self) -> int:
     def fit(self, samples: np.ndarray) -> List[float]:
         x = self.x[samples[0]]
         y = self.y[samples[0]]
+        # pyre-fixme[7]: Expected `List[float]` but got `List[ndarray[typing.Any,
+        #  dtype[typing.Any]]]`.
         return [y / x]
 
     def evaluate(self, model: np.ndarray) -> np.ndarray:
@@ -416,6 +421,9 @@ def fit_similarity_transform(
         errors = np.sqrt(np.sum((p2h.T - np.dot(best_T, p1h.T)) ** 2, axis=0))
         best_inliers = np.argwhere(errors < threshold)[:, 0]
 
+    # pyre-fixme[7]: Expected `Tuple[ndarray[typing.Any, typing.Any],
+    #  ndarray[typing.Any, typing.Any]]` but got `Tuple[ndarray[typing.Any,
+    #  typing.Any], Union[List[typing.Any], ndarray[typing.Any, dtype[typing.Any]]]]`.
     return best_T, best_inliers
 
 
@@ -453,7 +461,9 @@ def focal_from_homography(H: np.ndarray) -> np.ndarray:
 def R_from_homography(
     H: np.ndarray, f1: np.ndarray, f2: np.ndarray
 ) -> Optional[np.ndarray]:
+    # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     K1 = np.diag([f1, f1, 1])
+    # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     K2 = np.diag([f2, f2, 1])
     K2inv = np.linalg.inv(K2)
     R = K2inv.dot(H).dot(K1)
@@ -464,7 +474,6 @@ def R_from_homography(
 def project_to_rotation_matrix(A: np.ndarray) -> Optional[np.ndarray]:
     try:
         u, d, vt = np.linalg.svd(A)
-    # pyre-fixme[16]: Module `linalg` has no attribute `LinAlgError`.
     except np.linalg.linalg.LinAlgError:
         return None
     return u.dot(vt)
diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 214e251b3..2bae00157 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -472,6 +472,8 @@ def construct_pairs(
         order = np.argsort(distances)
         if enforce_other_cameras:
             pairs.update(
+                # pyre-fixme[6]: For 4th argument expected `List[int]` but got
+                #  `ndarray[typing.Any, dtype[typing.Any]]`.
                 pairs_from_neighbors(im, exifs, distances, order, other, max_neighbors)
             )
         else:
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index ad242f9ee..1c07b9f62 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -284,6 +284,8 @@ def _two_view_reconstruction_inliers(
 ) -> List[int]:
     """Returns indices of matches that can be triangulated."""
     ok = matching.compute_inliers_bearings(b1, b2, R, t, threshold)
+    # pyre-fixme[7]: Expected `List[int]` but got `ndarray[typing.Any,
+    #  dtype[typing.Any]]`.
     return np.nonzero(ok)[0]
 
 
@@ -318,6 +320,7 @@ def two_view_reconstruction_plane_based(
         inliers = _two_view_reconstruction_inliers(b1, b2, R.T, -R.T.dot(t), threshold)
         motion_inliers.append(inliers)
 
+    # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     best = np.argmax(map(len, motion_inliers))
     R, t, n, d = motions[best]
     inliers = motion_inliers[best]
@@ -370,6 +373,8 @@ def _two_view_rotation_inliers(
 ) -> List[int]:
     br2 = R.dot(b2.T).T
     ok = np.linalg.norm(br2 - b1, axis=1) < threshold
+    # pyre-fixme[7]: Expected `List[int]` but got `ndarray[typing.Any,
+    #  dtype[typing.Any]]`.
     return np.nonzero(ok)[0]
 
 
@@ -1048,6 +1053,8 @@ def triangulate_dlt(
 
         if len(Rts) >= 2:
             e, X = pygeometry.triangulate_bearings_dlt(
+                # pyre-fixme[6]: For 1st argument expected `List[ndarray[typing.Any,
+                #  typing.Any]]` but got `ndarray[typing.Any, dtype[typing.Any]]`.
                 np.asarray(Rts),
                 np.asarray(bs),
                 reproj_threshold,
diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index 0dd20c840..f856af382 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -201,6 +201,8 @@ def _gps_dop(shot: pymap.Shot) -> float:
     ):
         pose = rig_instance.pose.get_origin()
         if previous_pose is not None:
+            # pyre-fixme[58]: `+` is not supported for operand types `int` and
+            #  `floating[typing.Any]`.
             previous_time += np.linalg.norm(pose - previous_pose) / speed_ms
         previous_pose = pose
         for shot_id in rig_instance.shots:
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index f8fcc8140..6dcae3206 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -177,9 +177,11 @@ def __init__(
     def combine(self, other_scene: "SyntheticStreetScene") -> "SyntheticStreetScene":
         combined_scene = SyntheticStreetScene(None)
         combined_scene.wall_points = np.concatenate(
+            # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[ty...
             (self.wall_points, other_scene.wall_points)
         )
         combined_scene.floor_points = np.concatenate(
+            # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[ty...
             (self.floor_points, other_scene.floor_points)
         )
         combined_scene.cameras = self.cameras + other_scene.cameras
@@ -400,7 +402,11 @@ def get_reconstruction(self) -> types.Reconstruction:
         wall_color = [10, 90, 130]
 
         return sg.create_reconstruction(
+            # pyre-fixme[6]: For 1st argument expected `List[ndarray[typing.Any,
+            #  typing.Any]]` but got `ndarray[typing.Any, dtype[typing.Any]]`.
             points=np.asarray([self.floor_points, self.wall_points], dtype=object),
+            # pyre-fixme[6]: For 2nd argument expected `List[ndarray[typing.Any,
+            #  typing.Any]]` but got `ndarray[typing.Any, dtype[typing.Any]]`.
             colors=np.asarray([floor_color, wall_color]),
             cameras=self.cameras,
             shot_ids=self.shot_ids,
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index d3d499560..27aff4d8e 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -108,18 +108,13 @@ def test_bundle_projection_fixed_internals(scene_synthetic) -> None:
                 color = g_obs["feature_color"]
                 pt = g_obs["feature"]
                 obs = pymap.Observation(
-                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[0],
-                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[1],
                     # pyre-fixme[6]: For 3rd argument expected `float` but got
                     #  `Dict[str, typing.Any]`.
                     g_obs["feature_scale"],
-                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[0],
-                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[1],
-                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[2],
                     # pyre-fixme[6]: For 7th argument expected `int` but got
                     #  `Dict[str, typing.Any]`.
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 142887c82..17db15e38 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -26,6 +26,7 @@ def test_dataset_load_features_sift(tmpdir) -> None:
     after = data.load_features(image)
     assert after
     assert np.allclose(points, after.points)
+    # pyre-fixme[6]: For 2nd argument expected `Union[_SupportsArray[dtype[typing.Any...
     assert np.allclose(descriptors, after.descriptors)
     assert np.allclose(colors, after.colors)
     semantic = after.semantic
@@ -34,4 +35,5 @@ def test_dataset_load_features_sift(tmpdir) -> None:
         segmentations,
         semantic.segmentation,
     )
+    # pyre-fixme[6]: For 2nd argument expected `Union[_SupportsArray[dtype[typing.Any...
     assert np.allclose(instances, semantic.instances)
diff --git a/opensfm/test/test_multiview.py b/opensfm/test/test_multiview.py
index 8edc8cc8b..6911ad26c 100644
--- a/opensfm/test/test_multiview.py
+++ b/opensfm/test/test_multiview.py
@@ -21,7 +21,6 @@ def test_motion_from_plane_homography() -> None:
     scale = 2 * np.random.rand() - 1
     H = scale * (d * R - np.outer(t, n))
 
-    # pyre-fixme[6]: For 1st argument expected `ndarray` but got `int`.
     motions = multiview.motion_from_plane_homography(H)
     assert motions is not None
     goodness = []
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index 734be5d6c..ee9f8ceaf 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -50,6 +50,7 @@ def test_track_triangulator_spherical() -> None:
 
 
 def unit_vector(x: object) -> np.ndarray:
+    # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     return np.array(x) / np.linalg.norm(x)
 
 
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index c1b79798c..eb897855d 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -98,6 +98,10 @@ def create_tracks_manager(
                 instances[image][featureid] if image in instances else NO_VALUE,
             )
             obs = pymap.Observation(
+                # pyre-fixme[6]: For 8th argument expected `int` but got
+                #  `Union[ndarray[typing.Any, typing.Any], int]`.
+                # pyre-fixme[6]: For 9th argument expected `int` but got
+                #  `Union[ndarray[typing.Any, typing.Any], int]`.
                 x, y, s, int(r), int(g), int(b), featureid, segmentation, instance
             )
             tracks_manager.add_observation(image, str(track_id), obs)
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index 071915b64..dfd2d142d 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -411,6 +411,7 @@ def scale_matrix(
     """
     if direction is None:
         # uniform scaling
+        # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing...
         M = numpy.diag([factor, factor, factor, 1.0])
         if origin is not None:
             M[:3, 3] = origin[:3]
@@ -466,6 +467,10 @@ def scale_from_matrix(
         raise ValueError("no eigenvector corresponding to eigenvalue 1")
     origin = numpy.real(V[:, i[-1]]).squeeze()
     origin /= origin[3]
+    # pyre-fixme[7]: Expected `Tuple[ndarray[typing.Any, typing.Any],
+    #  ndarray[typing.Any, typing.Any], ndarray[typing.Any, typing.Any]]` but got
+    #  `Tuple[typing.Any, ndarray[typing.Any, dtype[typing.Any]],
+    #  Optional[ndarray[typing.Any, dtype[typing.Any]]]]`.
     return factor, origin, direction
 
 
@@ -1663,10 +1668,14 @@ def vector_norm(
         data *= data
         out = numpy.atleast_1d(numpy.sum(data, axis=axis))
         numpy.sqrt(out, out)
+        # pyre-fixme[7]: Expected `float` but got `ndarray[typing.Any,
+        #  dtype[typing.Any]]`.
         return out
     else:
         data *= data
         numpy.sum(data, axis=axis, out=out)
+        # pyre-fixme[7]: Expected `float` but got `ndarray[typing.Any,
+        #  dtype[typing.Any]]`.
         return numpy.sqrt(out, out)
 
 
@@ -1832,6 +1841,7 @@ def is_same_transform(matrix0: numpy.ndarray, matrix1: numpy.ndarray) -> numpy.n
     matrix0 /= matrix0[3, 3]
     matrix1 = numpy.array(matrix1, dtype=numpy.float64, copy=True)
     matrix1 /= matrix1[3, 3]
+    # pyre-fixme[7]: Expected `ndarray[typing.Any, typing.Any]` but got `bool`.
     return numpy.allclose(matrix0, matrix1)
 
 

From 03432a8e010081f360dd260981d6a55119c44089 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Mon, 14 Oct 2024 12:57:42 -0700
Subject: [PATCH 085/235] Remove unused-variable in
 mapillary/opensfm/opensfm/src/bundle/error/absolute_motion_errors.h

Summary:
LLVM-15 has a warning `-Wunused-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code or (b) qualifies the variable with `[[maybe_unused]]`.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: meyering

Differential Revision: D64279137

fbshipit-source-id: 68f17d9881c727d38065cd80d8314d28ac325f52
---
 opensfm/src/bundle/error/absolute_motion_errors.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/bundle/error/absolute_motion_errors.h b/opensfm/src/bundle/error/absolute_motion_errors.h
index 407267a91..d6a072bcc 100644
--- a/opensfm/src/bundle/error/absolute_motion_errors.h
+++ b/opensfm/src/bundle/error/absolute_motion_errors.h
@@ -93,7 +93,6 @@ struct RollAngleError {
     T ex[3] = {T(1), T(0), T(0)};  // A point to the right of the camera (x=1)
     T ez[3] = {T(0), T(0), T(1)};  // A point in front of the camera (z=1)
     T Rt_ex[3], Rt_ez[3];
-    T tangle_ = T(angle_);
     ceres::AngleAxisRotatePoint(R.data(), ex, Rt_ex);
     ceres::AngleAxisRotatePoint(R.data(), ez, Rt_ez);
 

From 61c0f12c580a305ce8a016827c7a3974059538e9 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Tue, 15 Oct 2024 13:58:42 -0700
Subject: [PATCH 086/235] Fix shadowed variable in
 mapillary/opensfm/opensfm/src/map/src/tracks_manager.cc

Summary:
Our upcoming compiler upgrade will require us not to have shadowed variables. Such variables have a _high_ bug rate and reduce readability, so we would like to avoid them even if the compiler was not forcing us to do so.

This codemod attempts to fix an instance of a shadowed variable. Please review with care: if it's failed the result will be a silent bug.

**What's a shadowed variable?**

Shadowed variables are variables in an inner scope with the same name as another variable in an outer scope. Having the same name for both variables might be semantically correct, but it can make the code confusing to read! It can also hide subtle bugs.

This diff fixes such an issue by renaming the variable.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: palmje

Differential Revision: D64398698

fbshipit-source-id: e70f61a9337391e8357fff7a8d07c0b927c63b4d
---
 opensfm/src/map/src/tracks_manager.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/opensfm/src/map/src/tracks_manager.cc b/opensfm/src/map/src/tracks_manager.cc
index 93272e5dd..89dc64aa4 100644
--- a/opensfm/src/map/src/tracks_manager.cc
+++ b/opensfm/src/map/src/tracks_manager.cc
@@ -356,7 +356,7 @@ TracksManager::GetAllPairsConnectivity(
 TracksManager TracksManager::MergeTracksManager(
     const std::vector<const TracksManager*>& tracks_managers) {
   // Some typedefs claryfying the aggregations
-  using FeatureId = std::pair<ShotId, int>;
+  using FeatureId_2 = std::pair<ShotId, int>;
   using SingleTrackId = std::pair<TrackId, int>;
 
   // Union-find main data
@@ -364,7 +364,7 @@ TracksManager TracksManager::MergeTracksManager(
       union_find_elements;
 
   // Aggregate tracks be merged using (shot_id, feature_id)
-  std::unordered_map<FeatureId, std::vector<int>, HashPair>
+  std::unordered_map<FeatureId_2, std::vector<int>, HashPair>
       observations_per_feature_id;
   for (int i = 0; i < tracks_managers.size(); ++i) {
     const auto& manager = tracks_managers[i];
@@ -387,7 +387,7 @@ TracksManager TracksManager::MergeTracksManager(
     return merged;
   }
 
-  // Union-find any two tracks sharing a common FeatureId
+  // Union-find any two tracks sharing a common FeatureId_2
   // For N tracks, make 0 the parent of [1, ... N-1[
   for (const auto& tracks_agg : observations_per_feature_id) {
     if (tracks_agg.second.empty()) {

From 4b19f0d8620f03d0f2e8a82c89dbc46195264b2d Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Tue, 15 Oct 2024 13:59:21 -0700
Subject: [PATCH 087/235] Fix shadowed variable in
 mapillary/opensfm/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp

Summary:
Our upcoming compiler upgrade will require us not to have shadowed variables. Such variables have a _high_ bug rate and reduce readability, so we would like to avoid them even if the compiler was not forcing us to do so.

This codemod attempts to fix an instance of a shadowed variable. Please review with care: if it's failed the result will be a silent bug.

**What's a shadowed variable?**

Shadowed variables are variables in an inner scope with the same name as another variable in an outer scope. Having the same name for both variables might be semantically correct, but it can make the code confusing to read! It can also hide subtle bugs.

This diff fixes such an issue by renaming the variable.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: palmje

Differential Revision: D64398715

fbshipit-source-id: 5a49263b83945d723e9f3046fb13e260e9c6af11
---
 .../akaze/lib/nldiffusion_functions.cpp        | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
index 9f50abd5a..5fa764094 100644
--- a/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
+++ b/opensfm/src/third_party/akaze/lib/nldiffusion_functions.cpp
@@ -299,22 +299,22 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, const float
     Lstep_row = Lstep.ptr<float>(i);
 
     float xpos_2 = (c_row_2[0]+c_row_2[1])*(Ld_row_2[1]-Ld_row_2[0]);
-    float ypos = (c_row_2[0]+c_row_p_2[0])*(Ld_row_p_2[0]-Ld_row_2[0]);
+    float ypos_2 = (c_row_2[0]+c_row_p_2[0])*(Ld_row_p_2[0]-Ld_row_2[0]);
     float yneg = (c_row_m[0]+c_row_2[0])*(Ld_row_2[0]-Ld_row_m[0]);
-    Lstep_row[0] = 0.5*stepsize*(xpos_2+ypos-yneg);
+    Lstep_row[0] = 0.5*stepsize*(xpos_2+ypos_2-yneg);
 
-    float xneg = (c_row_2[Lstep.cols-2]+c_row_2[Lstep.cols-1])*(Ld_row_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-2]);
-    ypos = (c_row_2[Lstep.cols-1]+c_row_p_2[Lstep.cols-1])*(Ld_row_p_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-1]);
+    float xneg_2 = (c_row_2[Lstep.cols-2]+c_row_2[Lstep.cols-1])*(Ld_row_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-2]);
+    ypos_2 = (c_row_2[Lstep.cols-1]+c_row_p_2[Lstep.cols-1])*(Ld_row_p_2[Lstep.cols-1]-Ld_row_2[Lstep.cols-1]);
     yneg = (c_row_m[Lstep.cols-1]+c_row_2[Lstep.cols-1])*(Ld_row_2[Lstep.cols-1]-Ld_row_m[Lstep.cols-1]);
-    Lstep_row[Lstep.cols-1] = 0.5*stepsize*(-xneg+ypos-yneg);
+    Lstep_row[Lstep.cols-1] = 0.5*stepsize*(-xneg_2+ypos_2-yneg);
   }
 
   // Ld = Ld + Lstep
   for (int y = 0; y < Lstep.rows; y++) {
-    float* Ld_row = Ld.ptr<float>(y);
-    float* Lstep_row = Lstep.ptr<float>(y);
-    for (int x = 0; x < Lstep.cols; x++) {
-      Ld_row[x] = Ld_row[x] + Lstep_row[x];
+    float* Ld_row_2 = Ld.ptr<float>(y);
+    float* Lstep_row_2 = Lstep.ptr<float>(y);
+    for (int x_2 = 0; x_2 < Lstep.cols; x_2++) {
+      Ld_row_2[x_2] = Ld_row_2[x_2] + Lstep_row_2[x_2];
     }
   }
 }

From afcf90bd0a48bef89c1af03b830d73cdd23edc71 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005279527
 <generatedunixname89002005279527@meta.com>
Date: Wed, 16 Oct 2024 01:37:54 -0700
Subject: [PATCH 088/235] 
 fbcode/mapillary/opensfm/opensfm/src/third_party/gtest/gmock

Reviewed By: bal-a

Differential Revision: D63973589

fbshipit-source-id: 93e60daee2c6d3fca353bfe03fbe2fe75b530d8d
---
 opensfm/src/third_party/gtest/gmock/gmock.h   | 14978 ----------------
 .../src/third_party/gtest/gmock/mock-log.h    |   160 -
 2 files changed, 15138 deletions(-)
 delete mode 100644 opensfm/src/third_party/gtest/gmock/gmock.h
 delete mode 100644 opensfm/src/third_party/gtest/gmock/mock-log.h

diff --git a/opensfm/src/third_party/gtest/gmock/gmock.h b/opensfm/src/third_party/gtest/gmock/gmock.h
deleted file mode 100644
index 70e227571..000000000
--- a/opensfm/src/third_party/gtest/gmock/gmock.h
+++ /dev/null
@@ -1,14978 +0,0 @@
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This is the main header file a user should include.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
-
-// This file implements the following syntax:
-//
-//   ON_CALL(mock_object.Method(...))
-//     .With(...) ?
-//     .WillByDefault(...);
-//
-// where With() is optional and WillByDefault() must appear exactly
-// once.
-//
-//   EXPECT_CALL(mock_object.Method(...))
-//     .With(...) ?
-//     .Times(...) ?
-//     .InSequence(...) *
-//     .WillOnce(...) *
-//     .WillRepeatedly(...) ?
-//     .RetiresOnSaturation() ? ;
-//
-// where all clauses are optional and WillOnce() can be repeated.
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used actions.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-
-#ifndef _WIN32_WCE
-# include <errno.h>
-#endif
-
-#include <algorithm>
-#include <string>
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file defines some utilities useful for implementing Google
-// Mock.  They are subject to change without notice, so please DO NOT
-// USE THEM IN USER CODE.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-
-#include <stdio.h>
-#include <ostream>  // NOLINT
-#include <string>
-
-// This file was GENERATED by command:
-//     pump.py gmock-generated-internal-utils.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file contains template meta-programming utility classes needed
-// for implementing Google Mock.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: vadimb@google.com (Vadim Berman)
-//
-// Low-level types and utilities for porting Google Mock to various
-// platforms.  All macros ending with _ and symbols defined in an
-// internal namespace are subject to change without notice.  Code
-// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
-// end with _ are part of Google Mock's public API and can be used by
-// code outside Google Mock.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-
-#include <assert.h>
-#include <stdlib.h>
-#include <iostream>
-
-// Most of the utilities needed for porting Google Mock are also
-// required for Google Test and are defined in gtest-port.h.
-//
-// Note to maintainers: to reduce code duplication, prefer adding
-// portability utilities to Google Test's gtest-port.h instead of
-// here, as Google Mock depends on Google Test.  Only add a utility
-// here if it's truly specific to Google Mock.
-#include "gtest/gtest.h"
-// Copyright 2015, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Injection point for custom user configurations.
-// The following macros can be defined:
-//
-//   Flag related macros:
-//     GMOCK_DECLARE_bool_(name)
-//     GMOCK_DECLARE_int32_(name)
-//     GMOCK_DECLARE_string_(name)
-//     GMOCK_DEFINE_bool_(name, default_val, doc)
-//     GMOCK_DEFINE_int32_(name, default_val, doc)
-//     GMOCK_DEFINE_string_(name, default_val, doc)
-//
-// ** Custom implementation starts here **
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-
-// To avoid conditional compilation everywhere, we make it
-// gmock-port.h's responsibility to #include the header implementing
-// tr1/tuple.  gmock-port.h does this via gtest-port.h, which is
-// guaranteed to pull in the tuple header.
-
-// For MS Visual C++, check the compiler version. At least VS 2003 is
-// required to compile Google Mock.
-#if defined(_MSC_VER) && _MSC_VER < 1310
-# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
-#endif
-
-// Macro for referencing flags.  This is public as we want the user to
-// use this syntax to reference Google Mock flags.
-#define GMOCK_FLAG(name) FLAGS_gmock_##name
-
-#if !defined(GMOCK_DECLARE_bool_)
-
-// Macros for declaring flags.
-#define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
-#define GMOCK_DECLARE_int32_(name) \
-    extern GTEST_API_ ::testing::internal::Int32 GMOCK_FLAG(name)
-#define GMOCK_DECLARE_string_(name) \
-    extern GTEST_API_ ::std::string GMOCK_FLAG(name)
-
-// Macros for defining flags.
-#define GMOCK_DEFINE_bool_(name, default_val, doc) \
-    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
-#define GMOCK_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::Int32 GMOCK_FLAG(name) = (default_val)
-#define GMOCK_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
-
-#endif  // !defined(GMOCK_DECLARE_bool_)
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-
-namespace testing {
-
-template <typename T>
-class Matcher;
-
-namespace internal {
-
-// An IgnoredValue object can be implicitly constructed from ANY value.
-// This is used in implementing the IgnoreResult(a) action.
-class IgnoredValue {
- public:
-  // This constructor template allows any value to be implicitly
-  // converted to IgnoredValue.  The object has no data member and
-  // doesn't try to remember anything about the argument.  We
-  // deliberately omit the 'explicit' keyword in order to allow the
-  // conversion to be implicit.
-  template <typename T>
-  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
-};
-
-// MatcherTuple<T>::type is a tuple type where each field is a Matcher
-// for the corresponding field in tuple type T.
-template <typename Tuple>
-struct MatcherTuple;
-
-template <>
-struct MatcherTuple< ::testing::tuple<> > {
-  typedef ::testing::tuple< > type;
-};
-
-template <typename A1>
-struct MatcherTuple< ::testing::tuple<A1> > {
-  typedef ::testing::tuple<Matcher<A1> > type;
-};
-
-template <typename A1, typename A2>
-struct MatcherTuple< ::testing::tuple<A1, A2> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
-};
-
-template <typename A1, typename A2, typename A3>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
-      Matcher<A4> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8, typename A9>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8, typename A9, typename A10>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-    A10> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
-      Matcher<A10> > type;
-};
-
-// Template struct Function<F>, where F must be a function type, contains
-// the following typedefs:
-//
-//   Result:               the function's return type.
-//   ArgumentN:            the type of the N-th argument, where N starts with 1.
-//   ArgumentTuple:        the tuple type consisting of all parameters of F.
-//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
-//                         parameters of F.
-//   MakeResultVoid:       the function type obtained by substituting void
-//                         for the return type of F.
-//   MakeResultIgnoredValue:
-//                         the function type obtained by substituting Something
-//                         for the return type of F.
-template <typename F>
-struct Function;
-
-template <typename R>
-struct Function<R()> {
-  typedef R Result;
-  typedef ::testing::tuple<> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid();
-  typedef IgnoredValue MakeResultIgnoredValue();
-};
-
-template <typename R, typename A1>
-struct Function<R(A1)>
-    : Function<R()> {
-  typedef A1 Argument1;
-  typedef ::testing::tuple<A1> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1);
-  typedef IgnoredValue MakeResultIgnoredValue(A1);
-};
-
-template <typename R, typename A1, typename A2>
-struct Function<R(A1, A2)>
-    : Function<R(A1)> {
-  typedef A2 Argument2;
-  typedef ::testing::tuple<A1, A2> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-struct Function<R(A1, A2, A3)>
-    : Function<R(A1, A2)> {
-  typedef A3 Argument3;
-  typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-struct Function<R(A1, A2, A3, A4)>
-    : Function<R(A1, A2, A3)> {
-  typedef A4 Argument4;
-  typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-struct Function<R(A1, A2, A3, A4, A5)>
-    : Function<R(A1, A2, A3, A4)> {
-  typedef A5 Argument5;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-struct Function<R(A1, A2, A3, A4, A5, A6)>
-    : Function<R(A1, A2, A3, A4, A5)> {
-  typedef A6 Argument6;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
-    : Function<R(A1, A2, A3, A4, A5, A6)> {
-  typedef A7 Argument7;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
-  typedef A8 Argument8;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
-  typedef A9 Argument9;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
-      A9);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
-  typedef A10 Argument10;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-      A10> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
-      A9, A10);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-
-namespace testing {
-namespace internal {
-
-// Converts an identifier name to a space-separated list of lower-case
-// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
-// treated as one word.  For example, both "FooBar123" and
-// "foo_bar_123" are converted to "foo bar 123".
-GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name);
-
-// PointeeOf<Pointer>::type is the type of a value pointed to by a
-// Pointer, which can be either a smart pointer or a raw pointer.  The
-// following default implementation is for the case where Pointer is a
-// smart pointer.
-template <typename Pointer>
-struct PointeeOf {
-  // Smart pointer classes define type element_type as the type of
-  // their pointees.
-  typedef typename Pointer::element_type type;
-};
-// This specialization is for the raw pointer case.
-template <typename T>
-struct PointeeOf<T*> { typedef T type; };  // NOLINT
-
-// GetRawPointer(p) returns the raw pointer underlying p when p is a
-// smart pointer, or returns p itself when p is already a raw pointer.
-// The following default implementation is for the smart pointer case.
-template <typename Pointer>
-inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
-  return p.get();
-}
-// This overloaded version is for the raw pointer case.
-template <typename Element>
-inline Element* GetRawPointer(Element* p) { return p; }
-
-// This comparator allows linked_ptr to be stored in sets.
-template <typename T>
-struct LinkedPtrLessThan {
-  bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
-                  const ::testing::internal::linked_ptr<T>& rhs) const {
-    return lhs.get() < rhs.get();
-  }
-};
-
-// Symbian compilation can be done with wchar_t being either a native
-// type or a typedef.  Using Google Mock with OpenC without wchar_t
-// should require the definition of _STLP_NO_WCHAR_T.
-//
-// MSVC treats wchar_t as a native type usually, but treats it as the
-// same as unsigned short when the compiler option /Zc:wchar_t- is
-// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
-// is a native type.
-#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
-    (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
-// wchar_t is a typedef.
-#else
-# define GMOCK_WCHAR_T_IS_NATIVE_ 1
-#endif
-
-// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
-// Using them is a bad practice and not portable.  So DON'T use them.
-//
-// Still, Google Mock is designed to work even if the user uses signed
-// wchar_t or unsigned wchar_t (obviously, assuming the compiler
-// supports them).
-//
-// To gcc,
-//   wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
-#ifdef __GNUC__
-// signed/unsigned wchar_t are valid types.
-# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
-#endif
-
-// In what follows, we use the term "kind" to indicate whether a type
-// is bool, an integer type (excluding bool), a floating-point type,
-// or none of them.  This categorization is useful for determining
-// when a matcher argument type can be safely converted to another
-// type in the implementation of SafeMatcherCast.
-enum TypeKind {
-  kBool, kInteger, kFloatingPoint, kOther
-};
-
-// KindOf<T>::value is the kind of type T.
-template <typename T> struct KindOf {
-  enum { value = kOther };  // The default kind.
-};
-
-// This macro declares that the kind of 'type' is 'kind'.
-#define GMOCK_DECLARE_KIND_(type, kind) \
-  template <> struct KindOf<type> { enum { value = kind }; }
-
-GMOCK_DECLARE_KIND_(bool, kBool);
-
-// All standard integer types.
-GMOCK_DECLARE_KIND_(char, kInteger);
-GMOCK_DECLARE_KIND_(signed char, kInteger);
-GMOCK_DECLARE_KIND_(unsigned char, kInteger);
-GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(int, kInteger);
-GMOCK_DECLARE_KIND_(unsigned int, kInteger);
-GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
-
-#if GMOCK_WCHAR_T_IS_NATIVE_
-GMOCK_DECLARE_KIND_(wchar_t, kInteger);
-#endif
-
-// Non-standard integer types.
-GMOCK_DECLARE_KIND_(Int64, kInteger);
-GMOCK_DECLARE_KIND_(UInt64, kInteger);
-
-// All standard floating-point types.
-GMOCK_DECLARE_KIND_(float, kFloatingPoint);
-GMOCK_DECLARE_KIND_(double, kFloatingPoint);
-GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
-
-#undef GMOCK_DECLARE_KIND_
-
-// Evaluates to the kind of 'type'.
-#define GMOCK_KIND_OF_(type) \
-  static_cast< ::testing::internal::TypeKind>( \
-      ::testing::internal::KindOf<type>::value)
-
-// Evaluates to true iff integer type T is signed.
-#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
-
-// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
-// is true iff arithmetic type From can be losslessly converted to
-// arithmetic type To.
-//
-// It's the user's responsibility to ensure that both From and To are
-// raw (i.e. has no CV modifier, is not a pointer, and is not a
-// reference) built-in arithmetic types, kFromKind is the kind of
-// From, and kToKind is the kind of To; the value is
-// implementation-defined when the above pre-condition is violated.
-template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
-struct LosslessArithmeticConvertibleImpl : public false_type {};
-
-// Converting bool to bool is lossless.
-template <>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
-    : public true_type {};  // NOLINT
-
-// Converting bool to any integer type is lossless.
-template <typename To>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
-    : public true_type {};  // NOLINT
-
-// Converting bool to any floating-point type is lossless.
-template <typename To>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
-    : public true_type {};  // NOLINT
-
-// Converting an integer to bool is lossy.
-template <typename From>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
-    : public false_type {};  // NOLINT
-
-// Converting an integer to another non-bool integer is lossless iff
-// the target type's range encloses the source type's range.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
-    : public bool_constant<
-      // When converting from a smaller size to a larger size, we are
-      // fine as long as we are not converting from signed to unsigned.
-      ((sizeof(From) < sizeof(To)) &&
-       (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
-      // When converting between the same size, the signedness must match.
-      ((sizeof(From) == sizeof(To)) &&
-       (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {};  // NOLINT
-
-#undef GMOCK_IS_SIGNED_
-
-// Converting an integer to a floating-point type may be lossy, since
-// the format of a floating-point number is implementation-defined.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to bool is lossy.
-template <typename From>
-struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to an integer is lossy.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to another floating-point is lossless
-// iff the target type is at least as big as the source type.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<
-  kFloatingPoint, From, kFloatingPoint, To>
-    : public bool_constant<sizeof(From) <= sizeof(To)> {};  // NOLINT
-
-// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic
-// type From can be losslessly converted to arithmetic type To.
-//
-// It's the user's responsibility to ensure that both From and To are
-// raw (i.e. has no CV modifier, is not a pointer, and is not a
-// reference) built-in arithmetic types; the value is
-// implementation-defined when the above pre-condition is violated.
-template <typename From, typename To>
-struct LosslessArithmeticConvertible
-    : public LosslessArithmeticConvertibleImpl<
-  GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {};  // NOLINT
-
-// This interface knows how to report a Google Mock failure (either
-// non-fatal or fatal).
-class FailureReporterInterface {
- public:
-  // The type of a failure (either non-fatal or fatal).
-  enum FailureType {
-    kNonfatal, kFatal
-  };
-
-  virtual ~FailureReporterInterface() {}
-
-  // Reports a failure that occurred at the given source file location.
-  virtual void ReportFailure(FailureType type, const char* file, int line,
-                             const string& message) = 0;
-};
-
-// Returns the failure reporter used by Google Mock.
-GTEST_API_ FailureReporterInterface* GetFailureReporter();
-
-// Asserts that condition is true; aborts the process with the given
-// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
-// as Google Mock might be used to mock the log sink itself.  We
-// inline this function to prevent it from showing up in the stack
-// trace.
-inline void Assert(bool condition, const char* file, int line,
-                   const string& msg) {
-  if (!condition) {
-    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
-                                        file, line, msg);
-  }
-}
-inline void Assert(bool condition, const char* file, int line) {
-  Assert(condition, file, line, "Assertion failed.");
-}
-
-// Verifies that condition is true; generates a non-fatal failure if
-// condition is false.
-inline void Expect(bool condition, const char* file, int line,
-                   const string& msg) {
-  if (!condition) {
-    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
-                                        file, line, msg);
-  }
-}
-inline void Expect(bool condition, const char* file, int line) {
-  Expect(condition, file, line, "Expectation failed.");
-}
-
-// Severity level of a log.
-enum LogSeverity {
-  kInfo = 0,
-  kWarning = 1
-};
-
-// Valid values for the --gmock_verbose flag.
-
-// All logs (informational and warnings) are printed.
-const char kInfoVerbosity[] = "info";
-// Only warnings are printed.
-const char kWarningVerbosity[] = "warning";
-// No logs are printed.
-const char kErrorVerbosity[] = "error";
-
-// Returns true iff a log with the given severity is visible according
-// to the --gmock_verbose flag.
-GTEST_API_ bool LogIsVisible(LogSeverity severity);
-
-// Prints the given message to stdout iff 'severity' >= the level
-// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
-// 0, also prints the stack trace excluding the top
-// stack_frames_to_skip frames.  In opt mode, any positive
-// stack_frames_to_skip is treated as 0, since we don't know which
-// function calls will be inlined by the compiler and need to be
-// conservative.
-GTEST_API_ void Log(LogSeverity severity,
-                    const string& message,
-                    int stack_frames_to_skip);
-
-// TODO(wan@google.com): group all type utilities together.
-
-// Type traits.
-
-// is_reference<T>::value is non-zero iff T is a reference type.
-template <typename T> struct is_reference : public false_type {};
-template <typename T> struct is_reference<T&> : public true_type {};
-
-// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
-template <typename T1, typename T2> struct type_equals : public false_type {};
-template <typename T> struct type_equals<T, T> : public true_type {};
-
-// remove_reference<T>::type removes the reference from type T, if any.
-template <typename T> struct remove_reference { typedef T type; };  // NOLINT
-template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
-
-// DecayArray<T>::type turns an array type U[N] to const U* and preserves
-// other types.  Useful for saving a copy of a function argument.
-template <typename T> struct DecayArray { typedef T type; };  // NOLINT
-template <typename T, size_t N> struct DecayArray<T[N]> {
-  typedef const T* type;
-};
-// Sometimes people use arrays whose size is not available at the use site
-// (e.g. extern const char kNamePrefix[]).  This specialization covers that
-// case.
-template <typename T> struct DecayArray<T[]> {
-  typedef const T* type;
-};
-
-// Disable MSVC warnings for infinite recursion, since in this case the
-// the recursion is unreachable.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4717)
-#endif
-
-// Invalid<T>() is usable as an expression of type T, but will terminate
-// the program with an assertion failure if actually run.  This is useful
-// when a value of type T is needed for compilation, but the statement
-// will not really be executed (or we don't care if the statement
-// crashes).
-template <typename T>
-inline T Invalid() {
-  Assert(false, "", -1, "Internal error: attempt to return invalid value");
-  // This statement is unreachable, and would never terminate even if it
-  // could be reached. It is provided only to placate compiler warnings
-  // about missing return statements.
-  return Invalid<T>();
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-// Given a raw type (i.e. having no top-level reference or const
-// modifier) RawContainer that's either an STL-style container or a
-// native array, class StlContainerView<RawContainer> has the
-// following members:
-//
-//   - type is a type that provides an STL-style container view to
-//     (i.e. implements the STL container concept for) RawContainer;
-//   - const_reference is a type that provides a reference to a const
-//     RawContainer;
-//   - ConstReference(raw_container) returns a const reference to an STL-style
-//     container view to raw_container, which is a RawContainer.
-//   - Copy(raw_container) returns an STL-style container view of a
-//     copy of raw_container, which is a RawContainer.
-//
-// This generic version is used when RawContainer itself is already an
-// STL-style container.
-template <class RawContainer>
-class StlContainerView {
- public:
-  typedef RawContainer type;
-  typedef const type& const_reference;
-
-  static const_reference ConstReference(const RawContainer& container) {
-    // Ensures that RawContainer is not a const type.
-    testing::StaticAssertTypeEq<RawContainer,
-        GTEST_REMOVE_CONST_(RawContainer)>();
-    return container;
-  }
-  static type Copy(const RawContainer& container) { return container; }
-};
-
-// This specialization is used when RawContainer is a native array type.
-template <typename Element, size_t N>
-class StlContainerView<Element[N]> {
- public:
-  typedef GTEST_REMOVE_CONST_(Element) RawElement;
-  typedef internal::NativeArray<RawElement> type;
-  // NativeArray<T> can represent a native array either by value or by
-  // reference (selected by a constructor argument), so 'const type'
-  // can be used to reference a const native array.  We cannot
-  // 'typedef const type& const_reference' here, as that would mean
-  // ConstReference() has to return a reference to a local variable.
-  typedef const type const_reference;
-
-  static const_reference ConstReference(const Element (&array)[N]) {
-    // Ensures that Element is not a const type.
-    testing::StaticAssertTypeEq<Element, RawElement>();
-#if GTEST_OS_SYMBIAN
-    // The Nokia Symbian compiler confuses itself in template instantiation
-    // for this call without the cast to Element*:
-    // function call '[testing::internal::NativeArray<char *>].NativeArray(
-    //     {lval} const char *[4], long, testing::internal::RelationToSource)'
-    //     does not match
-    // 'testing::internal::NativeArray<char *>::NativeArray(
-    //     char *const *, unsigned int, testing::internal::RelationToSource)'
-    // (instantiating: 'testing::internal::ContainsMatcherImpl
-    //     <const char * (&)[4]>::Matches(const char * (&)[4]) const')
-    // (instantiating: 'testing::internal::StlContainerView<char *[4]>::
-    //     ConstReference(const char * (&)[4])')
-    // (and though the N parameter type is mismatched in the above explicit
-    // conversion of it doesn't help - only the conversion of the array).
-    return type(const_cast<Element*>(&array[0]), N,
-                RelationToSourceReference());
-#else
-    return type(array, N, RelationToSourceReference());
-#endif  // GTEST_OS_SYMBIAN
-  }
-  static type Copy(const Element (&array)[N]) {
-#if GTEST_OS_SYMBIAN
-    return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
-#else
-    return type(array, N, RelationToSourceCopy());
-#endif  // GTEST_OS_SYMBIAN
-  }
-};
-
-// This specialization is used when RawContainer is a native array
-// represented as a (pointer, size) tuple.
-template <typename ElementPointer, typename Size>
-class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
- public:
-  typedef GTEST_REMOVE_CONST_(
-      typename internal::PointeeOf<ElementPointer>::type) RawElement;
-  typedef internal::NativeArray<RawElement> type;
-  typedef const type const_reference;
-
-  static const_reference ConstReference(
-      const ::testing::tuple<ElementPointer, Size>& array) {
-    return type(get<0>(array), get<1>(array), RelationToSourceReference());
-  }
-  static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
-    return type(get<0>(array), get<1>(array), RelationToSourceCopy());
-  }
-};
-
-// The following specialization prevents the user from instantiating
-// StlContainer with a reference type.
-template <typename T> class StlContainerView<T&>;
-
-// A type transform to remove constness from the first part of a pair.
-// Pairs like that are used as the value_type of associative containers,
-// and this transform produces a similar but assignable pair.
-template <typename T>
-struct RemoveConstFromKey {
-  typedef T type;
-};
-
-// Partially specialized to remove constness from std::pair<const K, V>.
-template <typename K, typename V>
-struct RemoveConstFromKey<std::pair<const K, V> > {
-  typedef std::pair<K, V> type;
-};
-
-// Mapping from booleans to types. Similar to boost::bool_<kValue> and
-// std::integral_constant<bool, kValue>.
-template <bool kValue>
-struct BooleanConstant {};
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-
-
-#if GTEST_LANG_CXX11  // Defined by gtest-port.h via gmock-port.h.
-#include <type_traits>
-#endif
-
-namespace testing {
-
-// To implement an action Foo, define:
-//   1. a class FooAction that implements the ActionInterface interface, and
-//   2. a factory function that creates an Action object from a
-//      const FooAction*.
-//
-// The two-level delegation design follows that of Matcher, providing
-// consistency for extension developers.  It also eases ownership
-// management as Action objects can now be copied like plain values.
-
-namespace internal {
-
-template <typename F1, typename F2>
-class ActionAdaptor;
-
-// BuiltInDefaultValueGetter<T, true>::Get() returns a
-// default-constructed T value.  BuiltInDefaultValueGetter<T,
-// false>::Get() crashes with an error.
-//
-// This primary template is used when kDefaultConstructible is true.
-template <typename T, bool kDefaultConstructible>
-struct BuiltInDefaultValueGetter {
-  static T Get() { return T(); }
-};
-template <typename T>
-struct BuiltInDefaultValueGetter<T, false> {
-  static T Get() {
-    Assert(false, __FILE__, __LINE__,
-           "Default action undefined for the function return type.");
-    return internal::Invalid<T>();
-    // The above statement will never be reached, but is required in
-    // order for this function to compile.
-  }
-};
-
-// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
-// for type T, which is NULL when T is a raw pointer type, 0 when T is
-// a numeric type, false when T is bool, or "" when T is string or
-// std::string.  In addition, in C++11 and above, it turns a
-// default-constructed T value if T is default constructible.  For any
-// other type T, the built-in default T value is undefined, and the
-// function will abort the process.
-template <typename T>
-class BuiltInDefaultValue {
- public:
-#if GTEST_LANG_CXX11
-  // This function returns true iff type T has a built-in default value.
-  static bool Exists() {
-    return ::std::is_default_constructible<T>::value;
-  }
-
-  static T Get() {
-    return BuiltInDefaultValueGetter<
-        T, ::std::is_default_constructible<T>::value>::Get();
-  }
-
-#else  // GTEST_LANG_CXX11
-  // This function returns true iff type T has a built-in default value.
-  static bool Exists() {
-    return false;
-  }
-
-  static T Get() {
-    return BuiltInDefaultValueGetter<T, false>::Get();
-  }
-
-#endif  // GTEST_LANG_CXX11
-};
-
-// This partial specialization says that we use the same built-in
-// default value for T and const T.
-template <typename T>
-class BuiltInDefaultValue<const T> {
- public:
-  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
-  static T Get() { return BuiltInDefaultValue<T>::Get(); }
-};
-
-// This partial specialization defines the default values for pointer
-// types.
-template <typename T>
-class BuiltInDefaultValue<T*> {
- public:
-  static bool Exists() { return true; }
-  static T* Get() { return NULL; }
-};
-
-// The following specializations define the default values for
-// specific types we care about.
-#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
-  template <> \
-  class BuiltInDefaultValue<type> { \
-   public: \
-    static bool Exists() { return true; } \
-    static type Get() { return value; } \
-  }
-
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
-#if GTEST_HAS_GLOBAL_STRING
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
-#endif  // GTEST_HAS_GLOBAL_STRING
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
-
-// There's no need for a default action for signed wchar_t, as that
-// type is the same as wchar_t for gcc, and invalid for MSVC.
-//
-// There's also no need for a default action for unsigned wchar_t, as
-// that type is the same as unsigned int for gcc, and invalid for
-// MSVC.
-#if GMOCK_WCHAR_T_IS_NATIVE_
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
-#endif
-
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
-
-#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
-
-}  // namespace internal
-
-// When an unexpected function call is encountered, Google Mock will
-// let it return a default value if the user has specified one for its
-// return type, or if the return type has a built-in default value;
-// otherwise Google Mock won't know what value to return and will have
-// to abort the process.
-//
-// The DefaultValue<T> class allows a user to specify the
-// default value for a type T that is both copyable and publicly
-// destructible (i.e. anything that can be used as a function return
-// type).  The usage is:
-//
-//   // Sets the default value for type T to be foo.
-//   DefaultValue<T>::Set(foo);
-template <typename T>
-class DefaultValue {
- public:
-  // Sets the default value for type T; requires T to be
-  // copy-constructable and have a public destructor.
-  static void Set(T x) {
-    delete producer_;
-    producer_ = new FixedValueProducer(x);
-  }
-
-  // Provides a factory function to be called to generate the default value.
-  // This method can be used even if T is only move-constructible, but it is not
-  // limited to that case.
-  typedef T (*FactoryFunction)();
-  static void SetFactory(FactoryFunction factory) {
-    delete producer_;
-    producer_ = new FactoryValueProducer(factory);
-  }
-
-  // Unsets the default value for type T.
-  static void Clear() {
-    delete producer_;
-    producer_ = NULL;
-  }
-
-  // Returns true iff the user has set the default value for type T.
-  static bool IsSet() { return producer_ != NULL; }
-
-  // Returns true if T has a default return value set by the user or there
-  // exists a built-in default value.
-  static bool Exists() {
-    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
-  }
-
-  // Returns the default value for type T if the user has set one;
-  // otherwise returns the built-in default value. Requires that Exists()
-  // is true, which ensures that the return value is well-defined.
-  static T Get() {
-    return producer_ == NULL ?
-        internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();
-  }
-
- private:
-  class ValueProducer {
-   public:
-    virtual ~ValueProducer() {}
-    virtual T Produce() = 0;
-  };
-
-  class FixedValueProducer : public ValueProducer {
-   public:
-    explicit FixedValueProducer(T value) : value_(value) {}
-    virtual T Produce() { return value_; }
-
-   private:
-    const T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
-  };
-
-  class FactoryValueProducer : public ValueProducer {
-   public:
-    explicit FactoryValueProducer(FactoryFunction factory)
-        : factory_(factory) {}
-    virtual T Produce() { return factory_(); }
-
-   private:
-    const FactoryFunction factory_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
-  };
-
-  static ValueProducer* producer_;
-};
-
-// This partial specialization allows a user to set default values for
-// reference types.
-template <typename T>
-class DefaultValue<T&> {
- public:
-  // Sets the default value for type T&.
-  static void Set(T& x) {  // NOLINT
-    address_ = &x;
-  }
-
-  // Unsets the default value for type T&.
-  static void Clear() {
-    address_ = NULL;
-  }
-
-  // Returns true iff the user has set the default value for type T&.
-  static bool IsSet() { return address_ != NULL; }
-
-  // Returns true if T has a default return value set by the user or there
-  // exists a built-in default value.
-  static bool Exists() {
-    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
-  }
-
-  // Returns the default value for type T& if the user has set one;
-  // otherwise returns the built-in default value if there is one;
-  // otherwise aborts the process.
-  static T& Get() {
-    return address_ == NULL ?
-        internal::BuiltInDefaultValue<T&>::Get() : *address_;
-  }
-
- private:
-  static T* address_;
-};
-
-// This specialization allows DefaultValue<void>::Get() to
-// compile.
-template <>
-class DefaultValue<void> {
- public:
-  static bool Exists() { return true; }
-  static void Get() {}
-};
-
-// Points to the user-set default value for type T.
-template <typename T>
-typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = NULL;
-
-// Points to the user-set default value for type T&.
-template <typename T>
-T* DefaultValue<T&>::address_ = NULL;
-
-// Implement this interface to define an action for function type F.
-template <typename F>
-class ActionInterface {
- public:
-  typedef typename internal::Function<F>::Result Result;
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  ActionInterface() {}
-  virtual ~ActionInterface() {}
-
-  // Performs the action.  This method is not const, as in general an
-  // action can have side effects and be stateful.  For example, a
-  // get-the-next-element-from-the-collection action will need to
-  // remember the current element.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
-};
-
-// An Action<F> is a copyable and IMMUTABLE (except by assignment)
-// object that represents an action to be taken when a mock function
-// of type F is called.  The implementation of Action<T> is just a
-// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
-// Don't inherit from Action!
-//
-// You can view an object implementing ActionInterface<F> as a
-// concrete action (including its current state), and an Action<F>
-// object as a handle to it.
-template <typename F>
-class Action {
- public:
-  typedef typename internal::Function<F>::Result Result;
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  // Constructs a null Action.  Needed for storing Action objects in
-  // STL containers.
-  Action() : impl_(NULL) {}
-
-  // Constructs an Action from its implementation.  A NULL impl is
-  // used to represent the "do-default" action.
-  explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
-
-  // Copy constructor.
-  Action(const Action& action) : impl_(action.impl_) {}
-
-  // This constructor allows us to turn an Action<Func> object into an
-  // Action<F>, as long as F's arguments can be implicitly converted
-  // to Func's and Func's return type can be implicitly converted to
-  // F's.
-  template <typename Func>
-  explicit Action(const Action<Func>& action);
-
-  // Returns true iff this is the DoDefault() action.
-  bool IsDoDefault() const { return impl_.get() == NULL; }
-
-  // Performs the action.  Note that this method is const even though
-  // the corresponding method in ActionInterface is not.  The reason
-  // is that a const Action<F> means that it cannot be re-bound to
-  // another concrete action, not that the concrete action it binds to
-  // cannot change state.  (Think of the difference between a const
-  // pointer and a pointer to const.)
-  Result Perform(const ArgumentTuple& args) const {
-    internal::Assert(
-        !IsDoDefault(), __FILE__, __LINE__,
-        "You are using DoDefault() inside a composite action like "
-        "DoAll() or WithArgs().  This is not supported for technical "
-        "reasons.  Please instead spell out the default action, or "
-        "assign the default action to an Action variable and use "
-        "the variable in various places.");
-    return impl_->Perform(args);
-  }
-
- private:
-  template <typename F1, typename F2>
-  friend class internal::ActionAdaptor;
-
-  internal::linked_ptr<ActionInterface<F> > impl_;
-};
-
-// The PolymorphicAction class template makes it easy to implement a
-// polymorphic action (i.e. an action that can be used in mock
-// functions of than one type, e.g. Return()).
-//
-// To define a polymorphic action, a user first provides a COPYABLE
-// implementation class that has a Perform() method template:
-//
-//   class FooAction {
-//    public:
-//     template <typename Result, typename ArgumentTuple>
-//     Result Perform(const ArgumentTuple& args) const {
-//       // Processes the arguments and returns a result, using
-//       // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple.
-//     }
-//     ...
-//   };
-//
-// Then the user creates the polymorphic action using
-// MakePolymorphicAction(object) where object has type FooAction.  See
-// the definition of Return(void) and SetArgumentPointee<N>(value) for
-// complete examples.
-template <typename Impl>
-class PolymorphicAction {
- public:
-  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
-
-  template <typename F>
-  operator Action<F>() const {
-    return Action<F>(new MonomorphicImpl<F>(impl_));
-  }
-
- private:
-  template <typename F>
-  class MonomorphicImpl : public ActionInterface<F> {
-   public:
-    typedef typename internal::Function<F>::Result Result;
-    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      return impl_.template Perform<Result>(args);
-    }
-
-   private:
-    Impl impl_;
-
-    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
-  };
-
-  Impl impl_;
-
-  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
-};
-
-// Creates an Action from its implementation and returns it.  The
-// created Action object owns the implementation.
-template <typename F>
-Action<F> MakeAction(ActionInterface<F>* impl) {
-  return Action<F>(impl);
-}
-
-// Creates a polymorphic action from its implementation.  This is
-// easier to use than the PolymorphicAction<Impl> constructor as it
-// doesn't require you to explicitly write the template argument, e.g.
-//
-//   MakePolymorphicAction(foo);
-// vs
-//   PolymorphicAction<TypeOfFoo>(foo);
-template <typename Impl>
-inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
-  return PolymorphicAction<Impl>(impl);
-}
-
-namespace internal {
-
-// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
-// and F1 are compatible.
-template <typename F1, typename F2>
-class ActionAdaptor : public ActionInterface<F1> {
- public:
-  typedef typename internal::Function<F1>::Result Result;
-  typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
-
-  explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
-
-  virtual Result Perform(const ArgumentTuple& args) {
-    return impl_->Perform(args);
-  }
-
- private:
-  const internal::linked_ptr<ActionInterface<F2> > impl_;
-
-  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
-};
-
-// Helper struct to specialize ReturnAction to execute a move instead of a copy
-// on return. Useful for move-only types, but could be used on any type.
-template <typename T>
-struct ByMoveWrapper {
-  explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
-  T payload;
-};
-
-// Implements the polymorphic Return(x) action, which can be used in
-// any function that returns the type of x, regardless of the argument
-// types.
-//
-// Note: The value passed into Return must be converted into
-// Function<F>::Result when this action is cast to Action<F> rather than
-// when that action is performed. This is important in scenarios like
-//
-// MOCK_METHOD1(Method, T(U));
-// ...
-// {
-//   Foo foo;
-//   X x(&foo);
-//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
-// }
-//
-// In the example above the variable x holds reference to foo which leaves
-// scope and gets destroyed.  If copying X just copies a reference to foo,
-// that copy will be left with a hanging reference.  If conversion to T
-// makes a copy of foo, the above code is safe. To support that scenario, we
-// need to make sure that the type conversion happens inside the EXPECT_CALL
-// statement, and conversion of the result of Return to Action<T(U)> is a
-// good place for that.
-//
-template <typename R>
-class ReturnAction {
- public:
-  // Constructs a ReturnAction object from the value to be returned.
-  // 'value' is passed by value instead of by const reference in order
-  // to allow Return("string literal") to compile.
-  explicit ReturnAction(R value) : value_(new R(internal::move(value))) {}
-
-  // This template type conversion operator allows Return(x) to be
-  // used in ANY function that returns x's type.
-  template <typename F>
-  operator Action<F>() const {
-    // Assert statement belongs here because this is the best place to verify
-    // conditions on F. It produces the clearest error messages
-    // in most compilers.
-    // Impl really belongs in this scope as a local class but can't
-    // because MSVC produces duplicate symbols in different translation units
-    // in this case. Until MS fixes that bug we put Impl into the class scope
-    // and put the typedef both here (for use in assert statement) and
-    // in the Impl class. But both definitions must be the same.
-    typedef typename Function<F>::Result Result;
-    GTEST_COMPILE_ASSERT_(
-        !is_reference<Result>::value,
-        use_ReturnRef_instead_of_Return_to_return_a_reference);
-    return Action<F>(new Impl<R, F>(value_));
-  }
-
- private:
-  // Implements the Return(x) action for a particular function type F.
-  template <typename R_, typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    // The implicit cast is necessary when Result has more than one
-    // single-argument constructor (e.g. Result is std::vector<int>) and R
-    // has a type conversion operator template.  In that case, value_(value)
-    // won't compile as the compiler doesn't known which constructor of
-    // Result to call.  ImplicitCast_ forces the compiler to convert R to
-    // Result without considering explicit constructors, thus resolving the
-    // ambiguity. value_ is then initialized using its copy constructor.
-    explicit Impl(const linked_ptr<R>& value)
-        : value_before_cast_(*value),
-          value_(ImplicitCast_<Result>(value_before_cast_)) {}
-
-    virtual Result Perform(const ArgumentTuple&) { return value_; }
-
-   private:
-    GTEST_COMPILE_ASSERT_(!is_reference<Result>::value,
-                          Result_cannot_be_a_reference_type);
-    // We save the value before casting just in case it is being cast to a
-    // wrapper type.
-    R value_before_cast_;
-    Result value_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
-  };
-
-  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
-  // move its contents instead.
-  template <typename R_, typename F>
-  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const linked_ptr<R>& wrapper)
-        : performed_(false), wrapper_(wrapper) {}
-
-    virtual Result Perform(const ArgumentTuple&) {
-      GTEST_CHECK_(!performed_)
-          << "A ByMove() action should only be performed once.";
-      performed_ = true;
-      return internal::move(wrapper_->payload);
-    }
-
-   private:
-    bool performed_;
-    const linked_ptr<R> wrapper_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const linked_ptr<R> value_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnAction);
-};
-
-// Implements the ReturnNull() action.
-class ReturnNullAction {
- public:
-  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
-  // this is enforced by returning nullptr, and in non-C++11 by asserting a
-  // pointer type on compile time.
-  template <typename Result, typename ArgumentTuple>
-  static Result Perform(const ArgumentTuple&) {
-#if GTEST_LANG_CXX11
-    return nullptr;
-#else
-    GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
-                          ReturnNull_can_be_used_to_return_a_pointer_only);
-    return NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-};
-
-// Implements the Return() action.
-class ReturnVoidAction {
- public:
-  // Allows Return() to be used in any void-returning function.
-  template <typename Result, typename ArgumentTuple>
-  static void Perform(const ArgumentTuple&) {
-    CompileAssertTypesEqual<void, Result>();
-  }
-};
-
-// Implements the polymorphic ReturnRef(x) action, which can be used
-// in any function that returns a reference to the type of x,
-// regardless of the argument types.
-template <typename T>
-class ReturnRefAction {
- public:
-  // Constructs a ReturnRefAction object from the reference to be returned.
-  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
-
-  // This template type conversion operator allows ReturnRef(x) to be
-  // used in ANY function that returns a reference to x's type.
-  template <typename F>
-  operator Action<F>() const {
-    typedef typename Function<F>::Result Result;
-    // Asserts that the function return type is a reference.  This
-    // catches the user error of using ReturnRef(x) when Return(x)
-    // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(internal::is_reference<Result>::value,
-                          use_Return_instead_of_ReturnRef_to_return_a_value);
-    return Action<F>(new Impl<F>(ref_));
-  }
-
- private:
-  // Implements the ReturnRef(x) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
-
-    virtual Result Perform(const ArgumentTuple&) {
-      return ref_;
-    }
-
-   private:
-    T& ref_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  T& ref_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
-};
-
-// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
-// used in any function that returns a reference to the type of x,
-// regardless of the argument types.
-template <typename T>
-class ReturnRefOfCopyAction {
- public:
-  // Constructs a ReturnRefOfCopyAction object from the reference to
-  // be returned.
-  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
-
-  // This template type conversion operator allows ReturnRefOfCopy(x) to be
-  // used in ANY function that returns a reference to x's type.
-  template <typename F>
-  operator Action<F>() const {
-    typedef typename Function<F>::Result Result;
-    // Asserts that the function return type is a reference.  This
-    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
-    // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(
-        internal::is_reference<Result>::value,
-        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
-    return Action<F>(new Impl<F>(value_));
-  }
-
- private:
-  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const T& value) : value_(value) {}  // NOLINT
-
-    virtual Result Perform(const ArgumentTuple&) {
-      return value_;
-    }
-
-   private:
-    T value_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const T value_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
-};
-
-// Implements the polymorphic DoDefault() action.
-class DoDefaultAction {
- public:
-  // This template type conversion operator allows DoDefault() to be
-  // used in any function.
-  template <typename F>
-  operator Action<F>() const { return Action<F>(NULL); }
-};
-
-// Implements the Assign action to set a given pointer referent to a
-// particular value.
-template <typename T1, typename T2>
-class AssignAction {
- public:
-  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& /* args */) const {
-    *ptr_ = value_;
-  }
-
- private:
-  T1* const ptr_;
-  const T2 value_;
-
-  GTEST_DISALLOW_ASSIGN_(AssignAction);
-};
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-// Implements the SetErrnoAndReturn action to simulate return from
-// various system calls and libc functions.
-template <typename T>
-class SetErrnoAndReturnAction {
- public:
-  SetErrnoAndReturnAction(int errno_value, T result)
-      : errno_(errno_value),
-        result_(result) {}
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) const {
-    errno = errno_;
-    return result_;
-  }
-
- private:
-  const int errno_;
-  const T result_;
-
-  GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
-};
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Implements the SetArgumentPointee<N>(x) action for any function
-// whose N-th argument (0-based) is a pointer to x's type.  The
-// template parameter kIsProto is true iff type A is ProtocolMessage,
-// proto2::Message, or a sub-class of those.
-template <size_t N, typename A, bool kIsProto>
-class SetArgumentPointeeAction {
- public:
-  // Constructs an action that sets the variable pointed to by the
-  // N-th function argument to 'value'.
-  explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& args) const {
-    CompileAssertTypesEqual<void, Result>();
-    *::testing::get<N>(args) = value_;
-  }
-
- private:
-  const A value_;
-
-  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
-};
-
-template <size_t N, typename Proto>
-class SetArgumentPointeeAction<N, Proto, true> {
- public:
-  // Constructs an action that sets the variable pointed to by the
-  // N-th function argument to 'proto'.  Both ProtocolMessage and
-  // proto2::Message have the CopyFrom() method, so the same
-  // implementation works for both.
-  explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) {
-    proto_->CopyFrom(proto);
-  }
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& args) const {
-    CompileAssertTypesEqual<void, Result>();
-    ::testing::get<N>(args)->CopyFrom(*proto_);
-  }
-
- private:
-  const internal::linked_ptr<Proto> proto_;
-
-  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
-};
-
-// Implements the InvokeWithoutArgs(f) action.  The template argument
-// FunctionImpl is the implementation type of f, which can be either a
-// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
-// Action<F> as long as f's type is compatible with F (i.e. f can be
-// assigned to a tr1::function<F>).
-template <typename FunctionImpl>
-class InvokeWithoutArgsAction {
- public:
-  // The c'tor makes a copy of function_impl (either a function
-  // pointer or a functor).
-  explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
-      : function_impl_(function_impl) {}
-
-  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
-  // compatible with f.
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple&) { return function_impl_(); }
-
- private:
-  FunctionImpl function_impl_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
-};
-
-// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
-template <class Class, typename MethodPtr>
-class InvokeMethodWithoutArgsAction {
- public:
-  InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
-      : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple&) const {
-    return (obj_ptr_->*method_ptr_)();
-  }
-
- private:
-  Class* const obj_ptr_;
-  const MethodPtr method_ptr_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
-};
-
-// Implements the IgnoreResult(action) action.
-template <typename A>
-class IgnoreResultAction {
- public:
-  explicit IgnoreResultAction(const A& action) : action_(action) {}
-
-  template <typename F>
-  operator Action<F>() const {
-    // Assert statement belongs here because this is the best place to verify
-    // conditions on F. It produces the clearest error messages
-    // in most compilers.
-    // Impl really belongs in this scope as a local class but can't
-    // because MSVC produces duplicate symbols in different translation units
-    // in this case. Until MS fixes that bug we put Impl into the class scope
-    // and put the typedef both here (for use in assert statement) and
-    // in the Impl class. But both definitions must be the same.
-    typedef typename internal::Function<F>::Result Result;
-
-    // Asserts at compile time that F returns void.
-    CompileAssertTypesEqual<void, Result>();
-
-    return Action<F>(new Impl<F>(action_));
-  }
-
- private:
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename internal::Function<F>::Result Result;
-    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const A& action) : action_(action) {}
-
-    virtual void Perform(const ArgumentTuple& args) {
-      // Performs the action and ignores its result.
-      action_.Perform(args);
-    }
-
-   private:
-    // Type OriginalFunction is the same as F except that its return
-    // type is IgnoredValue.
-    typedef typename internal::Function<F>::MakeResultIgnoredValue
-        OriginalFunction;
-
-    const Action<OriginalFunction> action_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const A action_;
-
-  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
-};
-
-// A ReferenceWrapper<T> object represents a reference to type T,
-// which can be either const or not.  It can be explicitly converted
-// from, and implicitly converted to, a T&.  Unlike a reference,
-// ReferenceWrapper<T> can be copied and can survive template type
-// inference.  This is used to support by-reference arguments in the
-// InvokeArgument<N>(...) action.  The idea was from "reference
-// wrappers" in tr1, which we don't have in our source tree yet.
-template <typename T>
-class ReferenceWrapper {
- public:
-  // Constructs a ReferenceWrapper<T> object from a T&.
-  explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {}  // NOLINT
-
-  // Allows a ReferenceWrapper<T> object to be implicitly converted to
-  // a T&.
-  operator T&() const { return *pointer_; }
- private:
-  T* pointer_;
-};
-
-// Allows the expression ByRef(x) to be printed as a reference to x.
-template <typename T>
-void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) {
-  T& value = ref;
-  UniversalPrinter<T&>::Print(value, os);
-}
-
-// Does two actions sequentially.  Used for implementing the DoAll(a1,
-// a2, ...) action.
-template <typename Action1, typename Action2>
-class DoBothAction {
- public:
-  DoBothAction(Action1 action1, Action2 action2)
-      : action1_(action1), action2_(action2) {}
-
-  // This template type conversion operator allows DoAll(a1, ..., a_n)
-  // to be used in ANY function of compatible type.
-  template <typename F>
-  operator Action<F>() const {
-    return Action<F>(new Impl<F>(action1_, action2_));
-  }
-
- private:
-  // Implements the DoAll(...) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-    typedef typename Function<F>::MakeResultVoid VoidResult;
-
-    Impl(const Action<VoidResult>& action1, const Action<F>& action2)
-        : action1_(action1), action2_(action2) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      action1_.Perform(args);
-      return action2_.Perform(args);
-    }
-
-   private:
-    const Action<VoidResult> action1_;
-    const Action<F> action2_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  Action1 action1_;
-  Action2 action2_;
-
-  GTEST_DISALLOW_ASSIGN_(DoBothAction);
-};
-
-}  // namespace internal
-
-// An Unused object can be implicitly constructed from ANY value.
-// This is handy when defining actions that ignore some or all of the
-// mock function arguments.  For example, given
-//
-//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-//   MOCK_METHOD3(Bar, double(int index, double x, double y));
-//
-// instead of
-//
-//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   double DistanceToOriginWithIndex(int index, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   ...
-//   EXEPCT_CALL(mock, Foo("abc", _, _))
-//       .WillOnce(Invoke(DistanceToOriginWithLabel));
-//   EXEPCT_CALL(mock, Bar(5, _, _))
-//       .WillOnce(Invoke(DistanceToOriginWithIndex));
-//
-// you could write
-//
-//   // We can declare any uninteresting argument as Unused.
-//   double DistanceToOrigin(Unused, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   ...
-//   EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
-//   EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
-typedef internal::IgnoredValue Unused;
-
-// This constructor allows us to turn an Action<From> object into an
-// Action<To>, as long as To's arguments can be implicitly converted
-// to From's and From's return type cann be implicitly converted to
-// To's.
-template <typename To>
-template <typename From>
-Action<To>::Action(const Action<From>& from)
-    : impl_(new internal::ActionAdaptor<To, From>(from)) {}
-
-// Creates an action that returns 'value'.  'value' is passed by value
-// instead of const reference - otherwise Return("string literal")
-// will trigger a compiler error about using array as initializer.
-template <typename R>
-internal::ReturnAction<R> Return(R value) {
-  return internal::ReturnAction<R>(internal::move(value));
-}
-
-// Creates an action that returns NULL.
-inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
-  return MakePolymorphicAction(internal::ReturnNullAction());
-}
-
-// Creates an action that returns from a void function.
-inline PolymorphicAction<internal::ReturnVoidAction> Return() {
-  return MakePolymorphicAction(internal::ReturnVoidAction());
-}
-
-// Creates an action that returns the reference to a variable.
-template <typename R>
-inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
-  return internal::ReturnRefAction<R>(x);
-}
-
-// Creates an action that returns the reference to a copy of the
-// argument.  The copy is created when the action is constructed and
-// lives as long as the action.
-template <typename R>
-inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
-  return internal::ReturnRefOfCopyAction<R>(x);
-}
-
-// Modifies the parent action (a Return() action) to perform a move of the
-// argument instead of a copy.
-// Return(ByMove()) actions can only be executed once and will assert this
-// invariant.
-template <typename R>
-internal::ByMoveWrapper<R> ByMove(R x) {
-  return internal::ByMoveWrapper<R>(internal::move(x));
-}
-
-// Creates an action that does the default action for the give mock function.
-inline internal::DoDefaultAction DoDefault() {
-  return internal::DoDefaultAction();
-}
-
-// Creates an action that sets the variable pointed by the N-th
-// (0-based) function argument to 'value'.
-template <size_t N, typename T>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<
-    N, T, internal::IsAProtocolMessage<T>::value> >
-SetArgPointee(const T& x) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, T, internal::IsAProtocolMessage<T>::value>(x));
-}
-
-#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
-// This overload allows SetArgPointee() to accept a string literal.
-// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish
-// this overload from the templated version and emit a compile error.
-template <size_t N>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<N, const char*, false> >
-SetArgPointee(const char* p) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, const char*, false>(p));
-}
-
-template <size_t N>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<N, const wchar_t*, false> >
-SetArgPointee(const wchar_t* p) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, const wchar_t*, false>(p));
-}
-#endif
-
-// The following version is DEPRECATED.
-template <size_t N, typename T>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<
-    N, T, internal::IsAProtocolMessage<T>::value> >
-SetArgumentPointee(const T& x) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, T, internal::IsAProtocolMessage<T>::value>(x));
-}
-
-// Creates an action that sets a pointer referent to a given value.
-template <typename T1, typename T2>
-PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
-  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
-}
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-// Creates an action that sets errno and returns the appropriate error.
-template <typename T>
-PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
-SetErrnoAndReturn(int errval, T result) {
-  return MakePolymorphicAction(
-      internal::SetErrnoAndReturnAction<T>(errval, result));
-}
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Various overloads for InvokeWithoutArgs().
-
-// Creates an action that invokes 'function_impl' with no argument.
-template <typename FunctionImpl>
-PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
-InvokeWithoutArgs(FunctionImpl function_impl) {
-  return MakePolymorphicAction(
-      internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
-}
-
-// Creates an action that invokes the given method on the given object
-// with no argument.
-template <class Class, typename MethodPtr>
-PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> >
-InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
-  return MakePolymorphicAction(
-      internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
-          obj_ptr, method_ptr));
-}
-
-// Creates an action that performs an_action and throws away its
-// result.  In other words, it changes the return type of an_action to
-// void.  an_action MUST NOT return void, or the code won't compile.
-template <typename A>
-inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
-  return internal::IgnoreResultAction<A>(an_action);
-}
-
-// Creates a reference wrapper for the given L-value.  If necessary,
-// you can explicitly specify the type of the reference.  For example,
-// suppose 'derived' is an object of type Derived, ByRef(derived)
-// would wrap a Derived&.  If you want to wrap a const Base& instead,
-// where Base is a base class of Derived, just write:
-//
-//   ByRef<const Base>(derived)
-template <typename T>
-inline internal::ReferenceWrapper<T> ByRef(T& l_value) {  // NOLINT
-  return internal::ReferenceWrapper<T>(l_value);
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used cardinalities.  More
-// cardinalities can be defined by the user implementing the
-// CardinalityInterface interface if necessary.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-
-#include <limits.h>
-#include <ostream>  // NOLINT
-
-namespace testing {
-
-// To implement a cardinality Foo, define:
-//   1. a class FooCardinality that implements the
-//      CardinalityInterface interface, and
-//   2. a factory function that creates a Cardinality object from a
-//      const FooCardinality*.
-//
-// The two-level delegation design follows that of Matcher, providing
-// consistency for extension developers.  It also eases ownership
-// management as Cardinality objects can now be copied like plain values.
-
-// The implementation of a cardinality.
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface() {}
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  virtual int ConservativeLowerBound() const { return 0; }
-  virtual int ConservativeUpperBound() const { return INT_MAX; }
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-
-// A Cardinality is a copyable and IMMUTABLE (except by assignment)
-// object that specifies how many times a mock function is expected to
-// be called.  The implementation of Cardinality is just a linked_ptr
-// to const CardinalityInterface, so copying is fairly cheap.
-// Don't inherit from Cardinality!
-class GTEST_API_ Cardinality {
- public:
-  // Constructs a null cardinality.  Needed for storing Cardinality
-  // objects in STL containers.
-  Cardinality() {}
-
-  // Constructs a Cardinality from its implementation.
-  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
-  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  bool IsSatisfiedByCallCount(int call_count) const {
-    return impl_->IsSatisfiedByCallCount(call_count);
-  }
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  bool IsSaturatedByCallCount(int call_count) const {
-    return impl_->IsSaturatedByCallCount(call_count);
-  }
-
-  // Returns true iff call_count calls will over-saturate this
-  // cardinality, i.e. exceed the maximum number of allowed calls.
-  bool IsOverSaturatedByCallCount(int call_count) const {
-    return impl_->IsSaturatedByCallCount(call_count) &&
-        !impl_->IsSatisfiedByCallCount(call_count);
-  }
-
-  // Describes self to an ostream
-  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
-
-  // Describes the given actual call count to an ostream.
-  static void DescribeActualCallCountTo(int actual_call_count,
-                                        ::std::ostream* os);
-
- private:
-  internal::linked_ptr<const CardinalityInterface> impl_;
-};
-
-// Creates a cardinality that allows at least n calls.
-GTEST_API_ Cardinality AtLeast(int n);
-
-// Creates a cardinality that allows at most n calls.
-GTEST_API_ Cardinality AtMost(int n);
-
-// Creates a cardinality that allows any number of calls.
-GTEST_API_ Cardinality AnyNumber();
-
-// Creates a cardinality that allows between min and max calls.
-GTEST_API_ Cardinality Between(int min, int max);
-
-// Creates a cardinality that allows exactly n calls.
-GTEST_API_ Cardinality Exactly(int n);
-
-// Creates a cardinality from its implementation.
-inline Cardinality MakeCardinality(const CardinalityInterface* c) {
-  return Cardinality(c);
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic actions.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-
-
-namespace testing {
-namespace internal {
-
-// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
-// function or method with the unpacked values, where F is a function
-// type that takes N arguments.
-template <typename Result, typename ArgumentTuple>
-class InvokeHelper;
-
-template <typename R>
-class InvokeHelper<R, ::testing::tuple<> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<>&) {
-           return function();
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<>&) {
-           return (obj_ptr->*method_ptr)();
-  }
-};
-
-template <typename R, typename A1>
-class InvokeHelper<R, ::testing::tuple<A1> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
-           return function(get<0>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2>
-class InvokeHelper<R, ::testing::tuple<A1, A2> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
-           return function(get<0>(args), get<1>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
-      A4>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
-      A5>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
-                            A7>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
-                            A8>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8, A9>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args), get<8>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
-                            A9>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args), get<8>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-    A10> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8, A9, A10>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args), get<8>(args), get<9>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
-                            A9, A10>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
-  }
-};
-
-// An INTERNAL macro for extracting the type of a tuple field.  It's
-// subject to change without notice - DO NOT USE IN USER CODE!
-#define GMOCK_FIELD_(Tuple, N) \
-    typename ::testing::tuple_element<N, Tuple>::type
-
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
-// type of an n-ary function whose i-th (1-based) argument type is the
-// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
-// type, and whose return type is Result.  For example,
-//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
-// is int(bool, long).
-//
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
-// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
-// For example,
-//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
-//       ::testing::make_tuple(true, 'a', 2.5))
-// returns tuple (2.5, true).
-//
-// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
-// in the range [0, 10].  Duplicates are allowed and they don't have
-// to be in an ascending or descending order.
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
-class SelectArgs {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
-      GMOCK_FIELD_(ArgumentTuple, k10));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args), get<k9>(args), get<k10>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple>
-class SelectArgs<Result, ArgumentTuple,
-                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type();
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& /* args */) {
-    return SelectedArgs();
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8, int k9>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args), get<k9>(args));
-  }
-};
-
-#undef GMOCK_FIELD_
-
-// Implements the WithArgs action.
-template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1, int k10 = -1>
-class WithArgsAction {
- public:
-  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
-
-  template <typename F>
-  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
-
- private:
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const InnerAction& action) : action_(action) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
-          k5, k6, k7, k8, k9, k10>::Select(args));
-    }
-
-   private:
-    typedef typename SelectArgs<Result, ArgumentTuple,
-        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
-
-    Action<InnerFunctionType> action_;
-  };
-
-  const InnerAction action_;
-
-  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
-};
-
-// A macro from the ACTION* family (defined later in this file)
-// defines an action that can be used in a mock function.  Typically,
-// these actions only care about a subset of the arguments of the mock
-// function.  For example, if such an action only uses the second
-// argument, it can be used in any mock function that takes >= 2
-// arguments where the type of the second argument is compatible.
-//
-// Therefore, the action implementation must be prepared to take more
-// arguments than it needs.  The ExcessiveArg type is used to
-// represent those excessive arguments.  In order to keep the compiler
-// error messages tractable, we define it in the testing namespace
-// instead of testing::internal.  However, this is an INTERNAL TYPE
-// and subject to change without notice, so a user MUST NOT USE THIS
-// TYPE DIRECTLY.
-struct ExcessiveArg {};
-
-// A helper class needed for implementing the ACTION* macros.
-template <typename Result, class Impl>
-class ActionHelper {
- public:
-  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
-    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
-    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
-    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
-        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
-        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
-      A3>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
-        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
-      A4>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
-        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7, typename A8>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7, A8>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
-        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7, typename A8, typename A9>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7, A8, A9>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
-        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
-        get<9>(args));
-  }
-};
-
-}  // namespace internal
-
-// Various overloads for Invoke().
-
-// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
-// the selected arguments of the mock function to an_action and
-// performs it.  It serves as an adaptor between actions with
-// different argument lists.  C++ doesn't support default arguments for
-// function templates, so we have to overload it.
-template <int k1, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1>(action);
-}
-
-template <int k1, int k2, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2>(action);
-}
-
-template <int k1, int k2, int k3, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
-}
-
-template <int k1, int k2, int k3, int k4, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
-    typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
-      k7>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
-      k8>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, int k10, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-    k9, k10>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9, k10>(action);
-}
-
-// Creates an action that does actions a1, a2, ..., sequentially in
-// each invocation.
-template <typename Action1, typename Action2>
-inline internal::DoBothAction<Action1, Action2>
-DoAll(Action1 a1, Action2 a2) {
-  return internal::DoBothAction<Action1, Action2>(a1, a2);
-}
-
-template <typename Action1, typename Action2, typename Action3>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    Action3> >
-DoAll(Action1 a1, Action2 a2, Action3 a3) {
-  return DoAll(a1, DoAll(a2, a3));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, Action4> > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
-  return DoAll(a1, DoAll(a2, a3, a4));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    Action5> > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, Action6> > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    Action7> > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, Action8> > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8, typename Action9>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
-    Action9> > > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8, Action9 a9) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8, typename Action9, typename Action10>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
-    internal::DoBothAction<Action9, Action10> > > > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
-}  // namespace testing
-
-// The ACTION* family of macros can be used in a namespace scope to
-// define custom actions easily.  The syntax:
-//
-//   ACTION(name) { statements; }
-//
-// will define an action with the given name that executes the
-// statements.  The value returned by the statements will be used as
-// the return value of the action.  Inside the statements, you can
-// refer to the K-th (0-based) argument of the mock function by
-// 'argK', and refer to its type by 'argK_type'.  For example:
-//
-//   ACTION(IncrementArg1) {
-//     arg1_type temp = arg1;
-//     return ++(*temp);
-//   }
-//
-// allows you to write
-//
-//   ...WillOnce(IncrementArg1());
-//
-// You can also refer to the entire argument tuple and its type by
-// 'args' and 'args_type', and refer to the mock function type and its
-// return type by 'function_type' and 'return_type'.
-//
-// Note that you don't need to specify the types of the mock function
-// arguments.  However rest assured that your code is still type-safe:
-// you'll get a compiler error if *arg1 doesn't support the ++
-// operator, or if the type of ++(*arg1) isn't compatible with the
-// mock function's return type, for example.
-//
-// Sometimes you'll want to parameterize the action.   For that you can use
-// another macro:
-//
-//   ACTION_P(name, param_name) { statements; }
-//
-// For example:
-//
-//   ACTION_P(Add, n) { return arg0 + n; }
-//
-// will allow you to write:
-//
-//   ...WillOnce(Add(5));
-//
-// Note that you don't need to provide the type of the parameter
-// either.  If you need to reference the type of a parameter named
-// 'foo', you can write 'foo_type'.  For example, in the body of
-// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
-// of 'n'.
-//
-// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
-// multi-parameter actions.
-//
-// For the purpose of typing, you can view
-//
-//   ACTION_Pk(Foo, p1, ..., pk) { ... }
-//
-// as shorthand for
-//
-//   template <typename p1_type, ..., typename pk_type>
-//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
-//
-// In particular, you can provide the template type arguments
-// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
-// although usually you can rely on the compiler to infer the types
-// for you automatically.  You can assign the result of expression
-// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
-// pk_type>.  This can be useful when composing actions.
-//
-// You can also overload actions with different numbers of parameters:
-//
-//   ACTION_P(Plus, a) { ... }
-//   ACTION_P2(Plus, a, b) { ... }
-//
-// While it's tempting to always use the ACTION* macros when defining
-// a new action, you should also consider implementing ActionInterface
-// or using MakePolymorphicAction() instead, especially if you need to
-// use the action a lot.  While these approaches require more work,
-// they give you more control on the types of the mock function
-// arguments and the action parameters, which in general leads to
-// better compiler error messages that pay off in the long run.  They
-// also allow overloading actions based on parameter types (as opposed
-// to just based on the number of parameters).
-//
-// CAVEAT:
-//
-// ACTION*() can only be used in a namespace scope.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using ACTION*() inside
-// a function.
-//
-// MORE INFORMATION:
-//
-// To learn more about using these macros, please search for 'ACTION'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-// An internal macro needed for implementing ACTION*().
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
-    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
-    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
-    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
-    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
-    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
-    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
-    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
-    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
-    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
-    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
-    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
-
-// Sometimes you want to give an action explicit template parameters
-// that cannot be inferred from its value parameters.  ACTION() and
-// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
-// and can be viewed as an extension to ACTION() and ACTION_P*().
-//
-// The syntax:
-//
-//   ACTION_TEMPLATE(ActionName,
-//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
-//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
-//
-// defines an action template that takes m explicit template
-// parameters and n value parameters.  name_i is the name of the i-th
-// template parameter, and kind_i specifies whether it's a typename,
-// an integral constant, or a template.  p_i is the name of the i-th
-// value parameter.
-//
-// Example:
-//
-//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
-//   // function to type T and copies it to *output.
-//   ACTION_TEMPLATE(DuplicateArg,
-//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-//                   AND_1_VALUE_PARAMS(output)) {
-//     *output = T(::testing::get<k>(args));
-//   }
-//   ...
-//     int n;
-//     EXPECT_CALL(mock, Foo(_, _))
-//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
-//
-// To create an instance of an action template, write:
-//
-//   ActionName<t1, ..., t_m>(v1, ..., v_n)
-//
-// where the ts are the template arguments and the vs are the value
-// arguments.  The value argument types are inferred by the compiler.
-// If you want to explicitly specify the value argument types, you can
-// provide additional template arguments:
-//
-//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
-//
-// where u_i is the desired type of v_i.
-//
-// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
-// number of value parameters, but not on the number of template
-// parameters.  Without the restriction, the meaning of the following
-// is unclear:
-//
-//   OverloadedAction<int, bool>(x);
-//
-// Are we using a single-template-parameter action where 'bool' refers
-// to the type of x, or are we using a two-template-parameter action
-// where the compiler is asked to infer the type of x?
-//
-// Implementation notes:
-//
-// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
-// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
-// implementing ACTION_TEMPLATE.  The main trick we use is to create
-// new macro invocations when expanding a macro.  For example, we have
-//
-//   #define ACTION_TEMPLATE(name, template_params, value_params)
-//       ... GMOCK_INTERNAL_DECL_##template_params ...
-//
-// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
-// to expand to
-//
-//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
-//
-// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
-// preprocessor will continue to expand it to
-//
-//       ... typename T ...
-//
-// This technique conforms to the C++ standard and is portable.  It
-// allows us to implement action templates using O(N) code, where N is
-// the maximum number of template/value parameters supported.  Without
-// using it, we'd have to devote O(N^2) amount of code to implement all
-// combinations of m and n.
-
-// Declares the template parameters.
-#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
-#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) kind0 name0, kind1 name1
-#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) kind0 name0, kind1 name1, kind2 name2
-#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3
-#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
-    kind2 name2, kind3 name3, kind4 name4
-#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
-#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
-    kind5 name5, kind6 name6
-#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
-    kind4 name4, kind5 name5, kind6 name6, kind7 name7
-#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
-    kind8 name8
-#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
-    kind6 name6, kind7 name7, kind8 name8, kind9 name9
-
-// Lists the template parameters.
-#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
-#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) name0, name1
-#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) name0, name1, name2
-#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) name0, name1, name2, name3
-#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
-    name4
-#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
-    name2, name3, name4, name5
-#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) name0, name1, name2, name3, name4, name5, name6
-#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
-#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
-    name6, name7, name8
-#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
-    name3, name4, name5, name6, name7, name8, name9
-
-// Declares the types of value parameters.
-#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
-    typename p0##_type, typename p1##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
-    typename p0##_type, typename p1##_type, typename p2##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type, typename p8##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
-    typename p2##_type, typename p3##_type, typename p4##_type, \
-    typename p5##_type, typename p6##_type, typename p7##_type, \
-    typename p8##_type, typename p9##_type
-
-// Initializes the value parameters.
-#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
-    ()
-#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
-    (p0##_type gmock_p0) : p0(gmock_p0)
-#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
-    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1)
-#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2)
-#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3)
-#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4)
-#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5)
-#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6)
-#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7)
-#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8)
-#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
-        p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8), p9(gmock_p9)
-
-// Declares the fields for storing the value parameters.
-#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
-#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
-    p1##_type p1;
-#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
-    p1##_type p1; p2##_type p2;
-#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
-    p1##_type p1; p2##_type p2; p3##_type p3;
-#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
-#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5;
-#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6;
-#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6; p7##_type p7;
-#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
-#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
-    p9##_type p9;
-
-// Lists the value parameters.
-#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
-#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
-#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
-#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
-#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
-    p2, p3, p4
-#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
-    p1, p2, p3, p4, p5
-#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0, p1, p2, p3, p4, p5, p6
-#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0, p1, p2, p3, p4, p5, p6, p7
-#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
-#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
-
-// Lists the value parameter types.
-#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
-    p1##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
-    p1##_type, p2##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    p0##_type, p1##_type, p2##_type, p3##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
-    p6##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
-
-// Declares the value parameters.
-#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
-#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
-    p1##_type p1
-#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
-    p1##_type p1, p2##_type p2
-#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
-    p1##_type p1, p2##_type p2, p3##_type p3
-#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
-#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5
-#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6
-#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6, p7##_type p7
-#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
-#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
-    p9##_type p9
-
-// The suffix of the class template implementing the action template.
-#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
-#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
-#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
-#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
-#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
-#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
-#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
-#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) P8
-#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) P9
-#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) P10
-
-// The name of the class template implementing the action template.
-#define GMOCK_ACTION_CLASS_(name, value_params)\
-    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
-
-#define ACTION_TEMPLATE(name, template_params, value_params)\
-  template <GMOCK_INTERNAL_DECL_##template_params\
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
-  class GMOCK_ACTION_CLASS_(name, value_params) {\
-   public:\
-    explicit GMOCK_ACTION_CLASS_(name, value_params)\
-        GMOCK_INTERNAL_INIT_##value_params {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      GMOCK_INTERNAL_DEFN_##value_params\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(\
-          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
-    }\
-    GMOCK_INTERNAL_DEFN_##value_params\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
-  };\
-  template <GMOCK_INTERNAL_DECL_##template_params\
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
-  inline GMOCK_ACTION_CLASS_(name, value_params)<\
-      GMOCK_INTERNAL_LIST_##template_params\
-      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
-          GMOCK_INTERNAL_DECL_##value_params) {\
-    return GMOCK_ACTION_CLASS_(name, value_params)<\
-        GMOCK_INTERNAL_LIST_##template_params\
-        GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
-            GMOCK_INTERNAL_LIST_##value_params);\
-  }\
-  template <GMOCK_INTERNAL_DECL_##template_params\
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      GMOCK_ACTION_CLASS_(name, value_params)<\
-          GMOCK_INTERNAL_LIST_##template_params\
-          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
-              gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION(name)\
-  class name##Action {\
-   public:\
-    name##Action() {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl() {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>());\
-    }\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##Action);\
-  };\
-  inline name##Action name() {\
-    return name##Action();\
-  }\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P(name, p0)\
-  template <typename p0##_type>\
-  class name##ActionP {\
-   public:\
-    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
-    }\
-    p0##_type p0;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
-  };\
-  template <typename p0##_type>\
-  inline name##ActionP<p0##_type> name(p0##_type p0) {\
-    return name##ActionP<p0##_type>(p0);\
-  }\
-  template <typename p0##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P2(name, p0, p1)\
-  template <typename p0##_type, typename p1##_type>\
-  class name##ActionP2 {\
-   public:\
-    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-        p1(gmock_p1) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-          p1(gmock_p1) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
-  };\
-  template <typename p0##_type, typename p1##_type>\
-  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
-      p1##_type p1) {\
-    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
-  }\
-  template <typename p0##_type, typename p1##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P3(name, p0, p1, p2)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  class name##ActionP3 {\
-   public:\
-    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
-          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2) {\
-    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP3<p0##_type, p1##_type, \
-          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P4(name, p0, p1, p2, p3)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  class name##ActionP4 {\
-   public:\
-    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3) {\
-    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
-        p2, p3);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP4<p0##_type, p1##_type, p2##_type, \
-          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P5(name, p0, p1, p2, p3, p4)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  class name##ActionP5 {\
-   public:\
-    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, \
-        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
-          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4) {\
-    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type>(p0, p1, p2, p3, p4);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  class name##ActionP6 {\
-   public:\
-    name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, \
-          p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3, p4##_type p4, p5##_type p5) {\
-    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  class name##ActionP7 {\
-   public:\
-    name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
-        p6(gmock_p6) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
-          p6));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
-      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6) {\
-    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  class name##ActionP8 {\
-   public:\
-    name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, \
-        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \
-          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
-          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
-          p6, p7));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6, p7##_type p7) {\
-    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
-        p6, p7);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, \
-          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  class name##ActionP9 {\
-   public:\
-    name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7, \
-          p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-          p7(gmock_p7), p8(gmock_p8) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-      p8##_type p8;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
-          p6, p7, p8));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-    p8##_type p8;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, \
-      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
-      p8##_type p8) {\
-    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
-        p3, p4, p5, p6, p7, p8);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, p7##_type, \
-          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  class name##ActionP10 {\
-   public:\
-    name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
-          p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-      p8##_type p8;\
-      p9##_type p9;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
-          p6, p7, p8, p9));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-    p8##_type p8;\
-    p9##_type p9;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
-      p9##_type p9) {\
-    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
-        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, p7##_type, p8##_type, \
-          p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-namespace testing {
-
-
-// The ACTION*() macros trigger warning C4100 (unreferenced formal
-// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
-// the macro definition, as the warnings are generated when the macro
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Various overloads for InvokeArgument<N>().
-//
-// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
-// (0-based) argument, which must be a k-ary callable, of the mock
-// function, with arguments a1, a2, ..., a_k.
-//
-// Notes:
-//
-//   1. The arguments are passed by value by default.  If you need to
-//   pass an argument by reference, wrap it inside ByRef().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but ByRef() is
-//   not used, it will receive the reference to a copy of the value,
-//   instead of the original value.  For example, when the 0-th
-//   argument of the mock function takes a const string&, the action
-//
-//     InvokeArgument<0>(string("Hello"))
-//
-//   makes a copy of the temporary string("Hello") object and passes a
-//   reference of the copy, instead of the original temporary object,
-//   to the callable.  This makes it easy for a user to define an
-//   InvokeArgument action from temporary values and have it performed
-//   later.
-
-namespace internal {
-namespace invoke_argument {
-
-// Appears in InvokeArgumentAdl's argument list to help avoid
-// accidental calls to user functions of the same name.
-struct AdlTag {};
-
-// InvokeArgumentAdl - a helper for InvokeArgument.
-// The basic overloads are provided here for generic functors.
-// Overloads for other custom-callables are provided in the
-// internal/custom/callback-actions.h header.
-
-template <typename R, typename F>
-R InvokeArgumentAdl(AdlTag, F f) {
-  return f();
-}
-template <typename R, typename F, typename A1>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
-  return f(a1);
-}
-template <typename R, typename F, typename A1, typename A2>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
-  return f(a1, a2);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
-  return f(a1, a2, a3);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
-  return f(a1, a2, a3, a4);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-  return f(a1, a2, a3, a4, a5);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-  return f(a1, a2, a3, a4, a5, a6);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7) {
-  return f(a1, a2, a3, a4, a5, a6, a7);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8, A9 a9) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9, typename A10>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8, A9 a9, A10 a10) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-}
-}  // namespace invoke_argument
-}  // namespace internal
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args));
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(p0)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_2_VALUE_PARAMS(p0, p1)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_3_VALUE_PARAMS(p0, p1, p2)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-// Various overloads for ReturnNew<T>().
-//
-// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
-// instance of type T, constructed on the heap with constructor arguments
-// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_0_VALUE_PARAMS()) {
-  return new T();
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_1_VALUE_PARAMS(p0)) {
-  return new T(p0);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_2_VALUE_PARAMS(p0, p1)) {
-  return new T(p0, p1);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_3_VALUE_PARAMS(p0, p1, p2)) {
-  return new T(p0, p1, p2);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
-  return new T(p0, p1, p2, p3);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
-  return new T(p0, p1, p2, p3, p4);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
-  return new T(p0, p1, p2, p3, p4, p5);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace testing
-
-// Include any custom actions added by the local installation.
-// We must include this header at the end to make sure it can use the
-// declarations from this file.
-// This file was GENERATED by command:
-//     pump.py gmock-generated-actions.h.pump
-// DO NOT EDIT BY HAND!!!
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-// This file was GENERATED by command:
-//     pump.py gmock-generated-function-mockers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements function mockers of various arities.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements the ON_CALL() and EXPECT_CALL() macros.
-//
-// A user can use the ON_CALL() macro to specify the default action of
-// a mock method.  The syntax is:
-//
-//   ON_CALL(mock_object, Method(argument-matchers))
-//       .With(multi-argument-matcher)
-//       .WillByDefault(action);
-//
-//  where the .With() clause is optional.
-//
-// A user can use the EXPECT_CALL() macro to specify an expectation on
-// a mock method.  The syntax is:
-//
-//   EXPECT_CALL(mock_object, Method(argument-matchers))
-//       .With(multi-argument-matchers)
-//       .Times(cardinality)
-//       .InSequence(sequences)
-//       .After(expectations)
-//       .WillOnce(action)
-//       .WillRepeatedly(action)
-//       .RetiresOnSaturation();
-//
-// where all clauses are optional, and .InSequence()/.After()/
-// .WillOnce() can appear any number of times.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>  // NOLINT
-#endif
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used argument matchers.  More
-// matchers can be defined by the user implementing the
-// MatcherInterface<T> interface if necessary.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-
-#include <math.h>
-#include <algorithm>
-#include <iterator>
-#include <limits>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-# include <initializer_list>  // NOLINT -- must be after gtest.h
-#endif
-
-namespace testing {
-
-// To implement a matcher Foo for type T, define:
-//   1. a class FooMatcherImpl that implements the
-//      MatcherInterface<T> interface, and
-//   2. a factory function that creates a Matcher<T> object from a
-//      FooMatcherImpl*.
-//
-// The two-level delegation design makes it possible to allow a user
-// to write "v" instead of "Eq(v)" where a Matcher is expected, which
-// is impossible if we pass matchers by pointers.  It also eases
-// ownership management as Matcher objects can now be copied like
-// plain values.
-
-// MatchResultListener is an abstract class.  Its << operator can be
-// used by a matcher to explain why a value matches or doesn't match.
-//
-// TODO(wan@google.com): add method
-//   bool InterestedInWhy(bool result) const;
-// to indicate whether the listener is interested in why the match
-// result is 'result'.
-class MatchResultListener {
- public:
-  // Creates a listener object with the given underlying ostream.  The
-  // listener does not own the ostream, and does not dereference it
-  // in the constructor or destructor.
-  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
-  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
-
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x) {
-    if (stream_ != NULL)
-      *stream_ << x;
-    return *this;
-  }
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream() { return stream_; }
-
-  // Returns true iff the listener is interested in an explanation of
-  // the match result.  A matcher's MatchAndExplain() method can use
-  // this information to avoid generating the explanation when no one
-  // intends to hear it.
-  bool IsInterested() const { return stream_ != NULL; }
-
- private:
-  ::std::ostream* const stream_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
-};
-
-inline MatchResultListener::~MatchResultListener() {
-}
-
-// An instance of a subclass of this knows how to describe itself as a
-// matcher.
-class MatcherDescriberInterface {
- public:
-  virtual ~MatcherDescriberInterface() {}
-
-  // Describes this matcher to an ostream.  The function should print
-  // a verb phrase that describes the property a value matching this
-  // matcher should have.  The subject of the verb phrase is the value
-  // being matched.  For example, the DescribeTo() method of the Gt(7)
-  // matcher prints "is greater than 7".
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.  For
-  // example, if the description of this matcher is "is greater than
-  // 7", the negated description could be "is not greater than 7".
-  // You are not required to override this when implementing
-  // MatcherInterface, but it is highly advised so that your matcher
-  // can produce good error messages.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "not (";
-    DescribeTo(os);
-    *os << ")";
-  }
-};
-
-// The implementation of a matcher.
-template <typename T>
-class MatcherInterface : public MatcherDescriberInterface {
- public:
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener' if necessary (see the next paragraph), in
-  // the form of a non-restrictive relative clause ("which ...",
-  // "whose ...", etc) that describes x.  For example, the
-  // MatchAndExplain() method of the Pointee(...) matcher should
-  // generate an explanation like "which points to ...".
-  //
-  // Implementations of MatchAndExplain() should add an explanation of
-  // the match result *if and only if* they can provide additional
-  // information that's not already present (or not obvious) in the
-  // print-out of x and the matcher's description.  Whether the match
-  // succeeds is not a factor in deciding whether an explanation is
-  // needed, as sometimes the caller needs to print a failure message
-  // when the match succeeds (e.g. when the matcher is used inside
-  // Not()).
-  //
-  // For example, a "has at least 10 elements" matcher should explain
-  // what the actual element count is, regardless of the match result,
-  // as it is useful information to the reader; on the other hand, an
-  // "is empty" matcher probably only needs to explain what the actual
-  // size is when the match fails, as it's redundant to say that the
-  // size is 0 when the value is already known to be empty.
-  //
-  // You should override this method when defining a new matcher.
-  //
-  // It's the responsibility of the caller (Google Mock) to guarantee
-  // that 'listener' is not NULL.  This helps to simplify a matcher's
-  // implementation when it doesn't care about the performance, as it
-  // can talk to 'listener' without checking its validity first.
-  // However, in order to implement dummy listeners efficiently,
-  // listener->stream() may be NULL.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Inherits these methods from MatcherDescriberInterface:
-  //   virtual void DescribeTo(::std::ostream* os) const = 0;
-  //   virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-
-// A match result listener that stores the explanation in a string.
-class StringMatchResultListener : public MatchResultListener {
- public:
-  StringMatchResultListener() : MatchResultListener(&ss_) {}
-
-  // Returns the explanation accumulated so far.
-  internal::string str() const { return ss_.str(); }
-
-  // Clears the explanation accumulated so far.
-  void Clear() { ss_.str(""); }
-
- private:
-  ::std::stringstream ss_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
-};
-
-namespace internal {
-
-struct AnyEq {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a == b; }
-};
-struct AnyNe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a != b; }
-};
-struct AnyLt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a < b; }
-};
-struct AnyGt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a > b; }
-};
-struct AnyLe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a <= b; }
-};
-struct AnyGe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a >= b; }
-};
-
-// A match result listener that ignores the explanation.
-class DummyMatchResultListener : public MatchResultListener {
- public:
-  DummyMatchResultListener() : MatchResultListener(NULL) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
-};
-
-// A match result listener that forwards the explanation to a given
-// ostream.  The difference between this and MatchResultListener is
-// that the former is concrete.
-class StreamMatchResultListener : public MatchResultListener {
- public:
-  explicit StreamMatchResultListener(::std::ostream* os)
-      : MatchResultListener(os) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
-};
-
-// An internal class for implementing Matcher<T>, which will derive
-// from it.  We put functionalities common to all Matcher<T>
-// specializations here to avoid code duplication.
-template <typename T>
-class MatcherBase {
- public:
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    return impl_->MatchAndExplain(x, listener);
-  }
-
-  // Returns true iff this matcher matches x.
-  bool Matches(T x) const {
-    DummyMatchResultListener dummy;
-    return MatchAndExplain(x, &dummy);
-  }
-
-  // Describes this matcher to an ostream.
-  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
-
-  // Describes the negation of this matcher to an ostream.
-  void DescribeNegationTo(::std::ostream* os) const {
-    impl_->DescribeNegationTo(os);
-  }
-
-  // Explains why x matches, or doesn't match, the matcher.
-  void ExplainMatchResultTo(T x, ::std::ostream* os) const {
-    StreamMatchResultListener listener(os);
-    MatchAndExplain(x, &listener);
-  }
-
-  // Returns the describer for this matcher object; retains ownership
-  // of the describer, which is only guaranteed to be alive when
-  // this matcher object is alive.
-  const MatcherDescriberInterface* GetDescriber() const {
-    return impl_.get();
-  }
-
- protected:
-  MatcherBase() {}
-
-  // Constructs a matcher from its implementation.
-  explicit MatcherBase(const MatcherInterface<T>* impl)
-      : impl_(impl) {}
-
-  virtual ~MatcherBase() {}
-
- private:
-  // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
-  // interfaces.  The former dynamically allocates a chunk of memory
-  // to hold the reference count, while the latter tracks all
-  // references using a circular linked list without allocating
-  // memory.  It has been observed that linked_ptr performs better in
-  // typical scenarios.  However, shared_ptr can out-perform
-  // linked_ptr when there are many more uses of the copy constructor
-  // than the default constructor.
-  //
-  // If performance becomes a problem, we should see if using
-  // shared_ptr helps.
-  ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
-};
-
-}  // namespace internal
-
-// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
-// object that can check whether a value of type T matches.  The
-// implementation of Matcher<T> is just a linked_ptr to const
-// MatcherInterface<T>, so copying is fairly cheap.  Don't inherit
-// from Matcher!
-template <typename T>
-class Matcher : public internal::MatcherBase<T> {
- public:
-  // Constructs a null matcher.  Needed for storing Matcher objects in STL
-  // containers.  A default-constructed matcher is not yet initialized.  You
-  // cannot use it until a valid value has been assigned to it.
-  explicit Matcher() {}  // NOLINT
-
-  // Constructs a matcher from its implementation.
-  explicit Matcher(const MatcherInterface<T>* impl)
-      : internal::MatcherBase<T>(impl) {}
-
-  // Implicit constructor here allows people to write
-  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
-  Matcher(T value);  // NOLINT
-};
-
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a string
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const internal::string&>
-    : public internal::MatcherBase<const internal::string&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const internal::string&>* impl)
-      : internal::MatcherBase<const internal::string&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<internal::string>
-    : public internal::MatcherBase<internal::string> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<internal::string>* impl)
-      : internal::MatcherBase<internal::string>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-#if GTEST_HAS_STRING_PIECE_
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const StringPiece&>
-    : public internal::MatcherBase<const StringPiece&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
-      : internal::MatcherBase<const StringPiece&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass StringPieces directly.
-  Matcher(StringPiece s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<StringPiece>
-    : public internal::MatcherBase<StringPiece> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<StringPiece>* impl)
-      : internal::MatcherBase<StringPiece>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass StringPieces directly.
-  Matcher(StringPiece s);  // NOLINT
-};
-#endif  // GTEST_HAS_STRING_PIECE_
-
-// The PolymorphicMatcher class template makes it easy to implement a
-// polymorphic matcher (i.e. a matcher that can match values of more
-// than one type, e.g. Eq(n) and NotNull()).
-//
-// To define a polymorphic matcher, a user should provide an Impl
-// class that has a DescribeTo() method and a DescribeNegationTo()
-// method, and define a member function (or member function template)
-//
-//   bool MatchAndExplain(const Value& value,
-//                        MatchResultListener* listener) const;
-//
-// See the definition of NotNull() for a complete example.
-template <class Impl>
-class PolymorphicMatcher {
- public:
-  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
-
-  // Returns a mutable reference to the underlying matcher
-  // implementation object.
-  Impl& mutable_impl() { return impl_; }
-
-  // Returns an immutable reference to the underlying matcher
-  // implementation object.
-  const Impl& impl() const { return impl_; }
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new MonomorphicImpl<T>(impl_));
-  }
-
- private:
-  template <typename T>
-  class MonomorphicImpl : public MatcherInterface<T> {
-   public:
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      impl_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      impl_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return impl_.MatchAndExplain(x, listener);
-    }
-
-   private:
-    const Impl impl_;
-
-    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
-  };
-
-  Impl impl_;
-
-  GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
-};
-
-// Creates a matcher from its implementation.  This is easier to use
-// than the Matcher<T> constructor as it doesn't require you to
-// explicitly write the template argument, e.g.
-//
-//   MakeMatcher(foo);
-// vs
-//   Matcher<const string&>(foo);
-template <typename T>
-inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
-  return Matcher<T>(impl);
-}
-
-// Creates a polymorphic matcher from its implementation.  This is
-// easier to use than the PolymorphicMatcher<Impl> constructor as it
-// doesn't require you to explicitly write the template argument, e.g.
-//
-//   MakePolymorphicMatcher(foo);
-// vs
-//   PolymorphicMatcher<TypeOfFoo>(foo);
-template <class Impl>
-inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
-  return PolymorphicMatcher<Impl>(impl);
-}
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// The MatcherCastImpl class template is a helper for implementing
-// MatcherCast().  We need this helper in order to partially
-// specialize the implementation of MatcherCast() (C++ allows
-// class/struct templates to be partially specialized, but not
-// function templates.).
-
-// This general version is used when MatcherCast()'s argument is a
-// polymorphic matcher (i.e. something that can be converted to a
-// Matcher but is not one yet; for example, Eq(value)) or a value (for
-// example, "hello").
-template <typename T, typename M>
-class MatcherCastImpl {
- public:
-  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
-    // M can be a polymorhic matcher, in which case we want to use
-    // its conversion operator to create Matcher<T>.  Or it can be a value
-    // that should be passed to the Matcher<T>'s constructor.
-    //
-    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
-    // polymorphic matcher because it'll be ambiguous if T has an implicit
-    // constructor from M (this usually happens when T has an implicit
-    // constructor from any type).
-    //
-    // It won't work to unconditionally implict_cast
-    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
-    // a user-defined conversion from M to T if one exists (assuming M is
-    // a value).
-    return CastImpl(
-        polymorphic_matcher_or_value,
-        BooleanConstant<
-            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
-  }
-
- private:
-  static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
-    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
-    // matcher.  It must be a value then.  Use direct initialization to create
-    // a matcher.
-    return Matcher<T>(ImplicitCast_<T>(value));
-  }
-
-  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
-                             BooleanConstant<true>) {
-    // M is implicitly convertible to Matcher<T>, which means that either
-    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
-    // from M.  In both cases using the implicit conversion will produce a
-    // matcher.
-    //
-    // Even if T has an implicit constructor from M, it won't be called because
-    // creating Matcher<T> would require a chain of two user-defined conversions
-    // (first to create T from M and then to create Matcher<T> from T).
-    return polymorphic_matcher_or_value;
-  }
-};
-
-// This more specialized version is used when MatcherCast()'s argument
-// is already a Matcher.  This only compiles when type T can be
-// statically converted to type U.
-template <typename T, typename U>
-class MatcherCastImpl<T, Matcher<U> > {
- public:
-  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
-    return Matcher<T>(new Impl(source_matcher));
-  }
-
- private:
-  class Impl : public MatcherInterface<T> {
-   public:
-    explicit Impl(const Matcher<U>& source_matcher)
-        : source_matcher_(source_matcher) {}
-
-    // We delegate the matching logic to the source matcher.
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      source_matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      source_matcher_.DescribeNegationTo(os);
-    }
-
-   private:
-    const Matcher<U> source_matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-};
-
-// This even more specialized version is used for efficiently casting
-// a matcher to its own type.
-template <typename T>
-class MatcherCastImpl<T, Matcher<T> > {
- public:
-  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
-};
-
-}  // namespace internal
-
-// In order to be safe and clear, casting between different matcher
-// types is done explicitly via MatcherCast<T>(m), which takes a
-// matcher m and returns a Matcher<T>.  It compiles only when T can be
-// statically converted to the argument type of m.
-template <typename T, typename M>
-inline Matcher<T> MatcherCast(const M& matcher) {
-  return internal::MatcherCastImpl<T, M>::Cast(matcher);
-}
-
-// Implements SafeMatcherCast().
-//
-// We use an intermediate class to do the actual safe casting as Nokia's
-// Symbian compiler cannot decide between
-// template <T, M> ... (M) and
-// template <T, U> ... (const Matcher<U>&)
-// for function templates but can for member function templates.
-template <typename T>
-class SafeMatcherCastImpl {
- public:
-  // This overload handles polymorphic matchers and values only since
-  // monomorphic matchers are handled by the next one.
-  template <typename M>
-  static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
-    return internal::MatcherCastImpl<T, M>::Cast(polymorphic_matcher_or_value);
-  }
-
-  // This overload handles monomorphic matchers.
-  //
-  // In general, if type T can be implicitly converted to type U, we can
-  // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
-  // contravariant): just keep a copy of the original Matcher<U>, convert the
-  // argument from type T to U, and then pass it to the underlying Matcher<U>.
-  // The only exception is when U is a reference and T is not, as the
-  // underlying Matcher<U> may be interested in the argument's address, which
-  // is not preserved in the conversion from T to U.
-  template <typename U>
-  static inline Matcher<T> Cast(const Matcher<U>& matcher) {
-    // Enforce that T can be implicitly converted to U.
-    GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
-                          T_must_be_implicitly_convertible_to_U);
-    // Enforce that we are not converting a non-reference type T to a reference
-    // type U.
-    GTEST_COMPILE_ASSERT_(
-        internal::is_reference<T>::value || !internal::is_reference<U>::value,
-        cannot_convert_non_referentce_arg_to_reference);
-    // In case both T and U are arithmetic types, enforce that the
-    // conversion is not lossy.
-    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
-    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
-    const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
-    const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
-    GTEST_COMPILE_ASSERT_(
-        kTIsOther || kUIsOther ||
-        (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
-        conversion_of_arithmetic_types_must_be_lossless);
-    return MatcherCast<T>(matcher);
-  }
-};
-
-template <typename T, typename M>
-inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
-  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
-}
-
-// A<T>() returns a matcher that matches any value of type T.
-template <typename T>
-Matcher<T> A();
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// If the explanation is not empty, prints it to the ostream.
-inline void PrintIfNotEmpty(const internal::string& explanation,
-                            ::std::ostream* os) {
-  if (explanation != "" && os != NULL) {
-    *os << ", " << explanation;
-  }
-}
-
-// Returns true if the given type name is easy to read by a human.
-// This is used to decide whether printing the type of a value might
-// be helpful.
-inline bool IsReadableTypeName(const string& type_name) {
-  // We consider a type name readable if it's short or doesn't contain
-  // a template or function type.
-  return (type_name.length() <= 20 ||
-          type_name.find_first_of("<(") == string::npos);
-}
-
-// Matches the value against the given matcher, prints the value and explains
-// the match result to the listener. Returns the match result.
-// 'listener' must not be NULL.
-// Value cannot be passed by const reference, because some matchers take a
-// non-const argument.
-template <typename Value, typename T>
-bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
-                          MatchResultListener* listener) {
-  if (!listener->IsInterested()) {
-    // If the listener is not interested, we do not need to construct the
-    // inner explanation.
-    return matcher.Matches(value);
-  }
-
-  StringMatchResultListener inner_listener;
-  const bool match = matcher.MatchAndExplain(value, &inner_listener);
-
-  UniversalPrint(value, listener->stream());
-#if GTEST_HAS_RTTI
-  const string& type_name = GetTypeName<Value>();
-  if (IsReadableTypeName(type_name))
-    *listener->stream() << " (of type " << type_name << ")";
-#endif
-  PrintIfNotEmpty(inner_listener.str(), listener->stream());
-
-  return match;
-}
-
-// An internal helper class for doing compile-time loop on a tuple's
-// fields.
-template <size_t N>
-class TuplePrefix {
- public:
-  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
-  // iff the first N fields of matcher_tuple matches the first N
-  // fields of value_tuple, respectively.
-  template <typename MatcherTuple, typename ValueTuple>
-  static bool Matches(const MatcherTuple& matcher_tuple,
-                      const ValueTuple& value_tuple) {
-    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple)
-        && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
-  }
-
-  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
-  // describes failures in matching the first N fields of matchers
-  // against the first N fields of values.  If there is no failure,
-  // nothing will be streamed to os.
-  template <typename MatcherTuple, typename ValueTuple>
-  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
-                                     const ValueTuple& values,
-                                     ::std::ostream* os) {
-    // First, describes failures in the first N - 1 fields.
-    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
-
-    // Then describes the failure (if any) in the (N - 1)-th (0-based)
-    // field.
-    typename tuple_element<N - 1, MatcherTuple>::type matcher =
-        get<N - 1>(matchers);
-    typedef typename tuple_element<N - 1, ValueTuple>::type Value;
-    Value value = get<N - 1>(values);
-    StringMatchResultListener listener;
-    if (!matcher.MatchAndExplain(value, &listener)) {
-      // TODO(wan): include in the message the name of the parameter
-      // as used in MOCK_METHOD*() when possible.
-      *os << "  Expected arg #" << N - 1 << ": ";
-      get<N - 1>(matchers).DescribeTo(os);
-      *os << "\n           Actual: ";
-      // We remove the reference in type Value to prevent the
-      // universal printer from printing the address of value, which
-      // isn't interesting to the user most of the time.  The
-      // matcher's MatchAndExplain() method handles the case when
-      // the address is interesting.
-      internal::UniversalPrint(value, os);
-      PrintIfNotEmpty(listener.str(), os);
-      *os << "\n";
-    }
-  }
-};
-
-// The base case.
-template <>
-class TuplePrefix<0> {
- public:
-  template <typename MatcherTuple, typename ValueTuple>
-  static bool Matches(const MatcherTuple& /* matcher_tuple */,
-                      const ValueTuple& /* value_tuple */) {
-    return true;
-  }
-
-  template <typename MatcherTuple, typename ValueTuple>
-  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
-                                     const ValueTuple& /* values */,
-                                     ::std::ostream* /* os */) {}
-};
-
-// TupleMatches(matcher_tuple, value_tuple) returns true iff all
-// matchers in matcher_tuple match the corresponding fields in
-// value_tuple.  It is a compiler error if matcher_tuple and
-// value_tuple have different number of fields or incompatible field
-// types.
-template <typename MatcherTuple, typename ValueTuple>
-bool TupleMatches(const MatcherTuple& matcher_tuple,
-                  const ValueTuple& value_tuple) {
-  // Makes sure that matcher_tuple and value_tuple have the same
-  // number of fields.
-  GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
-                        tuple_size<ValueTuple>::value,
-                        matcher_and_value_have_different_numbers_of_fields);
-  return TuplePrefix<tuple_size<ValueTuple>::value>::
-      Matches(matcher_tuple, value_tuple);
-}
-
-// Describes failures in matching matchers against values.  If there
-// is no failure, nothing will be streamed to os.
-template <typename MatcherTuple, typename ValueTuple>
-void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
-                                const ValueTuple& values,
-                                ::std::ostream* os) {
-  TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
-      matchers, values, os);
-}
-
-// TransformTupleValues and its helper.
-//
-// TransformTupleValuesHelper hides the internal machinery that
-// TransformTupleValues uses to implement a tuple traversal.
-template <typename Tuple, typename Func, typename OutIter>
-class TransformTupleValuesHelper {
- private:
-  typedef ::testing::tuple_size<Tuple> TupleSize;
-
- public:
-  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
-  // Returns the final value of 'out' in case the caller needs it.
-  static OutIter Run(Func f, const Tuple& t, OutIter out) {
-    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
-  }
-
- private:
-  template <typename Tup, size_t kRemainingSize>
-  struct IterateOverTuple {
-    OutIter operator() (Func f, const Tup& t, OutIter out) const {
-      *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
-      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
-    }
-  };
-  template <typename Tup>
-  struct IterateOverTuple<Tup, 0> {
-    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
-      return out;
-    }
-  };
-};
-
-// Successively invokes 'f(element)' on each element of the tuple 't',
-// appending each result to the 'out' iterator. Returns the final value
-// of 'out'.
-template <typename Tuple, typename Func, typename OutIter>
-OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
-  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
-}
-
-// Implements A<T>().
-template <typename T>
-class AnyMatcherImpl : public MatcherInterface<T> {
- public:
-  virtual bool MatchAndExplain(
-      T /* x */, MatchResultListener* /* listener */) const { return true; }
-  virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    // This is mostly for completeness' safe, as it's not very useful
-    // to write Not(A<bool>()).  However we cannot completely rule out
-    // such a possibility, and it doesn't hurt to be prepared.
-    *os << "never matches";
-  }
-};
-
-// Implements _, a matcher that matches any value of any
-// type.  This is a polymorphic matcher, so we need a template type
-// conversion operator to make it appearing as a Matcher<T> for any
-// type T.
-class AnythingMatcher {
- public:
-  template <typename T>
-  operator Matcher<T>() const { return A<T>(); }
-};
-
-// Implements a matcher that compares a given value with a
-// pre-supplied value using one of the ==, <=, <, etc, operators.  The
-// two values being compared don't have to have the same type.
-//
-// The matcher defined here is polymorphic (for example, Eq(5) can be
-// used to match an int, a short, a double, etc).  Therefore we use
-// a template type conversion operator in the implementation.
-//
-// The following template definition assumes that the Rhs parameter is
-// a "bare" type (i.e. neither 'const T' nor 'T&').
-template <typename D, typename Rhs, typename Op>
-class ComparisonBase {
- public:
-  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
-  template <typename Lhs>
-  operator Matcher<Lhs>() const {
-    return MakeMatcher(new Impl<Lhs>(rhs_));
-  }
-
- private:
-  template <typename Lhs>
-  class Impl : public MatcherInterface<Lhs> {
-   public:
-    explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
-    virtual bool MatchAndExplain(
-        Lhs lhs, MatchResultListener* /* listener */) const {
-      return Op()(lhs, rhs_);
-    }
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << D::Desc() << " ";
-      UniversalPrint(rhs_, os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << D::NegatedDesc() <<  " ";
-      UniversalPrint(rhs_, os);
-    }
-   private:
-    Rhs rhs_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-  Rhs rhs_;
-  GTEST_DISALLOW_ASSIGN_(ComparisonBase);
-};
-
-template <typename Rhs>
-class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
- public:
-  explicit EqMatcher(const Rhs& rhs)
-      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
-  static const char* Desc() { return "is equal to"; }
-  static const char* NegatedDesc() { return "isn't equal to"; }
-};
-template <typename Rhs>
-class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
- public:
-  explicit NeMatcher(const Rhs& rhs)
-      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
-  static const char* Desc() { return "isn't equal to"; }
-  static const char* NegatedDesc() { return "is equal to"; }
-};
-template <typename Rhs>
-class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
- public:
-  explicit LtMatcher(const Rhs& rhs)
-      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
-  static const char* Desc() { return "is <"; }
-  static const char* NegatedDesc() { return "isn't <"; }
-};
-template <typename Rhs>
-class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
- public:
-  explicit GtMatcher(const Rhs& rhs)
-      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
-  static const char* Desc() { return "is >"; }
-  static const char* NegatedDesc() { return "isn't >"; }
-};
-template <typename Rhs>
-class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
- public:
-  explicit LeMatcher(const Rhs& rhs)
-      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
-  static const char* Desc() { return "is <="; }
-  static const char* NegatedDesc() { return "isn't <="; }
-};
-template <typename Rhs>
-class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
- public:
-  explicit GeMatcher(const Rhs& rhs)
-      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
-  static const char* Desc() { return "is >="; }
-  static const char* NegatedDesc() { return "isn't >="; }
-};
-
-// Implements the polymorphic IsNull() matcher, which matches any raw or smart
-// pointer that is NULL.
-class IsNullMatcher {
- public:
-  template <typename Pointer>
-  bool MatchAndExplain(const Pointer& p,
-                       MatchResultListener* /* listener */) const {
-#if GTEST_LANG_CXX11
-    return p == nullptr;
-#else  // GTEST_LANG_CXX11
-    return GetRawPointer(p) == NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-
-  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "isn't NULL";
-  }
-};
-
-// Implements the polymorphic NotNull() matcher, which matches any raw or smart
-// pointer that is not NULL.
-class NotNullMatcher {
- public:
-  template <typename Pointer>
-  bool MatchAndExplain(const Pointer& p,
-                       MatchResultListener* /* listener */) const {
-#if GTEST_LANG_CXX11
-    return p != nullptr;
-#else  // GTEST_LANG_CXX11
-    return GetRawPointer(p) != NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-
-  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is NULL";
-  }
-};
-
-// Ref(variable) matches any argument that is a reference to
-// 'variable'.  This matcher is polymorphic as it can match any
-// super type of the type of 'variable'.
-//
-// The RefMatcher template class implements Ref(variable).  It can
-// only be instantiated with a reference type.  This prevents a user
-// from mistakenly using Ref(x) to match a non-reference function
-// argument.  For example, the following will righteously cause a
-// compiler error:
-//
-//   int n;
-//   Matcher<int> m1 = Ref(n);   // This won't compile.
-//   Matcher<int&> m2 = Ref(n);  // This will compile.
-template <typename T>
-class RefMatcher;
-
-template <typename T>
-class RefMatcher<T&> {
-  // Google Mock is a generic framework and thus needs to support
-  // mocking any function types, including those that take non-const
-  // reference arguments.  Therefore the template parameter T (and
-  // Super below) can be instantiated to either a const type or a
-  // non-const type.
- public:
-  // RefMatcher() takes a T& instead of const T&, as we want the
-  // compiler to catch using Ref(const_value) as a matcher for a
-  // non-const reference.
-  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
-
-  template <typename Super>
-  operator Matcher<Super&>() const {
-    // By passing object_ (type T&) to Impl(), which expects a Super&,
-    // we make sure that Super is a super type of T.  In particular,
-    // this catches using Ref(const_value) as a matcher for a
-    // non-const reference, as you cannot implicitly convert a const
-    // reference to a non-const reference.
-    return MakeMatcher(new Impl<Super>(object_));
-  }
-
- private:
-  template <typename Super>
-  class Impl : public MatcherInterface<Super&> {
-   public:
-    explicit Impl(Super& x) : object_(x) {}  // NOLINT
-
-    // MatchAndExplain() takes a Super& (as opposed to const Super&)
-    // in order to match the interface MatcherInterface<Super&>.
-    virtual bool MatchAndExplain(
-        Super& x, MatchResultListener* listener) const {
-      *listener << "which is located @" << static_cast<const void*>(&x);
-      return &x == &object_;
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "references the variable ";
-      UniversalPrinter<Super&>::Print(object_, os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "does not reference the variable ";
-      UniversalPrinter<Super&>::Print(object_, os);
-    }
-
-   private:
-    const Super& object_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  T& object_;
-
-  GTEST_DISALLOW_ASSIGN_(RefMatcher);
-};
-
-// Polymorphic helper functions for narrow and wide string matchers.
-inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
-  return String::CaseInsensitiveCStringEquals(lhs, rhs);
-}
-
-inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
-                                         const wchar_t* rhs) {
-  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
-}
-
-// String comparison for narrow or wide strings that can have embedded NUL
-// characters.
-template <typename StringType>
-bool CaseInsensitiveStringEquals(const StringType& s1,
-                                 const StringType& s2) {
-  // Are the heads equal?
-  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
-    return false;
-  }
-
-  // Skip the equal heads.
-  const typename StringType::value_type nul = 0;
-  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
-
-  // Are we at the end of either s1 or s2?
-  if (i1 == StringType::npos || i2 == StringType::npos) {
-    return i1 == i2;
-  }
-
-  // Are the tails equal?
-  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
-}
-
-// String matchers.
-
-// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
-template <typename StringType>
-class StrEqualityMatcher {
- public:
-  StrEqualityMatcher(const StringType& str, bool expect_eq,
-                     bool case_sensitive)
-      : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    if (s == NULL) {
-      return !expect_eq_;
-    }
-    return MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    const bool eq = case_sensitive_ ? s2 == string_ :
-        CaseInsensitiveStringEquals(s2, string_);
-    return expect_eq_ == eq;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    DescribeToHelper(expect_eq_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    DescribeToHelper(!expect_eq_, os);
-  }
-
- private:
-  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
-    *os << (expect_eq ? "is " : "isn't ");
-    *os << "equal to ";
-    if (!case_sensitive_) {
-      *os << "(ignoring case) ";
-    }
-    UniversalPrint(string_, os);
-  }
-
-  const StringType string_;
-  const bool expect_eq_;
-  const bool case_sensitive_;
-
-  GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
-};
-
-// Implements the polymorphic HasSubstr(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class HasSubstrMatcher {
- public:
-  explicit HasSubstrMatcher(const StringType& substring)
-      : substring_(substring) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.find(substring_) != StringType::npos;
-  }
-
-  // Describes what this matcher matches.
-  void DescribeTo(::std::ostream* os) const {
-    *os << "has substring ";
-    UniversalPrint(substring_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "has no substring ";
-    UniversalPrint(substring_, os);
-  }
-
- private:
-  const StringType substring_;
-
-  GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
-};
-
-// Implements the polymorphic StartsWith(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class StartsWithMatcher {
- public:
-  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
-  }
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.length() >= prefix_.length() &&
-        s2.substr(0, prefix_.length()) == prefix_;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "starts with ";
-    UniversalPrint(prefix_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't start with ";
-    UniversalPrint(prefix_, os);
-  }
-
- private:
-  const StringType prefix_;
-
-  GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
-};
-
-// Implements the polymorphic EndsWith(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class EndsWithMatcher {
- public:
-  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.length() >= suffix_.length() &&
-        s2.substr(s2.length() - suffix_.length()) == suffix_;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "ends with ";
-    UniversalPrint(suffix_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't end with ";
-    UniversalPrint(suffix_, os);
-  }
-
- private:
-  const StringType suffix_;
-
-  GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
-};
-
-// Implements polymorphic matchers MatchesRegex(regex) and
-// ContainsRegex(regex), which can be used as a Matcher<T> as long as
-// T can be converted to a string.
-class MatchesRegexMatcher {
- public:
-  MatchesRegexMatcher(const RE* regex, bool full_match)
-      : regex_(regex), full_match_(full_match) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(internal::string(s), listener);
-  }
-
-  // Matches anything that can convert to internal::string.
-  //
-  // This is a template, not just a plain function with const internal::string&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <class MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const internal::string& s2(s);
-    return full_match_ ? RE::FullMatch(s2, *regex_) :
-        RE::PartialMatch(s2, *regex_);
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << (full_match_ ? "matches" : "contains")
-        << " regular expression ";
-    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't " << (full_match_ ? "match" : "contain")
-        << " regular expression ";
-    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
-  }
-
- private:
-  const internal::linked_ptr<const RE> regex_;
-  const bool full_match_;
-
-  GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
-};
-
-// Implements a matcher that compares the two fields of a 2-tuple
-// using one of the ==, <=, <, etc, operators.  The two fields being
-// compared don't have to have the same type.
-//
-// The matcher defined here is polymorphic (for example, Eq() can be
-// used to match a tuple<int, short>, a tuple<const long&, double>,
-// etc).  Therefore we use a template type conversion operator in the
-// implementation.
-template <typename D, typename Op>
-class PairMatchBase {
- public:
-  template <typename T1, typename T2>
-  operator Matcher< ::testing::tuple<T1, T2> >() const {
-    return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
-  }
-  template <typename T1, typename T2>
-  operator Matcher<const ::testing::tuple<T1, T2>&>() const {
-    return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
-  }
-
- private:
-  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
-    return os << D::Desc();
-  }
-
-  template <typename Tuple>
-  class Impl : public MatcherInterface<Tuple> {
-   public:
-    virtual bool MatchAndExplain(
-        Tuple args,
-        MatchResultListener* /* listener */) const {
-      return Op()(::testing::get<0>(args), ::testing::get<1>(args));
-    }
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "are " << GetDesc;
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "aren't " << GetDesc;
-    }
-  };
-};
-
-class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
- public:
-  static const char* Desc() { return "an equal pair"; }
-};
-class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
- public:
-  static const char* Desc() { return "an unequal pair"; }
-};
-class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
- public:
-  static const char* Desc() { return "a pair where the first < the second"; }
-};
-class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
- public:
-  static const char* Desc() { return "a pair where the first > the second"; }
-};
-class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
- public:
-  static const char* Desc() { return "a pair where the first <= the second"; }
-};
-class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
- public:
-  static const char* Desc() { return "a pair where the first >= the second"; }
-};
-
-// Implements the Not(...) matcher for a particular argument type T.
-// We do not nest it inside the NotMatcher class template, as that
-// will prevent different instantiations of NotMatcher from sharing
-// the same NotMatcherImpl<T> class.
-template <typename T>
-class NotMatcherImpl : public MatcherInterface<T> {
- public:
-  explicit NotMatcherImpl(const Matcher<T>& matcher)
-      : matcher_(matcher) {}
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    return !matcher_.MatchAndExplain(x, listener);
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    matcher_.DescribeNegationTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    matcher_.DescribeTo(os);
-  }
-
- private:
-  const Matcher<T> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
-};
-
-// Implements the Not(m) matcher, which matches a value that doesn't
-// match matcher m.
-template <typename InnerMatcher>
-class NotMatcher {
- public:
-  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
-
-  // This template type conversion operator allows Not(m) to be used
-  // to match any type m can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
-  }
-
- private:
-  InnerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(NotMatcher);
-};
-
-// Implements the AllOf(m1, m2) matcher for a particular argument type
-// T. We do not nest it inside the BothOfMatcher class template, as
-// that will prevent different instantiations of BothOfMatcher from
-// sharing the same BothOfMatcherImpl<T> class.
-template <typename T>
-class BothOfMatcherImpl : public MatcherInterface<T> {
- public:
-  BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeTo(os);
-    *os << ") and (";
-    matcher2_.DescribeTo(os);
-    *os << ")";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeNegationTo(os);
-    *os << ") or (";
-    matcher2_.DescribeNegationTo(os);
-    *os << ")";
-  }
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    // If either matcher1_ or matcher2_ doesn't match x, we only need
-    // to explain why one of them fails.
-    StringMatchResultListener listener1;
-    if (!matcher1_.MatchAndExplain(x, &listener1)) {
-      *listener << listener1.str();
-      return false;
-    }
-
-    StringMatchResultListener listener2;
-    if (!matcher2_.MatchAndExplain(x, &listener2)) {
-      *listener << listener2.str();
-      return false;
-    }
-
-    // Otherwise we need to explain why *both* of them match.
-    const internal::string s1 = listener1.str();
-    const internal::string s2 = listener2.str();
-
-    if (s1 == "") {
-      *listener << s2;
-    } else {
-      *listener << s1;
-      if (s2 != "") {
-        *listener << ", and " << s2;
-      }
-    }
-    return true;
-  }
-
- private:
-  const Matcher<T> matcher1_;
-  const Matcher<T> matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
-};
-
-#if GTEST_LANG_CXX11
-// MatcherList provides mechanisms for storing a variable number of matchers in
-// a list structure (ListType) and creating a combining matcher from such a
-// list.
-// The template is defined recursively using the following template paramters:
-//   * kSize is the length of the MatcherList.
-//   * Head is the type of the first matcher of the list.
-//   * Tail denotes the types of the remaining matchers of the list.
-template <int kSize, typename Head, typename... Tail>
-struct MatcherList {
-  typedef MatcherList<kSize - 1, Tail...> MatcherListTail;
-  typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType;
-
-  // BuildList stores variadic type values in a nested pair structure.
-  // Example:
-  // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return
-  // the corresponding result of type pair<int, pair<string, float>>.
-  static ListType BuildList(const Head& matcher, const Tail&... tail) {
-    return ListType(matcher, MatcherListTail::BuildList(tail...));
-  }
-
-  // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
-  // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
-  // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a
-  // constructor taking two Matcher<T>s as input.
-  template <typename T, template <typename /* T */> class CombiningMatcher>
-  static Matcher<T> CreateMatcher(const ListType& matchers) {
-    return Matcher<T>(new CombiningMatcher<T>(
-        SafeMatcherCast<T>(matchers.first),
-        MatcherListTail::template CreateMatcher<T, CombiningMatcher>(
-            matchers.second)));
-  }
-};
-
-// The following defines the base case for the recursive definition of
-// MatcherList.
-template <typename Matcher1, typename Matcher2>
-struct MatcherList<2, Matcher1, Matcher2> {
-  typedef ::std::pair<Matcher1, Matcher2> ListType;
-
-  static ListType BuildList(const Matcher1& matcher1,
-                            const Matcher2& matcher2) {
-    return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2);
-  }
-
-  template <typename T, template <typename /* T */> class CombiningMatcher>
-  static Matcher<T> CreateMatcher(const ListType& matchers) {
-    return Matcher<T>(new CombiningMatcher<T>(
-        SafeMatcherCast<T>(matchers.first),
-        SafeMatcherCast<T>(matchers.second)));
-  }
-};
-
-// VariadicMatcher is used for the variadic implementation of
-// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
-// CombiningMatcher<T> is used to recursively combine the provided matchers
-// (of type Args...).
-template <template <typename T> class CombiningMatcher, typename... Args>
-class VariadicMatcher {
- public:
-  VariadicMatcher(const Args&... matchers)  // NOLINT
-      : matchers_(MatcherListType::BuildList(matchers...)) {}
-
-  // This template type conversion operator allows an
-  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
-  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return MatcherListType::template CreateMatcher<T, CombiningMatcher>(
-        matchers_);
-  }
-
- private:
-  typedef MatcherList<sizeof...(Args), Args...> MatcherListType;
-
-  const typename MatcherListType::ListType matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
-};
-
-template <typename... Args>
-using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>;
-
-#endif  // GTEST_LANG_CXX11
-
-// Used for implementing the AllOf(m_1, ..., m_n) matcher, which
-// matches a value that matches all of the matchers m_1, ..., and m_n.
-template <typename Matcher1, typename Matcher2>
-class BothOfMatcher {
- public:
-  BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  // This template type conversion operator allows a
-  // BothOfMatcher<Matcher1, Matcher2> object to match any type that
-  // both Matcher1 and Matcher2 can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
-                                               SafeMatcherCast<T>(matcher2_)));
-  }
-
- private:
-  Matcher1 matcher1_;
-  Matcher2 matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
-};
-
-// Implements the AnyOf(m1, m2) matcher for a particular argument type
-// T.  We do not nest it inside the AnyOfMatcher class template, as
-// that will prevent different instantiations of AnyOfMatcher from
-// sharing the same EitherOfMatcherImpl<T> class.
-template <typename T>
-class EitherOfMatcherImpl : public MatcherInterface<T> {
- public:
-  EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeTo(os);
-    *os << ") or (";
-    matcher2_.DescribeTo(os);
-    *os << ")";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeNegationTo(os);
-    *os << ") and (";
-    matcher2_.DescribeNegationTo(os);
-    *os << ")";
-  }
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    // If either matcher1_ or matcher2_ matches x, we just need to
-    // explain why *one* of them matches.
-    StringMatchResultListener listener1;
-    if (matcher1_.MatchAndExplain(x, &listener1)) {
-      *listener << listener1.str();
-      return true;
-    }
-
-    StringMatchResultListener listener2;
-    if (matcher2_.MatchAndExplain(x, &listener2)) {
-      *listener << listener2.str();
-      return true;
-    }
-
-    // Otherwise we need to explain why *both* of them fail.
-    const internal::string s1 = listener1.str();
-    const internal::string s2 = listener2.str();
-
-    if (s1 == "") {
-      *listener << s2;
-    } else {
-      *listener << s1;
-      if (s2 != "") {
-        *listener << ", and " << s2;
-      }
-    }
-    return false;
-  }
-
- private:
-  const Matcher<T> matcher1_;
-  const Matcher<T> matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
-};
-
-#if GTEST_LANG_CXX11
-// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
-template <typename... Args>
-using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>;
-
-#endif  // GTEST_LANG_CXX11
-
-// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
-// matches a value that matches at least one of the matchers m_1, ...,
-// and m_n.
-template <typename Matcher1, typename Matcher2>
-class EitherOfMatcher {
- public:
-  EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  // This template type conversion operator allows a
-  // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
-  // both Matcher1 and Matcher2 can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new EitherOfMatcherImpl<T>(
-        SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
-  }
-
- private:
-  Matcher1 matcher1_;
-  Matcher2 matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
-};
-
-// Used for implementing Truly(pred), which turns a predicate into a
-// matcher.
-template <typename Predicate>
-class TrulyMatcher {
- public:
-  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
-
-  // This method template allows Truly(pred) to be used as a matcher
-  // for type T where T is the argument type of predicate 'pred'.  The
-  // argument is passed by reference as the predicate may be
-  // interested in the address of the argument.
-  template <typename T>
-  bool MatchAndExplain(T& x,  // NOLINT
-                       MatchResultListener* /* listener */) const {
-    // Without the if-statement, MSVC sometimes warns about converting
-    // a value to bool (warning 4800).
-    //
-    // We cannot write 'return !!predicate_(x);' as that doesn't work
-    // when predicate_(x) returns a class convertible to bool but
-    // having no operator!().
-    if (predicate_(x))
-      return true;
-    return false;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "satisfies the given predicate";
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't satisfy the given predicate";
-  }
-
- private:
-  Predicate predicate_;
-
-  GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
-};
-
-// Used for implementing Matches(matcher), which turns a matcher into
-// a predicate.
-template <typename M>
-class MatcherAsPredicate {
- public:
-  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
-
-  // This template operator() allows Matches(m) to be used as a
-  // predicate on type T where m is a matcher on type T.
-  //
-  // The argument x is passed by reference instead of by value, as
-  // some matcher may be interested in its address (e.g. as in
-  // Matches(Ref(n))(x)).
-  template <typename T>
-  bool operator()(const T& x) const {
-    // We let matcher_ commit to a particular type here instead of
-    // when the MatcherAsPredicate object was constructed.  This
-    // allows us to write Matches(m) where m is a polymorphic matcher
-    // (e.g. Eq(5)).
-    //
-    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
-    // compile when matcher_ has type Matcher<const T&>; if we write
-    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
-    // when matcher_ has type Matcher<T>; if we just write
-    // matcher_.Matches(x), it won't compile when matcher_ is
-    // polymorphic, e.g. Eq(5).
-    //
-    // MatcherCast<const T&>() is necessary for making the code work
-    // in all of the above situations.
-    return MatcherCast<const T&>(matcher_).Matches(x);
-  }
-
- private:
-  M matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
-};
-
-// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
-// argument M must be a type that can be converted to a matcher.
-template <typename M>
-class PredicateFormatterFromMatcher {
- public:
-  explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
-
-  // This template () operator allows a PredicateFormatterFromMatcher
-  // object to act as a predicate-formatter suitable for using with
-  // Google Test's EXPECT_PRED_FORMAT1() macro.
-  template <typename T>
-  AssertionResult operator()(const char* value_text, const T& x) const {
-    // We convert matcher_ to a Matcher<const T&> *now* instead of
-    // when the PredicateFormatterFromMatcher object was constructed,
-    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
-    // know which type to instantiate it to until we actually see the
-    // type of x here.
-    //
-    // We write SafeMatcherCast<const T&>(matcher_) instead of
-    // Matcher<const T&>(matcher_), as the latter won't compile when
-    // matcher_ has type Matcher<T> (e.g. An<int>()).
-    // We don't write MatcherCast<const T&> either, as that allows
-    // potentially unsafe downcasting of the matcher argument.
-    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
-    StringMatchResultListener listener;
-    if (MatchPrintAndExplain(x, matcher, &listener))
-      return AssertionSuccess();
-
-    ::std::stringstream ss;
-    ss << "Value of: " << value_text << "\n"
-       << "Expected: ";
-    matcher.DescribeTo(&ss);
-    ss << "\n  Actual: " << listener.str();
-    return AssertionFailure() << ss.str();
-  }
-
- private:
-  const M matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
-};
-
-// A helper function for converting a matcher to a predicate-formatter
-// without the user needing to explicitly write the type.  This is
-// used for implementing ASSERT_THAT() and EXPECT_THAT().
-// Implementation detail: 'matcher' is received by-value to force decaying.
-template <typename M>
-inline PredicateFormatterFromMatcher<M>
-MakePredicateFormatterFromMatcher(M matcher) {
-  return PredicateFormatterFromMatcher<M>(internal::move(matcher));
-}
-
-// Implements the polymorphic floating point equality matcher, which matches
-// two float values using ULP-based approximation or, optionally, a
-// user-specified epsilon.  The template is meant to be instantiated with
-// FloatType being either float or double.
-template <typename FloatType>
-class FloatingEqMatcher {
- public:
-  // Constructor for FloatingEqMatcher.
-  // The matcher's input will be compared with expected.  The matcher treats two
-  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
-  // equality comparisons between NANs will always return false.  We specify a
-  // negative max_abs_error_ term to indicate that ULP-based approximation will
-  // be used for comparison.
-  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
-    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
-  }
-
-  // Constructor that supports a user-specified max_abs_error that will be used
-  // for comparison instead of ULP-based approximation.  The max absolute
-  // should be non-negative.
-  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
-                    FloatType max_abs_error)
-      : expected_(expected),
-        nan_eq_nan_(nan_eq_nan),
-        max_abs_error_(max_abs_error) {
-    GTEST_CHECK_(max_abs_error >= 0)
-        << ", where max_abs_error is" << max_abs_error;
-  }
-
-  // Implements floating point equality matcher as a Matcher<T>.
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
-        : expected_(expected),
-          nan_eq_nan_(nan_eq_nan),
-          max_abs_error_(max_abs_error) {}
-
-    virtual bool MatchAndExplain(T value,
-                                 MatchResultListener* listener) const {
-      const FloatingPoint<FloatType> actual(value), expected(expected_);
-
-      // Compares NaNs first, if nan_eq_nan_ is true.
-      if (actual.is_nan() || expected.is_nan()) {
-        if (actual.is_nan() && expected.is_nan()) {
-          return nan_eq_nan_;
-        }
-        // One is nan; the other is not nan.
-        return false;
-      }
-      if (HasMaxAbsError()) {
-        // We perform an equality check so that inf will match inf, regardless
-        // of error bounds.  If the result of value - expected_ would result in
-        // overflow or if either value is inf, the default result is infinity,
-        // which should only match if max_abs_error_ is also infinity.
-        if (value == expected_) {
-          return true;
-        }
-
-        const FloatType diff = value - expected_;
-        if (fabs(diff) <= max_abs_error_) {
-          return true;
-        }
-
-        if (listener->IsInterested()) {
-          *listener << "which is " << diff << " from " << expected_;
-        }
-        return false;
-      } else {
-        return actual.AlmostEquals(expected);
-      }
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      // os->precision() returns the previously set precision, which we
-      // store to restore the ostream to its original configuration
-      // after outputting.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
-      if (FloatingPoint<FloatType>(expected_).is_nan()) {
-        if (nan_eq_nan_) {
-          *os << "is NaN";
-        } else {
-          *os << "never matches";
-        }
-      } else {
-        *os << "is approximately " << expected_;
-        if (HasMaxAbsError()) {
-          *os << " (absolute error <= " << max_abs_error_ << ")";
-        }
-      }
-      os->precision(old_precision);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      // As before, get original precision.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
-      if (FloatingPoint<FloatType>(expected_).is_nan()) {
-        if (nan_eq_nan_) {
-          *os << "isn't NaN";
-        } else {
-          *os << "is anything";
-        }
-      } else {
-        *os << "isn't approximately " << expected_;
-        if (HasMaxAbsError()) {
-          *os << " (absolute error > " << max_abs_error_ << ")";
-        }
-      }
-      // Restore original precision.
-      os->precision(old_precision);
-    }
-
-   private:
-    bool HasMaxAbsError() const {
-      return max_abs_error_ >= 0;
-    }
-
-    const FloatType expected_;
-    const bool nan_eq_nan_;
-    // max_abs_error will be used for value comparison when >= 0.
-    const FloatType max_abs_error_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  // The following 3 type conversion operators allow FloatEq(expected) and
-  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
-  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
-  // (While Google's C++ coding style doesn't allow arguments passed
-  // by non-const reference, we may see them in code not conforming to
-  // the style.  Therefore Google Mock needs to support them.)
-  operator Matcher<FloatType>() const {
-    return MakeMatcher(
-        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
-  operator Matcher<const FloatType&>() const {
-    return MakeMatcher(
-        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
-  operator Matcher<FloatType&>() const {
-    return MakeMatcher(
-        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
- private:
-  const FloatType expected_;
-  const bool nan_eq_nan_;
-  // max_abs_error will be used for value comparison when >= 0.
-  const FloatType max_abs_error_;
-
-  GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
-};
-
-// Implements the Pointee(m) matcher for matching a pointer whose
-// pointee matches matcher m.  The pointer can be either raw or smart.
-template <typename InnerMatcher>
-class PointeeMatcher {
- public:
-  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
-
-  // This type conversion operator template allows Pointee(m) to be
-  // used as a matcher for any pointer type whose pointee type is
-  // compatible with the inner matcher, where type Pointer can be
-  // either a raw pointer or a smart pointer.
-  //
-  // The reason we do this instead of relying on
-  // MakePolymorphicMatcher() is that the latter is not flexible
-  // enough for implementing the DescribeTo() method of Pointee().
-  template <typename Pointer>
-  operator Matcher<Pointer>() const {
-    return MakeMatcher(new Impl<Pointer>(matcher_));
-  }
-
- private:
-  // The monomorphic implementation that works for a particular pointer type.
-  template <typename Pointer>
-  class Impl : public MatcherInterface<Pointer> {
-   public:
-    typedef typename PointeeOf<GTEST_REMOVE_CONST_(  // NOLINT
-        GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
-
-    explicit Impl(const InnerMatcher& matcher)
-        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "points to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "does not point to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual bool MatchAndExplain(Pointer pointer,
-                                 MatchResultListener* listener) const {
-      if (GetRawPointer(pointer) == NULL)
-        return false;
-
-      *listener << "which points to ";
-      return MatchPrintAndExplain(*pointer, matcher_, listener);
-    }
-
-   private:
-    const Matcher<const Pointee&> matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const InnerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
-};
-
-// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
-// reference that matches inner_matcher when dynamic_cast<T> is applied.
-// The result of dynamic_cast<To> is forwarded to the inner matcher.
-// If To is a pointer and the cast fails, the inner matcher will receive NULL.
-// If To is a reference and the cast fails, this matcher returns false
-// immediately.
-template <typename To>
-class WhenDynamicCastToMatcherBase {
- public:
-  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
-      : matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    GetCastTypeDescription(os);
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    GetCastTypeDescription(os);
-    matcher_.DescribeNegationTo(os);
-  }
-
- protected:
-  const Matcher<To> matcher_;
-
-  static string GetToName() {
-#if GTEST_HAS_RTTI
-    return GetTypeName<To>();
-#else  // GTEST_HAS_RTTI
-    return "the target type";
-#endif  // GTEST_HAS_RTTI
-  }
-
- private:
-  static void GetCastTypeDescription(::std::ostream* os) {
-    *os << "when dynamic_cast to " << GetToName() << ", ";
-  }
-
-  GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase);
-};
-
-// Primary template.
-// To is a pointer. Cast and forward the result.
-template <typename To>
-class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
- public:
-  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
-      : WhenDynamicCastToMatcherBase<To>(matcher) {}
-
-  template <typename From>
-  bool MatchAndExplain(From from, MatchResultListener* listener) const {
-    // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail?
-    To to = dynamic_cast<To>(from);
-    return MatchPrintAndExplain(to, this->matcher_, listener);
-  }
-};
-
-// Specialize for references.
-// In this case we return false if the dynamic_cast fails.
-template <typename To>
-class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
- public:
-  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
-      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
-
-  template <typename From>
-  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
-    // We don't want an std::bad_cast here, so do the cast with pointers.
-    To* to = dynamic_cast<To*>(&from);
-    if (to == NULL) {
-      *listener << "which cannot be dynamic_cast to " << this->GetToName();
-      return false;
-    }
-    return MatchPrintAndExplain(*to, this->matcher_, listener);
-  }
-};
-
-// Implements the Field() matcher for matching a field (i.e. member
-// variable) of an object.
-template <typename Class, typename FieldType>
-class FieldMatcher {
- public:
-  FieldMatcher(FieldType Class::*field,
-               const Matcher<const FieldType&>& matcher)
-      : field_(field), matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "is an object whose given field ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object whose given field ";
-    matcher_.DescribeNegationTo(os);
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
-    return MatchAndExplainImpl(
-        typename ::testing::internal::
-            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
-        value, listener);
-  }
-
- private:
-  // The first argument of MatchAndExplainImpl() is needed to help
-  // Symbian's C++ compiler choose which overload to use.  Its type is
-  // true_type iff the Field() matcher is used to match a pointer.
-  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
-                           MatchResultListener* listener) const {
-    *listener << "whose given field is ";
-    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
-  }
-
-  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
-                           MatchResultListener* listener) const {
-    if (p == NULL)
-      return false;
-
-    *listener << "which points to an object ";
-    // Since *p has a field, it must be a class/struct/union type and
-    // thus cannot be a pointer.  Therefore we pass false_type() as
-    // the first argument.
-    return MatchAndExplainImpl(false_type(), *p, listener);
-  }
-
-  const FieldType Class::*field_;
-  const Matcher<const FieldType&> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(FieldMatcher);
-};
-
-// Implements the Property() matcher for matching a property
-// (i.e. return value of a getter method) of an object.
-template <typename Class, typename PropertyType>
-class PropertyMatcher {
- public:
-  // The property may have a reference type, so 'const PropertyType&'
-  // may cause double references and fail to compile.  That's why we
-  // need GTEST_REFERENCE_TO_CONST, which works regardless of
-  // PropertyType being a reference or not.
-  typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
-
-  PropertyMatcher(PropertyType (Class::*property)() const,
-                  const Matcher<RefToConstProperty>& matcher)
-      : property_(property), matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "is an object whose given property ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object whose given property ";
-    matcher_.DescribeNegationTo(os);
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
-    return MatchAndExplainImpl(
-        typename ::testing::internal::
-            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
-        value, listener);
-  }
-
- private:
-  // The first argument of MatchAndExplainImpl() is needed to help
-  // Symbian's C++ compiler choose which overload to use.  Its type is
-  // true_type iff the Property() matcher is used to match a pointer.
-  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
-                           MatchResultListener* listener) const {
-    *listener << "whose given property is ";
-    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
-    // which takes a non-const reference as argument.
-#if defined(_PREFAST_ ) && _MSC_VER == 1800
-    // Workaround bug in VC++ 2013's /analyze parser.
-    // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
-    posix::Abort();  // To make sure it is never run.
-    return false;
-#else
-    RefToConstProperty result = (obj.*property_)();
-    return MatchPrintAndExplain(result, matcher_, listener);
-#endif
-  }
-
-  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
-                           MatchResultListener* listener) const {
-    if (p == NULL)
-      return false;
-
-    *listener << "which points to an object ";
-    // Since *p has a property method, it must be a class/struct/union
-    // type and thus cannot be a pointer.  Therefore we pass
-    // false_type() as the first argument.
-    return MatchAndExplainImpl(false_type(), *p, listener);
-  }
-
-  PropertyType (Class::*property_)() const;
-  const Matcher<RefToConstProperty> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
-};
-
-// Type traits specifying various features of different functors for ResultOf.
-// The default template specifies features for functor objects.
-// Functor classes have to typedef argument_type and result_type
-// to be compatible with ResultOf.
-template <typename Functor>
-struct CallableTraits {
-  typedef typename Functor::result_type ResultType;
-  typedef Functor StorageType;
-
-  static void CheckIsValid(Functor /* functor */) {}
-  template <typename T>
-  static ResultType Invoke(Functor f, T arg) { return f(arg); }
-};
-
-// Specialization for function pointers.
-template <typename ArgType, typename ResType>
-struct CallableTraits<ResType(*)(ArgType)> {
-  typedef ResType ResultType;
-  typedef ResType(*StorageType)(ArgType);
-
-  static void CheckIsValid(ResType(*f)(ArgType)) {
-    GTEST_CHECK_(f != NULL)
-        << "NULL function pointer is passed into ResultOf().";
-  }
-  template <typename T>
-  static ResType Invoke(ResType(*f)(ArgType), T arg) {
-    return (*f)(arg);
-  }
-};
-
-// Implements the ResultOf() matcher for matching a return value of a
-// unary function of an object.
-template <typename Callable>
-class ResultOfMatcher {
- public:
-  typedef typename CallableTraits<Callable>::ResultType ResultType;
-
-  ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher)
-      : callable_(callable), matcher_(matcher) {
-    CallableTraits<Callable>::CheckIsValid(callable_);
-  }
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new Impl<T>(callable_, matcher_));
-  }
-
- private:
-  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
-
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
-        : callable_(callable), matcher_(matcher) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "is mapped by the given callable to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "is mapped by the given callable to a value that ";
-      matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(T obj, MatchResultListener* listener) const {
-      *listener << "which is mapped by the given callable to ";
-      // Cannot pass the return value (for example, int) to
-      // MatchPrintAndExplain, which takes a non-const reference as argument.
-      ResultType result =
-          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
-      return MatchPrintAndExplain(result, matcher_, listener);
-    }
-
-   private:
-    // Functors often define operator() as non-const method even though
-    // they are actualy stateless. But we need to use them even when
-    // 'this' is a const pointer. It's the user's responsibility not to
-    // use stateful callables with ResultOf(), which does't guarantee
-    // how many times the callable will be invoked.
-    mutable CallableStorageType callable_;
-    const Matcher<ResultType> matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };  // class Impl
-
-  const CallableStorageType callable_;
-  const Matcher<ResultType> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
-};
-
-// Implements a matcher that checks the size of an STL-style container.
-template <typename SizeMatcher>
-class SizeIsMatcher {
- public:
-  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
-       : size_matcher_(size_matcher) {
-  }
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new Impl<Container>(size_matcher_));
-  }
-
-  template <typename Container>
-  class Impl : public MatcherInterface<Container> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
-    typedef typename ContainerView::type::size_type SizeType;
-    explicit Impl(const SizeMatcher& size_matcher)
-        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "size ";
-      size_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "size ";
-      size_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(Container container,
-                                 MatchResultListener* listener) const {
-      SizeType size = container.size();
-      StringMatchResultListener size_listener;
-      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
-      *listener
-          << "whose size " << size << (result ? " matches" : " doesn't match");
-      PrintIfNotEmpty(size_listener.str(), listener->stream());
-      return result;
-    }
-
-   private:
-    const Matcher<SizeType> size_matcher_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const SizeMatcher size_matcher_;
-  GTEST_DISALLOW_ASSIGN_(SizeIsMatcher);
-};
-
-// Implements a matcher that checks the begin()..end() distance of an STL-style
-// container.
-template <typename DistanceMatcher>
-class BeginEndDistanceIsMatcher {
- public:
-  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
-      : distance_matcher_(distance_matcher) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new Impl<Container>(distance_matcher_));
-  }
-
-  template <typename Container>
-  class Impl : public MatcherInterface<Container> {
-   public:
-    typedef internal::StlContainerView<
-        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
-    typedef typename std::iterator_traits<
-        typename ContainerView::type::const_iterator>::difference_type
-        DistanceType;
-    explicit Impl(const DistanceMatcher& distance_matcher)
-        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "distance between begin() and end() ";
-      distance_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "distance between begin() and end() ";
-      distance_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(Container container,
-                                 MatchResultListener* listener) const {
-#if GTEST_HAS_STD_BEGIN_AND_END_
-      using std::begin;
-      using std::end;
-      DistanceType distance = std::distance(begin(container), end(container));
-#else
-      DistanceType distance = std::distance(container.begin(), container.end());
-#endif
-      StringMatchResultListener distance_listener;
-      const bool result =
-          distance_matcher_.MatchAndExplain(distance, &distance_listener);
-      *listener << "whose distance between begin() and end() " << distance
-                << (result ? " matches" : " doesn't match");
-      PrintIfNotEmpty(distance_listener.str(), listener->stream());
-      return result;
-    }
-
-   private:
-    const Matcher<DistanceType> distance_matcher_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const DistanceMatcher distance_matcher_;
-  GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher);
-};
-
-// Implements an equality matcher for any STL-style container whose elements
-// support ==. This matcher is like Eq(), but its failure explanations provide
-// more detailed information that is useful when the container is used as a set.
-// The failure message reports elements that are in one of the operands but not
-// the other. The failure messages do not report duplicate or out-of-order
-// elements in the containers (which don't properly matter to sets, but can
-// occur if the containers are vectors or lists, for example).
-//
-// Uses the container's const_iterator, value_type, operator ==,
-// begin(), and end().
-template <typename Container>
-class ContainerEqMatcher {
- public:
-  typedef internal::StlContainerView<Container> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-
-  // We make a copy of expected in case the elements in it are modified
-  // after this matcher is created.
-  explicit ContainerEqMatcher(const Container& expected)
-      : expected_(View::Copy(expected)) {
-    // Makes sure the user doesn't instantiate this class template
-    // with a const or reference type.
-    (void)testing::StaticAssertTypeEq<Container,
-        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "equals ";
-    UniversalPrint(expected_, os);
-  }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "does not equal ";
-    UniversalPrint(expected_, os);
-  }
-
-  template <typename LhsContainer>
-  bool MatchAndExplain(const LhsContainer& lhs,
-                       MatchResultListener* listener) const {
-    // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
-    // that causes LhsContainer to be a const type sometimes.
-    typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
-        LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-    if (lhs_stl_container == expected_)
-      return true;
-
-    ::std::ostream* const os = listener->stream();
-    if (os != NULL) {
-      // Something is different. Check for extra values first.
-      bool printed_header = false;
-      for (typename LhsStlContainer::const_iterator it =
-               lhs_stl_container.begin();
-           it != lhs_stl_container.end(); ++it) {
-        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
-            expected_.end()) {
-          if (printed_header) {
-            *os << ", ";
-          } else {
-            *os << "which has these unexpected elements: ";
-            printed_header = true;
-          }
-          UniversalPrint(*it, os);
-        }
-      }
-
-      // Now check for missing values.
-      bool printed_header2 = false;
-      for (typename StlContainer::const_iterator it = expected_.begin();
-           it != expected_.end(); ++it) {
-        if (internal::ArrayAwareFind(
-                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
-            lhs_stl_container.end()) {
-          if (printed_header2) {
-            *os << ", ";
-          } else {
-            *os << (printed_header ? ",\nand" : "which")
-                << " doesn't have these expected elements: ";
-            printed_header2 = true;
-          }
-          UniversalPrint(*it, os);
-        }
-      }
-    }
-
-    return false;
-  }
-
- private:
-  const StlContainer expected_;
-
-  GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
-};
-
-// A comparator functor that uses the < operator to compare two values.
-struct LessComparator {
-  template <typename T, typename U>
-  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
-};
-
-// Implements WhenSortedBy(comparator, container_matcher).
-template <typename Comparator, typename ContainerMatcher>
-class WhenSortedByMatcher {
- public:
-  WhenSortedByMatcher(const Comparator& comparator,
-                      const ContainerMatcher& matcher)
-      : comparator_(comparator), matcher_(matcher) {}
-
-  template <typename LhsContainer>
-  operator Matcher<LhsContainer>() const {
-    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
-  }
-
-  template <typename LhsContainer>
-  class Impl : public MatcherInterface<LhsContainer> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    typedef typename LhsView::const_reference LhsStlContainerReference;
-    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
-    // so that we can match associative containers.
-    typedef typename RemoveConstFromKey<
-        typename LhsStlContainer::value_type>::type LhsValue;
-
-    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
-        : comparator_(comparator), matcher_(matcher) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "(when sorted) ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "(when sorted) ";
-      matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(LhsContainer lhs,
-                                 MatchResultListener* listener) const {
-      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
-                                               lhs_stl_container.end());
-      ::std::sort(
-           sorted_container.begin(), sorted_container.end(), comparator_);
-
-      if (!listener->IsInterested()) {
-        // If the listener is not interested, we do not need to
-        // construct the inner explanation.
-        return matcher_.Matches(sorted_container);
-      }
-
-      *listener << "which is ";
-      UniversalPrint(sorted_container, listener->stream());
-      *listener << " when sorted";
-
-      StringMatchResultListener inner_listener;
-      const bool match = matcher_.MatchAndExplain(sorted_container,
-                                                  &inner_listener);
-      PrintIfNotEmpty(inner_listener.str(), listener->stream());
-      return match;
-    }
-
-   private:
-    const Comparator comparator_;
-    const Matcher<const ::std::vector<LhsValue>&> matcher_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
-  };
-
- private:
-  const Comparator comparator_;
-  const ContainerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher);
-};
-
-// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
-// must be able to be safely cast to Matcher<tuple<const T1&, const
-// T2&> >, where T1 and T2 are the types of elements in the LHS
-// container and the RHS container respectively.
-template <typename TupleMatcher, typename RhsContainer>
-class PointwiseMatcher {
- public:
-  typedef internal::StlContainerView<RhsContainer> RhsView;
-  typedef typename RhsView::type RhsStlContainer;
-  typedef typename RhsStlContainer::value_type RhsValue;
-
-  // Like ContainerEq, we make a copy of rhs in case the elements in
-  // it are modified after this matcher is created.
-  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
-      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {
-    // Makes sure the user doesn't instantiate this class template
-    // with a const or reference type.
-    (void)testing::StaticAssertTypeEq<RhsContainer,
-        GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
-  }
-
-  template <typename LhsContainer>
-  operator Matcher<LhsContainer>() const {
-    return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
-  }
-
-  template <typename LhsContainer>
-  class Impl : public MatcherInterface<LhsContainer> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    typedef typename LhsView::const_reference LhsStlContainerReference;
-    typedef typename LhsStlContainer::value_type LhsValue;
-    // We pass the LHS value and the RHS value to the inner matcher by
-    // reference, as they may be expensive to copy.  We must use tuple
-    // instead of pair here, as a pair cannot hold references (C++ 98,
-    // 20.2.2 [lib.pairs]).
-    typedef ::testing::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
-
-    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
-        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
-        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
-          rhs_(rhs) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "contains " << rhs_.size()
-          << " values, where each value and its corresponding value in ";
-      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
-      *os << " ";
-      mono_tuple_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "doesn't contain exactly " << rhs_.size()
-          << " values, or contains a value x at some index i"
-          << " where x and the i-th value of ";
-      UniversalPrint(rhs_, os);
-      *os << " ";
-      mono_tuple_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(LhsContainer lhs,
-                                 MatchResultListener* listener) const {
-      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-      const size_t actual_size = lhs_stl_container.size();
-      if (actual_size != rhs_.size()) {
-        *listener << "which contains " << actual_size << " values";
-        return false;
-      }
-
-      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
-      typename RhsStlContainer::const_iterator right = rhs_.begin();
-      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
-        const InnerMatcherArg value_pair(*left, *right);
-
-        if (listener->IsInterested()) {
-          StringMatchResultListener inner_listener;
-          if (!mono_tuple_matcher_.MatchAndExplain(
-                  value_pair, &inner_listener)) {
-            *listener << "where the value pair (";
-            UniversalPrint(*left, listener->stream());
-            *listener << ", ";
-            UniversalPrint(*right, listener->stream());
-            *listener << ") at index #" << i << " don't match";
-            PrintIfNotEmpty(inner_listener.str(), listener->stream());
-            return false;
-          }
-        } else {
-          if (!mono_tuple_matcher_.Matches(value_pair))
-            return false;
-        }
-      }
-
-      return true;
-    }
-
-   private:
-    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
-    const RhsStlContainer rhs_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const TupleMatcher tuple_matcher_;
-  const RhsStlContainer rhs_;
-
-  GTEST_DISALLOW_ASSIGN_(PointwiseMatcher);
-};
-
-// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
-template <typename Container>
-class QuantifierMatcherImpl : public MatcherInterface<Container> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::value_type Element;
-
-  template <typename InnerMatcher>
-  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
-      : inner_matcher_(
-           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
-
-  // Checks whether:
-  // * All elements in the container match, if all_elements_should_match.
-  // * Any element in the container matches, if !all_elements_should_match.
-  bool MatchAndExplainImpl(bool all_elements_should_match,
-                           Container container,
-                           MatchResultListener* listener) const {
-    StlContainerReference stl_container = View::ConstReference(container);
-    size_t i = 0;
-    for (typename StlContainer::const_iterator it = stl_container.begin();
-         it != stl_container.end(); ++it, ++i) {
-      StringMatchResultListener inner_listener;
-      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
-
-      if (matches != all_elements_should_match) {
-        *listener << "whose element #" << i
-                  << (matches ? " matches" : " doesn't match");
-        PrintIfNotEmpty(inner_listener.str(), listener->stream());
-        return !all_elements_should_match;
-      }
-    }
-    return all_elements_should_match;
-  }
-
- protected:
-  const Matcher<const Element&> inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl);
-};
-
-// Implements Contains(element_matcher) for the given argument type Container.
-// Symmetric to EachMatcherImpl.
-template <typename Container>
-class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
- public:
-  template <typename InnerMatcher>
-  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
-      : QuantifierMatcherImpl<Container>(inner_matcher) {}
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "contains at least one element that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't contain any element that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    return this->MatchAndExplainImpl(false, container, listener);
-  }
-
- private:
-  GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
-};
-
-// Implements Each(element_matcher) for the given argument type Container.
-// Symmetric to ContainsMatcherImpl.
-template <typename Container>
-class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
- public:
-  template <typename InnerMatcher>
-  explicit EachMatcherImpl(InnerMatcher inner_matcher)
-      : QuantifierMatcherImpl<Container>(inner_matcher) {}
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "only contains elements that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "contains some element that ";
-    this->inner_matcher_.DescribeNegationTo(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    return this->MatchAndExplainImpl(true, container, listener);
-  }
-
- private:
-  GTEST_DISALLOW_ASSIGN_(EachMatcherImpl);
-};
-
-// Implements polymorphic Contains(element_matcher).
-template <typename M>
-class ContainsMatcher {
- public:
-  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_));
-  }
-
- private:
-  const M inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
-};
-
-// Implements polymorphic Each(element_matcher).
-template <typename M>
-class EachMatcher {
- public:
-  explicit EachMatcher(M m) : inner_matcher_(m) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
-  }
-
- private:
-  const M inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(EachMatcher);
-};
-
-// Implements Key(inner_matcher) for the given argument pair type.
-// Key(inner_matcher) matches an std::pair whose 'first' field matches
-// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
-// std::map that contains at least one element whose key is >= 5.
-template <typename PairType>
-class KeyMatcherImpl : public MatcherInterface<PairType> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
-  typedef typename RawPairType::first_type KeyType;
-
-  template <typename InnerMatcher>
-  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
-      : inner_matcher_(
-          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
-  }
-
-  // Returns true iff 'key_value.first' (the key) matches the inner matcher.
-  virtual bool MatchAndExplain(PairType key_value,
-                               MatchResultListener* listener) const {
-    StringMatchResultListener inner_listener;
-    const bool match = inner_matcher_.MatchAndExplain(key_value.first,
-                                                      &inner_listener);
-    const internal::string explanation = inner_listener.str();
-    if (explanation != "") {
-      *listener << "whose first field is a value " << explanation;
-    }
-    return match;
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "has a key that ";
-    inner_matcher_.DescribeTo(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't have a key that ";
-    inner_matcher_.DescribeTo(os);
-  }
-
- private:
-  const Matcher<const KeyType&> inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
-};
-
-// Implements polymorphic Key(matcher_for_key).
-template <typename M>
-class KeyMatcher {
- public:
-  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
-
-  template <typename PairType>
-  operator Matcher<PairType>() const {
-    return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
-  }
-
- private:
-  const M matcher_for_key_;
-
-  GTEST_DISALLOW_ASSIGN_(KeyMatcher);
-};
-
-// Implements Pair(first_matcher, second_matcher) for the given argument pair
-// type with its two matchers. See Pair() function below.
-template <typename PairType>
-class PairMatcherImpl : public MatcherInterface<PairType> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
-  typedef typename RawPairType::first_type FirstType;
-  typedef typename RawPairType::second_type SecondType;
-
-  template <typename FirstMatcher, typename SecondMatcher>
-  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
-      : first_matcher_(
-            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
-        second_matcher_(
-            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "has a first field that ";
-    first_matcher_.DescribeTo(os);
-    *os << ", and has a second field that ";
-    second_matcher_.DescribeTo(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "has a first field that ";
-    first_matcher_.DescribeNegationTo(os);
-    *os << ", or has a second field that ";
-    second_matcher_.DescribeNegationTo(os);
-  }
-
-  // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second'
-  // matches second_matcher.
-  virtual bool MatchAndExplain(PairType a_pair,
-                               MatchResultListener* listener) const {
-    if (!listener->IsInterested()) {
-      // If the listener is not interested, we don't need to construct the
-      // explanation.
-      return first_matcher_.Matches(a_pair.first) &&
-             second_matcher_.Matches(a_pair.second);
-    }
-    StringMatchResultListener first_inner_listener;
-    if (!first_matcher_.MatchAndExplain(a_pair.first,
-                                        &first_inner_listener)) {
-      *listener << "whose first field does not match";
-      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
-      return false;
-    }
-    StringMatchResultListener second_inner_listener;
-    if (!second_matcher_.MatchAndExplain(a_pair.second,
-                                         &second_inner_listener)) {
-      *listener << "whose second field does not match";
-      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
-      return false;
-    }
-    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
-                   listener);
-    return true;
-  }
-
- private:
-  void ExplainSuccess(const internal::string& first_explanation,
-                      const internal::string& second_explanation,
-                      MatchResultListener* listener) const {
-    *listener << "whose both fields match";
-    if (first_explanation != "") {
-      *listener << ", where the first field is a value " << first_explanation;
-    }
-    if (second_explanation != "") {
-      *listener << ", ";
-      if (first_explanation != "") {
-        *listener << "and ";
-      } else {
-        *listener << "where ";
-      }
-      *listener << "the second field is a value " << second_explanation;
-    }
-  }
-
-  const Matcher<const FirstType&> first_matcher_;
-  const Matcher<const SecondType&> second_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
-};
-
-// Implements polymorphic Pair(first_matcher, second_matcher).
-template <typename FirstMatcher, typename SecondMatcher>
-class PairMatcher {
- public:
-  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
-      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
-
-  template <typename PairType>
-  operator Matcher<PairType> () const {
-    return MakeMatcher(
-        new PairMatcherImpl<PairType>(
-            first_matcher_, second_matcher_));
-  }
-
- private:
-  const FirstMatcher first_matcher_;
-  const SecondMatcher second_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PairMatcher);
-};
-
-// Implements ElementsAre() and ElementsAreArray().
-template <typename Container>
-class ElementsAreMatcherImpl : public MatcherInterface<Container> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef internal::StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::value_type Element;
-
-  // Constructs the matcher from a sequence of element values or
-  // element matchers.
-  template <typename InputIter>
-  ElementsAreMatcherImpl(InputIter first, InputIter last) {
-    while (first != last) {
-      matchers_.push_back(MatcherCast<const Element&>(*first++));
-    }
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    if (count() == 0) {
-      *os << "is empty";
-    } else if (count() == 1) {
-      *os << "has 1 element that ";
-      matchers_[0].DescribeTo(os);
-    } else {
-      *os << "has " << Elements(count()) << " where\n";
-      for (size_t i = 0; i != count(); ++i) {
-        *os << "element #" << i << " ";
-        matchers_[i].DescribeTo(os);
-        if (i + 1 < count()) {
-          *os << ",\n";
-        }
-      }
-    }
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    if (count() == 0) {
-      *os << "isn't empty";
-      return;
-    }
-
-    *os << "doesn't have " << Elements(count()) << ", or\n";
-    for (size_t i = 0; i != count(); ++i) {
-      *os << "element #" << i << " ";
-      matchers_[i].DescribeNegationTo(os);
-      if (i + 1 < count()) {
-        *os << ", or\n";
-      }
-    }
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    // To work with stream-like "containers", we must only walk
-    // through the elements in one pass.
-
-    const bool listener_interested = listener->IsInterested();
-
-    // explanations[i] is the explanation of the element at index i.
-    ::std::vector<internal::string> explanations(count());
-    StlContainerReference stl_container = View::ConstReference(container);
-    typename StlContainer::const_iterator it = stl_container.begin();
-    size_t exam_pos = 0;
-    bool mismatch_found = false;  // Have we found a mismatched element yet?
-
-    // Go through the elements and matchers in pairs, until we reach
-    // the end of either the elements or the matchers, or until we find a
-    // mismatch.
-    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
-      bool match;  // Does the current element match the current matcher?
-      if (listener_interested) {
-        StringMatchResultListener s;
-        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
-        explanations[exam_pos] = s.str();
-      } else {
-        match = matchers_[exam_pos].Matches(*it);
-      }
-
-      if (!match) {
-        mismatch_found = true;
-        break;
-      }
-    }
-    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
-
-    // Find how many elements the actual container has.  We avoid
-    // calling size() s.t. this code works for stream-like "containers"
-    // that don't define size().
-    size_t actual_count = exam_pos;
-    for (; it != stl_container.end(); ++it) {
-      ++actual_count;
-    }
-
-    if (actual_count != count()) {
-      // The element count doesn't match.  If the container is empty,
-      // there's no need to explain anything as Google Mock already
-      // prints the empty container.  Otherwise we just need to show
-      // how many elements there actually are.
-      if (listener_interested && (actual_count != 0)) {
-        *listener << "which has " << Elements(actual_count);
-      }
-      return false;
-    }
-
-    if (mismatch_found) {
-      // The element count matches, but the exam_pos-th element doesn't match.
-      if (listener_interested) {
-        *listener << "whose element #" << exam_pos << " doesn't match";
-        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
-      }
-      return false;
-    }
-
-    // Every element matches its expectation.  We need to explain why
-    // (the obvious ones can be skipped).
-    if (listener_interested) {
-      bool reason_printed = false;
-      for (size_t i = 0; i != count(); ++i) {
-        const internal::string& s = explanations[i];
-        if (!s.empty()) {
-          if (reason_printed) {
-            *listener << ",\nand ";
-          }
-          *listener << "whose element #" << i << " matches, " << s;
-          reason_printed = true;
-        }
-      }
-    }
-    return true;
-  }
-
- private:
-  static Message Elements(size_t count) {
-    return Message() << count << (count == 1 ? " element" : " elements");
-  }
-
-  size_t count() const { return matchers_.size(); }
-
-  ::std::vector<Matcher<const Element&> > matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
-};
-
-// Connectivity matrix of (elements X matchers), in element-major order.
-// Initially, there are no edges.
-// Use NextGraph() to iterate over all possible edge configurations.
-// Use Randomize() to generate a random edge configuration.
-class GTEST_API_ MatchMatrix {
- public:
-  MatchMatrix(size_t num_elements, size_t num_matchers)
-      : num_elements_(num_elements),
-        num_matchers_(num_matchers),
-        matched_(num_elements_* num_matchers_, 0) {
-  }
-
-  size_t LhsSize() const { return num_elements_; }
-  size_t RhsSize() const { return num_matchers_; }
-  bool HasEdge(size_t ilhs, size_t irhs) const {
-    return matched_[SpaceIndex(ilhs, irhs)] == 1;
-  }
-  void SetEdge(size_t ilhs, size_t irhs, bool b) {
-    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
-  }
-
-  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
-  // adds 1 to that number; returns false if incrementing the graph left it
-  // empty.
-  bool NextGraph();
-
-  void Randomize();
-
-  string DebugString() const;
-
- private:
-  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
-    return ilhs * num_matchers_ + irhs;
-  }
-
-  size_t num_elements_;
-  size_t num_matchers_;
-
-  // Each element is a char interpreted as bool. They are stored as a
-  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
-  // a (ilhs, irhs) matrix coordinate into an offset.
-  ::std::vector<char> matched_;
-};
-
-typedef ::std::pair<size_t, size_t> ElementMatcherPair;
-typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
-
-// Returns a maximum bipartite matching for the specified graph 'g'.
-// The matching is represented as a vector of {element, matcher} pairs.
-GTEST_API_ ElementMatcherPairs
-FindMaxBipartiteMatching(const MatchMatrix& g);
-
-GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
-                            MatchResultListener* listener);
-
-// Untyped base class for implementing UnorderedElementsAre.  By
-// putting logic that's not specific to the element type here, we
-// reduce binary bloat and increase compilation speed.
-class GTEST_API_ UnorderedElementsAreMatcherImplBase {
- protected:
-  // A vector of matcher describers, one for each element matcher.
-  // Does not own the describers (and thus can be used only when the
-  // element matchers are alive).
-  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
-
-  // Describes this UnorderedElementsAre matcher.
-  void DescribeToImpl(::std::ostream* os) const;
-
-  // Describes the negation of this UnorderedElementsAre matcher.
-  void DescribeNegationToImpl(::std::ostream* os) const;
-
-  bool VerifyAllElementsAndMatchersAreMatched(
-      const ::std::vector<string>& element_printouts,
-      const MatchMatrix& matrix,
-      MatchResultListener* listener) const;
-
-  MatcherDescriberVec& matcher_describers() {
-    return matcher_describers_;
-  }
-
-  static Message Elements(size_t n) {
-    return Message() << n << " element" << (n == 1 ? "" : "s");
-  }
-
- private:
-  MatcherDescriberVec matcher_describers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase);
-};
-
-// Implements unordered ElementsAre and unordered ElementsAreArray.
-template <typename Container>
-class UnorderedElementsAreMatcherImpl
-    : public MatcherInterface<Container>,
-      public UnorderedElementsAreMatcherImplBase {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef internal::StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::const_iterator StlContainerConstIterator;
-  typedef typename StlContainer::value_type Element;
-
-  // Constructs the matcher from a sequence of element values or
-  // element matchers.
-  template <typename InputIter>
-  UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) {
-    for (; first != last; ++first) {
-      matchers_.push_back(MatcherCast<const Element&>(*first));
-      matcher_describers().push_back(matchers_.back().GetDescriber());
-    }
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    StlContainerReference stl_container = View::ConstReference(container);
-    ::std::vector<string> element_printouts;
-    MatchMatrix matrix = AnalyzeElements(stl_container.begin(),
-                                         stl_container.end(),
-                                         &element_printouts,
-                                         listener);
-
-    const size_t actual_count = matrix.LhsSize();
-    if (actual_count == 0 && matchers_.empty()) {
-      return true;
-    }
-    if (actual_count != matchers_.size()) {
-      // The element count doesn't match.  If the container is empty,
-      // there's no need to explain anything as Google Mock already
-      // prints the empty container. Otherwise we just need to show
-      // how many elements there actually are.
-      if (actual_count != 0 && listener->IsInterested()) {
-        *listener << "which has " << Elements(actual_count);
-      }
-      return false;
-    }
-
-    return VerifyAllElementsAndMatchersAreMatched(element_printouts,
-                                                  matrix, listener) &&
-           FindPairing(matrix, listener);
-  }
-
- private:
-  typedef ::std::vector<Matcher<const Element&> > MatcherVec;
-
-  template <typename ElementIter>
-  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
-                              ::std::vector<string>* element_printouts,
-                              MatchResultListener* listener) const {
-    element_printouts->clear();
-    ::std::vector<char> did_match;
-    size_t num_elements = 0;
-    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
-      if (listener->IsInterested()) {
-        element_printouts->push_back(PrintToString(*elem_first));
-      }
-      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
-        did_match.push_back(Matches(matchers_[irhs])(*elem_first));
-      }
-    }
-
-    MatchMatrix matrix(num_elements, matchers_.size());
-    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
-    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
-      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
-        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
-      }
-    }
-    return matrix;
-  }
-
-  MatcherVec matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl);
-};
-
-// Functor for use in TransformTuple.
-// Performs MatcherCast<Target> on an input argument of any type.
-template <typename Target>
-struct CastAndAppendTransform {
-  template <typename Arg>
-  Matcher<Target> operator()(const Arg& a) const {
-    return MatcherCast<Target>(a);
-  }
-};
-
-// Implements UnorderedElementsAre.
-template <typename MatcherTuple>
-class UnorderedElementsAreMatcher {
- public:
-  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
-      : matchers_(args) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-    typedef typename internal::StlContainerView<RawContainer>::type View;
-    typedef typename View::value_type Element;
-    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
-    MatcherVec matchers;
-    matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
-    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
-                         ::std::back_inserter(matchers));
-    return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
-                           matchers.begin(), matchers.end()));
-  }
-
- private:
-  const MatcherTuple matchers_;
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher);
-};
-
-// Implements ElementsAre.
-template <typename MatcherTuple>
-class ElementsAreMatcher {
- public:
-  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-    typedef typename internal::StlContainerView<RawContainer>::type View;
-    typedef typename View::value_type Element;
-    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
-    MatcherVec matchers;
-    matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
-    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
-                         ::std::back_inserter(matchers));
-    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
-                           matchers.begin(), matchers.end()));
-  }
-
- private:
-  const MatcherTuple matchers_;
-  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher);
-};
-
-// Implements UnorderedElementsAreArray().
-template <typename T>
-class UnorderedElementsAreArrayMatcher {
- public:
-  UnorderedElementsAreArrayMatcher() {}
-
-  template <typename Iter>
-  UnorderedElementsAreArrayMatcher(Iter first, Iter last)
-      : matchers_(first, last) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(
-        new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(),
-                                                       matchers_.end()));
-  }
-
- private:
-  ::std::vector<T> matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher);
-};
-
-// Implements ElementsAreArray().
-template <typename T>
-class ElementsAreArrayMatcher {
- public:
-  template <typename Iter>
-  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
-        matchers_.begin(), matchers_.end()));
-  }
-
- private:
-  const ::std::vector<T> matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(ElementsAreArrayMatcher);
-};
-
-// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
-// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
-// second) is a polymorphic matcher that matches a value x iff tm
-// matches tuple (x, second).  Useful for implementing
-// UnorderedPointwise() in terms of UnorderedElementsAreArray().
-//
-// BoundSecondMatcher is copyable and assignable, as we need to put
-// instances of this class in a vector when implementing
-// UnorderedPointwise().
-template <typename Tuple2Matcher, typename Second>
-class BoundSecondMatcher {
- public:
-  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
-      : tuple2_matcher_(tm), second_value_(second) {}
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
-  }
-
-  // We have to define this for UnorderedPointwise() to compile in
-  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
-  // which requires the elements to be assignable in C++98.  The
-  // compiler cannot generate the operator= for us, as Tuple2Matcher
-  // and Second may not be assignable.
-  //
-  // However, this should never be called, so the implementation just
-  // need to assert.
-  void operator=(const BoundSecondMatcher& /*rhs*/) {
-    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
-  }
-
- private:
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    typedef ::testing::tuple<T, Second> ArgTuple;
-
-    Impl(const Tuple2Matcher& tm, const Second& second)
-        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
-          second_value_(second) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "and ";
-      UniversalPrint(second_value_, os);
-      *os << " ";
-      mono_tuple2_matcher_.DescribeTo(os);
-    }
-
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
-                                                  listener);
-    }
-
-   private:
-    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
-    const Second second_value_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const Tuple2Matcher tuple2_matcher_;
-  const Second second_value_;
-};
-
-// Given a 2-tuple matcher tm and a value second,
-// MatcherBindSecond(tm, second) returns a matcher that matches a
-// value x iff tm matches tuple (x, second).  Useful for implementing
-// UnorderedPointwise() in terms of UnorderedElementsAreArray().
-template <typename Tuple2Matcher, typename Second>
-BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
-    const Tuple2Matcher& tm, const Second& second) {
-  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
-}
-
-// Returns the description for a matcher defined using the MATCHER*()
-// macro where the user-supplied description string is "", if
-// 'negation' is false; otherwise returns the description of the
-// negation of the matcher.  'param_values' contains a list of strings
-// that are the print-out of the matcher's parameters.
-GTEST_API_ string FormatMatcherDescription(bool negation,
-                                           const char* matcher_name,
-                                           const Strings& param_values);
-
-}  // namespace internal
-
-// ElementsAreArray(first, last)
-// ElementsAreArray(pointer, count)
-// ElementsAreArray(array)
-// ElementsAreArray(container)
-// ElementsAreArray({ e1, e2, ..., en })
-//
-// The ElementsAreArray() functions are like ElementsAre(...), except
-// that they are given a homogeneous sequence rather than taking each
-// element as a function argument. The sequence can be specified as an
-// array, a pointer and count, a vector, an initializer list, or an
-// STL iterator range. In each of these cases, the underlying sequence
-// can be either a sequence of values or a sequence of matchers.
-//
-// All forms of ElementsAreArray() make a copy of the input matcher sequence.
-
-template <typename Iter>
-inline internal::ElementsAreArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-ElementsAreArray(Iter first, Iter last) {
-  typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::ElementsAreArrayMatcher<T>(first, last);
-}
-
-template <typename T>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T* pointer, size_t count) {
-  return ElementsAreArray(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T (&array)[N]) {
-  return ElementsAreArray(array, N);
-}
-
-template <typename Container>
-inline internal::ElementsAreArrayMatcher<typename Container::value_type>
-ElementsAreArray(const Container& container) {
-  return ElementsAreArray(container.begin(), container.end());
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-template <typename T>
-inline internal::ElementsAreArrayMatcher<T>
-ElementsAreArray(::std::initializer_list<T> xs) {
-  return ElementsAreArray(xs.begin(), xs.end());
-}
-#endif
-
-// UnorderedElementsAreArray(first, last)
-// UnorderedElementsAreArray(pointer, count)
-// UnorderedElementsAreArray(array)
-// UnorderedElementsAreArray(container)
-// UnorderedElementsAreArray({ e1, e2, ..., en })
-//
-// The UnorderedElementsAreArray() functions are like
-// ElementsAreArray(...), but allow matching the elements in any order.
-template <typename Iter>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-UnorderedElementsAreArray(Iter first, Iter last) {
-  typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::UnorderedElementsAreArrayMatcher<T>(first, last);
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T* pointer, size_t count) {
-  return UnorderedElementsAreArray(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T (&array)[N]) {
-  return UnorderedElementsAreArray(array, N);
-}
-
-template <typename Container>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename Container::value_type>
-UnorderedElementsAreArray(const Container& container) {
-  return UnorderedElementsAreArray(container.begin(), container.end());
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(::std::initializer_list<T> xs) {
-  return UnorderedElementsAreArray(xs.begin(), xs.end());
-}
-#endif
-
-// _ is a matcher that matches anything of any type.
-//
-// This definition is fine as:
-//
-//   1. The C++ standard permits using the name _ in a namespace that
-//      is not the global namespace or ::std.
-//   2. The AnythingMatcher class has no data member or constructor,
-//      so it's OK to create global variables of this type.
-//   3. c-style has approved of using _ in this case.
-const internal::AnythingMatcher _ = {};
-// Creates a matcher that matches any value of the given type T.
-template <typename T>
-inline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
-
-// Creates a matcher that matches any value of the given type T.
-template <typename T>
-inline Matcher<T> An() { return A<T>(); }
-
-// Creates a polymorphic matcher that matches anything equal to x.
-// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
-// wouldn't compile.
-template <typename T>
-inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
-
-// Constructs a Matcher<T> from a 'value' of type T.  The constructed
-// matcher matches any value that's equal to 'value'.
-template <typename T>
-Matcher<T>::Matcher(T value) { *this = Eq(value); }
-
-// Creates a monomorphic matcher that matches anything with type Lhs
-// and equal to rhs.  A user may need to use this instead of Eq(...)
-// in order to resolve an overloading ambiguity.
-//
-// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
-// or Matcher<T>(x), but more readable than the latter.
-//
-// We could define similar monomorphic matchers for other comparison
-// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
-// it yet as those are used much less than Eq() in practice.  A user
-// can always write Matcher<T>(Lt(5)) to be explicit about the type,
-// for example.
-template <typename Lhs, typename Rhs>
-inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
-
-// Creates a polymorphic matcher that matches anything >= x.
-template <typename Rhs>
-inline internal::GeMatcher<Rhs> Ge(Rhs x) {
-  return internal::GeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything > x.
-template <typename Rhs>
-inline internal::GtMatcher<Rhs> Gt(Rhs x) {
-  return internal::GtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything <= x.
-template <typename Rhs>
-inline internal::LeMatcher<Rhs> Le(Rhs x) {
-  return internal::LeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything < x.
-template <typename Rhs>
-inline internal::LtMatcher<Rhs> Lt(Rhs x) {
-  return internal::LtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything != x.
-template <typename Rhs>
-inline internal::NeMatcher<Rhs> Ne(Rhs x) {
-  return internal::NeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches any NULL pointer.
-inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
-  return MakePolymorphicMatcher(internal::IsNullMatcher());
-}
-
-// Creates a polymorphic matcher that matches any non-NULL pointer.
-// This is convenient as Not(NULL) doesn't compile (the compiler
-// thinks that that expression is comparing a pointer with an integer).
-inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
-  return MakePolymorphicMatcher(internal::NotNullMatcher());
-}
-
-// Creates a polymorphic matcher that matches any argument that
-// references variable x.
-template <typename T>
-inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
-  return internal::RefMatcher<T&>(x);
-}
-
-// Creates a matcher that matches any double argument approximately
-// equal to rhs, where two NANs are considered unequal.
-inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
-  return internal::FloatingEqMatcher<double>(rhs, false);
-}
-
-// Creates a matcher that matches any double argument approximately
-// equal to rhs, including NaN values when rhs is NaN.
-inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
-  return internal::FloatingEqMatcher<double>(rhs, true);
-}
-
-// Creates a matcher that matches any double argument approximately equal to
-// rhs, up to the specified max absolute error bound, where two NANs are
-// considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<double> DoubleNear(
-    double rhs, double max_abs_error) {
-  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
-}
-
-// Creates a matcher that matches any double argument approximately equal to
-// rhs, up to the specified max absolute error bound, including NaN values when
-// rhs is NaN.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
-    double rhs, double max_abs_error) {
-  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
-}
-
-// Creates a matcher that matches any float argument approximately
-// equal to rhs, where two NANs are considered unequal.
-inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
-  return internal::FloatingEqMatcher<float>(rhs, false);
-}
-
-// Creates a matcher that matches any float argument approximately
-// equal to rhs, including NaN values when rhs is NaN.
-inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
-  return internal::FloatingEqMatcher<float>(rhs, true);
-}
-
-// Creates a matcher that matches any float argument approximately equal to
-// rhs, up to the specified max absolute error bound, where two NANs are
-// considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<float> FloatNear(
-    float rhs, float max_abs_error) {
-  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
-}
-
-// Creates a matcher that matches any float argument approximately equal to
-// rhs, up to the specified max absolute error bound, including NaN values when
-// rhs is NaN.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
-    float rhs, float max_abs_error) {
-  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
-}
-
-// Creates a matcher that matches a pointer (raw or smart) that points
-// to a value that matches inner_matcher.
-template <typename InnerMatcher>
-inline internal::PointeeMatcher<InnerMatcher> Pointee(
-    const InnerMatcher& inner_matcher) {
-  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
-}
-
-// Creates a matcher that matches a pointer or reference that matches
-// inner_matcher when dynamic_cast<To> is applied.
-// The result of dynamic_cast<To> is forwarded to the inner matcher.
-// If To is a pointer and the cast fails, the inner matcher will receive NULL.
-// If To is a reference and the cast fails, this matcher returns false
-// immediately.
-template <typename To>
-inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
-WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
-  return MakePolymorphicMatcher(
-      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
-}
-
-// Creates a matcher that matches an object whose given field matches
-// 'matcher'.  For example,
-//   Field(&Foo::number, Ge(5))
-// matches a Foo object x iff x.number >= 5.
-template <typename Class, typename FieldType, typename FieldMatcher>
-inline PolymorphicMatcher<
-  internal::FieldMatcher<Class, FieldType> > Field(
-    FieldType Class::*field, const FieldMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::FieldMatcher<Class, FieldType>(
-          field, MatcherCast<const FieldType&>(matcher)));
-  // The call to MatcherCast() is required for supporting inner
-  // matchers of compatible types.  For example, it allows
-  //   Field(&Foo::bar, m)
-  // to compile where bar is an int32 and m is a matcher for int64.
-}
-
-// Creates a matcher that matches an object whose given property
-// matches 'matcher'.  For example,
-//   Property(&Foo::str, StartsWith("hi"))
-// matches a Foo object x iff x.str() starts with "hi".
-template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<
-  internal::PropertyMatcher<Class, PropertyType> > Property(
-    PropertyType (Class::*property)() const, const PropertyMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType>(
-          property,
-          MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
-  // The call to MatcherCast() is required for supporting inner
-  // matchers of compatible types.  For example, it allows
-  //   Property(&Foo::bar, m)
-  // to compile where bar() returns an int32 and m is a matcher for int64.
-}
-
-// Creates a matcher that matches an object iff the result of applying
-// a callable to x matches 'matcher'.
-// For example,
-//   ResultOf(f, StartsWith("hi"))
-// matches a Foo object x iff f(x) starts with "hi".
-// callable parameter can be a function, function pointer, or a functor.
-// Callable has to satisfy the following conditions:
-//   * It is required to keep no state affecting the results of
-//     the calls on it and make no assumptions about how many calls
-//     will be made. Any state it keeps must be protected from the
-//     concurrent access.
-//   * If it is a function object, it has to define type result_type.
-//     We recommend deriving your functor classes from std::unary_function.
-template <typename Callable, typename ResultOfMatcher>
-internal::ResultOfMatcher<Callable> ResultOf(
-    Callable callable, const ResultOfMatcher& matcher) {
-  return internal::ResultOfMatcher<Callable>(
-          callable,
-          MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
-              matcher));
-  // The call to MatcherCast() is required for supporting inner
-  // matchers of compatible types.  For example, it allows
-  //   ResultOf(Function, m)
-  // to compile where Function() returns an int32 and m is a matcher for int64.
-}
-
-// String matchers.
-
-// Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrEq(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, true, true));
-}
-
-// Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrNe(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, false, true));
-}
-
-// Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrCaseEq(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, true, false));
-}
-
-// Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrCaseNe(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, false, false));
-}
-
-// Creates a matcher that matches any string, std::string, or C string
-// that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
-    HasSubstr(const internal::string& substring) {
-  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
-      substring));
-}
-
-// Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
-    StartsWith(const internal::string& prefix) {
-  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
-      prefix));
-}
-
-// Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
-    EndsWith(const internal::string& suffix) {
-  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
-      suffix));
-}
-
-// Matches a string that fully matches regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::string& regex) {
-  return MatchesRegex(new internal::RE(regex));
-}
-
-// Matches a string that contains regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::string& regex) {
-  return ContainsRegex(new internal::RE(regex));
-}
-
-#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
-// Wide string matchers.
-
-// Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrEq(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, true, true));
-}
-
-// Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrNe(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, false, true));
-}
-
-// Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrCaseEq(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, true, false));
-}
-
-// Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrCaseNe(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, false, false));
-}
-
-// Creates a matcher that matches any wstring, std::wstring, or C wide string
-// that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
-    HasSubstr(const internal::wstring& substring) {
-  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>(
-      substring));
-}
-
-// Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
-    StartsWith(const internal::wstring& prefix) {
-  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>(
-      prefix));
-}
-
-// Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
-    EndsWith(const internal::wstring& suffix) {
-  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>(
-      suffix));
-}
-
-#endif  // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field == the second field.
-inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field >= the second field.
-inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field > the second field.
-inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field <= the second field.
-inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field < the second field.
-inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field != the second field.
-inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
-
-// Creates a matcher that matches any value of type T that m doesn't
-// match.
-template <typename InnerMatcher>
-inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
-  return internal::NotMatcher<InnerMatcher>(m);
-}
-
-// Returns a matcher that matches anything that satisfies the given
-// predicate.  The predicate can be any unary function or functor
-// whose return type can be implicitly converted to bool.
-template <typename Predicate>
-inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
-Truly(Predicate pred) {
-  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
-}
-
-// Returns a matcher that matches the container size. The container must
-// support both size() and size_type which all STL-like containers provide.
-// Note that the parameter 'size' can be a value of type size_type as well as
-// matcher. For instance:
-//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
-//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
-template <typename SizeMatcher>
-inline internal::SizeIsMatcher<SizeMatcher>
-SizeIs(const SizeMatcher& size_matcher) {
-  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
-}
-
-// Returns a matcher that matches the distance between the container's begin()
-// iterator and its end() iterator, i.e. the size of the container. This matcher
-// can be used instead of SizeIs with containers such as std::forward_list which
-// do not implement size(). The container must provide const_iterator (with
-// valid iterator_traits), begin() and end().
-template <typename DistanceMatcher>
-inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
-BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
-  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
-}
-
-// Returns a matcher that matches an equal container.
-// This matcher behaves like Eq(), but in the event of mismatch lists the
-// values that are included in one container but not the other. (Duplicate
-// values and order differences are not explained.)
-template <typename Container>
-inline PolymorphicMatcher<internal::ContainerEqMatcher<  // NOLINT
-                            GTEST_REMOVE_CONST_(Container)> >
-    ContainerEq(const Container& rhs) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes Container to be a const type sometimes.
-  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
-  return MakePolymorphicMatcher(
-      internal::ContainerEqMatcher<RawContainer>(rhs));
-}
-
-// Returns a matcher that matches a container that, when sorted using
-// the given comparator, matches container_matcher.
-template <typename Comparator, typename ContainerMatcher>
-inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
-WhenSortedBy(const Comparator& comparator,
-             const ContainerMatcher& container_matcher) {
-  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
-      comparator, container_matcher);
-}
-
-// Returns a matcher that matches a container that, when sorted using
-// the < operator, matches container_matcher.
-template <typename ContainerMatcher>
-inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
-WhenSorted(const ContainerMatcher& container_matcher) {
-  return
-      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
-          internal::LessComparator(), container_matcher);
-}
-
-// Matches an STL-style container or a native array that contains the
-// same number of elements as in rhs, where its i-th element and rhs's
-// i-th element (as a pair) satisfy the given pair matcher, for all i.
-// TupleMatcher must be able to be safely cast to Matcher<tuple<const
-// T1&, const T2&> >, where T1 and T2 are the types of elements in the
-// LHS container and the RHS container respectively.
-template <typename TupleMatcher, typename Container>
-inline internal::PointwiseMatcher<TupleMatcher,
-                                  GTEST_REMOVE_CONST_(Container)>
-Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes Container to be a const type sometimes (e.g. when
-  // rhs is a const int[])..
-  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
-  return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
-      tuple_matcher, rhs);
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Supports the Pointwise(m, {a, b, c}) syntax.
-template <typename TupleMatcher, typename T>
-inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
-    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
-  return Pointwise(tuple_matcher, std::vector<T>(rhs));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
-// container or a native array that contains the same number of
-// elements as in rhs, where in some permutation of the container, its
-// i-th element and rhs's i-th element (as a pair) satisfy the given
-// pair matcher, for all i.  Tuple2Matcher must be able to be safely
-// cast to Matcher<tuple<const T1&, const T2&> >, where T1 and T2 are
-// the types of elements in the LHS container and the RHS container
-// respectively.
-//
-// This is like Pointwise(pair_matcher, rhs), except that the element
-// order doesn't matter.
-template <typename Tuple2Matcher, typename RhsContainer>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename internal::BoundSecondMatcher<
-        Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_(
-                           RhsContainer)>::type::value_type> >
-UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
-                   const RhsContainer& rhs_container) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes RhsContainer to be a const type sometimes (e.g. when
-  // rhs_container is a const int[]).
-  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
-
-  // RhsView allows the same code to handle RhsContainer being a
-  // STL-style container and it being a native C-style array.
-  typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
-  typedef typename RhsView::type RhsStlContainer;
-  typedef typename RhsStlContainer::value_type Second;
-  const RhsStlContainer& rhs_stl_container =
-      RhsView::ConstReference(rhs_container);
-
-  // Create a matcher for each element in rhs_container.
-  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
-  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
-       it != rhs_stl_container.end(); ++it) {
-    matchers.push_back(
-        internal::MatcherBindSecond(tuple2_matcher, *it));
-  }
-
-  // Delegate the work to UnorderedElementsAreArray().
-  return UnorderedElementsAreArray(matchers);
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
-template <typename Tuple2Matcher, typename T>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
-UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
-                   std::initializer_list<T> rhs) {
-  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Matches an STL-style container or a native array that contains at
-// least one element matching the given value or matcher.
-//
-// Examples:
-//   ::std::set<int> page_ids;
-//   page_ids.insert(3);
-//   page_ids.insert(1);
-//   EXPECT_THAT(page_ids, Contains(1));
-//   EXPECT_THAT(page_ids, Contains(Gt(2)));
-//   EXPECT_THAT(page_ids, Not(Contains(4)));
-//
-//   ::std::map<int, size_t> page_lengths;
-//   page_lengths[1] = 100;
-//   EXPECT_THAT(page_lengths,
-//               Contains(::std::pair<const int, size_t>(1, 100)));
-//
-//   const char* user_ids[] = { "joe", "mike", "tom" };
-//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
-template <typename M>
-inline internal::ContainsMatcher<M> Contains(M matcher) {
-  return internal::ContainsMatcher<M>(matcher);
-}
-
-// Matches an STL-style container or a native array that contains only
-// elements matching the given value or matcher.
-//
-// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
-// the messages are different.
-//
-// Examples:
-//   ::std::set<int> page_ids;
-//   // Each(m) matches an empty container, regardless of what m is.
-//   EXPECT_THAT(page_ids, Each(Eq(1)));
-//   EXPECT_THAT(page_ids, Each(Eq(77)));
-//
-//   page_ids.insert(3);
-//   EXPECT_THAT(page_ids, Each(Gt(0)));
-//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
-//   page_ids.insert(1);
-//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
-//
-//   ::std::map<int, size_t> page_lengths;
-//   page_lengths[1] = 100;
-//   page_lengths[2] = 200;
-//   page_lengths[3] = 300;
-//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
-//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
-//
-//   const char* user_ids[] = { "joe", "mike", "tom" };
-//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
-template <typename M>
-inline internal::EachMatcher<M> Each(M matcher) {
-  return internal::EachMatcher<M>(matcher);
-}
-
-// Key(inner_matcher) matches an std::pair whose 'first' field matches
-// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
-// std::map that contains at least one element whose key is >= 5.
-template <typename M>
-inline internal::KeyMatcher<M> Key(M inner_matcher) {
-  return internal::KeyMatcher<M>(inner_matcher);
-}
-
-// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
-// matches first_matcher and whose 'second' field matches second_matcher.  For
-// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
-// to match a std::map<int, string> that contains exactly one element whose key
-// is >= 5 and whose value equals "foo".
-template <typename FirstMatcher, typename SecondMatcher>
-inline internal::PairMatcher<FirstMatcher, SecondMatcher>
-Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
-  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
-      first_matcher, second_matcher);
-}
-
-// Returns a predicate that is satisfied by anything that matches the
-// given matcher.
-template <typename M>
-inline internal::MatcherAsPredicate<M> Matches(M matcher) {
-  return internal::MatcherAsPredicate<M>(matcher);
-}
-
-// Returns true iff the value matches the matcher.
-template <typename T, typename M>
-inline bool Value(const T& value, M matcher) {
-  return testing::Matches(matcher)(value);
-}
-
-// Matches the value against the given matcher and explains the match
-// result to listener.
-template <typename T, typename M>
-inline bool ExplainMatchResult(
-    M matcher, const T& value, MatchResultListener* listener) {
-  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
-}
-
-#if GTEST_LANG_CXX11
-// Define variadic matcher versions. They are overloaded in
-// gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
-template <typename... Args>
-inline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) {
-  return internal::AllOfMatcher<Args...>(matchers...);
-}
-
-template <typename... Args>
-inline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) {
-  return internal::AnyOfMatcher<Args...>(matchers...);
-}
-
-#endif  // GTEST_LANG_CXX11
-
-// AllArgs(m) is a synonym of m.  This is useful in
-//
-//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
-//
-// which is easier to read than
-//
-//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
-template <typename InnerMatcher>
-inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
-
-// These macros allow using matchers to check values in Google Test
-// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
-// succeed iff the value matches the matcher.  If the assertion fails,
-// the value and the description of the matcher will be printed.
-#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
-    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
-#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
-    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
-
-}  // namespace testing
-
-// Include any custom callback matchers added by the local installation.
-// We must include this header at the end to make sure it can use the
-// declarations from this file.
-// Copyright 2015, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// ============================================================
-// An installation-specific extension point for gmock-matchers.h.
-// ============================================================
-//
-// Adds google3 callback support to CallableTraits.
-//
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
-
-#endif  //  GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-
-namespace testing {
-
-// An abstract handle of an expectation.
-class Expectation;
-
-// A set of expectation handles.
-class ExpectationSet;
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// Implements a mock function.
-template <typename F> class FunctionMocker;
-
-// Base class for expectations.
-class ExpectationBase;
-
-// Implements an expectation.
-template <typename F> class TypedExpectation;
-
-// Helper class for testing the Expectation class template.
-class ExpectationTester;
-
-// Base class for function mockers.
-template <typename F> class FunctionMockerBase;
-
-// Protects the mock object registry (in class Mock), all function
-// mockers, and all expectations.
-//
-// The reason we don't use more fine-grained protection is: when a
-// mock function Foo() is called, it needs to consult its expectations
-// to see which one should be picked.  If another thread is allowed to
-// call a mock function (either Foo() or a different one) at the same
-// time, it could affect the "retired" attributes of Foo()'s
-// expectations when InSequence() is used, and thus affect which
-// expectation gets picked.  Therefore, we sequence all mock function
-// calls to ensure the integrity of the mock objects' states.
-GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
-
-// Untyped base class for ActionResultHolder<R>.
-class UntypedActionResultHolderBase;
-
-// Abstract base class of FunctionMockerBase.  This is the
-// type-agnostic part of the function mocker interface.  Its pure
-// virtual methods are implemented by FunctionMockerBase.
-class GTEST_API_ UntypedFunctionMockerBase {
- public:
-  UntypedFunctionMockerBase();
-  virtual ~UntypedFunctionMockerBase();
-
-  // Verifies that all expectations on this mock function have been
-  // satisfied.  Reports one or more Google Test non-fatal failures
-  // and returns false if not.
-  bool VerifyAndClearExpectationsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Clears the ON_CALL()s set on this mock function.
-  virtual void ClearDefaultActionsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
-
-  // In all of the following Untyped* functions, it's the caller's
-  // responsibility to guarantee the correctness of the arguments'
-  // types.
-
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      const void* untyped_args,
-      const string& call_description) const = 0;
-
-  // Performs the given action with the given arguments and returns
-  // the action's result.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action,
-      const void* untyped_args) const = 0;
-
-  // Writes a message that the call is uninteresting (i.e. neither
-  // explicitly expected nor explicitly unexpected) to the given
-  // ostream.
-  virtual void UntypedDescribeUninterestingCall(
-      const void* untyped_args,
-      ::std::ostream* os) const
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
-
-  // Returns the expectation that matches the given function arguments
-  // (or NULL is there's no match); when a match is found,
-  // untyped_action is set to point to the action that should be
-  // performed (or NULL if the action is "do default"), and
-  // is_excessive is modified to indicate whether the call exceeds the
-  // expected number.
-  virtual const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args,
-      const void** untyped_action, bool* is_excessive,
-      ::std::ostream* what, ::std::ostream* why)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
-
-  // Prints the given function arguments to the ostream.
-  virtual void UntypedPrintArgs(const void* untyped_args,
-                                ::std::ostream* os) const = 0;
-
-  // Sets the mock object this mock method belongs to, and registers
-  // this information in the global mock registry.  Will be called
-  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
-  // method.
-  // TODO(wan@google.com): rename to SetAndRegisterOwner().
-  void RegisterOwner(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Sets the mock object this mock method belongs to, and sets the
-  // name of the mock function.  Will be called upon each invocation
-  // of this mock function.
-  void SetOwnerAndName(const void* mock_obj, const char* name)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the mock object this mock method belongs to.  Must be
-  // called after RegisterOwner() or SetOwnerAndName() has been
-  // called.
-  const void* MockObject() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the name of this mock method.  Must be called after
-  // SetOwnerAndName() has been called.
-  const char* Name() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.  The caller is responsible for deleting the
-  // result.
-  UntypedActionResultHolderBase* UntypedInvokeWith(
-      const void* untyped_args)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
- protected:
-  typedef std::vector<const void*> UntypedOnCallSpecs;
-
-  typedef std::vector<internal::linked_ptr<ExpectationBase> >
-  UntypedExpectations;
-
-  // Returns an Expectation object that references and co-owns exp,
-  // which must be an expectation on this mock function.
-  Expectation GetHandleOf(ExpectationBase* exp);
-
-  // Address of the mock object this mock method belongs to.  Only
-  // valid after this mock method has been called or
-  // ON_CALL/EXPECT_CALL has been invoked on it.
-  const void* mock_obj_;  // Protected by g_gmock_mutex.
-
-  // Name of the function being mocked.  Only valid after this mock
-  // method has been called.
-  const char* name_;  // Protected by g_gmock_mutex.
-
-  // All default action specs for this function mocker.
-  UntypedOnCallSpecs untyped_on_call_specs_;
-
-  // All expectations for this function mocker.
-  UntypedExpectations untyped_expectations_;
-};  // class UntypedFunctionMockerBase
-
-// Untyped base class for OnCallSpec<F>.
-class UntypedOnCallSpecBase {
- public:
-  // The arguments are the location of the ON_CALL() statement.
-  UntypedOnCallSpecBase(const char* a_file, int a_line)
-      : file_(a_file), line_(a_line), last_clause_(kNone) {}
-
-  // Where in the source file was the default action spec defined?
-  const char* file() const { return file_; }
-  int line() const { return line_; }
-
- protected:
-  // Gives each clause in the ON_CALL() statement a name.
-  enum Clause {
-    // Do not change the order of the enum members!  The run-time
-    // syntax checking relies on it.
-    kNone,
-    kWith,
-    kWillByDefault
-  };
-
-  // Asserts that the ON_CALL() statement has a certain property.
-  void AssertSpecProperty(bool property, const string& failure_message) const {
-    Assert(property, file_, line_, failure_message);
-  }
-
-  // Expects that the ON_CALL() statement has a certain property.
-  void ExpectSpecProperty(bool property, const string& failure_message) const {
-    Expect(property, file_, line_, failure_message);
-  }
-
-  const char* file_;
-  int line_;
-
-  // The last clause in the ON_CALL() statement as seen so far.
-  // Initially kNone and changes as the statement is parsed.
-  Clause last_clause_;
-};  // class UntypedOnCallSpecBase
-
-// This template class implements an ON_CALL spec.
-template <typename F>
-class OnCallSpec : public UntypedOnCallSpecBase {
- public:
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-
-  // Constructs an OnCallSpec object from the information inside
-  // the parenthesis of an ON_CALL() statement.
-  OnCallSpec(const char* a_file, int a_line,
-             const ArgumentMatcherTuple& matchers)
-      : UntypedOnCallSpecBase(a_file, a_line),
-        matchers_(matchers),
-        // By default, extra_matcher_ should match anything.  However,
-        // we cannot initialize it with _ as that triggers a compiler
-        // bug in Symbian's C++ compiler (cannot decide between two
-        // overloaded constructors of Matcher<const ArgumentTuple&>).
-        extra_matcher_(A<const ArgumentTuple&>()) {
-  }
-
-  // Implements the .With() clause.
-  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
-    // Makes sure this is called at most once.
-    ExpectSpecProperty(last_clause_ < kWith,
-                       ".With() cannot appear "
-                       "more than once in an ON_CALL().");
-    last_clause_ = kWith;
-
-    extra_matcher_ = m;
-    return *this;
-  }
-
-  // Implements the .WillByDefault() clause.
-  OnCallSpec& WillByDefault(const Action<F>& action) {
-    ExpectSpecProperty(last_clause_ < kWillByDefault,
-                       ".WillByDefault() must appear "
-                       "exactly once in an ON_CALL().");
-    last_clause_ = kWillByDefault;
-
-    ExpectSpecProperty(!action.IsDoDefault(),
-                       "DoDefault() cannot be used in ON_CALL().");
-    action_ = action;
-    return *this;
-  }
-
-  // Returns true iff the given arguments match the matchers.
-  bool Matches(const ArgumentTuple& args) const {
-    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
-  }
-
-  // Returns the action specified by the user.
-  const Action<F>& GetAction() const {
-    AssertSpecProperty(last_clause_ == kWillByDefault,
-                       ".WillByDefault() must appear exactly "
-                       "once in an ON_CALL().");
-    return action_;
-  }
-
- private:
-  // The information in statement
-  //
-  //   ON_CALL(mock_object, Method(matchers))
-  //       .With(multi-argument-matcher)
-  //       .WillByDefault(action);
-  //
-  // is recorded in the data members like this:
-  //
-  //   source file that contains the statement => file_
-  //   line number of the statement            => line_
-  //   matchers                                => matchers_
-  //   multi-argument-matcher                  => extra_matcher_
-  //   action                                  => action_
-  ArgumentMatcherTuple matchers_;
-  Matcher<const ArgumentTuple&> extra_matcher_;
-  Action<F> action_;
-};  // class OnCallSpec
-
-// Possible reactions on uninteresting calls.
-enum CallReaction {
-  kAllow,
-  kWarn,
-  kFail,
-  kDefault = kWarn  // By default, warn about uninteresting calls.
-};
-
-}  // namespace internal
-
-// Utilities for manipulating mock objects.
-class GTEST_API_ Mock {
- public:
-  // The following public methods can be called concurrently.
-
-  // Tells Google Mock to ignore mock_obj when checking for leaked
-  // mock objects.
-  static void AllowLeak(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies and clears all expectations on the given mock object.
-  // If the expectations aren't satisfied, generates one or more
-  // Google Test non-fatal failures and returns false.
-  static bool VerifyAndClearExpectations(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies all expectations on the given mock object and clears its
-  // default actions and expectations.  Returns true iff the
-  // verification was successful.
-  static bool VerifyAndClear(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
- private:
-  friend class internal::UntypedFunctionMockerBase;
-
-  // Needed for a function mocker to register itself (so that we know
-  // how to clear a mock object).
-  template <typename F>
-  friend class internal::FunctionMockerBase;
-
-  template <typename M>
-  friend class NiceMock;
-
-  template <typename M>
-  friend class NaggyMock;
-
-  template <typename M>
-  friend class StrictMock;
-
-  // Tells Google Mock to allow uninteresting calls on the given mock
-  // object.
-  static void AllowUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock to warn the user about uninteresting calls on
-  // the given mock object.
-  static void WarnUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock to fail uninteresting calls on the given mock
-  // object.
-  static void FailUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock the given mock object is being destroyed and
-  // its entry in the call-reaction table should be removed.
-  static void UnregisterCallReaction(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Returns the reaction Google Mock will have on uninteresting calls
-  // made on the given mock object.
-  static internal::CallReaction GetReactionOnUninterestingCalls(
-      const void* mock_obj)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies that all expectations on the given mock object have been
-  // satisfied.  Reports one or more Google Test non-fatal failures
-  // and returns false if not.
-  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-
-  // Clears all ON_CALL()s set on the given mock object.
-  static void ClearDefaultActionsLocked(void* mock_obj)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-
-  // Registers a mock object and a mock method it owns.
-  static void Register(
-      const void* mock_obj,
-      internal::UntypedFunctionMockerBase* mocker)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock where in the source code mock_obj is used in an
-  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
-  // information helps the user identify which object it is.
-  static void RegisterUseByOnCallOrExpectCall(
-      const void* mock_obj, const char* file, int line)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Unregisters a mock method; removes the owning mock object from
-  // the registry when the last mock method associated with it has
-  // been unregistered.  This is called only in the destructor of
-  // FunctionMockerBase.
-  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-};  // class Mock
-
-// An abstract handle of an expectation.  Useful in the .After()
-// clause of EXPECT_CALL() for setting the (partial) order of
-// expectations.  The syntax:
-//
-//   Expectation e1 = EXPECT_CALL(...)...;
-//   EXPECT_CALL(...).After(e1)...;
-//
-// sets two expectations where the latter can only be matched after
-// the former has been satisfied.
-//
-// Notes:
-//   - This class is copyable and has value semantics.
-//   - Constness is shallow: a const Expectation object itself cannot
-//     be modified, but the mutable methods of the ExpectationBase
-//     object it references can be called via expectation_base().
-//   - The constructors and destructor are defined out-of-line because
-//     the Symbian WINSCW compiler wants to otherwise instantiate them
-//     when it sees this class definition, at which point it doesn't have
-//     ExpectationBase available yet, leading to incorrect destruction
-//     in the linked_ptr (or compilation errors if using a checking
-//     linked_ptr).
-class GTEST_API_ Expectation {
- public:
-  // Constructs a null object that doesn't reference any expectation.
-  Expectation();
-
-  ~Expectation();
-
-  // This single-argument ctor must not be explicit, in order to support the
-  //   Expectation e = EXPECT_CALL(...);
-  // syntax.
-  //
-  // A TypedExpectation object stores its pre-requisites as
-  // Expectation objects, and needs to call the non-const Retire()
-  // method on the ExpectationBase objects they reference.  Therefore
-  // Expectation must receive a *non-const* reference to the
-  // ExpectationBase object.
-  Expectation(internal::ExpectationBase& exp);  // NOLINT
-
-  // The compiler-generated copy ctor and operator= work exactly as
-  // intended, so we don't need to define our own.
-
-  // Returns true iff rhs references the same expectation as this object does.
-  bool operator==(const Expectation& rhs) const {
-    return expectation_base_ == rhs.expectation_base_;
-  }
-
-  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
-
- private:
-  friend class ExpectationSet;
-  friend class Sequence;
-  friend class ::testing::internal::ExpectationBase;
-  friend class ::testing::internal::UntypedFunctionMockerBase;
-
-  template <typename F>
-  friend class ::testing::internal::FunctionMockerBase;
-
-  template <typename F>
-  friend class ::testing::internal::TypedExpectation;
-
-  // This comparator is needed for putting Expectation objects into a set.
-  class Less {
-   public:
-    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
-      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
-    }
-  };
-
-  typedef ::std::set<Expectation, Less> Set;
-
-  Expectation(
-      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
-
-  // Returns the expectation this object references.
-  const internal::linked_ptr<internal::ExpectationBase>&
-  expectation_base() const {
-    return expectation_base_;
-  }
-
-  // A linked_ptr that co-owns the expectation this handle references.
-  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
-};
-
-// A set of expectation handles.  Useful in the .After() clause of
-// EXPECT_CALL() for setting the (partial) order of expectations.  The
-// syntax:
-//
-//   ExpectationSet es;
-//   es += EXPECT_CALL(...)...;
-//   es += EXPECT_CALL(...)...;
-//   EXPECT_CALL(...).After(es)...;
-//
-// sets three expectations where the last one can only be matched
-// after the first two have both been satisfied.
-//
-// This class is copyable and has value semantics.
-class ExpectationSet {
- public:
-  // A bidirectional iterator that can read a const element in the set.
-  typedef Expectation::Set::const_iterator const_iterator;
-
-  // An object stored in the set.  This is an alias of Expectation.
-  typedef Expectation::Set::value_type value_type;
-
-  // Constructs an empty set.
-  ExpectationSet() {}
-
-  // This single-argument ctor must not be explicit, in order to support the
-  //   ExpectationSet es = EXPECT_CALL(...);
-  // syntax.
-  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
-    *this += Expectation(exp);
-  }
-
-  // This single-argument ctor implements implicit conversion from
-  // Expectation and thus must not be explicit.  This allows either an
-  // Expectation or an ExpectationSet to be used in .After().
-  ExpectationSet(const Expectation& e) {  // NOLINT
-    *this += e;
-  }
-
-  // The compiler-generator ctor and operator= works exactly as
-  // intended, so we don't need to define our own.
-
-  // Returns true iff rhs contains the same set of Expectation objects
-  // as this does.
-  bool operator==(const ExpectationSet& rhs) const {
-    return expectations_ == rhs.expectations_;
-  }
-
-  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
-
-  // Implements the syntax
-  //   expectation_set += EXPECT_CALL(...);
-  ExpectationSet& operator+=(const Expectation& e) {
-    expectations_.insert(e);
-    return *this;
-  }
-
-  int size() const { return static_cast<int>(expectations_.size()); }
-
-  const_iterator begin() const { return expectations_.begin(); }
-  const_iterator end() const { return expectations_.end(); }
-
- private:
-  Expectation::Set expectations_;
-};
-
-
-// Sequence objects are used by a user to specify the relative order
-// in which the expectations should match.  They are copyable (we rely
-// on the compiler-defined copy constructor and assignment operator).
-class GTEST_API_ Sequence {
- public:
-  // Constructs an empty sequence.
-  Sequence() : last_expectation_(new Expectation) {}
-
-  // Adds an expectation to this sequence.  The caller must ensure
-  // that no other thread is accessing this Sequence object.
-  void AddExpectation(const Expectation& expectation) const;
-
- private:
-  // The last expectation in this sequence.  We use a linked_ptr here
-  // because Sequence objects are copyable and we want the copies to
-  // be aliases.  The linked_ptr allows the copies to co-own and share
-  // the same Expectation object.
-  internal::linked_ptr<Expectation> last_expectation_;
-};  // class Sequence
-
-// An object of this type causes all EXPECT_CALL() statements
-// encountered in its scope to be put in an anonymous sequence.  The
-// work is done in the constructor and destructor.  You should only
-// create an InSequence object on the stack.
-//
-// The sole purpose for this class is to support easy definition of
-// sequential expectations, e.g.
-//
-//   {
-//     InSequence dummy;  // The name of the object doesn't matter.
-//
-//     // The following expectations must match in the order they appear.
-//     EXPECT_CALL(a, Bar())...;
-//     EXPECT_CALL(a, Baz())...;
-//     ...
-//     EXPECT_CALL(b, Xyz())...;
-//   }
-//
-// You can create InSequence objects in multiple threads, as long as
-// they are used to affect different mock objects.  The idea is that
-// each thread can create and set up its own mocks as if it's the only
-// thread.  However, for clarity of your tests we recommend you to set
-// up mocks in the main thread unless you have a good reason not to do
-// so.
-class GTEST_API_ InSequence {
- public:
-  InSequence();
-  ~InSequence();
- private:
-  bool sequence_created_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
-} GTEST_ATTRIBUTE_UNUSED_;
-
-namespace internal {
-
-// Points to the implicit sequence introduced by a living InSequence
-// object (if any) in the current thread or NULL.
-GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
-
-// Base class for implementing expectations.
-//
-// There are two reasons for having a type-agnostic base class for
-// Expectation:
-//
-//   1. We need to store collections of expectations of different
-//   types (e.g. all pre-requisites of a particular expectation, all
-//   expectations in a sequence).  Therefore these expectation objects
-//   must share a common base class.
-//
-//   2. We can avoid binary code bloat by moving methods not depending
-//   on the template argument of Expectation to the base class.
-//
-// This class is internal and mustn't be used by user code directly.
-class GTEST_API_ ExpectationBase {
- public:
-  // source_text is the EXPECT_CALL(...) source that created this Expectation.
-  ExpectationBase(const char* file, int line, const string& source_text);
-
-  virtual ~ExpectationBase();
-
-  // Where in the source file was the expectation spec defined?
-  const char* file() const { return file_; }
-  int line() const { return line_; }
-  const char* source_text() const { return source_text_.c_str(); }
-  // Returns the cardinality specified in the expectation spec.
-  const Cardinality& cardinality() const { return cardinality_; }
-
-  // Describes the source file location of this expectation.
-  void DescribeLocationTo(::std::ostream* os) const {
-    *os << FormatFileLocation(file(), line()) << " ";
-  }
-
-  // Describes how many times a function call matching this
-  // expectation has occurred.
-  void DescribeCallCountTo(::std::ostream* os) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // If this mock method has an extra matcher (i.e. .With(matcher)),
-  // describes it to the ostream.
-  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
-
- protected:
-  friend class ::testing::Expectation;
-  friend class UntypedFunctionMockerBase;
-
-  enum Clause {
-    // Don't change the order of the enum members!
-    kNone,
-    kWith,
-    kTimes,
-    kInSequence,
-    kAfter,
-    kWillOnce,
-    kWillRepeatedly,
-    kRetiresOnSaturation
-  };
-
-  typedef std::vector<const void*> UntypedActions;
-
-  // Returns an Expectation object that references and co-owns this
-  // expectation.
-  virtual Expectation GetHandle() = 0;
-
-  // Asserts that the EXPECT_CALL() statement has the given property.
-  void AssertSpecProperty(bool property, const string& failure_message) const {
-    Assert(property, file_, line_, failure_message);
-  }
-
-  // Expects that the EXPECT_CALL() statement has the given property.
-  void ExpectSpecProperty(bool property, const string& failure_message) const {
-    Expect(property, file_, line_, failure_message);
-  }
-
-  // Explicitly specifies the cardinality of this expectation.  Used
-  // by the subclasses to implement the .Times() clause.
-  void SpecifyCardinality(const Cardinality& cardinality);
-
-  // Returns true iff the user specified the cardinality explicitly
-  // using a .Times().
-  bool cardinality_specified() const { return cardinality_specified_; }
-
-  // Sets the cardinality of this expectation spec.
-  void set_cardinality(const Cardinality& a_cardinality) {
-    cardinality_ = a_cardinality;
-  }
-
-  // The following group of methods should only be called after the
-  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
-  // the current thread.
-
-  // Retires all pre-requisites of this expectation.
-  void RetireAllPreRequisites()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Returns true iff this expectation is retired.
-  bool is_retired() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return retired_;
-  }
-
-  // Retires this expectation.
-  void Retire()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    retired_ = true;
-  }
-
-  // Returns true iff this expectation is satisfied.
-  bool IsSatisfied() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return cardinality().IsSatisfiedByCallCount(call_count_);
-  }
-
-  // Returns true iff this expectation is saturated.
-  bool IsSaturated() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return cardinality().IsSaturatedByCallCount(call_count_);
-  }
-
-  // Returns true iff this expectation is over-saturated.
-  bool IsOverSaturated() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return cardinality().IsOverSaturatedByCallCount(call_count_);
-  }
-
-  // Returns true iff all pre-requisites of this expectation are satisfied.
-  bool AllPrerequisitesAreSatisfied() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Adds unsatisfied pre-requisites of this expectation to 'result'.
-  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Returns the number this expectation has been invoked.
-  int call_count() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return call_count_;
-  }
-
-  // Increments the number this expectation has been invoked.
-  void IncrementCallCount()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    call_count_++;
-  }
-
-  // Checks the action count (i.e. the number of WillOnce() and
-  // WillRepeatedly() clauses) against the cardinality if this hasn't
-  // been done before.  Prints a warning if there are too many or too
-  // few actions.
-  void CheckActionCountIfNotDone() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  friend class ::testing::Sequence;
-  friend class ::testing::internal::ExpectationTester;
-
-  template <typename Function>
-  friend class TypedExpectation;
-
-  // Implements the .Times() clause.
-  void UntypedTimes(const Cardinality& a_cardinality);
-
-  // This group of fields are part of the spec and won't change after
-  // an EXPECT_CALL() statement finishes.
-  const char* file_;          // The file that contains the expectation.
-  int line_;                  // The line number of the expectation.
-  const string source_text_;  // The EXPECT_CALL(...) source text.
-  // True iff the cardinality is specified explicitly.
-  bool cardinality_specified_;
-  Cardinality cardinality_;            // The cardinality of the expectation.
-  // The immediate pre-requisites (i.e. expectations that must be
-  // satisfied before this expectation can be matched) of this
-  // expectation.  We use linked_ptr in the set because we want an
-  // Expectation object to be co-owned by its FunctionMocker and its
-  // successors.  This allows multiple mock objects to be deleted at
-  // different times.
-  ExpectationSet immediate_prerequisites_;
-
-  // This group of fields are the current state of the expectation,
-  // and can change as the mock function is called.
-  int call_count_;  // How many times this expectation has been invoked.
-  bool retired_;    // True iff this expectation has retired.
-  UntypedActions untyped_actions_;
-  bool extra_matcher_specified_;
-  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
-  bool retires_on_saturation_;
-  Clause last_clause_;
-  mutable bool action_count_checked_;  // Under mutex_.
-  mutable Mutex mutex_;  // Protects action_count_checked_.
-
-  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
-};  // class ExpectationBase
-
-// Impements an expectation for the given function type.
-template <typename F>
-class TypedExpectation : public ExpectationBase {
- public:
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-  typedef typename Function<F>::Result Result;
-
-  TypedExpectation(FunctionMockerBase<F>* owner,
-                   const char* a_file, int a_line, const string& a_source_text,
-                   const ArgumentMatcherTuple& m)
-      : ExpectationBase(a_file, a_line, a_source_text),
-        owner_(owner),
-        matchers_(m),
-        // By default, extra_matcher_ should match anything.  However,
-        // we cannot initialize it with _ as that triggers a compiler
-        // bug in Symbian's C++ compiler (cannot decide between two
-        // overloaded constructors of Matcher<const ArgumentTuple&>).
-        extra_matcher_(A<const ArgumentTuple&>()),
-        repeated_action_(DoDefault()) {}
-
-  virtual ~TypedExpectation() {
-    // Check the validity of the action count if it hasn't been done
-    // yet (for example, if the expectation was never used).
-    CheckActionCountIfNotDone();
-    for (UntypedActions::const_iterator it = untyped_actions_.begin();
-         it != untyped_actions_.end(); ++it) {
-      delete static_cast<const Action<F>*>(*it);
-    }
-  }
-
-  // Implements the .With() clause.
-  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
-    if (last_clause_ == kWith) {
-      ExpectSpecProperty(false,
-                         ".With() cannot appear "
-                         "more than once in an EXPECT_CALL().");
-    } else {
-      ExpectSpecProperty(last_clause_ < kWith,
-                         ".With() must be the first "
-                         "clause in an EXPECT_CALL().");
-    }
-    last_clause_ = kWith;
-
-    extra_matcher_ = m;
-    extra_matcher_specified_ = true;
-    return *this;
-  }
-
-  // Implements the .Times() clause.
-  TypedExpectation& Times(const Cardinality& a_cardinality) {
-    ExpectationBase::UntypedTimes(a_cardinality);
-    return *this;
-  }
-
-  // Implements the .Times() clause.
-  TypedExpectation& Times(int n) {
-    return Times(Exactly(n));
-  }
-
-  // Implements the .InSequence() clause.
-  TypedExpectation& InSequence(const Sequence& s) {
-    ExpectSpecProperty(last_clause_ <= kInSequence,
-                       ".InSequence() cannot appear after .After(),"
-                       " .WillOnce(), .WillRepeatedly(), or "
-                       ".RetiresOnSaturation().");
-    last_clause_ = kInSequence;
-
-    s.AddExpectation(GetHandle());
-    return *this;
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
-    return InSequence(s1).InSequence(s2);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3) {
-    return InSequence(s1, s2).InSequence(s3);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3, const Sequence& s4) {
-    return InSequence(s1, s2, s3).InSequence(s4);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3, const Sequence& s4,
-                               const Sequence& s5) {
-    return InSequence(s1, s2, s3, s4).InSequence(s5);
-  }
-
-  // Implements that .After() clause.
-  TypedExpectation& After(const ExpectationSet& s) {
-    ExpectSpecProperty(last_clause_ <= kAfter,
-                       ".After() cannot appear after .WillOnce(),"
-                       " .WillRepeatedly(), or "
-                       ".RetiresOnSaturation().");
-    last_clause_ = kAfter;
-
-    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
-      immediate_prerequisites_ += *it;
-    }
-    return *this;
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
-    return After(s1).After(s2);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3) {
-    return After(s1, s2).After(s3);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3, const ExpectationSet& s4) {
-    return After(s1, s2, s3).After(s4);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3, const ExpectationSet& s4,
-                          const ExpectationSet& s5) {
-    return After(s1, s2, s3, s4).After(s5);
-  }
-
-  // Implements the .WillOnce() clause.
-  TypedExpectation& WillOnce(const Action<F>& action) {
-    ExpectSpecProperty(last_clause_ <= kWillOnce,
-                       ".WillOnce() cannot appear after "
-                       ".WillRepeatedly() or .RetiresOnSaturation().");
-    last_clause_ = kWillOnce;
-
-    untyped_actions_.push_back(new Action<F>(action));
-    if (!cardinality_specified()) {
-      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
-    }
-    return *this;
-  }
-
-  // Implements the .WillRepeatedly() clause.
-  TypedExpectation& WillRepeatedly(const Action<F>& action) {
-    if (last_clause_ == kWillRepeatedly) {
-      ExpectSpecProperty(false,
-                         ".WillRepeatedly() cannot appear "
-                         "more than once in an EXPECT_CALL().");
-    } else {
-      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
-                         ".WillRepeatedly() cannot appear "
-                         "after .RetiresOnSaturation().");
-    }
-    last_clause_ = kWillRepeatedly;
-    repeated_action_specified_ = true;
-
-    repeated_action_ = action;
-    if (!cardinality_specified()) {
-      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
-    }
-
-    // Now that no more action clauses can be specified, we check
-    // whether their count makes sense.
-    CheckActionCountIfNotDone();
-    return *this;
-  }
-
-  // Implements the .RetiresOnSaturation() clause.
-  TypedExpectation& RetiresOnSaturation() {
-    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
-                       ".RetiresOnSaturation() cannot appear "
-                       "more than once.");
-    last_clause_ = kRetiresOnSaturation;
-    retires_on_saturation_ = true;
-
-    // Now that no more action clauses can be specified, we check
-    // whether their count makes sense.
-    CheckActionCountIfNotDone();
-    return *this;
-  }
-
-  // Returns the matchers for the arguments as specified inside the
-  // EXPECT_CALL() macro.
-  const ArgumentMatcherTuple& matchers() const {
-    return matchers_;
-  }
-
-  // Returns the matcher specified by the .With() clause.
-  const Matcher<const ArgumentTuple&>& extra_matcher() const {
-    return extra_matcher_;
-  }
-
-  // Returns the action specified by the .WillRepeatedly() clause.
-  const Action<F>& repeated_action() const { return repeated_action_; }
-
-  // If this mock method has an extra matcher (i.e. .With(matcher)),
-  // describes it to the ostream.
-  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
-    if (extra_matcher_specified_) {
-      *os << "    Expected args: ";
-      extra_matcher_.DescribeTo(os);
-      *os << "\n";
-    }
-  }
-
- private:
-  template <typename Function>
-  friend class FunctionMockerBase;
-
-  // Returns an Expectation object that references and co-owns this
-  // expectation.
-  virtual Expectation GetHandle() {
-    return owner_->GetHandleOf(this);
-  }
-
-  // The following methods will be called only after the EXPECT_CALL()
-  // statement finishes and when the current thread holds
-  // g_gmock_mutex.
-
-  // Returns true iff this expectation matches the given arguments.
-  bool Matches(const ArgumentTuple& args) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
-  }
-
-  // Returns true iff this expectation should handle the given arguments.
-  bool ShouldHandleArguments(const ArgumentTuple& args) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    // In case the action count wasn't checked when the expectation
-    // was defined (e.g. if this expectation has no WillRepeatedly()
-    // or RetiresOnSaturation() clause), we check it when the
-    // expectation is used for the first time.
-    CheckActionCountIfNotDone();
-    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
-  }
-
-  // Describes the result of matching the arguments against this
-  // expectation to the given ostream.
-  void ExplainMatchResultTo(
-      const ArgumentTuple& args,
-      ::std::ostream* os) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    if (is_retired()) {
-      *os << "         Expected: the expectation is active\n"
-          << "           Actual: it is retired\n";
-    } else if (!Matches(args)) {
-      if (!TupleMatches(matchers_, args)) {
-        ExplainMatchFailureTupleTo(matchers_, args, os);
-      }
-      StringMatchResultListener listener;
-      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
-        *os << "    Expected args: ";
-        extra_matcher_.DescribeTo(os);
-        *os << "\n           Actual: don't match";
-
-        internal::PrintIfNotEmpty(listener.str(), os);
-        *os << "\n";
-      }
-    } else if (!AllPrerequisitesAreSatisfied()) {
-      *os << "         Expected: all pre-requisites are satisfied\n"
-          << "           Actual: the following immediate pre-requisites "
-          << "are not satisfied:\n";
-      ExpectationSet unsatisfied_prereqs;
-      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
-      int i = 0;
-      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
-           it != unsatisfied_prereqs.end(); ++it) {
-        it->expectation_base()->DescribeLocationTo(os);
-        *os << "pre-requisite #" << i++ << "\n";
-      }
-      *os << "                   (end of pre-requisites)\n";
-    } else {
-      // This line is here just for completeness' sake.  It will never
-      // be executed as currently the ExplainMatchResultTo() function
-      // is called only when the mock function call does NOT match the
-      // expectation.
-      *os << "The call matches the expectation.\n";
-    }
-  }
-
-  // Returns the action that should be taken for the current invocation.
-  const Action<F>& GetCurrentAction(
-      const FunctionMockerBase<F>* mocker,
-      const ArgumentTuple& args) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    const int count = call_count();
-    Assert(count >= 1, __FILE__, __LINE__,
-           "call_count() is <= 0 when GetCurrentAction() is "
-           "called - this should never happen.");
-
-    const int action_count = static_cast<int>(untyped_actions_.size());
-    if (action_count > 0 && !repeated_action_specified_ &&
-        count > action_count) {
-      // If there is at least one WillOnce() and no WillRepeatedly(),
-      // we warn the user when the WillOnce() clauses ran out.
-      ::std::stringstream ss;
-      DescribeLocationTo(&ss);
-      ss << "Actions ran out in " << source_text() << "...\n"
-         << "Called " << count << " times, but only "
-         << action_count << " WillOnce()"
-         << (action_count == 1 ? " is" : "s are") << " specified - ";
-      mocker->DescribeDefaultActionTo(args, &ss);
-      Log(kWarning, ss.str(), 1);
-    }
-
-    return count <= action_count ?
-        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
-        repeated_action();
-  }
-
-  // Given the arguments of a mock function call, if the call will
-  // over-saturate this expectation, returns the default action;
-  // otherwise, returns the next action in this expectation.  Also
-  // describes *what* happened to 'what', and explains *why* Google
-  // Mock does it to 'why'.  This method is not const as it calls
-  // IncrementCallCount().  A return value of NULL means the default
-  // action.
-  const Action<F>* GetActionForArguments(
-      const FunctionMockerBase<F>* mocker,
-      const ArgumentTuple& args,
-      ::std::ostream* what,
-      ::std::ostream* why)
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    if (IsSaturated()) {
-      // We have an excessive call.
-      IncrementCallCount();
-      *what << "Mock function called more times than expected - ";
-      mocker->DescribeDefaultActionTo(args, what);
-      DescribeCallCountTo(why);
-
-      // TODO(wan@google.com): allow the user to control whether
-      // unexpected calls should fail immediately or continue using a
-      // flag --gmock_unexpected_calls_are_fatal.
-      return NULL;
-    }
-
-    IncrementCallCount();
-    RetireAllPreRequisites();
-
-    if (retires_on_saturation_ && IsSaturated()) {
-      Retire();
-    }
-
-    // Must be done after IncrementCount()!
-    *what << "Mock function call matches " << source_text() <<"...\n";
-    return &(GetCurrentAction(mocker, args));
-  }
-
-  // All the fields below won't change once the EXPECT_CALL()
-  // statement finishes.
-  FunctionMockerBase<F>* const owner_;
-  ArgumentMatcherTuple matchers_;
-  Matcher<const ArgumentTuple&> extra_matcher_;
-  Action<F> repeated_action_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
-};  // class TypedExpectation
-
-// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
-// specifying the default behavior of, or expectation on, a mock
-// function.
-
-// Note: class MockSpec really belongs to the ::testing namespace.
-// However if we define it in ::testing, MSVC will complain when
-// classes in ::testing::internal declare it as a friend class
-// template.  To workaround this compiler bug, we define MockSpec in
-// ::testing::internal and import it into ::testing.
-
-// Logs a message including file and line number information.
-GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
-                                const char* file, int line,
-                                const string& message);
-
-template <typename F>
-class MockSpec {
- public:
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename internal::Function<F>::ArgumentMatcherTuple
-      ArgumentMatcherTuple;
-
-  // Constructs a MockSpec object, given the function mocker object
-  // that the spec is associated with.
-  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
-      : function_mocker_(function_mocker) {}
-
-  // Adds a new default action spec to the function mocker and returns
-  // the newly created spec.
-  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
-      const char* file, int line, const char* obj, const char* call) {
-    LogWithLocation(internal::kInfo, file, line,
-        string("ON_CALL(") + obj + ", " + call + ") invoked");
-    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
-  }
-
-  // Adds a new expectation spec to the function mocker and returns
-  // the newly created spec.
-  internal::TypedExpectation<F>& InternalExpectedAt(
-      const char* file, int line, const char* obj, const char* call) {
-    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
-    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
-    return function_mocker_->AddNewExpectation(
-        file, line, source_text, matchers_);
-  }
-
- private:
-  template <typename Function>
-  friend class internal::FunctionMocker;
-
-  void SetMatchers(const ArgumentMatcherTuple& matchers) {
-    matchers_ = matchers;
-  }
-
-  // The function mocker that owns this spec.
-  internal::FunctionMockerBase<F>* const function_mocker_;
-  // The argument matchers specified in the spec.
-  ArgumentMatcherTuple matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(MockSpec);
-};  // class MockSpec
-
-// Wrapper type for generically holding an ordinary value or lvalue reference.
-// If T is not a reference type, it must be copyable or movable.
-// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
-// T is a move-only value type (which means that it will always be copyable
-// if the current platform does not support move semantics).
-//
-// The primary template defines handling for values, but function header
-// comments describe the contract for the whole template (including
-// specializations).
-template <typename T>
-class ReferenceOrValueWrapper {
- public:
-  // Constructs a wrapper from the given value/reference.
-  explicit ReferenceOrValueWrapper(T value)
-      : value_(::testing::internal::move(value)) {
-  }
-
-  // Unwraps and returns the underlying value/reference, exactly as
-  // originally passed. The behavior of calling this more than once on
-  // the same object is unspecified.
-  T Unwrap() { return ::testing::internal::move(value_); }
-
-  // Provides nondestructive access to the underlying value/reference.
-  // Always returns a const reference (more precisely,
-  // const RemoveReference<T>&). The behavior of calling this after
-  // calling Unwrap on the same object is unspecified.
-  const T& Peek() const {
-    return value_;
-  }
-
- private:
-  T value_;
-};
-
-// Specialization for lvalue reference types. See primary template
-// for documentation.
-template <typename T>
-class ReferenceOrValueWrapper<T&> {
- public:
-  // Workaround for debatable pass-by-reference lint warning (c-library-team
-  // policy precludes NOLINT in this context)
-  typedef T& reference;
-  explicit ReferenceOrValueWrapper(reference ref)
-      : value_ptr_(&ref) {}
-  T& Unwrap() { return *value_ptr_; }
-  const T& Peek() const { return *value_ptr_; }
-
- private:
-  T* value_ptr_;
-};
-
-// MSVC warns about using 'this' in base member initializer list, so
-// we need to temporarily disable the warning.  We have to do it for
-// the entire class to suppress the warning, even though it's about
-// the constructor only.
-
-#ifdef _MSC_VER
-# pragma warning(push)          // Saves the current warning state.
-# pragma warning(disable:4355)  // Temporarily disables warning 4355.
-#endif  // _MSV_VER
-
-// C++ treats the void type specially.  For example, you cannot define
-// a void-typed variable or pass a void value to a function.
-// ActionResultHolder<T> holds a value of type T, where T must be a
-// copyable type or void (T doesn't need to be default-constructable).
-// It hides the syntactic difference between void and other types, and
-// is used to unify the code for invoking both void-returning and
-// non-void-returning mock functions.
-
-// Untyped base class for ActionResultHolder<T>.
-class UntypedActionResultHolderBase {
- public:
-  virtual ~UntypedActionResultHolderBase() {}
-
-  // Prints the held value as an action's result to os.
-  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
-};
-
-// This generic definition is used when T is not void.
-template <typename T>
-class ActionResultHolder : public UntypedActionResultHolderBase {
- public:
-  // Returns the held value. Must not be called more than once.
-  T Unwrap() {
-    return result_.Unwrap();
-  }
-
-  // Prints the held value as an action's result to os.
-  virtual void PrintAsActionResult(::std::ostream* os) const {
-    *os << "\n          Returns: ";
-    // T may be a reference type, so we don't use UniversalPrint().
-    UniversalPrinter<T>::Print(result_.Peek(), os);
-  }
-
-  // Performs the given mock function's default action and returns the
-  // result in a new-ed ActionResultHolder.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMockerBase<F>* func_mocker,
-      const typename Function<F>::ArgumentTuple& args,
-      const string& call_description) {
-    return new ActionResultHolder(Wrapper(
-        func_mocker->PerformDefaultAction(args, call_description)));
-  }
-
-  // Performs the given action and returns the result in a new-ed
-  // ActionResultHolder.
-  template <typename F>
-  static ActionResultHolder*
-  PerformAction(const Action<F>& action,
-                const typename Function<F>::ArgumentTuple& args) {
-    return new ActionResultHolder(Wrapper(action.Perform(args)));
-  }
-
- private:
-  typedef ReferenceOrValueWrapper<T> Wrapper;
-
-  explicit ActionResultHolder(Wrapper result)
-      : result_(::testing::internal::move(result)) {
-  }
-
-  Wrapper result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
-};
-
-// Specialization for T = void.
-template <>
-class ActionResultHolder<void> : public UntypedActionResultHolderBase {
- public:
-  void Unwrap() { }
-
-  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
-
-  // Performs the given mock function's default action and returns ownership
-  // of an empty ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMockerBase<F>* func_mocker,
-      const typename Function<F>::ArgumentTuple& args,
-      const string& call_description) {
-    func_mocker->PerformDefaultAction(args, call_description);
-    return new ActionResultHolder;
-  }
-
-  // Performs the given action and returns ownership of an empty
-  // ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformAction(
-      const Action<F>& action,
-      const typename Function<F>::ArgumentTuple& args) {
-    action.Perform(args);
-    return new ActionResultHolder;
-  }
-
- private:
-  ActionResultHolder() {}
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
-};
-
-// The base of the function mocker class for the given function type.
-// We put the methods in this class instead of its child to avoid code
-// bloat.
-template <typename F>
-class FunctionMockerBase : public UntypedFunctionMockerBase {
- public:
-  typedef typename Function<F>::Result Result;
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-
-  FunctionMockerBase() : current_spec_(this) {}
-
-  // The destructor verifies that all expectations on this mock
-  // function have been satisfied.  If not, it will report Google Test
-  // non-fatal failures for the violations.
-  virtual ~FunctionMockerBase()
-        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    MutexLock l(&g_gmock_mutex);
-    VerifyAndClearExpectationsLocked();
-    Mock::UnregisterLocked(this);
-    ClearDefaultActionsLocked();
-  }
-
-  // Returns the ON_CALL spec that matches this mock function with the
-  // given arguments; returns NULL if no matching ON_CALL is found.
-  // L = *
-  const OnCallSpec<F>* FindOnCallSpec(
-      const ArgumentTuple& args) const {
-    for (UntypedOnCallSpecs::const_reverse_iterator it
-             = untyped_on_call_specs_.rbegin();
-         it != untyped_on_call_specs_.rend(); ++it) {
-      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
-      if (spec->Matches(args))
-        return spec;
-    }
-
-    return NULL;
-  }
-
-  // Performs the default action of this mock function on the given
-  // arguments and returns the result. Asserts (or throws if
-  // exceptions are enabled) with a helpful call descrption if there
-  // is no valid return value. This method doesn't depend on the
-  // mutable state of this object, and thus can be called concurrently
-  // without locking.
-  // L = *
-  Result PerformDefaultAction(const ArgumentTuple& args,
-                              const string& call_description) const {
-    const OnCallSpec<F>* const spec =
-        this->FindOnCallSpec(args);
-    if (spec != NULL) {
-      return spec->GetAction().Perform(args);
-    }
-    const string message = call_description +
-        "\n    The mock function has no default action "
-        "set, and its return type has no default value set.";
-#if GTEST_HAS_EXCEPTIONS
-    if (!DefaultValue<Result>::Exists()) {
-      throw std::runtime_error(message);
-    }
-#else
-    Assert(DefaultValue<Result>::Exists(), "", -1, message);
-#endif
-    return DefaultValue<Result>::Get();
-  }
-
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.  The caller is responsible for deleting the result.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      const void* untyped_args,  // must point to an ArgumentTuple
-      const string& call_description) const {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformDefaultAction(this, args, call_description);
-  }
-
-  // Performs the given action with the given arguments and returns
-  // the action's result.  The caller is responsible for deleting the
-  // result.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, const void* untyped_args) const {
-    // Make a copy of the action before performing it, in case the
-    // action deletes the mock object (and thus deletes itself).
-    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformAction(action, args);
-  }
-
-  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
-  // clears the ON_CALL()s set on this mock function.
-  virtual void ClearDefaultActionsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    // Deleting our default actions may trigger other mock objects to be
-    // deleted, for example if an action contains a reference counted smart
-    // pointer to that mock object, and that is the last reference. So if we
-    // delete our actions within the context of the global mutex we may deadlock
-    // when this method is called again. Instead, make a copy of the set of
-    // actions to delete, clear our set within the mutex, and then delete the
-    // actions outside of the mutex.
-    UntypedOnCallSpecs specs_to_delete;
-    untyped_on_call_specs_.swap(specs_to_delete);
-
-    g_gmock_mutex.Unlock();
-    for (UntypedOnCallSpecs::const_iterator it =
-             specs_to_delete.begin();
-         it != specs_to_delete.end(); ++it) {
-      delete static_cast<const OnCallSpec<F>*>(*it);
-    }
-
-    // Lock the mutex again, since the caller expects it to be locked when we
-    // return.
-    g_gmock_mutex.Lock();
-  }
-
- protected:
-  template <typename Function>
-  friend class MockSpec;
-
-  typedef ActionResultHolder<Result> ResultHolder;
-
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.
-  Result InvokeWith(const ArgumentTuple& args)
-        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    scoped_ptr<ResultHolder> holder(
-        DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
-    return holder->Unwrap();
-  }
-
-  // Adds and returns a default action spec for this mock function.
-  OnCallSpec<F>& AddNewOnCallSpec(
-      const char* file, int line,
-      const ArgumentMatcherTuple& m)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
-    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
-    untyped_on_call_specs_.push_back(on_call_spec);
-    return *on_call_spec;
-  }
-
-  // Adds and returns an expectation spec for this mock function.
-  TypedExpectation<F>& AddNewExpectation(
-      const char* file,
-      int line,
-      const string& source_text,
-      const ArgumentMatcherTuple& m)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
-    TypedExpectation<F>* const expectation =
-        new TypedExpectation<F>(this, file, line, source_text, m);
-    const linked_ptr<ExpectationBase> untyped_expectation(expectation);
-    untyped_expectations_.push_back(untyped_expectation);
-
-    // Adds this expectation into the implicit sequence if there is one.
-    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
-    if (implicit_sequence != NULL) {
-      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
-    }
-
-    return *expectation;
-  }
-
-  // The current spec (either default action spec or expectation spec)
-  // being described on this function mocker.
-  MockSpec<F>& current_spec() { return current_spec_; }
-
- private:
-  template <typename Func> friend class TypedExpectation;
-
-  // Some utilities needed for implementing UntypedInvokeWith().
-
-  // Describes what default action will be performed for the given
-  // arguments.
-  // L = *
-  void DescribeDefaultActionTo(const ArgumentTuple& args,
-                               ::std::ostream* os) const {
-    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
-
-    if (spec == NULL) {
-      *os << (internal::type_equals<Result, void>::value ?
-              "returning directly.\n" :
-              "returning default value.\n");
-    } else {
-      *os << "taking default action specified at:\n"
-          << FormatFileLocation(spec->file(), spec->line()) << "\n";
-    }
-  }
-
-  // Writes a message that the call is uninteresting (i.e. neither
-  // explicitly expected nor explicitly unexpected) to the given
-  // ostream.
-  virtual void UntypedDescribeUninterestingCall(
-      const void* untyped_args,
-      ::std::ostream* os) const
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    *os << "Uninteresting mock function call - ";
-    DescribeDefaultActionTo(args, os);
-    *os << "    Function call: " << Name();
-    UniversalPrint(args, os);
-  }
-
-  // Returns the expectation that matches the given function arguments
-  // (or NULL is there's no match); when a match is found,
-  // untyped_action is set to point to the action that should be
-  // performed (or NULL if the action is "do default"), and
-  // is_excessive is modified to indicate whether the call exceeds the
-  // expected number.
-  //
-  // Critical section: We must find the matching expectation and the
-  // corresponding action that needs to be taken in an ATOMIC
-  // transaction.  Otherwise another thread may call this mock
-  // method in the middle and mess up the state.
-  //
-  // However, performing the action has to be left out of the critical
-  // section.  The reason is that we have no control on what the
-  // action does (it can invoke an arbitrary user function or even a
-  // mock function) and excessive locking could cause a dead lock.
-  virtual const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args,
-      const void** untyped_action, bool* is_excessive,
-      ::std::ostream* what, ::std::ostream* why)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    MutexLock l(&g_gmock_mutex);
-    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
-    if (exp == NULL) {  // A match wasn't found.
-      this->FormatUnexpectedCallMessageLocked(args, what, why);
-      return NULL;
-    }
-
-    // This line must be done before calling GetActionForArguments(),
-    // which will increment the call count for *exp and thus affect
-    // its saturation status.
-    *is_excessive = exp->IsSaturated();
-    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
-    if (action != NULL && action->IsDoDefault())
-      action = NULL;  // Normalize "do default" to NULL.
-    *untyped_action = action;
-    return exp;
-  }
-
-  // Prints the given function arguments to the ostream.
-  virtual void UntypedPrintArgs(const void* untyped_args,
-                                ::std::ostream* os) const {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    UniversalPrint(args, os);
-  }
-
-  // Returns the expectation that matches the arguments, or NULL if no
-  // expectation matches them.
-  TypedExpectation<F>* FindMatchingExpectationLocked(
-      const ArgumentTuple& args) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    for (typename UntypedExpectations::const_reverse_iterator it =
-             untyped_expectations_.rbegin();
-         it != untyped_expectations_.rend(); ++it) {
-      TypedExpectation<F>* const exp =
-          static_cast<TypedExpectation<F>*>(it->get());
-      if (exp->ShouldHandleArguments(args)) {
-        return exp;
-      }
-    }
-    return NULL;
-  }
-
-  // Returns a message that the arguments don't match any expectation.
-  void FormatUnexpectedCallMessageLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* os,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    *os << "\nUnexpected mock function call - ";
-    DescribeDefaultActionTo(args, os);
-    PrintTriedExpectationsLocked(args, why);
-  }
-
-  // Prints a list of expectations that have been tried against the
-  // current mock function call.
-  void PrintTriedExpectationsLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    const int count = static_cast<int>(untyped_expectations_.size());
-    *why << "Google Mock tried the following " << count << " "
-         << (count == 1 ? "expectation, but it didn't match" :
-             "expectations, but none matched")
-         << ":\n";
-    for (int i = 0; i < count; i++) {
-      TypedExpectation<F>* const expectation =
-          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
-      *why << "\n";
-      expectation->DescribeLocationTo(why);
-      if (count > 1) {
-        *why << "tried expectation #" << i << ": ";
-      }
-      *why << expectation->source_text() << "...\n";
-      expectation->ExplainMatchResultTo(args, why);
-      expectation->DescribeCallCountTo(why);
-    }
-  }
-
-  // The current spec (either default action spec or expectation spec)
-  // being described on this function mocker.
-  MockSpec<F> current_spec_;
-
-  // There is no generally useful and implementable semantics of
-  // copying a mock object, so copying a mock is usually a user error.
-  // Thus we disallow copying function mockers.  If the user really
-  // wants to copy a mock object, he should implement his own copy
-  // operation, for example:
-  //
-  //   class MockFoo : public Foo {
-  //    public:
-  //     // Defines a copy constructor explicitly.
-  //     MockFoo(const MockFoo& src) {}
-  //     ...
-  //   };
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
-};  // class FunctionMockerBase
-
-#ifdef _MSC_VER
-# pragma warning(pop)  // Restores the warning state.
-#endif  // _MSV_VER
-
-// Implements methods of FunctionMockerBase.
-
-// Verifies that all expectations on this mock function have been
-// satisfied.  Reports one or more Google Test non-fatal failures and
-// returns false if not.
-
-// Reports an uninteresting call (whose description is in msg) in the
-// manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const string& msg);
-
-}  // namespace internal
-
-// The style guide prohibits "using" statements in a namespace scope
-// inside a header file.  However, the MockSpec class template is
-// meant to be defined in the ::testing namespace.  The following line
-// is just a trick for working around a bug in MSVC 8.0, which cannot
-// handle it if we define MockSpec in ::testing.
-using internal::MockSpec;
-
-// Const(x) is a convenient function for obtaining a const reference
-// to x.  This is useful for setting expectations on an overloaded
-// const mock method, e.g.
-//
-//   class MockFoo : public FooInterface {
-//    public:
-//     MOCK_METHOD0(Bar, int());
-//     MOCK_CONST_METHOD0(Bar, int&());
-//   };
-//
-//   MockFoo foo;
-//   // Expects a call to non-const MockFoo::Bar().
-//   EXPECT_CALL(foo, Bar());
-//   // Expects a call to const MockFoo::Bar().
-//   EXPECT_CALL(Const(foo), Bar());
-template <typename T>
-inline const T& Const(const T& x) { return x; }
-
-// Constructs an Expectation object that references and co-owns exp.
-inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
-    : expectation_base_(exp.GetHandle().expectation_base()) {}
-
-}  // namespace testing
-
-// A separate macro is required to avoid compile errors when the name
-// of the method used in call is a result of macro expansion.
-// See CompilesWithMethodNameExpandedFromMacro tests in
-// internal/gmock-spec-builders_test.cc for more details.
-#define GMOCK_ON_CALL_IMPL_(obj, call) \
-    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
-                                                    #obj, #call)
-#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
-
-#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
-    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
-#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-
-#if GTEST_HAS_STD_FUNCTION_
-# include <functional>
-#endif
-
-namespace testing {
-namespace internal {
-
-template <typename F>
-class FunctionMockerBase;
-
-// Note: class FunctionMocker really belongs to the ::testing
-// namespace.  However if we define it in ::testing, MSVC will
-// complain when classes in ::testing::internal declare it as a
-// friend class template.  To workaround this compiler bug, we define
-// FunctionMocker in ::testing::internal and import it into ::testing.
-template <typename F>
-class FunctionMocker;
-
-template <typename R>
-class FunctionMocker<R()> : public
-    internal::FunctionMockerBase<R()> {
- public:
-  typedef R F();
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With() {
-    return this->current_spec();
-  }
-
-  R Invoke() {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple());
-  }
-};
-
-template <typename R, typename A1>
-class FunctionMocker<R(A1)> : public
-    internal::FunctionMockerBase<R(A1)> {
- public:
-  typedef R F(A1);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1));
-  }
-};
-
-template <typename R, typename A1, typename A2>
-class FunctionMocker<R(A1, A2)> : public
-    internal::FunctionMockerBase<R(A1, A2)> {
- public:
-  typedef R F(A1, A2);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-class FunctionMocker<R(A1, A2, A3)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3)> {
- public:
-  typedef R F(A1, A2, A3);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class FunctionMocker<R(A1, A2, A3, A4)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
- public:
-  typedef R F(A1, A2, A3, A4);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
-      const Matcher<A9>& m9) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8, m9));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
-      const Matcher<A9>& m9, const Matcher<A10>& m10) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8, m9, m10));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
-      A10 a10) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
-        a10));
-  }
-};
-
-}  // namespace internal
-
-// The style guide prohibits "using" statements in a namespace scope
-// inside a header file.  However, the FunctionMocker class template
-// is meant to be defined in the ::testing namespace.  The following
-// line is just a trick for working around a bug in MSVC 8.0, which
-// cannot handle it if we define FunctionMocker in ::testing.
-using internal::FunctionMocker;
-
-// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
-// We define this as a variadic macro in case F contains unprotected
-// commas (the same reason that we use variadic macros in other places
-// in this file).
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_RESULT_(tn, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Result
-
-// The type of argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_ARG_(tn, N, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
-
-// The matcher type for argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MATCHER_(tn, N, ...) \
-    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
-
-// The variable for mocking the given method.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MOCKER_(arity, constness, Method) \
-    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      ) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 0), \
-        this_method_does_not_take_0_arguments); \
-    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method() constness { \
-    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(0, constness, Method).With(); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 1), \
-        this_method_does_not_take_1_argument); \
-    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
-    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 2), \
-        this_method_does_not_take_2_arguments); \
-    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
-    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 3), \
-        this_method_does_not_take_3_arguments); \
-    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
-    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 4), \
-        this_method_does_not_take_4_arguments); \
-    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
-    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 5), \
-        this_method_does_not_take_5_arguments); \
-    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
-    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 6), \
-        this_method_does_not_take_6_arguments); \
-    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
-    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 7), \
-        this_method_does_not_take_7_arguments); \
-    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
-    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 8), \
-        this_method_does_not_take_8_arguments); \
-    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
-    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
-      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 9), \
-        this_method_does_not_take_9_arguments); \
-    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
-        gmock_a9); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
-                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
-    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
-        gmock_a9); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
-      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \
-      GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 10), \
-        this_method_does_not_take_10_arguments); \
-    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
-        gmock_a10); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
-                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
-                     GMOCK_MATCHER_(tn, 10, \
-                         __VA_ARGS__) gmock_a10) constness { \
-    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
-        gmock_a10); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \
-      Method)
-
-#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
-
-#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T(m, ...) \
-    GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T(m, ...) \
-    GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T(m, ...) \
-    GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T(m, ...) \
-    GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T(m, ...) \
-    GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T(m, ...) \
-    GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T(m, ...) \
-    GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T(m, ...) \
-    GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T(m, ...) \
-    GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T(m, ...) \
-    GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T(m, ...) \
-    GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
-
-#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
-
-#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
-
-// A MockFunction<F> class has one mock method whose type is F.  It is
-// useful when you just want your test code to emit some messages and
-// have Google Mock verify the right messages are sent (and perhaps at
-// the right times).  For example, if you are exercising code:
-//
-//   Foo(1);
-//   Foo(2);
-//   Foo(3);
-//
-// and want to verify that Foo(1) and Foo(3) both invoke
-// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
-//
-// TEST(FooTest, InvokesBarCorrectly) {
-//   MyMock mock;
-//   MockFunction<void(string check_point_name)> check;
-//   {
-//     InSequence s;
-//
-//     EXPECT_CALL(mock, Bar("a"));
-//     EXPECT_CALL(check, Call("1"));
-//     EXPECT_CALL(check, Call("2"));
-//     EXPECT_CALL(mock, Bar("a"));
-//   }
-//   Foo(1);
-//   check.Call("1");
-//   Foo(2);
-//   check.Call("2");
-//   Foo(3);
-// }
-//
-// The expectation spec says that the first Bar("a") must happen
-// before check point "1", the second Bar("a") must happen after check
-// point "2", and nothing should happen between the two check
-// points. The explicit check points make it easy to tell which
-// Bar("a") is called by which call to Foo().
-//
-// MockFunction<F> can also be used to exercise code that accepts
-// std::function<F> callbacks. To do so, use AsStdFunction() method
-// to create std::function proxy forwarding to original object's Call.
-// Example:
-//
-// TEST(FooTest, RunsCallbackWithBarArgument) {
-//   MockFunction<int(string)> callback;
-//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
-//   Foo(callback.AsStdFunction());
-// }
-template <typename F>
-class MockFunction;
-
-template <typename R>
-class MockFunction<R()> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD0_T(Call, R());
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R()> AsStdFunction() {
-    return [this]() -> R {
-      return this->Call();
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0>
-class MockFunction<R(A0)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD1_T(Call, R(A0));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0)> AsStdFunction() {
-    return [this](A0 a0) -> R {
-      return this->Call(a0);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1>
-class MockFunction<R(A0, A1)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD2_T(Call, R(A0, A1));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1)> AsStdFunction() {
-    return [this](A0 a0, A1 a1) -> R {
-      return this->Call(a0, a1);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2>
-class MockFunction<R(A0, A1, A2)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD3_T(Call, R(A0, A1, A2));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2) -> R {
-      return this->Call(a0, a1, a2);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3>
-class MockFunction<R(A0, A1, A2, A3)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
-      return this->Call(a0, a1, a2, a3);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4>
-class MockFunction<R(A0, A1, A2, A3, A4)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
-      return this->Call(a0, a1, a2, a3, a4);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5>
-class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-        A8 a8) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-        A8 a8, A9 a9) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-// This file was GENERATED by command:
-//     pump.py gmock-generated-nice-strict.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Implements class templates NiceMock, NaggyMock, and StrictMock.
-//
-// Given a mock class MockFoo that is created using Google Mock,
-// NiceMock<MockFoo> is a subclass of MockFoo that allows
-// uninteresting calls (i.e. calls to mock methods that have no
-// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
-// that prints a warning when an uninteresting call occurs, and
-// StrictMock<MockFoo> is a subclass of MockFoo that treats all
-// uninteresting calls as errors.
-//
-// Currently a mock is naggy by default, so MockFoo and
-// NaggyMock<MockFoo> behave like the same.  However, we will soon
-// switch the default behavior of mocks to be nice, as that in general
-// leads to more maintainable tests.  When that happens, MockFoo will
-// stop behaving like NaggyMock<MockFoo> and start behaving like
-// NiceMock<MockFoo>.
-//
-// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
-// their respective base class, with up-to 10 arguments.  Therefore
-// you can write NiceMock<MockFoo>(5, "a") to construct a nice mock
-// where MockFoo has a constructor that accepts (int, const char*),
-// for example.
-//
-// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
-// and StrictMock<MockFoo> only works for mock methods defined using
-// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
-// If a mock method is defined in a base class of MockFoo, the "nice"
-// or "strict" modifier may not affect it, depending on the compiler.
-// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
-// supported.
-//
-// Another known limitation is that the constructors of the base mock
-// cannot have arguments passed by non-const reference, which are
-// banned by the Google C++ style guide anyway.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-
-
-namespace testing {
-
-template <class MockClass>
-class NiceMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  NiceMock() {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit NiceMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~NiceMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
-};
-
-template <class MockClass>
-class NaggyMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  NaggyMock() {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit NaggyMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~NaggyMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
-};
-
-template <class MockClass>
-class StrictMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  StrictMock() {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit StrictMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~StrictMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
-};
-
-// The following specializations catch some (relatively more common)
-// user errors of nesting nice and strict mocks.  They do NOT catch
-// all possible errors.
-
-// These specializations are declared but not defined, as NiceMock,
-// NaggyMock, and StrictMock cannot be nested.
-
-template <typename MockClass>
-class NiceMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class NaggyMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class StrictMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<StrictMock<MockClass> >;
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-// This file was GENERATED by command:
-//     pump.py gmock-generated-matchers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic matchers.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-
-#include <iterator>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace testing {
-namespace internal {
-
-// The type of the i-th (0-based) field of Tuple.
-#define GMOCK_FIELD_TYPE_(Tuple, i) \
-    typename ::testing::tuple_element<i, Tuple>::type
-
-// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
-// tuple of type Tuple.  It has two members:
-//
-//   type: a tuple type whose i-th field is the ki-th field of Tuple.
-//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
-//
-// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
-//
-//   type is tuple<int, bool>, and
-//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
-
-template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1>
-class TupleFields;
-
-// This generic version is used when there are 10 selectors.
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7, int k8, int k9>
-class TupleFields {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
-      GMOCK_FIELD_TYPE_(Tuple, k9)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
-  }
-};
-
-// The following specialization is used for 0 ~ 9 selectors.
-
-template <class Tuple>
-class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<> type;
-  static type GetSelectedFields(const Tuple& /* t */) {
-    return type();
-  }
-};
-
-template <class Tuple, int k0>
-class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1>
-class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2>
-class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3>
-class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7, int k8>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
-  }
-};
-
-#undef GMOCK_FIELD_TYPE_
-
-// Implements the Args() matcher.
-template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1>
-class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
- public:
-  // ArgsTuple may have top-level const or reference modifiers.
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
-  typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
-      k6, k7, k8, k9>::type SelectedArgs;
-  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
-
-  template <typename InnerMatcher>
-  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
-      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
-
-  virtual bool MatchAndExplain(ArgsTuple args,
-                               MatchResultListener* listener) const {
-    const SelectedArgs& selected_args = GetSelectedArgs(args);
-    if (!listener->IsInterested())
-      return inner_matcher_.Matches(selected_args);
-
-    PrintIndices(listener->stream());
-    *listener << "are " << PrintToString(selected_args);
-
-    StringMatchResultListener inner_listener;
-    const bool match = inner_matcher_.MatchAndExplain(selected_args,
-                                                      &inner_listener);
-    PrintIfNotEmpty(inner_listener.str(), listener->stream());
-    return match;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
-    return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
-        k9>::GetSelectedFields(args);
-  }
-
-  // Prints the indices of the selected fields.
-  static void PrintIndices(::std::ostream* os) {
-    *os << "whose fields (";
-    const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
-    for (int i = 0; i < 10; i++) {
-      if (indices[i] < 0)
-        break;
-
-      if (i >= 1)
-        *os << ", ";
-
-      *os << "#" << indices[i];
-    }
-    *os << ") ";
-  }
-
-  const MonomorphicInnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
-};
-
-template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
-    int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
-    int k8 = -1, int k9 = -1>
-class ArgsMatcher {
- public:
-  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
-      : inner_matcher_(inner_matcher) {}
-
-  template <typename ArgsTuple>
-  operator Matcher<ArgsTuple>() const {
-    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
-        k6, k7, k8, k9>(inner_matcher_));
-  }
-
- private:
-  const InnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
-};
-
-// A set of metafunctions for computing the result type of AllOf.
-// AllOf(m1, ..., mN) returns
-// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AllOf isn't defined for one argument, AllOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AllOfResult1 {
-  typedef M1 type;
-};
-
-template <typename M1, typename M2>
-struct AllOfResult2 {
-  typedef BothOfMatcher<
-      typename AllOfResult1<M1>::type,
-      typename AllOfResult1<M2>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3>
-struct AllOfResult3 {
-  typedef BothOfMatcher<
-      typename AllOfResult1<M1>::type,
-      typename AllOfResult2<M2, M3>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4>
-struct AllOfResult4 {
-  typedef BothOfMatcher<
-      typename AllOfResult2<M1, M2>::type,
-      typename AllOfResult2<M3, M4>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-struct AllOfResult5 {
-  typedef BothOfMatcher<
-      typename AllOfResult2<M1, M2>::type,
-      typename AllOfResult3<M3, M4, M5>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-struct AllOfResult6 {
-  typedef BothOfMatcher<
-      typename AllOfResult3<M1, M2, M3>::type,
-      typename AllOfResult3<M4, M5, M6>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-struct AllOfResult7 {
-  typedef BothOfMatcher<
-      typename AllOfResult3<M1, M2, M3>::type,
-      typename AllOfResult4<M4, M5, M6, M7>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-struct AllOfResult8 {
-  typedef BothOfMatcher<
-      typename AllOfResult4<M1, M2, M3, M4>::type,
-      typename AllOfResult4<M5, M6, M7, M8>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-struct AllOfResult9 {
-  typedef BothOfMatcher<
-      typename AllOfResult4<M1, M2, M3, M4>::type,
-      typename AllOfResult5<M5, M6, M7, M8, M9>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-struct AllOfResult10 {
-  typedef BothOfMatcher<
-      typename AllOfResult5<M1, M2, M3, M4, M5>::type,
-      typename AllOfResult5<M6, M7, M8, M9, M10>::type
-  > type;
-};
-
-// A set of metafunctions for computing the result type of AnyOf.
-// AnyOf(m1, ..., mN) returns
-// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AnyOfResult1 {
-  typedef M1 type;
-};
-
-template <typename M1, typename M2>
-struct AnyOfResult2 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult1<M1>::type,
-      typename AnyOfResult1<M2>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3>
-struct AnyOfResult3 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult1<M1>::type,
-      typename AnyOfResult2<M2, M3>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4>
-struct AnyOfResult4 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult2<M1, M2>::type,
-      typename AnyOfResult2<M3, M4>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-struct AnyOfResult5 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult2<M1, M2>::type,
-      typename AnyOfResult3<M3, M4, M5>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-struct AnyOfResult6 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult3<M1, M2, M3>::type,
-      typename AnyOfResult3<M4, M5, M6>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-struct AnyOfResult7 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult3<M1, M2, M3>::type,
-      typename AnyOfResult4<M4, M5, M6, M7>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-struct AnyOfResult8 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult4<M1, M2, M3, M4>::type,
-      typename AnyOfResult4<M5, M6, M7, M8>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-struct AnyOfResult9 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult4<M1, M2, M3, M4>::type,
-      typename AnyOfResult5<M5, M6, M7, M8, M9>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-struct AnyOfResult10 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
-      typename AnyOfResult5<M6, M7, M8, M9, M10>::type
-  > type;
-};
-
-}  // namespace internal
-
-// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
-// fields of it matches a_matcher.  C++ doesn't support default
-// arguments for function templates, so we have to overload it.
-template <typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher>(matcher);
-}
-
-template <int k1, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
-}
-
-template <int k1, int k2, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
-}
-
-template <int k1, int k2, int k3, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
-    typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
-      k7>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
-      k8>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, int k10, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
-    k10>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9, k10>(matcher);
-}
-
-// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
-// n elements, where the i-th element in the container must
-// match the i-th argument in the list.  Each argument of
-// ElementsAre() can be either a value or a matcher.  We support up to
-// 10 arguments.
-//
-// The use of DecayArray in the implementation allows ElementsAre()
-// to accept string literals, whose type is const char[N], but we
-// want to treat them as const char*.
-//
-// NOTE: Since ElementsAre() cares about the order of the elements, it
-// must not be used with containers whose elements's order is
-// undefined (e.g. hash_map).
-
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<> >
-ElementsAre() {
-  typedef ::testing::tuple<> Args;
-  return internal::ElementsAreMatcher<Args>(Args());
-}
-
-template <typename T1>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type> >
-ElementsAre(const T1& e1) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1));
-}
-
-template <typename T1, typename T2>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type> >
-ElementsAre(const T1& e1, const T2& e2) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2));
-}
-
-template <typename T1, typename T2, typename T3>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8, e9));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type,
-        typename internal::DecayArray<T10>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
-    const T10& e10) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type,
-      typename internal::DecayArray<T10>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8, e9, e10));
-}
-
-// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
-// that matches n elements in any order.  We support up to n=10 arguments.
-
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<> >
-UnorderedElementsAre() {
-  typedef ::testing::tuple<> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args());
-}
-
-template <typename T1>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type> >
-UnorderedElementsAre(const T1& e1) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
-}
-
-template <typename T1, typename T2>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
-}
-
-template <typename T1, typename T2, typename T3>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8, e9));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type,
-        typename internal::DecayArray<T10>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
-    const T10& e10) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type,
-      typename internal::DecayArray<T10>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8, e9, e10));
-}
-
-// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
-// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
-
-template <typename M1, typename M2>
-inline typename internal::AllOfResult2<M1, M2>::type
-AllOf(M1 m1, M2 m2) {
-  return typename internal::AllOfResult2<M1, M2>::type(
-      m1,
-      m2);
-}
-
-template <typename M1, typename M2, typename M3>
-inline typename internal::AllOfResult3<M1, M2, M3>::type
-AllOf(M1 m1, M2 m2, M3 m3) {
-  return typename internal::AllOfResult3<M1, M2, M3>::type(
-      m1,
-      ::testing::AllOf(m2, m3));
-}
-
-template <typename M1, typename M2, typename M3, typename M4>
-inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
-  return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
-      ::testing::AllOf(m1, m2),
-      ::testing::AllOf(m3, m4));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
-  return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
-      ::testing::AllOf(m1, m2),
-      ::testing::AllOf(m3, m4, m5));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
-  return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
-      ::testing::AllOf(m1, m2, m3),
-      ::testing::AllOf(m4, m5, m6));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
-  return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
-      ::testing::AllOf(m1, m2, m3),
-      ::testing::AllOf(m4, m5, m6, m7));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
-  return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
-      ::testing::AllOf(m1, m2, m3, m4),
-      ::testing::AllOf(m5, m6, m7, m8));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
-  return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
-      M9>::type(
-      ::testing::AllOf(m1, m2, m3, m4),
-      ::testing::AllOf(m5, m6, m7, m8, m9));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-    M10>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
-  return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-      M10>::type(
-      ::testing::AllOf(m1, m2, m3, m4, m5),
-      ::testing::AllOf(m6, m7, m8, m9, m10));
-}
-
-// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
-// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
-
-template <typename M1, typename M2>
-inline typename internal::AnyOfResult2<M1, M2>::type
-AnyOf(M1 m1, M2 m2) {
-  return typename internal::AnyOfResult2<M1, M2>::type(
-      m1,
-      m2);
-}
-
-template <typename M1, typename M2, typename M3>
-inline typename internal::AnyOfResult3<M1, M2, M3>::type
-AnyOf(M1 m1, M2 m2, M3 m3) {
-  return typename internal::AnyOfResult3<M1, M2, M3>::type(
-      m1,
-      ::testing::AnyOf(m2, m3));
-}
-
-template <typename M1, typename M2, typename M3, typename M4>
-inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
-  return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
-      ::testing::AnyOf(m1, m2),
-      ::testing::AnyOf(m3, m4));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
-  return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
-      ::testing::AnyOf(m1, m2),
-      ::testing::AnyOf(m3, m4, m5));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
-  return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
-      ::testing::AnyOf(m1, m2, m3),
-      ::testing::AnyOf(m4, m5, m6));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
-  return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
-      ::testing::AnyOf(m1, m2, m3),
-      ::testing::AnyOf(m4, m5, m6, m7));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
-  return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
-      ::testing::AnyOf(m1, m2, m3, m4),
-      ::testing::AnyOf(m5, m6, m7, m8));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
-  return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
-      M9>::type(
-      ::testing::AnyOf(m1, m2, m3, m4),
-      ::testing::AnyOf(m5, m6, m7, m8, m9));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-    M10>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
-  return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-      M10>::type(
-      ::testing::AnyOf(m1, m2, m3, m4, m5),
-      ::testing::AnyOf(m6, m7, m8, m9, m10));
-}
-
-}  // namespace testing
-
-
-// The MATCHER* family of macros can be used in a namespace scope to
-// define custom matchers easily.
-//
-// Basic Usage
-// ===========
-//
-// The syntax
-//
-//   MATCHER(name, description_string) { statements; }
-//
-// defines a matcher with the given name that executes the statements,
-// which must return a bool to indicate if the match succeeds.  Inside
-// the statements, you can refer to the value being matched by 'arg',
-// and refer to its type by 'arg_type'.
-//
-// The description string documents what the matcher does, and is used
-// to generate the failure message when the match fails.  Since a
-// MATCHER() is usually defined in a header file shared by multiple
-// C++ source files, we require the description to be a C-string
-// literal to avoid possible side effects.  It can be empty, in which
-// case we'll use the sequence of words in the matcher name as the
-// description.
-//
-// For example:
-//
-//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
-//
-// allows you to write
-//
-//   // Expects mock_foo.Bar(n) to be called where n is even.
-//   EXPECT_CALL(mock_foo, Bar(IsEven()));
-//
-// or,
-//
-//   // Verifies that the value of some_expression is even.
-//   EXPECT_THAT(some_expression, IsEven());
-//
-// If the above assertion fails, it will print something like:
-//
-//   Value of: some_expression
-//   Expected: is even
-//     Actual: 7
-//
-// where the description "is even" is automatically calculated from the
-// matcher name IsEven.
-//
-// Argument Type
-// =============
-//
-// Note that the type of the value being matched (arg_type) is
-// determined by the context in which you use the matcher and is
-// supplied to you by the compiler, so you don't need to worry about
-// declaring it (nor can you).  This allows the matcher to be
-// polymorphic.  For example, IsEven() can be used to match any type
-// where the value of "(arg % 2) == 0" can be implicitly converted to
-// a bool.  In the "Bar(IsEven())" example above, if method Bar()
-// takes an int, 'arg_type' will be int; if it takes an unsigned long,
-// 'arg_type' will be unsigned long; and so on.
-//
-// Parameterizing Matchers
-// =======================
-//
-// Sometimes you'll want to parameterize the matcher.  For that you
-// can use another macro:
-//
-//   MATCHER_P(name, param_name, description_string) { statements; }
-//
-// For example:
-//
-//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
-//
-// will allow you to write:
-//
-//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
-//
-// which may lead to this message (assuming n is 10):
-//
-//   Value of: Blah("a")
-//   Expected: has absolute value 10
-//     Actual: -9
-//
-// Note that both the matcher description and its parameter are
-// printed, making the message human-friendly.
-//
-// In the matcher definition body, you can write 'foo_type' to
-// reference the type of a parameter named 'foo'.  For example, in the
-// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
-// 'value_type' to refer to the type of 'value'.
-//
-// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
-// support multi-parameter matchers.
-//
-// Describing Parameterized Matchers
-// =================================
-//
-// The last argument to MATCHER*() is a string-typed expression.  The
-// expression can reference all of the matcher's parameters and a
-// special bool-typed variable named 'negation'.  When 'negation' is
-// false, the expression should evaluate to the matcher's description;
-// otherwise it should evaluate to the description of the negation of
-// the matcher.  For example,
-//
-//   using testing::PrintToString;
-//
-//   MATCHER_P2(InClosedRange, low, hi,
-//       string(negation ? "is not" : "is") + " in range [" +
-//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
-//     return low <= arg && arg <= hi;
-//   }
-//   ...
-//   EXPECT_THAT(3, InClosedRange(4, 6));
-//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
-//
-// would generate two failures that contain the text:
-//
-//   Expected: is in range [4, 6]
-//   ...
-//   Expected: is not in range [2, 4]
-//
-// If you specify "" as the description, the failure message will
-// contain the sequence of words in the matcher name followed by the
-// parameter values printed as a tuple.  For example,
-//
-//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
-//   ...
-//   EXPECT_THAT(3, InClosedRange(4, 6));
-//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
-//
-// would generate two failures that contain the text:
-//
-//   Expected: in closed range (4, 6)
-//   ...
-//   Expected: not (in closed range (2, 4))
-//
-// Types of Matcher Parameters
-// ===========================
-//
-// For the purpose of typing, you can view
-//
-//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
-//
-// as shorthand for
-//
-//   template <typename p1_type, ..., typename pk_type>
-//   FooMatcherPk<p1_type, ..., pk_type>
-//   Foo(p1_type p1, ..., pk_type pk) { ... }
-//
-// When you write Foo(v1, ..., vk), the compiler infers the types of
-// the parameters v1, ..., and vk for you.  If you are not happy with
-// the result of the type inference, you can specify the types by
-// explicitly instantiating the template, as in Foo<long, bool>(5,
-// false).  As said earlier, you don't get to (or need to) specify
-// 'arg_type' as that's determined by the context in which the matcher
-// is used.  You can assign the result of expression Foo(p1, ..., pk)
-// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
-// can be useful when composing matchers.
-//
-// While you can instantiate a matcher template with reference types,
-// passing the parameters by pointer usually makes your code more
-// readable.  If, however, you still want to pass a parameter by
-// reference, be aware that in the failure message generated by the
-// matcher you will see the value of the referenced object but not its
-// address.
-//
-// Explaining Match Results
-// ========================
-//
-// Sometimes the matcher description alone isn't enough to explain why
-// the match has failed or succeeded.  For example, when expecting a
-// long string, it can be very helpful to also print the diff between
-// the expected string and the actual one.  To achieve that, you can
-// optionally stream additional information to a special variable
-// named result_listener, whose type is a pointer to class
-// MatchResultListener:
-//
-//   MATCHER_P(EqualsLongString, str, "") {
-//     if (arg == str) return true;
-//
-//     *result_listener << "the difference: "
-///                     << DiffStrings(str, arg);
-//     return false;
-//   }
-//
-// Overloading Matchers
-// ====================
-//
-// You can overload matchers with different numbers of parameters:
-//
-//   MATCHER_P(Blah, a, description_string1) { ... }
-//   MATCHER_P2(Blah, a, b, description_string2) { ... }
-//
-// Caveats
-// =======
-//
-// When defining a new matcher, you should also consider implementing
-// MatcherInterface or using MakePolymorphicMatcher().  These
-// approaches require more work than the MATCHER* macros, but also
-// give you more control on the types of the value being matched and
-// the matcher parameters, which may leads to better compiler error
-// messages when the matcher is used wrong.  They also allow
-// overloading matchers based on parameter types (as opposed to just
-// based on the number of parameters).
-//
-// MATCHER*() can only be used in a namespace scope.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using MATCHER*() inside
-// a function.
-//
-// More Information
-// ================
-//
-// To learn more about using these macros, please search for 'MATCHER'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-#define MATCHER(name, description)\
-  class name##Matcher {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl()\
-           {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<>()));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>());\
-    }\
-    name##Matcher() {\
-    }\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
-  };\
-  inline name##Matcher name() {\
-    return name##Matcher();\
-  }\
-  template <typename arg_type>\
-  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P(name, p0, description)\
-  template <typename p0##_type>\
-  class name##MatcherP {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      explicit gmock_Impl(p0##_type gmock_p0)\
-           : p0(gmock_p0) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type>(p0)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0));\
-    }\
-    explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
-    }\
-    p0##_type p0;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
-  };\
-  template <typename p0##_type>\
-  inline name##MatcherP<p0##_type> name(p0##_type p0) {\
-    return name##MatcherP<p0##_type>(p0);\
-  }\
-  template <typename p0##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P2(name, p0, p1, description)\
-  template <typename p0##_type, typename p1##_type>\
-  class name##MatcherP2 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
-           : p0(gmock_p0), p1(gmock_p1) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1));\
-    }\
-    name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-        p1(gmock_p1) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
-  };\
-  template <typename p0##_type, typename p1##_type>\
-  inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
-      p1##_type p1) {\
-    return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
-  }\
-  template <typename p0##_type, typename p1##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP2<p0##_type, \
-      p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P3(name, p0, p1, p2, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  class name##MatcherP3 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
-                    p2)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2));\
-    }\
-    name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2) {\
-    return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP3<p0##_type, p1##_type, \
-      p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P4(name, p0, p1, p2, p3, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  class name##MatcherP4 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, \
-                    p3##_type>(p0, p1, p2, p3)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3));\
-    }\
-    name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3) {\
-    return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
-        p1, p2, p3);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  class name##MatcherP5 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type>(p0, p1, p2, p3, p4)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
-    }\
-    name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, \
-        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4) {\
-    return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type>(p0, p1, p2, p3, p4);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  class name##MatcherP6 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
-    }\
-    name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3, p4##_type p4, p5##_type p5) {\
-    return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  class name##MatcherP7 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
-                    p6)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
-    }\
-    name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
-        p6(gmock_p6) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
-      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6) {\
-    return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  class name##MatcherP8 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
-                    p3, p4, p5, p6, p7)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
-    }\
-    name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, \
-        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6, p7##_type p7) {\
-    return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
-        p6, p7);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type, \
-      p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  class name##MatcherP9 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-               p8(gmock_p8) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-      p8##_type p8;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type, \
-                    p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
-    }\
-    name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-    p8##_type p8;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, \
-      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
-      p8##_type p8) {\
-    return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
-        p3, p4, p5, p6, p7, p8);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type, p7##_type, \
-      p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  class name##MatcherP10 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
-          p9##_type gmock_p9)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-               p8(gmock_p8), p9(gmock_p9) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-      p8##_type p8;\
-      p9##_type p9;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-                    p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
-    }\
-    name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-    p7##_type p7;\
-    p8##_type p8;\
-    p9##_type p9;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
-      p9##_type p9) {\
-    return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
-        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type, typename p8##_type, \
-      typename p9##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some actions that depend on gmock-generated-actions.h.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-
-#include <algorithm>
-
-
-namespace testing {
-namespace internal {
-
-// Implements the Invoke(f) action.  The template argument
-// FunctionImpl is the implementation type of f, which can be either a
-// function pointer or a functor.  Invoke(f) can be used as an
-// Action<F> as long as f's type is compatible with F (i.e. f can be
-// assigned to a tr1::function<F>).
-template <typename FunctionImpl>
-class InvokeAction {
- public:
-  // The c'tor makes a copy of function_impl (either a function
-  // pointer or a functor).
-  explicit InvokeAction(FunctionImpl function_impl)
-      : function_impl_(function_impl) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
-  }
-
- private:
-  FunctionImpl function_impl_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeAction);
-};
-
-// Implements the Invoke(object_ptr, &Class::Method) action.
-template <class Class, typename MethodPtr>
-class InvokeMethodAction {
- public:
-  InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
-      : method_ptr_(method_ptr), obj_ptr_(obj_ptr) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
-        obj_ptr_, method_ptr_, args);
-  }
-
- private:
-  // The order of these members matters.  Reversing the order can trigger
-  // warning C4121 in MSVC (see
-  // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm ).
-  const MethodPtr method_ptr_;
-  Class* const obj_ptr_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
-};
-
-// An internal replacement for std::copy which mimics its behavior. This is
-// necessary because Visual Studio deprecates ::std::copy, issuing warning 4996.
-// However Visual Studio 2010 and later do not honor #pragmas which disable that
-// warning.
-template<typename InputIterator, typename OutputIterator>
-inline OutputIterator CopyElements(InputIterator first,
-                                   InputIterator last,
-                                   OutputIterator output) {
-  for (; first != last; ++first, ++output) {
-    *output = *first;
-  }
-  return output;
-}
-
-}  // namespace internal
-
-// Various overloads for Invoke().
-
-// Creates an action that invokes 'function_impl' with the mock
-// function's arguments.
-template <typename FunctionImpl>
-PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
-    FunctionImpl function_impl) {
-  return MakePolymorphicAction(
-      internal::InvokeAction<FunctionImpl>(function_impl));
-}
-
-// Creates an action that invokes the given method on the given object
-// with the mock function's arguments.
-template <class Class, typename MethodPtr>
-PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
-    Class* obj_ptr, MethodPtr method_ptr) {
-  return MakePolymorphicAction(
-      internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
-}
-
-// WithoutArgs(inner_action) can be used in a mock function with a
-// non-empty argument list to perform inner_action, which takes no
-// argument.  In other words, it adapts an action accepting no
-// argument to one that accepts (and ignores) arguments.
-template <typename InnerAction>
-inline internal::WithArgsAction<InnerAction>
-WithoutArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction>(action);
-}
-
-// WithArg<k>(an_action) creates an action that passes the k-th
-// (0-based) argument of the mock function to an_action and performs
-// it.  It adapts an action accepting one argument to one that accepts
-// multiple arguments.  For convenience, we also provide
-// WithArgs<k>(an_action) (defined below) as a synonym.
-template <int k, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k>
-WithArg(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k>(action);
-}
-
-// The ACTION*() macros trigger warning C4100 (unreferenced formal
-// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
-// the macro definition, as the warnings are generated when the macro
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Action ReturnArg<k>() returns the k-th argument of the mock function.
-ACTION_TEMPLATE(ReturnArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  return ::testing::get<k>(args);
-}
-
-// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
-// mock function to *pointer.
-ACTION_TEMPLATE(SaveArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(pointer)) {
-  *pointer = ::testing::get<k>(args);
-}
-
-// Action SaveArgPointee<k>(pointer) saves the value pointed to
-// by the k-th (0-based) argument of the mock function to *pointer.
-ACTION_TEMPLATE(SaveArgPointee,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(pointer)) {
-  *pointer = *::testing::get<k>(args);
-}
-
-// Action SetArgReferee<k>(value) assigns 'value' to the variable
-// referenced by the k-th (0-based) argument of the mock function.
-ACTION_TEMPLATE(SetArgReferee,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(value)) {
-  typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
-  // Ensures that argument #k is a reference.  If you get a compiler
-  // error on the next line, you are using SetArgReferee<k>(value) in
-  // a mock function whose k-th (0-based) argument is not a reference.
-  GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
-                        SetArgReferee_must_be_used_with_a_reference_argument);
-  ::testing::get<k>(args) = value;
-}
-
-// Action SetArrayArgument<k>(first, last) copies the elements in
-// source range [first, last) to the array pointed to by the k-th
-// (0-based) argument, which can be either a pointer or an
-// iterator. The action does not take ownership of the elements in the
-// source range.
-ACTION_TEMPLATE(SetArrayArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_2_VALUE_PARAMS(first, last)) {
-  // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
-#ifdef _MSC_VER
-  internal::CopyElements(first, last, ::testing::get<k>(args));
-#else
-  ::std::copy(first, last, ::testing::get<k>(args));
-#endif
-}
-
-// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
-// function.
-ACTION_TEMPLATE(DeleteArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  delete ::testing::get<k>(args);
-}
-
-// This action returns the value pointed to by 'pointer'.
-ACTION_P(ReturnPointee, pointer) { return *pointer; }
-
-// Action Throw(exception) can be used in a mock function of any type
-// to throw the given exception.  Any copyable value can be thrown.
-#if GTEST_HAS_EXCEPTIONS
-
-// Suppresses the 'unreachable code' warning that VC generates in opt modes.
-# ifdef _MSC_VER
-#  pragma warning(push)          // Saves the current warning state.
-#  pragma warning(disable:4702)  // Temporarily disables warning 4702.
-# endif
-ACTION_P(Throw, exception) { throw exception; }
-# ifdef _MSC_VER
-#  pragma warning(pop)           // Restores the warning state.
-# endif
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-// Copyright 2013, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: marcus.boerger@google.com (Marcus Boerger)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some matchers that depend on gmock-generated-matchers.h.
-//
-// Note that tests are implemented in gmock-matchers_test.cc rather than
-// gmock-more-matchers-test.cc.
-
-#ifndef GMOCK_GMOCK_MORE_MATCHERS_H_
-#define GMOCK_GMOCK_MORE_MATCHERS_H_
-
-
-namespace testing {
-
-// Defines a matcher that matches an empty container. The container must
-// support both size() and empty(), which all STL-like containers provide.
-MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
-  if (arg.empty()) {
-    return true;
-  }
-  *result_listener << "whose size is " << arg.size();
-  return false;
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_GMOCK_MORE_MATCHERS_H_
-
-namespace testing {
-
-// Declares Google Mock flags that we want a user to use programmatically.
-GMOCK_DECLARE_bool_(catch_leaked_mocks);
-GMOCK_DECLARE_string_(verbose);
-
-// Initializes Google Mock.  This must be called before running the
-// tests.  In particular, it parses the command line for the flags
-// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
-// it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Mock flag variables are
-// updated.
-//
-// Since Google Test is needed for Google Mock to work, this function
-// also initializes Google Test and parses its flags, if that hasn't
-// been done.
-GTEST_API_ void InitGoogleMock(int* argc, char** argv);
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/opensfm/src/third_party/gtest/gmock/mock-log.h b/opensfm/src/third_party/gtest/gmock/mock-log.h
deleted file mode 100644
index bce54ab5e..000000000
--- a/opensfm/src/third_party/gtest/gmock/mock-log.h
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: Zhanyong Wan
-//
-// Defines the ScopedMockLog class (using Google C++ Mocking
-// Framework), which is convenient for testing code that uses LOG().
-//
-// NOTE(keir): This is a fork until Google Log exports the scoped mock log
-// class; see: http://code.google.com/p/google-glog/issues/detail?id=88
-
-#ifndef GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
-#define GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
-
-#include <string>
-
-#include <gmock/gmock.h>
-
-#include "glog/logging.h"
-
-// Needed to make the scoped mock log tests work without modification.
-namespace ceres {
-namespace internal {
-using google::WARNING;
-}  // namespace internal
-}  // namespace ceres
-
-namespace testing {
-
-// A ScopedMockLog object intercepts LOG() messages issued during its
-// lifespan.  Using this together with Google C++ Mocking Framework,
-// it's very easy to test how a piece of code calls LOG().  The
-// typical usage:
-//
-//   TEST(FooTest, LogsCorrectly) {
-//     ScopedMockLog log;
-//
-//     // We expect the WARNING "Something bad!" exactly twice.
-//     EXPECT_CALL(log, Log(WARNING, _, "Something bad!"))
-//         .Times(2);
-//
-//     // We allow foo.cc to call LOG(INFO) any number of times.
-//     EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _))
-//         .Times(AnyNumber());
-//
-//     Foo();  // Exercises the code under test.
-//   }
-class ScopedMockLog : public google::LogSink {
- public:
-  // When a ScopedMockLog object is constructed, it starts to
-  // intercept logs.
-  ScopedMockLog() { AddLogSink(this); }
-
-  // When the object is destructed, it stops intercepting logs.
-  virtual ~ScopedMockLog() { RemoveLogSink(this); }
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity, const string& file_path,
-  //            const string& message);
-  //
-  // The second argument to Send() is the full path of the source file
-  // in which the LOG() was issued.
-  //
-  // Note, that in a multi-threaded environment, all LOG() messages from a
-  // single thread will be handled in sequence, but that cannot be guaranteed
-  // for messages from different threads. In fact, if the same or multiple
-  // expectations are matched on two threads concurrently, their actions will
-  // be executed concurrently as well and may interleave.
-  MOCK_METHOD3(Log, void(google::LogSeverity severity,
-                         const std::string& file_path,
-                         const std::string& message));
-
- private:
-  // Implements the send() virtual function in class LogSink.
-  // Whenever a LOG() statement is executed, this function will be
-  // invoked with information presented in the LOG().
-  //
-  // The method argument list is long and carries much information a
-  // test usually doesn't care about, so we trim the list before
-  // forwarding the call to Log(), which is much easier to use in
-  // tests.
-  //
-  // We still cannot call Log() directly, as it may invoke other LOG()
-  // messages, either due to Invoke, or due to an error logged in
-  // Google C++ Mocking Framework code, which would trigger a deadlock
-  // since a lock is held during send().
-  //
-  // Hence, we save the message for WaitTillSent() which will be called after
-  // the lock on send() is released, and we'll call Log() inside
-  // WaitTillSent(). Since while a single send() call may be running at a
-  // time, multiple WaitTillSent() calls (along with the one send() call) may
-  // be running simultaneously, we ensure thread-safety of the exchange between
-  // send() and WaitTillSent(), and that for each message, LOG(), send(),
-  // WaitTillSent() and Log() are executed in the same thread.
-  virtual void send(google::LogSeverity severity,
-                    const char* full_filename,
-                    const char* base_filename, int line, const tm* tm_time,
-                    const char* message, size_t message_len) {
-    // We are only interested in the log severity, full file name, and
-    // log message.
-    message_info_.severity = severity;
-    message_info_.file_path = full_filename;
-    message_info_.message = std::string(message, message_len);
-  }
-
-  // Implements the WaitTillSent() virtual function in class LogSink.
-  // It will be executed after send() and after the global logging lock is
-  // released, so calls within it (or rather within the Log() method called
-  // within) may also issue LOG() statements.
-  //
-  // LOG(), send(), WaitTillSent() and Log() will occur in the same thread for
-  // a given log message.
-  virtual void WaitTillSent() {
-    // First, and very importantly, we save a copy of the message being
-    // processed before calling Log(), since Log() may indirectly call send()
-    // and WaitTillSent() in the same thread again.
-    MessageInfo message_info = message_info_;
-    Log(message_info.severity, message_info.file_path, message_info.message);
-  }
-
-  // All relevant information about a logged message that needs to be passed
-  // from send() to WaitTillSent().
-  struct MessageInfo {
-    google::LogSeverity severity;
-    std::string file_path;
-    std::string message;
-  };
-  MessageInfo message_info_;
-};
-
-}  // namespace testing
-
-#endif  // GOOGLE_CERES_INTERNAL_MOCK_LOG_H_

From 129ab66c7176630d0a6082e868b6ef02ca39b284 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005279527
 <generatedunixname89002005279527@meta.com>
Date: Wed, 16 Oct 2024 01:38:26 -0700
Subject: [PATCH 089/235] 
 fbcode/mapillary/opensfm/opensfm/src/third_party/gtest/gtest

Reviewed By: bal-a

Differential Revision: D63970634

fbshipit-source-id: 572499517f09942641f6b0bb28e44bd05783026e
---
 opensfm/src/third_party/gtest/gtest/gtest.h | 21201 ------------------
 1 file changed, 21201 deletions(-)
 delete mode 100644 opensfm/src/third_party/gtest/gtest/gtest.h

diff --git a/opensfm/src/third_party/gtest/gtest/gtest.h b/opensfm/src/third_party/gtest/gtest/gtest.h
deleted file mode 100644
index e6a9600be..000000000
--- a/opensfm/src/third_party/gtest/gtest/gtest.h
+++ /dev/null
@@ -1,21201 +0,0 @@
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the public API for Google Test.  It should be
-// included by any test program that uses Google Test.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-//
-// Acknowledgment: Google Test borrowed the idea of automatic test
-// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
-// easyUnit framework.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_H_
-
-#include <limits>
-#include <ostream>
-#include <vector>
-
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file declares functions and macros used internally by
-// Google Test.  They are subject to change without notice.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: wan@google.com (Zhanyong Wan)
-//
-// Low-level types and utilities for porting Google Test to various
-// platforms.  All macros ending with _ and symbols defined in an
-// internal namespace are subject to change without notice.  Code
-// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
-// end with _ are part of Google Test's public API and can be used by
-// code outside Google Test.
-//
-// This file is fundamental to Google Test.  All other Google Test source
-// files are expected to #include this.  Therefore, it cannot #include
-// any other Google Test header.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-
-// Environment-describing macros
-// -----------------------------
-//
-// Google Test can be used in many different environments.  Macros in
-// this section tell Google Test what kind of environment it is being
-// used in, such that Google Test can provide environment-specific
-// features and implementations.
-//
-// Google Test tries to automatically detect the properties of its
-// environment, so users usually don't need to worry about these
-// macros.  However, the automatic detection is not perfect.
-// Sometimes it's necessary for a user to define some of the following
-// macros in the build script to override Google Test's decisions.
-//
-// If the user doesn't define a macro in the list, Google Test will
-// provide a default definition.  After this header is #included, all
-// macros in this list will be defined to either 1 or 0.
-//
-// Notes to maintainers:
-//   - Each macro here is a user-tweakable knob; do not grow the list
-//     lightly.
-//   - Use #if to key off these macros.  Don't use #ifdef or "#if
-//     defined(...)", which will not work as these macros are ALWAYS
-//     defined.
-//
-//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
-//                              is/isn't available.
-//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
-//                              are enabled.
-//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
-//                              is/isn't available (some systems define
-//                              ::string, which is different to std::string).
-//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
-//                              is/isn't available (some systems define
-//                              ::wstring, which is different to std::wstring).
-//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
-//                              expressions are/aren't available.
-//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
-//                              is/isn't available.
-//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
-//                              enabled.
-//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
-//                              std::wstring does/doesn't work (Google Test can
-//                              be used where std::wstring is unavailable).
-//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
-//                              is/isn't available.
-//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
-//                              compiler supports Microsoft's "Structured
-//                              Exception Handling".
-//   GTEST_HAS_STREAM_REDIRECTION
-//                            - Define it to 1/0 to indicate whether the
-//                              platform supports I/O stream redirection using
-//                              dup() and dup2().
-//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
-//                              Test's own tr1 tuple implementation should be
-//                              used.  Unused when the user sets
-//                              GTEST_HAS_TR1_TUPLE to 0.
-//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
-//                              is building in C++11/C++98 mode.
-//   GTEST_LINKED_AS_SHARED_LIBRARY
-//                            - Define to 1 when compiling tests that use
-//                              Google Test as a shared library (known as
-//                              DLL on Windows).
-//   GTEST_CREATE_SHARED_LIBRARY
-//                            - Define to 1 when compiling Google Test itself
-//                              as a shared library.
-
-// Platform-indicating macros
-// --------------------------
-//
-// Macros indicating the platform on which Google Test is being used
-// (a macro is defined to 1 if compiled on the given platform;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-//   GTEST_OS_AIX      - IBM AIX
-//   GTEST_OS_CYGWIN   - Cygwin
-//   GTEST_OS_FREEBSD  - FreeBSD
-//   GTEST_OS_HPUX     - HP-UX
-//   GTEST_OS_LINUX    - Linux
-//     GTEST_OS_LINUX_ANDROID - Google Android
-//   GTEST_OS_MAC      - Mac OS X
-//     GTEST_OS_IOS    - iOS
-//   GTEST_OS_NACL     - Google Native Client (NaCl)
-//   GTEST_OS_OPENBSD  - OpenBSD
-//   GTEST_OS_QNX      - QNX
-//   GTEST_OS_SOLARIS  - Sun Solaris
-//   GTEST_OS_SYMBIAN  - Symbian
-//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
-//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
-//     GTEST_OS_WINDOWS_MINGW    - MinGW
-//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
-//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
-//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
-//   GTEST_OS_ZOS      - z/OS
-//
-// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
-// most stable support.  Since core members of the Google Test project
-// don't have access to other platforms, support for them may be less
-// stable.  If you notice any problems on your platform, please notify
-// googletestframework@googlegroups.com (patches for fixing them are
-// even more welcome!).
-//
-// It is possible that none of the GTEST_OS_* macros are defined.
-
-// Feature-indicating macros
-// -------------------------
-//
-// Macros indicating which Google Test features are available (a macro
-// is defined to 1 if the corresponding feature is supported;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-// These macros are public so that portable tests can be written.
-// Such tests typically surround code using a feature with an #if
-// which controls that code.  For example:
-//
-// #if GTEST_HAS_DEATH_TEST
-//   EXPECT_DEATH(DoSomethingDeadly());
-// #endif
-//
-//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
-//                            tests)
-//   GTEST_HAS_DEATH_TEST   - death tests
-//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
-//   GTEST_HAS_TYPED_TEST   - typed tests
-//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
-//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
-//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
-//                            GTEST_HAS_POSIX_RE (see above) which users can
-//                            define themselves.
-//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
-//                            the above two are mutually exclusive.
-//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
-
-// Misc public macros
-// ------------------
-//
-//   GTEST_FLAG(flag_name)  - references the variable corresponding to
-//                            the given Google Test flag.
-
-// Internal utilities
-// ------------------
-//
-// The following macros and utilities are for Google Test's INTERNAL
-// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
-//
-// Macros for basic C++ coding:
-//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
-//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
-//                              variable don't have to be used.
-//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
-//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
-//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
-//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
-//                                        suppressed (constant conditional).
-//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
-//                                        is suppressed.
-//
-// C++11 feature wrappers:
-//
-//   testing::internal::move  - portability wrapper for std::move.
-//
-// Synchronization:
-//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
-//                            - synchronization primitives.
-//
-// Template meta programming:
-//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
-//   IteratorTraits - partial implementation of std::iterator_traits, which
-//                    is not available in libCstd when compiled with Sun C++.
-//
-// Smart pointers:
-//   scoped_ptr     - as in TR2.
-//
-// Regular expressions:
-//   RE             - a simple regular expression class using the POSIX
-//                    Extended Regular Expression syntax on UNIX-like
-//                    platforms, or a reduced regular exception syntax on
-//                    other platforms, including Windows.
-//
-// Logging:
-//   GTEST_LOG_()   - logs messages at the specified severity level.
-//   LogToStderr()  - directs all log messages to stderr.
-//   FlushInfoLog() - flushes informational log messages.
-//
-// Stdout and stderr capturing:
-//   CaptureStdout()     - starts capturing stdout.
-//   GetCapturedStdout() - stops capturing stdout and returns the captured
-//                         string.
-//   CaptureStderr()     - starts capturing stderr.
-//   GetCapturedStderr() - stops capturing stderr and returns the captured
-//                         string.
-//
-// Integer types:
-//   TypeWithSize   - maps an integer to a int type.
-//   Int32, UInt32, Int64, UInt64, TimeInMillis
-//                  - integers of known sizes.
-//   BiggestInt     - the biggest signed integer type.
-//
-// Command-line utilities:
-//   GTEST_DECLARE_*()  - declares a flag.
-//   GTEST_DEFINE_*()   - defines a flag.
-//   GetInjectableArgvs() - returns the command line as a vector of strings.
-//
-// Environment variable utilities:
-//   GetEnv()             - gets the value of an environment variable.
-//   BoolFromGTestEnv()   - parses a bool environment variable.
-//   Int32FromGTestEnv()  - parses an Int32 environment variable.
-//   StringFromGTestEnv() - parses a string environment variable.
-
-#include <ctype.h>   // for isspace, etc
-#include <stddef.h>  // for ptrdiff_t
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#ifndef _WIN32_WCE
-# include <sys/types.h>
-# include <sys/stat.h>
-#endif  // !_WIN32_WCE
-
-#if defined __APPLE__
-# include <AvailabilityMacros.h>
-# include <TargetConditionals.h>
-#endif
-
-#include <algorithm>  // NOLINT
-#include <iostream>  // NOLINT
-#include <sstream>  // NOLINT
-#include <string>  // NOLINT
-#include <utility>
-#include <vector>  // NOLINT
-
-// Copyright 2015, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the GTEST_OS_* macro.
-// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-
-// Determines the platform on which Google Test is compiled.
-#ifdef __CYGWIN__
-# define GTEST_OS_CYGWIN 1
-#elif defined __SYMBIAN32__
-# define GTEST_OS_SYMBIAN 1
-#elif defined _WIN32
-# define GTEST_OS_WINDOWS 1
-# ifdef _WIN32_WCE
-#  define GTEST_OS_WINDOWS_MOBILE 1
-# elif defined(__MINGW__) || defined(__MINGW32__)
-#  define GTEST_OS_WINDOWS_MINGW 1
-# elif defined(WINAPI_FAMILY)
-#  include <winapifamily.h>
-#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-#   define GTEST_OS_WINDOWS_RT 1
-#  else
-    // WINAPI_FAMILY defined but no known partition matched.
-    // Default to desktop.
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  endif
-# else
-#  define GTEST_OS_WINDOWS_DESKTOP 1
-# endif  // _WIN32_WCE
-#elif defined __APPLE__
-# define GTEST_OS_MAC 1
-# if TARGET_OS_IPHONE
-#  define GTEST_OS_IOS 1
-# endif
-#elif defined __FreeBSD__
-# define GTEST_OS_FREEBSD 1
-#elif defined __linux__
-# define GTEST_OS_LINUX 1
-# if defined __ANDROID__
-#  define GTEST_OS_LINUX_ANDROID 1
-# endif
-#elif defined __MVS__
-# define GTEST_OS_ZOS 1
-#elif defined(__sun) && defined(__SVR4)
-# define GTEST_OS_SOLARIS 1
-#elif defined(_AIX)
-# define GTEST_OS_AIX 1
-#elif defined(__hpux)
-# define GTEST_OS_HPUX 1
-#elif defined __native_client__
-# define GTEST_OS_NACL 1
-#elif defined __OpenBSD__
-# define GTEST_OS_OPENBSD 1
-#elif defined __QNX__
-# define GTEST_OS_QNX 1
-#endif  // __CYGWIN__
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-// Copyright 2015, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Injection point for custom user configurations.
-// The following macros can be defined:
-//
-//   Flag related macros:
-//     GTEST_FLAG(flag_name)
-//     GTEST_USE_OWN_FLAGFILE_FLAG_  - Define to 0 when the system provides its
-//                                     own flagfile flag parsing.
-//     GTEST_DECLARE_bool_(name)
-//     GTEST_DECLARE_int32_(name)
-//     GTEST_DECLARE_string_(name)
-//     GTEST_DEFINE_bool_(name, default_val, doc)
-//     GTEST_DEFINE_int32_(name, default_val, doc)
-//     GTEST_DEFINE_string_(name, default_val, doc)
-//
-//   Test filtering:
-//     GTEST_TEST_FILTER_ENV_VAR_ - The name of an environment variable that
-//                                  will be used if --GTEST_FLAG(test_filter)
-//                                  is not provided.
-//
-//   Logging:
-//     GTEST_LOG_(severity)
-//     GTEST_CHECK_(condition)
-//     Functions LogToStderr() and FlushInfoLog() have to be provided too.
-//
-//   Threading:
-//     GTEST_HAS_NOTIFICATION_ - Enabled if Notification is already provided.
-//     GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Enabled if Mutex and ThreadLocal are
-//                                         already provided.
-//     Must also provide GTEST_DECLARE_STATIC_MUTEX_(mutex) and
-//     GTEST_DEFINE_STATIC_MUTEX_(mutex)
-//
-//     GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-//     GTEST_LOCK_EXCLUDED_(locks)
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-
-#if !defined(GTEST_DEV_EMAIL_)
-# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
-# define GTEST_FLAG_PREFIX_ "gtest_"
-# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
-# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
-# define GTEST_NAME_ "Google Test"
-# define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
-#endif  // !defined(GTEST_DEV_EMAIL_)
-
-#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
-#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-
-// Determines the version of gcc that is used to compile this.
-#ifdef __GNUC__
-// 40302 means version 4.3.2.
-# define GTEST_GCC_VER_ \
-    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
-#endif  // __GNUC__
-
-// Macros for disabling Microsoft Visual C++ warnings.
-//
-//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
-//   /* code that triggers warnings C4800 and C4385 */
-//   GTEST_DISABLE_MSC_WARNINGS_POP_()
-#if _MSC_VER >= 1500
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
-    __pragma(warning(push))                        \
-    __pragma(warning(disable: warnings))
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
-    __pragma(warning(pop))
-#else
-// Older versions of MSVC don't have __pragma.
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-#ifndef GTEST_LANG_CXX11
-// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
-// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
-// value for __cplusplus, and recent versions of clang, gcc, and
-// probably other compilers set that too in C++11 mode.
-# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
-// Compiling in at least C++11 mode.
-#  define GTEST_LANG_CXX11 1
-# else
-#  define GTEST_LANG_CXX11 0
-# endif
-#endif
-
-// Distinct from C++11 language support, some environments don't provide
-// proper C++11 library support. Notably, it's possible to build in
-// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
-// with no C++11 support.
-//
-// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
-// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
-// this date, so check for those versions by their date stamps.
-// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
-#if GTEST_LANG_CXX11 && \
-    (!defined(__GLIBCXX__) || ( \
-        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
-        /* Block list of patch releases of older branches: */ \
-        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
-        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
-        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
-        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
-# define GTEST_STDLIB_CXX11 1
-#endif
-
-// Only use C++11 library features if the library provides them.
-#if GTEST_STDLIB_CXX11
-# define GTEST_HAS_STD_BEGIN_AND_END_ 1
-# define GTEST_HAS_STD_FORWARD_LIST_ 1
-# define GTEST_HAS_STD_FUNCTION_ 1
-# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
-# define GTEST_HAS_STD_MOVE_ 1
-# define GTEST_HAS_STD_UNIQUE_PTR_ 1
-# define GTEST_HAS_STD_SHARED_PTR_ 1
-#endif
-
-// C++11 specifies that <tuple> provides std::tuple.
-// Some platforms still might not have it, however.
-#if GTEST_LANG_CXX11
-# define GTEST_HAS_STD_TUPLE_ 1
-# if defined(__clang__)
-// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
-#  if defined(__has_include) && !__has_include(<tuple>)
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# elif defined(_MSC_VER)
-// Inspired by boost/config/stdlib/dinkumware.hpp
-#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# elif defined(__GLIBCXX__)
-// Inspired by boost/config/stdlib/libstdcpp3.hpp,
-// http://gcc.gnu.org/gcc-4.2/changes.html and
-// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
-#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# endif
-#endif
-
-// Brings in definitions for functions used in the testing::internal::posix
-// namespace (read, write, close, chdir, isatty, stat). We do not currently
-// use them on Windows Mobile.
-#if GTEST_OS_WINDOWS
-# if !GTEST_OS_WINDOWS_MOBILE
-#  include <direct.h>
-#  include <io.h>
-# endif
-// In order to avoid having to include <windows.h>, use forward declaration
-// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
-// This assumption is verified by
-// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
-struct _RTL_CRITICAL_SECTION;
-#else
-// This assumes that non-Windows OSes provide unistd.h. For OSes where this
-// is not the case, we need to include headers that provide the functions
-// mentioned above.
-# include <unistd.h>
-# include <strings.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_LINUX_ANDROID
-// Used to define __ANDROID_API__ matching the target NDK API level.
-#  include <android/api-level.h>  // NOLINT
-#endif
-
-// Defines this to true iff Google Test can use POSIX regular expressions.
-#ifndef GTEST_HAS_POSIX_RE
-# if GTEST_OS_LINUX_ANDROID
-// On Android, <regex.h> is only available starting with Gingerbread.
-#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
-# else
-#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
-# endif
-#endif
-
-#if GTEST_USES_PCRE
-// The appropriate headers have already been included.
-
-#elif GTEST_HAS_POSIX_RE
-
-// On some platforms, <regex.h> needs someone to define size_t, and
-// won't compile otherwise.  We can #include it here as we already
-// included <stdlib.h>, which is guaranteed to define size_t through
-// <stddef.h>.
-# include <regex.h>  // NOLINT
-
-# define GTEST_USES_POSIX_RE 1
-
-#elif GTEST_OS_WINDOWS
-
-// <regex.h> is not available on Windows.  Use our own simple regex
-// implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#else
-
-// <regex.h> may not be available on this platform.  Use our own
-// simple regex implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#endif  // GTEST_USES_PCRE
-
-#ifndef GTEST_HAS_EXCEPTIONS
-// The user didn't tell us whether exceptions are enabled, so we need
-// to figure it out.
-# if defined(_MSC_VER) || defined(__BORLANDC__)
-// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
-// macro to enable exceptions, so we'll do the same.
-// Assumes that exceptions are enabled by default.
-#  ifndef _HAS_EXCEPTIONS
-#   define _HAS_EXCEPTIONS 1
-#  endif  // _HAS_EXCEPTIONS
-#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
-# elif defined(__clang__)
-// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
-// but iff cleanups are enabled after that. In Obj-C++ files, there can be
-// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
-// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
-// exceptions starting at clang r206352, but which checked for cleanups prior to
-// that. To reliably check for C++ exception availability with clang, check for
-// __EXCEPTIONS && __has_feature(cxx_exceptions).
-#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
-# elif defined(__GNUC__) && __EXCEPTIONS
-// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__SUNPRO_CC)
-// Sun Pro CC supports exceptions.  However, there is no compile-time way of
-// detecting whether they are enabled or not.  Therefore, we assume that
-// they are enabled unless the user tells us otherwise.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__IBMCPP__) && __EXCEPTIONS
-// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__HP_aCC)
-// Exception handling is in effect by default in HP aCC compiler. It has to
-// be turned of by +noeh compiler option if desired.
-#  define GTEST_HAS_EXCEPTIONS 1
-# else
-// For other compilers, we assume exceptions are disabled to be
-// conservative.
-#  define GTEST_HAS_EXCEPTIONS 0
-# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#if !defined(GTEST_HAS_STD_STRING)
-// Even though we don't use this macro any longer, we keep it in case
-// some clients still depend on it.
-# define GTEST_HAS_STD_STRING 1
-#elif !GTEST_HAS_STD_STRING
-// The user told us that ::std::string isn't available.
-# error "Google Test cannot be used where ::std::string isn't available."
-#endif  // !defined(GTEST_HAS_STD_STRING)
-
-#ifndef GTEST_HAS_GLOBAL_STRING
-// The user didn't tell us whether ::string is available, so we need
-// to figure it out.
-
-# define GTEST_HAS_GLOBAL_STRING 0
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#ifndef GTEST_HAS_STD_WSTRING
-// The user didn't tell us whether ::std::wstring is available, so we need
-// to figure it out.
-// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
-//   is available.
-
-// Cygwin 1.7 and below doesn't support ::std::wstring.
-// Solaris' libc++ doesn't support it either.  Android has
-// no support for it at least as recent as Froyo (2.2).
-# define GTEST_HAS_STD_WSTRING \
-    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-#ifndef GTEST_HAS_GLOBAL_WSTRING
-// The user didn't tell us whether ::wstring is available, so we need
-// to figure it out.
-# define GTEST_HAS_GLOBAL_WSTRING \
-    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// Determines whether RTTI is available.
-#ifndef GTEST_HAS_RTTI
-// The user didn't tell us whether RTTI is enabled, so we need to
-// figure it out.
-
-# ifdef _MSC_VER
-
-#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
-
-// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
-# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
-
-#  ifdef __GXX_RTTI
-// When building against STLport with the Android NDK and with
-// -frtti -fno-exceptions, the build fails at link time with undefined
-// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
-// so disable RTTI when detected.
-#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
-       !defined(__EXCEPTIONS)
-#    define GTEST_HAS_RTTI 0
-#   else
-#    define GTEST_HAS_RTTI 1
-#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif  // __GXX_RTTI
-
-// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
-// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
-// first version with C++ support.
-# elif defined(__clang__)
-
-#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
-
-// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
-// both the typeid and dynamic_cast features are present.
-# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
-
-#  ifdef __RTTI_ALL__
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
-
-# else
-
-// For all other compilers, we assume RTTI is enabled.
-#  define GTEST_HAS_RTTI 1
-
-# endif  // _MSC_VER
-
-#endif  // GTEST_HAS_RTTI
-
-// It's this header's responsibility to #include <typeinfo> when RTTI
-// is enabled.
-#if GTEST_HAS_RTTI
-# include <typeinfo>
-#endif
-
-// Determines whether Google Test can use the pthreads library.
-#ifndef GTEST_HAS_PTHREAD
-// The user didn't tell us explicitly, so we make reasonable assumptions about
-// which platforms have pthreads support.
-//
-// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
-// to your compiler flags.
-# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
-    || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL)
-#endif  // GTEST_HAS_PTHREAD
-
-#if GTEST_HAS_PTHREAD
-// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
-// true.
-# include <pthread.h>  // NOLINT
-
-// For timespec and nanosleep, used below.
-# include <time.h>  // NOLINT
-#endif
-
-// Determines if hash_map/hash_set are available.
-// Only used for testing against those containers.
-#if !defined(GTEST_HAS_HASH_MAP_)
-# if _MSC_VER
-#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
-#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
-# endif  // _MSC_VER
-#endif  // !defined(GTEST_HAS_HASH_MAP_)
-
-// Determines whether Google Test can use tr1/tuple.  You can define
-// this macro to 0 to prevent Google Test from using tuple (any
-// feature depending on tuple with be disabled in this mode).
-#ifndef GTEST_HAS_TR1_TUPLE
-# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
-// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
-#  define GTEST_HAS_TR1_TUPLE 0
-# else
-// The user didn't tell us not to do it, so we assume it's OK.
-#  define GTEST_HAS_TR1_TUPLE 1
-# endif
-#endif  // GTEST_HAS_TR1_TUPLE
-
-// Determines whether Google Test's own tr1 tuple implementation
-// should be used.
-#ifndef GTEST_USE_OWN_TR1_TUPLE
-// The user didn't tell us, so we need to figure it out.
-
-// We use our own TR1 tuple if we aren't sure the user has an
-// implementation of it already.  At this time, libstdc++ 4.0.0+ and
-// MSVC 2010 are the only mainstream standard libraries that come
-// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
-// pretends to be GCC by defining __GNUC__ and friends, but cannot
-// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
-// tuple in a 323 MB Feature Pack download, which we cannot assume the
-// user has.  QNX's QCC compiler is a modified GCC but it doesn't
-// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
-// and it can be used with some compilers that define __GNUC__.
-# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
-      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
-#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
-# endif
-
-// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
-// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
-// can build with clang but need to use gcc4.2's libstdc++).
-# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
-#  define GTEST_ENV_HAS_STD_TUPLE_ 1
-# endif
-
-# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
-#  define GTEST_USE_OWN_TR1_TUPLE 0
-# else
-#  define GTEST_USE_OWN_TR1_TUPLE 1
-# endif
-
-#endif  // GTEST_USE_OWN_TR1_TUPLE
-
-// To avoid conditional compilation everywhere, we make it
-// gtest-port.h's responsibility to #include the header implementing
-// tuple.
-#if GTEST_HAS_STD_TUPLE_
-# include <tuple>  // IWYU pragma: export
-# define GTEST_TUPLE_NAMESPACE_ ::std
-#endif  // GTEST_HAS_STD_TUPLE_
-
-// We include tr1::tuple even if std::tuple is available to define printers for
-// them.
-#if GTEST_HAS_TR1_TUPLE
-# ifndef GTEST_TUPLE_NAMESPACE_
-#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
-# endif  // GTEST_TUPLE_NAMESPACE_
-
-# if GTEST_USE_OWN_TR1_TUPLE
-// This file was GENERATED by command:
-//     pump.py gtest-tuple.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2009 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-
-#include <utility>  // For ::std::pair.
-
-// The compiler used in Symbian has a bug that prevents us from declaring the
-// tuple template as a friend (it complains that tuple is redefined).  This
-// hack bypasses the bug by declaring the members that should otherwise be
-// private as public.
-// Sun Studio versions < 12 also have the above bug.
-#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
-#else
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
-    template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
-   private:
-#endif
-
-// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
-// with our own definitions. Therefore using our own tuple does not work on
-// those compilers.
-#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
-# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
-GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
-#endif
-
-// GTEST_n_TUPLE_(T) is the type of an n-tuple.
-#define GTEST_0_TUPLE_(T) tuple<>
-#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
-    void, void, void>
-#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
-    void, void, void>
-#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
-    void, void, void>
-#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
-    void, void, void>
-#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
-    void, void, void>
-#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
-    void, void, void>
-#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    void, void, void>
-#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, void, void>
-#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, T##8, void>
-#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, T##8, T##9>
-
-// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
-#define GTEST_0_TYPENAMES_(T)
-#define GTEST_1_TYPENAMES_(T) typename T##0
-#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
-#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
-#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3
-#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4
-#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5
-#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6
-#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
-#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, \
-    typename T##7, typename T##8
-#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, \
-    typename T##7, typename T##8, typename T##9
-
-// In theory, defining stuff in the ::std namespace is undefined
-// behavior.  We can do this as we are playing the role of a standard
-// library vendor.
-namespace std {
-namespace tr1 {
-
-template <typename T0 = void, typename T1 = void, typename T2 = void,
-    typename T3 = void, typename T4 = void, typename T5 = void,
-    typename T6 = void, typename T7 = void, typename T8 = void,
-    typename T9 = void>
-class tuple;
-
-// Anything in namespace gtest_internal is Google Test's INTERNAL
-// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
-namespace gtest_internal {
-
-// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
-template <typename T>
-struct ByRef { typedef const T& type; };  // NOLINT
-template <typename T>
-struct ByRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for ByRef.
-#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
-
-// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
-// is the same as tr1::add_reference<T>::type.
-template <typename T>
-struct AddRef { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for AddRef.
-#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
-
-// A helper for implementing get<k>().
-template <int k> class Get;
-
-// A helper for implementing tuple_element<k, T>.  kIndexValid is true
-// iff k < the number of fields in tuple type T.
-template <bool kIndexValid, int kIndex, class Tuple>
-struct TupleElement;
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
-  typedef T0 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
-  typedef T1 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
-  typedef T2 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
-  typedef T3 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
-  typedef T4 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
-  typedef T5 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
-  typedef T6 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
-  typedef T7 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
-  typedef T8 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
-  typedef T9 type;
-};
-
-}  // namespace gtest_internal
-
-template <>
-class tuple<> {
- public:
-  tuple() {}
-  tuple(const tuple& /* t */)  {}
-  tuple& operator=(const tuple& /* t */) { return *this; }
-};
-
-template <GTEST_1_TYPENAMES_(T)>
-class GTEST_1_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
-
-  tuple(const tuple& t) : f0_(t.f0_) {}
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    return *this;
-  }
-
-  T0 f0_;
-};
-
-template <GTEST_2_TYPENAMES_(T)>
-class GTEST_2_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
-      f1_(f1) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
-  template <typename U0, typename U1>
-  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-  template <typename U0, typename U1>
-  tuple& operator=(const ::std::pair<U0, U1>& p) {
-    f0_ = p.first;
-    f1_ = p.second;
-    return *this;
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-};
-
-template <GTEST_3_TYPENAMES_(T)>
-class GTEST_3_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-};
-
-template <GTEST_4_TYPENAMES_(T)>
-class GTEST_4_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-};
-
-template <GTEST_5_TYPENAMES_(T)>
-class GTEST_5_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
-      GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_) {}
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-};
-
-template <GTEST_6_TYPENAMES_(T)>
-class GTEST_6_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_) {}
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-};
-
-template <GTEST_7_TYPENAMES_(T)>
-class GTEST_7_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-};
-
-template <GTEST_8_TYPENAMES_(T)>
-class GTEST_8_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
-      GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5), f6_(f6), f7_(f7) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-};
-
-template <GTEST_9_TYPENAMES_(T)>
-class GTEST_9_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
-      GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    f8_ = t.f8_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-  T8 f8_;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-class tuple {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
-      f9_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
-      GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
-      f9_(t.f9_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    f8_ = t.f8_;
-    f9_ = t.f9_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-  T8 f8_;
-  T9 f9_;
-};
-
-// 6.1.3.2 Tuple creation functions.
-
-// Known limitations: we don't support passing an
-// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
-// implement tie().
-
-inline tuple<> make_tuple() { return tuple<>(); }
-
-template <GTEST_1_TYPENAMES_(T)>
-inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
-  return GTEST_1_TUPLE_(T)(f0);
-}
-
-template <GTEST_2_TYPENAMES_(T)>
-inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
-  return GTEST_2_TUPLE_(T)(f0, f1);
-}
-
-template <GTEST_3_TYPENAMES_(T)>
-inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
-  return GTEST_3_TUPLE_(T)(f0, f1, f2);
-}
-
-template <GTEST_4_TYPENAMES_(T)>
-inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3) {
-  return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
-}
-
-template <GTEST_5_TYPENAMES_(T)>
-inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4) {
-  return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
-}
-
-template <GTEST_6_TYPENAMES_(T)>
-inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5) {
-  return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
-}
-
-template <GTEST_7_TYPENAMES_(T)>
-inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
-  return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
-}
-
-template <GTEST_8_TYPENAMES_(T)>
-inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
-  return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
-}
-
-template <GTEST_9_TYPENAMES_(T)>
-inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
-    const T8& f8) {
-  return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
-}
-
-template <GTEST_10_TYPENAMES_(T)>
-inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
-    const T8& f8, const T9& f9) {
-  return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
-}
-
-// 6.1.3.3 Tuple helper classes.
-
-template <typename Tuple> struct tuple_size;
-
-template <GTEST_0_TYPENAMES_(T)>
-struct tuple_size<GTEST_0_TUPLE_(T) > {
-  static const int value = 0;
-};
-
-template <GTEST_1_TYPENAMES_(T)>
-struct tuple_size<GTEST_1_TUPLE_(T) > {
-  static const int value = 1;
-};
-
-template <GTEST_2_TYPENAMES_(T)>
-struct tuple_size<GTEST_2_TUPLE_(T) > {
-  static const int value = 2;
-};
-
-template <GTEST_3_TYPENAMES_(T)>
-struct tuple_size<GTEST_3_TUPLE_(T) > {
-  static const int value = 3;
-};
-
-template <GTEST_4_TYPENAMES_(T)>
-struct tuple_size<GTEST_4_TUPLE_(T) > {
-  static const int value = 4;
-};
-
-template <GTEST_5_TYPENAMES_(T)>
-struct tuple_size<GTEST_5_TUPLE_(T) > {
-  static const int value = 5;
-};
-
-template <GTEST_6_TYPENAMES_(T)>
-struct tuple_size<GTEST_6_TUPLE_(T) > {
-  static const int value = 6;
-};
-
-template <GTEST_7_TYPENAMES_(T)>
-struct tuple_size<GTEST_7_TUPLE_(T) > {
-  static const int value = 7;
-};
-
-template <GTEST_8_TYPENAMES_(T)>
-struct tuple_size<GTEST_8_TUPLE_(T) > {
-  static const int value = 8;
-};
-
-template <GTEST_9_TYPENAMES_(T)>
-struct tuple_size<GTEST_9_TUPLE_(T) > {
-  static const int value = 9;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct tuple_size<GTEST_10_TUPLE_(T) > {
-  static const int value = 10;
-};
-
-template <int k, class Tuple>
-struct tuple_element {
-  typedef typename gtest_internal::TupleElement<
-      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
-};
-
-#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
-
-// 6.1.3.4 Element access.
-
-namespace gtest_internal {
-
-template <>
-class Get<0> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
-  Field(Tuple& t) { return t.f0_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
-  ConstField(const Tuple& t) { return t.f0_; }
-};
-
-template <>
-class Get<1> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
-  Field(Tuple& t) { return t.f1_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
-  ConstField(const Tuple& t) { return t.f1_; }
-};
-
-template <>
-class Get<2> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
-  Field(Tuple& t) { return t.f2_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
-  ConstField(const Tuple& t) { return t.f2_; }
-};
-
-template <>
-class Get<3> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
-  Field(Tuple& t) { return t.f3_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
-  ConstField(const Tuple& t) { return t.f3_; }
-};
-
-template <>
-class Get<4> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
-  Field(Tuple& t) { return t.f4_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
-  ConstField(const Tuple& t) { return t.f4_; }
-};
-
-template <>
-class Get<5> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
-  Field(Tuple& t) { return t.f5_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
-  ConstField(const Tuple& t) { return t.f5_; }
-};
-
-template <>
-class Get<6> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
-  Field(Tuple& t) { return t.f6_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
-  ConstField(const Tuple& t) { return t.f6_; }
-};
-
-template <>
-class Get<7> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
-  Field(Tuple& t) { return t.f7_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
-  ConstField(const Tuple& t) { return t.f7_; }
-};
-
-template <>
-class Get<8> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
-  Field(Tuple& t) { return t.f8_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
-  ConstField(const Tuple& t) { return t.f8_; }
-};
-
-template <>
-class Get<9> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
-  Field(Tuple& t) { return t.f9_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
-  ConstField(const Tuple& t) { return t.f9_; }
-};
-
-}  // namespace gtest_internal
-
-template <int k, GTEST_10_TYPENAMES_(T)>
-GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
-get(GTEST_10_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::Field(t);
-}
-
-template <int k, GTEST_10_TYPENAMES_(T)>
-GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
-get(const GTEST_10_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::ConstField(t);
-}
-
-// 6.1.3.5 Relational operators
-
-// We only implement == and !=, as we don't have a need for the rest yet.
-
-namespace gtest_internal {
-
-// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
-// first k fields of t1 equals the first k fields of t2.
-// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
-// k1 != k2.
-template <int kSize1, int kSize2>
-struct SameSizeTuplePrefixComparator;
-
-template <>
-struct SameSizeTuplePrefixComparator<0, 0> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
-    return true;
-  }
-};
-
-template <int k>
-struct SameSizeTuplePrefixComparator<k, k> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
-    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
-        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
-  }
-};
-
-}  // namespace gtest_internal
-
-template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
-inline bool operator==(const GTEST_10_TUPLE_(T)& t,
-                       const GTEST_10_TUPLE_(U)& u) {
-  return gtest_internal::SameSizeTuplePrefixComparator<
-      tuple_size<GTEST_10_TUPLE_(T) >::value,
-      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
-}
-
-template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
-inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
-                       const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
-
-// 6.1.4 Pairs.
-// Unimplemented.
-
-}  // namespace tr1
-}  // namespace std
-
-#undef GTEST_0_TUPLE_
-#undef GTEST_1_TUPLE_
-#undef GTEST_2_TUPLE_
-#undef GTEST_3_TUPLE_
-#undef GTEST_4_TUPLE_
-#undef GTEST_5_TUPLE_
-#undef GTEST_6_TUPLE_
-#undef GTEST_7_TUPLE_
-#undef GTEST_8_TUPLE_
-#undef GTEST_9_TUPLE_
-#undef GTEST_10_TUPLE_
-
-#undef GTEST_0_TYPENAMES_
-#undef GTEST_1_TYPENAMES_
-#undef GTEST_2_TYPENAMES_
-#undef GTEST_3_TYPENAMES_
-#undef GTEST_4_TYPENAMES_
-#undef GTEST_5_TYPENAMES_
-#undef GTEST_6_TYPENAMES_
-#undef GTEST_7_TYPENAMES_
-#undef GTEST_8_TYPENAMES_
-#undef GTEST_9_TYPENAMES_
-#undef GTEST_10_TYPENAMES_
-
-#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
-#undef GTEST_BY_REF_
-#undef GTEST_ADD_REF_
-#undef GTEST_TUPLE_ELEMENT_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-# elif GTEST_ENV_HAS_STD_TUPLE_
-#  include <tuple>
-// C++11 puts its tuple into the ::std namespace rather than
-// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
-// This causes undefined behavior, but supported compilers react in
-// the way we intend.
-namespace std {
-namespace tr1 {
-using ::std::get;
-using ::std::make_tuple;
-using ::std::tuple;
-using ::std::tuple_element;
-using ::std::tuple_size;
-}
-}
-
-# elif GTEST_OS_SYMBIAN
-
-// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
-// use STLport's tuple implementation, which unfortunately doesn't
-// work as the copy of STLport distributed with Symbian is incomplete.
-// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
-// use its own tuple implementation.
-#  ifdef BOOST_HAS_TR1_TUPLE
-#   undef BOOST_HAS_TR1_TUPLE
-#  endif  // BOOST_HAS_TR1_TUPLE
-
-// This prevents <boost/tr1/detail/config.hpp>, which defines
-// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
-#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
-#  include <tuple>  // IWYU pragma: export  // NOLINT
-
-# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
-// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
-// not conform to the TR1 spec, which requires the header to be <tuple>.
-
-#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
-// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
-// which is #included by <tr1/tuple>, to not compile when RTTI is
-// disabled.  _TR1_FUNCTIONAL is the header guard for
-// <tr1/functional>.  Hence the following #define is a hack to prevent
-// <tr1/functional> from being included.
-#   define _TR1_FUNCTIONAL 1
-#   include <tr1/tuple>
-#   undef _TR1_FUNCTIONAL  // Allows the user to #include
-                        // <tr1/functional> if he chooses to.
-#  else
-#   include <tr1/tuple>  // NOLINT
-#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
-
-# else
-// If the compiler is not GCC 4.0+, we assume the user is using a
-// spec-conforming TR1 implementation.
-#  include <tuple>  // IWYU pragma: export  // NOLINT
-# endif  // GTEST_USE_OWN_TR1_TUPLE
-
-#endif  // GTEST_HAS_TR1_TUPLE
-
-// Determines whether clone(2) is supported.
-// Usually it will only be available on Linux, excluding
-// Linux on the Itanium architecture.
-// Also see http://linux.die.net/man/2/clone.
-#ifndef GTEST_HAS_CLONE
-// The user didn't tell us, so we need to figure it out.
-
-# if GTEST_OS_LINUX && !defined(__ia64__)
-#  if GTEST_OS_LINUX_ANDROID
-// On Android, clone() is only available on ARM starting with Gingerbread.
-#    if defined(__arm__) && __ANDROID_API__ >= 9
-#     define GTEST_HAS_CLONE 1
-#    else
-#     define GTEST_HAS_CLONE 0
-#    endif
-#  else
-#   define GTEST_HAS_CLONE 1
-#  endif
-# else
-#  define GTEST_HAS_CLONE 0
-# endif  // GTEST_OS_LINUX && !defined(__ia64__)
-
-#endif  // GTEST_HAS_CLONE
-
-// Determines whether to support stream redirection. This is used to test
-// output correctness and to implement death tests.
-#ifndef GTEST_HAS_STREAM_REDIRECTION
-// By default, we assume that stream redirection is supported on all
-// platforms except known mobile ones.
-# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
-    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-#  define GTEST_HAS_STREAM_REDIRECTION 0
-# else
-#  define GTEST_HAS_STREAM_REDIRECTION 1
-# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Determines whether to support death tests.
-// Google Test does not support death tests for VC 7.1 and earlier as
-// abort() in a VC 7.1 application compiled as GUI in debug config
-// pops up a dialog window that cannot be suppressed programmatically.
-#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
-     (GTEST_OS_MAC && !GTEST_OS_IOS) || \
-     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
-     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
-     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
-# define GTEST_HAS_DEATH_TEST 1
-#endif
-
-// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
-// all the compilers we care about are adequate for supporting
-// value-parameterized tests.
-#define GTEST_HAS_PARAM_TEST 1
-
-// Determines whether to support type-driven tests.
-
-// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
-// Sun Pro CC, IBM Visual Age, and HP aCC support.
-#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
-    defined(__IBMCPP__) || defined(__HP_aCC)
-# define GTEST_HAS_TYPED_TEST 1
-# define GTEST_HAS_TYPED_TEST_P 1
-#endif
-
-// Determines whether to support Combine(). This only makes sense when
-// value-parameterized tests are enabled.  The implementation doesn't
-// work on Sun Studio since it doesn't understand templated conversion
-// operators.
-#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
-# define GTEST_HAS_COMBINE 1
-#endif
-
-// Determines whether the system compiler uses UTF-16 for encoding wide strings.
-#define GTEST_WIDE_STRING_USES_UTF16_ \
-    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
-
-// Determines whether test results can be streamed to a socket.
-#if GTEST_OS_LINUX
-# define GTEST_CAN_STREAM_RESULTS_ 1
-#endif
-
-// Defines some utility macros.
-
-// The GNU compiler emits a warning if nested "if" statements are followed by
-// an "else" statement and braces are not used to explicitly disambiguate the
-// "else" binding.  This leads to problems with code like:
-//
-//   if (gate)
-//     ASSERT_*(condition) << "Some message";
-//
-// The "switch (0) case 0:" idiom is used to suppress this.
-#ifdef __INTEL_COMPILER
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
-#else
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
-#endif
-
-// Use this annotation at the end of a struct/class definition to
-// prevent the compiler from optimizing away instances that are never
-// used.  This is useful when all interesting logic happens inside the
-// c'tor and / or d'tor.  Example:
-//
-//   struct Foo {
-//     Foo() { ... }
-//   } GTEST_ATTRIBUTE_UNUSED_;
-//
-// Also use it after a variable or parameter declaration to tell the
-// compiler the variable/parameter does not have to be used.
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-#elif defined(__clang__)
-# if __has_attribute(unused)
-#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-# endif
-#endif
-#ifndef GTEST_ATTRIBUTE_UNUSED_
-# define GTEST_ATTRIBUTE_UNUSED_
-#endif
-
-// A macro to disallow operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_ASSIGN_(type)\
-  void operator=(type const &)
-
-// A macro to disallow copy constructor and operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
-  type(type const &);\
-  GTEST_DISALLOW_ASSIGN_(type)
-
-// Tell the compiler to warn about unused return values for functions declared
-// with this macro.  The macro should be used on function declarations
-// following the argument list:
-//
-//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
-#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
-# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
-#else
-# define GTEST_MUST_USE_RESULT_
-#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
-
-// MS C++ compiler emits warning when a conditional expression is compile time
-// constant. In some contexts this warning is false positive and needs to be
-// suppressed. Use the following two macros in such cases:
-//
-// GTEST_INTENTIONAL_CONST_COND_PUSH_()
-// while (true) {
-// GTEST_INTENTIONAL_CONST_COND_POP_()
-// }
-# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
-# define GTEST_INTENTIONAL_CONST_COND_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-// Determine whether the compiler supports Microsoft's Structured Exception
-// Handling.  This is supported by several Windows compilers but generally
-// does not exist on any other system.
-#ifndef GTEST_HAS_SEH
-// The user didn't tell us, so we need to figure it out.
-
-# if defined(_MSC_VER) || defined(__BORLANDC__)
-// These two compilers are known to support SEH.
-#  define GTEST_HAS_SEH 1
-# else
-// Assume no SEH.
-#  define GTEST_HAS_SEH 0
-# endif
-
-#define GTEST_IS_THREADSAFE \
-    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
-     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \
-     || GTEST_HAS_PTHREAD)
-
-#endif  // GTEST_HAS_SEH
-
-#ifdef _MSC_VER
-
-# if GTEST_LINKED_AS_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllimport)
-# elif GTEST_CREATE_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllexport)
-# endif
-
-#endif  // _MSC_VER
-
-#ifndef GTEST_API_
-# define GTEST_API_
-#endif
-
-#ifdef __GNUC__
-// Ask the compiler to never inline a given function.
-# define GTEST_NO_INLINE_ __attribute__((noinline))
-#else
-# define GTEST_NO_INLINE_
-#endif
-
-// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
-#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
-# define GTEST_HAS_CXXABI_H_ 1
-#else
-# define GTEST_HAS_CXXABI_H_ 0
-#endif
-
-// A function level attribute to disable checking for use of uninitialized
-// memory when built with MemorySanitizer.
-#if defined(__clang__)
-# if __has_feature(memory_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
-       __attribute__((no_sanitize_memory))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-# endif  // __has_feature(memory_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-#endif  // __clang__
-
-// A function level attribute to disable AddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(address_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
-       __attribute__((no_sanitize_address))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-# endif  // __has_feature(address_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-#endif  // __clang__
-
-// A function level attribute to disable ThreadSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(thread_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
-       __attribute__((no_sanitize_thread))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-# endif  // __has_feature(thread_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-#endif  // __clang__
-
-namespace testing {
-
-class Message;
-
-#if defined(GTEST_TUPLE_NAMESPACE_)
-// Import tuple and friends into the ::testing namespace.
-// It is part of our interface, having them in ::testing allows us to change
-// their types as needed.
-using GTEST_TUPLE_NAMESPACE_::get;
-using GTEST_TUPLE_NAMESPACE_::make_tuple;
-using GTEST_TUPLE_NAMESPACE_::tuple;
-using GTEST_TUPLE_NAMESPACE_::tuple_size;
-using GTEST_TUPLE_NAMESPACE_::tuple_element;
-#endif  // defined(GTEST_TUPLE_NAMESPACE_)
-
-namespace internal {
-
-// A secret type that Google Test users don't know about.  It has no
-// definition on purpose.  Therefore it's impossible to create a
-// Secret object, which is what we want.
-class Secret;
-
-// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
-// expression is true. For example, you could use it to verify the
-// size of a static array:
-//
-//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
-//                         names_incorrect_size);
-//
-// or to make sure a struct is smaller than a certain size:
-//
-//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
-//
-// The second argument to the macro is the name of the variable. If
-// the expression is false, most compilers will issue a warning/error
-// containing the name of the variable.
-
-#if GTEST_LANG_CXX11
-# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
-#else  // !GTEST_LANG_CXX11
-template <bool>
-  struct CompileAssert {
-};
-
-# define GTEST_COMPILE_ASSERT_(expr, msg) \
-  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
-      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
-#endif  // !GTEST_LANG_CXX11
-
-// Implementation details of GTEST_COMPILE_ASSERT_:
-//
-// (In C++11, we simply use static_assert instead of the following)
-//
-// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
-//   elements (and thus is invalid) when the expression is false.
-//
-// - The simpler definition
-//
-//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
-//
-//   does not work, as gcc supports variable-length arrays whose sizes
-//   are determined at run-time (this is gcc's extension and not part
-//   of the C++ standard).  As a result, gcc fails to reject the
-//   following code with the simple definition:
-//
-//     int foo;
-//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
-//                                      // not a compile-time constant.
-//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
-//   expr is a compile-time constant.  (Template arguments must be
-//   determined at compile-time.)
-//
-// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
-//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
-//
-//     CompileAssert<bool(expr)>
-//
-//   instead, these compilers will refuse to compile
-//
-//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
-//
-//   (They seem to think the ">" in "5 > 0" marks the end of the
-//   template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
-//
-//     ((expr) ? 1 : -1).
-//
-//   This is to avoid running into a bug in MS VC 7.1, which
-//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
-
-// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
-//
-// This template is declared, but intentionally undefined.
-template <typename T1, typename T2>
-struct StaticAssertTypeEqHelper;
-
-template <typename T>
-struct StaticAssertTypeEqHelper<T, T> {
-  enum { value = true };
-};
-
-// Evaluates to the number of elements in 'array'.
-#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
-
-#if GTEST_HAS_GLOBAL_STRING
-typedef ::string string;
-#else
-typedef ::std::string string;
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-typedef ::wstring wstring;
-#elif GTEST_HAS_STD_WSTRING
-typedef ::std::wstring wstring;
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// A helper for suppressing warnings on constant condition.  It just
-// returns 'condition'.
-GTEST_API_ bool IsTrue(bool condition);
-
-// Defines scoped_ptr.
-
-// This implementation of scoped_ptr is PARTIAL - it only contains
-// enough stuff to satisfy Google Test's need.
-template <typename T>
-class scoped_ptr {
- public:
-  typedef T element_type;
-
-  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
-  ~scoped_ptr() { reset(); }
-
-  T& operator*() const { return *ptr_; }
-  T* operator->() const { return ptr_; }
-  T* get() const { return ptr_; }
-
-  T* release() {
-    T* const ptr = ptr_;
-    ptr_ = NULL;
-    return ptr;
-  }
-
-  void reset(T* p = NULL) {
-    if (p != ptr_) {
-      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
-        delete ptr_;
-      }
-      ptr_ = p;
-    }
-  }
-
-  friend void swap(scoped_ptr& a, scoped_ptr& b) {
-    using std::swap;
-    swap(a.ptr_, b.ptr_);
-  }
-
- private:
-  T* ptr_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
-};
-
-// Defines RE.
-
-// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
-// Regular Expression syntax.
-class GTEST_API_ RE {
- public:
-  // A copy constructor is required by the Standard to initialize object
-  // references from r-values.
-  RE(const RE& other) { Init(other.pattern()); }
-
-  // Constructs an RE from a string.
-  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
-
-#if GTEST_HAS_GLOBAL_STRING
-
-  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  RE(const char* regex) { Init(regex); }  // NOLINT
-  ~RE();
-
-  // Returns the string representation of the regex.
-  const char* pattern() const { return pattern_; }
-
-  // FullMatch(str, re) returns true iff regular expression re matches
-  // the entire str.
-  // PartialMatch(str, re) returns true iff regular expression re
-  // matches a substring of str (including str itself).
-  //
-  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
-  // when str contains NUL characters.
-  static bool FullMatch(const ::std::string& str, const RE& re) {
-    return FullMatch(str.c_str(), re);
-  }
-  static bool PartialMatch(const ::std::string& str, const RE& re) {
-    return PartialMatch(str.c_str(), re);
-  }
-
-#if GTEST_HAS_GLOBAL_STRING
-
-  static bool FullMatch(const ::string& str, const RE& re) {
-    return FullMatch(str.c_str(), re);
-  }
-  static bool PartialMatch(const ::string& str, const RE& re) {
-    return PartialMatch(str.c_str(), re);
-  }
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  static bool FullMatch(const char* str, const RE& re);
-  static bool PartialMatch(const char* str, const RE& re);
-
- private:
-  void Init(const char* regex);
-
-  // We use a const char* instead of an std::string, as Google Test used to be
-  // used where std::string is not available.  TODO(wan@google.com): change to
-  // std::string.
-  const char* pattern_;
-  bool is_valid_;
-
-#if GTEST_USES_POSIX_RE
-
-  regex_t full_regex_;     // For FullMatch().
-  regex_t partial_regex_;  // For PartialMatch().
-
-#else  // GTEST_USES_SIMPLE_RE
-
-  const char* full_pattern_;  // For FullMatch();
-
-#endif
-
-  GTEST_DISALLOW_ASSIGN_(RE);
-};
-
-// Formats a source file path and a line number as they would appear
-// in an error message from the compiler used to compile this code.
-GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
-                                                               int line);
-
-// Defines logging utilities:
-//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
-//                          message itself is streamed into the macro.
-//   LogToStderr()  - directs all log messages to stderr.
-//   FlushInfoLog() - flushes informational log messages.
-
-enum GTestLogSeverity {
-  GTEST_INFO,
-  GTEST_WARNING,
-  GTEST_ERROR,
-  GTEST_FATAL
-};
-
-// Formats log entry severity, provides a stream object for streaming the
-// log message, and terminates the message with a newline when going out of
-// scope.
-class GTEST_API_ GTestLog {
- public:
-  GTestLog(GTestLogSeverity severity, const char* file, int line);
-
-  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-  ~GTestLog();
-
-  ::std::ostream& GetStream() { return ::std::cerr; }
-
- private:
-  const GTestLogSeverity severity_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
-};
-
-#if !defined(GTEST_LOG_)
-
-# define GTEST_LOG_(severity) \
-    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
-                                  __FILE__, __LINE__).GetStream()
-
-inline void LogToStderr() {}
-inline void FlushInfoLog() { fflush(NULL); }
-
-#endif  // !defined(GTEST_LOG_)
-
-#if !defined(GTEST_CHECK_)
-// INTERNAL IMPLEMENTATION - DO NOT USE.
-//
-// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
-// is not satisfied.
-//  Synopsys:
-//    GTEST_CHECK_(boolean_condition);
-//     or
-//    GTEST_CHECK_(boolean_condition) << "Additional message";
-//
-//    This checks the condition and if the condition is not satisfied
-//    it prints message about the condition violation, including the
-//    condition itself, plus additional message streamed into it, if any,
-//    and then it aborts the program. It aborts the program irrespective of
-//    whether it is built in the debug mode or not.
-# define GTEST_CHECK_(condition) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::IsTrue(condition)) \
-      ; \
-    else \
-      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
-#endif  // !defined(GTEST_CHECK_)
-
-// An all-mode assert to verify that the given POSIX-style function
-// call returns 0 (indicating success).  Known limitation: this
-// doesn't expand to a balanced 'if' statement, so enclose the macro
-// in {} if you need to use it as the only statement in an 'if'
-// branch.
-#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
-  if (const int gtest_error = (posix_call)) \
-    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
-                      << gtest_error
-
-#if GTEST_HAS_STD_MOVE_
-using std::move;
-#else  // GTEST_HAS_STD_MOVE_
-template <typename T>
-const T& move(const T& t) {
-  return t;
-}
-#endif  // GTEST_HAS_STD_MOVE_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Use ImplicitCast_ as a safe version of static_cast for upcasting in
-// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
-// const Foo*).  When you use ImplicitCast_, the compiler checks that
-// the cast is safe.  Such explicit ImplicitCast_s are necessary in
-// surprisingly many situations where C++ demands an exact type match
-// instead of an argument type convertable to a target type.
-//
-// The syntax for using ImplicitCast_ is the same as for static_cast:
-//
-//   ImplicitCast_<ToType>(expr)
-//
-// ImplicitCast_ would have been part of the C++ standard library,
-// but the proposal was submitted too late.  It will probably make
-// its way into the language in the future.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., implicit_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To>
-inline To ImplicitCast_(To x) { return x; }
-
-// When you upcast (that is, cast a pointer from type Foo to type
-// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
-// always succeed.  When you downcast (that is, cast a pointer from
-// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
-// how do you know the pointer is really of type SubclassOfFoo?  It
-// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
-// when you downcast, you should use this macro.  In debug mode, we
-// use dynamic_cast<> to double-check the downcast is legal (we die
-// if it's not).  In normal mode, we do the efficient static_cast<>
-// instead.  Thus, it's important to test in debug mode to make sure
-// the cast is legal!
-//    This is the only place in the code we should use dynamic_cast<>.
-// In particular, you SHOULDN'T be using dynamic_cast<> in order to
-// do RTTI (eg code like this:
-//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
-//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
-// You should design the code some other way not to need this.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., down_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
-inline To DownCast_(From* f) {  // so we only accept pointers
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (false) {
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-    const To to = NULL;
-    ::testing::internal::ImplicitCast_<From*>(to);
-  }
-
-#if GTEST_HAS_RTTI
-  // RTTI: debug mode only!
-  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
-#endif
-  return static_cast<To>(f);
-}
-
-// Downcasts the pointer of type Base to Derived.
-// Derived must be a subclass of Base. The parameter MUST
-// point to a class of type Derived, not any subclass of it.
-// When RTTI is available, the function performs a runtime
-// check to enforce this.
-template <class Derived, class Base>
-Derived* CheckedDowncastToActualType(Base* base) {
-#if GTEST_HAS_RTTI
-  GTEST_CHECK_(typeid(*base) == typeid(Derived));
-#endif
-
-#if GTEST_HAS_DOWNCAST_
-  return ::down_cast<Derived*>(base);
-#elif GTEST_HAS_RTTI
-  return dynamic_cast<Derived*>(base);  // NOLINT
-#else
-  return static_cast<Derived*>(base);  // Poor man's downcast.
-#endif
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Defines the stderr capturer:
-//   CaptureStdout     - starts capturing stdout.
-//   GetCapturedStdout - stops capturing stdout and returns the captured string.
-//   CaptureStderr     - starts capturing stderr.
-//   GetCapturedStderr - stops capturing stderr and returns the captured string.
-//
-GTEST_API_ void CaptureStdout();
-GTEST_API_ std::string GetCapturedStdout();
-GTEST_API_ void CaptureStderr();
-GTEST_API_ std::string GetCapturedStderr();
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Returns a path to temporary directory.
-GTEST_API_ std::string TempDir();
-
-// Returns the size (in bytes) of a file.
-GTEST_API_ size_t GetFileSize(FILE* file);
-
-// Reads the entire content of a file as a string.
-GTEST_API_ std::string ReadEntireFile(FILE* file);
-
-// All command line arguments.
-GTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
-
-#if GTEST_HAS_DEATH_TEST
-
-const ::std::vector<testing::internal::string>& GetInjectableArgvs();
-void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
-                             new_argvs);
-
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Defines synchronization primitives.
-#if GTEST_IS_THREADSAFE
-# if GTEST_HAS_PTHREAD
-// Sleeps for (roughly) n milliseconds.  This function is only for testing
-// Google Test's own constructs.  Don't use it in user tests, either
-// directly or indirectly.
-inline void SleepMilliseconds(int n) {
-  const timespec time = {
-    0,                  // 0 seconds.
-    n * 1000L * 1000L,  // And n ms.
-  };
-  nanosleep(&time, NULL);
-}
-# endif  // GTEST_HAS_PTHREAD
-
-# if GTEST_HAS_NOTIFICATION_
-// Notification has already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_HAS_PTHREAD
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class Notification {
- public:
-  Notification() : notified_(false) {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
-  }
-  ~Notification() {
-    pthread_mutex_destroy(&mutex_);
-  }
-
-  // Notifies all threads created with this notification to start. Must
-  // be called from the controller thread.
-  void Notify() {
-    pthread_mutex_lock(&mutex_);
-    notified_ = true;
-    pthread_mutex_unlock(&mutex_);
-  }
-
-  // Blocks until the controller thread notifies. Must be called from a test
-  // thread.
-  void WaitForNotification() {
-    for (;;) {
-      pthread_mutex_lock(&mutex_);
-      const bool notified = notified_;
-      pthread_mutex_unlock(&mutex_);
-      if (notified)
-        break;
-      SleepMilliseconds(10);
-    }
-  }
-
- private:
-  pthread_mutex_t mutex_;
-  bool notified_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-GTEST_API_ void SleepMilliseconds(int n);
-
-// Provides leak-safe Windows kernel handle ownership.
-// Used in death tests and in threading support.
-class GTEST_API_ AutoHandle {
- public:
-  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
-  // avoid including <windows.h> in this header file. Including <windows.h> is
-  // undesirable because it defines a lot of symbols and macros that tend to
-  // conflict with client code. This assumption is verified by
-  // WindowsTypesTest.HANDLEIsVoidStar.
-  typedef void* Handle;
-  AutoHandle();
-  explicit AutoHandle(Handle handle);
-
-  ~AutoHandle();
-
-  Handle Get() const;
-  void Reset();
-  void Reset(Handle handle);
-
- private:
-  // Returns true iff the handle is a valid handle object that can be closed.
-  bool IsCloseable() const;
-
-  Handle handle_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
-};
-
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class GTEST_API_ Notification {
- public:
-  Notification();
-  void Notify();
-  void WaitForNotification();
-
- private:
-  AutoHandle event_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-# endif  // GTEST_HAS_NOTIFICATION_
-
-// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
-// defined, but we don't want to use MinGW's pthreads implementation, which
-// has conformance problems with some versions of the POSIX standard.
-# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
-
-// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
-// Consequently, it cannot select a correct instantiation of ThreadWithParam
-// in order to call its Run(). Introducing ThreadWithParamBase as a
-// non-templated base class for ThreadWithParam allows us to bypass this
-// problem.
-class ThreadWithParamBase {
- public:
-  virtual ~ThreadWithParamBase() {}
-  virtual void Run() = 0;
-};
-
-// pthread_create() accepts a pointer to a function type with the C linkage.
-// According to the Standard (7.5/1), function types with different linkages
-// are different even if they are otherwise identical.  Some compilers (for
-// example, SunStudio) treat them as different types.  Since class methods
-// cannot be defined with C-linkage we need to define a free C-function to
-// pass into pthread_create().
-extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
-  static_cast<ThreadWithParamBase*>(thread)->Run();
-  return NULL;
-}
-
-// Helper class for testing Google Test's multi-threading constructs.
-// To use it, write:
-//
-//   void ThreadFunc(int param) { /* Do things with param */ }
-//   Notification thread_can_start;
-//   ...
-//   // The thread_can_start parameter is optional; you can supply NULL.
-//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
-//   thread_can_start.Notify();
-//
-// These classes are only for testing Google Test's own constructs. Do
-// not use them in user tests, either directly or indirectly.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : func_(func),
-        param_(param),
-        thread_can_start_(thread_can_start),
-        finished_(false) {
-    ThreadWithParamBase* const base = this;
-    // The thread can be created only after all fields except thread_
-    // have been initialized.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
-  }
-  ~ThreadWithParam() { Join(); }
-
-  void Join() {
-    if (!finished_) {
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
-      finished_ = true;
-    }
-  }
-
-  virtual void Run() {
-    if (thread_can_start_ != NULL)
-      thread_can_start_->WaitForNotification();
-    func_(param_);
-  }
-
- private:
-  UserThreadFunc* const func_;  // User-supplied thread function.
-  const T param_;  // User-supplied parameter to the thread function.
-  // When non-NULL, used to block execution until the controller thread
-  // notifies.
-  Notification* const thread_can_start_;
-  bool finished_;  // true iff we know that the thread function has finished.
-  pthread_t thread_;  // The native thread object.
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
-         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-// Mutex and ThreadLocal have already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-// Mutex implements mutex on Windows platforms.  It is used in conjunction
-// with class MutexLock:
-//
-//   Mutex mutex;
-//   ...
-//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
-//                            // end of the current scope.
-//
-// A static Mutex *must* be defined or declared using one of the following
-// macros:
-//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
-//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
-//
-// (A non-static Mutex is defined/declared in the usual way).
-class GTEST_API_ Mutex {
- public:
-  enum MutexType { kStatic = 0, kDynamic = 1 };
-  // We rely on kStaticMutex being 0 as it is to what the linker initializes
-  // type_ in static mutexes.  critical_section_ will be initialized lazily
-  // in ThreadSafeLazyInit().
-  enum StaticConstructorSelector { kStaticMutex = 0 };
-
-  // This constructor intentionally does nothing.  It relies on type_ being
-  // statically initialized to 0 (effectively setting it to kStatic) and on
-  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
-  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
-
-  Mutex();
-  ~Mutex();
-
-  void Lock();
-
-  void Unlock();
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld();
-
- private:
-  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
-  void ThreadSafeLazyInit();
-
-  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
-  // we assume that 0 is an invalid value for thread IDs.
-  unsigned int owner_thread_id_;
-
-  // For static mutexes, we rely on these members being initialized to zeros
-  // by the linker.
-  MutexType type_;
-  long critical_section_init_phase_;  // NOLINT
-  _RTL_CRITICAL_SECTION* critical_section_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-    extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  Mutex* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
-// without knowing its type.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Provides a way for a thread to send notifications to a ThreadLocal
-// regardless of its parameter type.
-class ThreadLocalBase {
- public:
-  // Creates a new ValueHolder<T> object holding a default value passed to
-  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
-  // responsibility not to call this when the ThreadLocal<T> instance already
-  // has a value on the current thread.
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
-
- protected:
-  ThreadLocalBase() {}
-  virtual ~ThreadLocalBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
-};
-
-// Maps a thread to a set of ThreadLocals that have values instantiated on that
-// thread and notifies them when the thread exits.  A ThreadLocal instance is
-// expected to persist until all threads it has values on have terminated.
-class GTEST_API_ ThreadLocalRegistry {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance);
-
-  // Invoked when a ThreadLocal instance is destroyed.
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance);
-};
-
-class GTEST_API_ ThreadWithParamBase {
- public:
-  void Join();
-
- protected:
-  class Runnable {
-   public:
-    virtual ~Runnable() {}
-    virtual void Run() = 0;
-  };
-
-  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
-  virtual ~ThreadWithParamBase();
-
- private:
-  AutoHandle thread_;
-};
-
-// Helper class for testing Google Test's multi-threading constructs.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
-  }
-  virtual ~ThreadWithParam() {}
-
- private:
-  class RunnableImpl : public Runnable {
-   public:
-    RunnableImpl(UserThreadFunc* func, T param)
-        : func_(func),
-          param_(param) {
-    }
-    virtual ~RunnableImpl() {}
-    virtual void Run() {
-      func_(param_);
-    }
-
-   private:
-    UserThreadFunc* const func_;
-    const T param_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
-  };
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-
-// Implements thread-local storage on Windows systems.
-//
-//   // Thread 1
-//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
-//
-//   // Thread 2
-//   tl.set(150);  // Changes the value for thread 2 only.
-//   EXPECT_EQ(150, tl.get());
-//
-//   // Thread 1
-//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
-//   tl.set(200);
-//   EXPECT_EQ(200, tl.get());
-//
-// The template type argument T must have a public copy constructor.
-// In addition, the default ThreadLocal constructor requires T to have
-// a public default constructor.
-//
-// The users of a TheadLocal instance have to make sure that all but one
-// threads (including the main one) using that instance have exited before
-// destroying it. Otherwise, the per-thread objects managed for them by the
-// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
-//
-// Google Test only uses global ThreadLocal objects.  That means they
-// will die after main() has returned.  Therefore, no per-thread
-// object managed by Google Test will be leaked as long as all threads
-// using Google Test have exited when main() returns.
-template <typename T>
-class ThreadLocal : public ThreadLocalBase {
- public:
-  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of T.  Can be deleted via its base class without the caller
-  // knowing the type of T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-
-  T* GetOrCreateValue() const {
-    return static_cast<ValueHolder*>(
-        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
-  }
-
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
-    return default_factory_->MakeNewHolder();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  scoped_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# elif GTEST_HAS_PTHREAD
-
-// MutexBase and Mutex implement mutex on pthreads-based platforms.
-class MutexBase {
- public:
-  // Acquires this mutex.
-  void Lock() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
-    owner_ = pthread_self();
-    has_owner_ = true;
-  }
-
-  // Releases this mutex.
-  void Unlock() {
-    // Since the lock is being released the owner_ field should no longer be
-    // considered valid. We don't protect writing to has_owner_ here, as it's
-    // the caller's responsibility to ensure that the current thread holds the
-    // mutex when this is called.
-    has_owner_ = false;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
-  }
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld() const {
-    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
-        << "The current thread is not holding the mutex @" << this;
-  }
-
-  // A static mutex may be used before main() is entered.  It may even
-  // be used before the dynamic initialization stage.  Therefore we
-  // must be able to initialize a static mutex object at link time.
-  // This means MutexBase has to be a POD and its member variables
-  // have to be public.
- public:
-  pthread_mutex_t mutex_;  // The underlying pthread mutex.
-  // has_owner_ indicates whether the owner_ field below contains a valid thread
-  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
-  // accesses to the owner_ field should be protected by a check of this field.
-  // An alternative might be to memset() owner_ to all zeros, but there's no
-  // guarantee that a zero'd pthread_t is necessarily invalid or even different
-  // from pthread_self().
-  bool has_owner_;
-  pthread_t owner_;  // The thread holding the mutex.
-};
-
-// Forward-declares a static mutex.
-#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-     extern ::testing::internal::MutexBase mutex
-
-// Defines and statically (i.e. at link time) initializes a static mutex.
-// The initialization list here does not explicitly initialize each field,
-// instead relying on default initialization for the unspecified fields. In
-// particular, the owner_ field (a pthread_t) is not explicitly initialized.
-// This allows initialization to work whether pthread_t is a scalar or struct.
-// The flag -Wmissing-field-initializers must not be specified for this to work.
-#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
-
-// The Mutex class can only be used for mutexes created at runtime. It
-// shares its API with MutexBase otherwise.
-class Mutex : public MutexBase {
- public:
-  Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
-    has_owner_ = false;
-  }
-  ~Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(MutexBase* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  MutexBase* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Helpers for ThreadLocal.
-
-// pthread_key_create() requires DeleteThreadLocalValue() to have
-// C-linkage.  Therefore it cannot be templatized to access
-// ThreadLocal<T>.  Hence the need for class
-// ThreadLocalValueHolderBase.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Called by pthread to delete thread-local data stored by
-// pthread_setspecific().
-extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
-  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
-}
-
-// Implements thread-local storage on pthreads-based systems.
-template <typename T>
-class ThreadLocal {
- public:
-  ThreadLocal()
-      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : key_(CreateKey()),
-        default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() {
-    // Destroys the managed object for the current thread, if any.
-    DeleteThreadLocalValue(pthread_getspecific(key_));
-
-    // Releases resources associated with the key.  This will *not*
-    // delete managed objects for other threads.
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
-  }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of type T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-  static pthread_key_t CreateKey() {
-    pthread_key_t key;
-    // When a thread exits, DeleteThreadLocalValue() will be called on
-    // the object managed for that thread.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_key_create(&key, &DeleteThreadLocalValue));
-    return key;
-  }
-
-  T* GetOrCreateValue() const {
-    ThreadLocalValueHolderBase* const holder =
-        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
-    if (holder != NULL) {
-      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
-    }
-
-    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
-    ThreadLocalValueHolderBase* const holder_base = new_holder;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
-    return new_holder->pointer();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  // A key pthreads uses for looking up per-thread values.
-  const pthread_key_t key_;
-  scoped_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-#else  // GTEST_IS_THREADSAFE
-
-// A dummy implementation of synchronization primitives (mutex, lock,
-// and thread-local variable).  Necessary for compiling Google Test where
-// mutex is not supported - using Google Test in multiple threads is not
-// supported on such platforms.
-
-class Mutex {
- public:
-  Mutex() {}
-  void Lock() {}
-  void Unlock() {}
-  void AssertHeld() const {}
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-  extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex*) {}  // NOLINT
-};
-
-typedef GTestMutexLock MutexLock;
-
-template <typename T>
-class ThreadLocal {
- public:
-  ThreadLocal() : value_() {}
-  explicit ThreadLocal(const T& value) : value_(value) {}
-  T* pointer() { return &value_; }
-  const T* pointer() const { return &value_; }
-  const T& get() const { return value_; }
-  void set(const T& value) { value_ = value; }
- private:
-  T value_;
-};
-
-#endif  // GTEST_IS_THREADSAFE
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-GTEST_API_ size_t GetThreadCount();
-
-// Passing non-POD classes through ellipsis (...) crashes the ARM
-// compiler and generates a warning in Sun Studio.  The Nokia Symbian
-// and the IBM XL C/C++ compiler try to instantiate a copy constructor
-// for objects passed through ellipsis (...), failing for uncopyable
-// objects.  We define this to ensure that only POD is passed through
-// ellipsis on these systems.
-#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
-// We lose support for NULL detection where the compiler doesn't like
-// passing non-POD classes through ellipsis (...).
-# define GTEST_ELLIPSIS_NEEDS_POD_ 1
-#else
-# define GTEST_CAN_COMPARE_NULL 1
-#endif
-
-// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
-// const T& and const T* in a function template.  These compilers
-// _can_ decide between class template specializations for T and T*,
-// so a tr1::type_traits-like is_pointer works.
-#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
-# define GTEST_NEEDS_IS_POINTER_ 1
-#endif
-
-template <bool bool_value>
-struct bool_constant {
-  typedef bool_constant<bool_value> type;
-  static const bool value = bool_value;
-};
-template <bool bool_value> const bool bool_constant<bool_value>::value;
-
-typedef bool_constant<false> false_type;
-typedef bool_constant<true> true_type;
-
-template <typename T>
-struct is_pointer : public false_type {};
-
-template <typename T>
-struct is_pointer<T*> : public true_type {};
-
-template <typename Iterator>
-struct IteratorTraits {
-  typedef typename Iterator::value_type value_type;
-};
-
-template <typename T>
-struct IteratorTraits<T*> {
-  typedef T value_type;
-};
-
-template <typename T>
-struct IteratorTraits<const T*> {
-  typedef T value_type;
-};
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_SEP_ "\\"
-# define GTEST_HAS_ALT_PATH_SEP_ 1
-// The biggest signed integer type the compiler supports.
-typedef __int64 BiggestInt;
-#else
-# define GTEST_PATH_SEP_ "/"
-# define GTEST_HAS_ALT_PATH_SEP_ 0
-typedef long long BiggestInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-// Utilities for char.
-
-// isspace(int ch) and friends accept an unsigned char or EOF.  char
-// may be signed, depending on the compiler (or compiler flags).
-// Therefore we need to cast a char to unsigned char before calling
-// isspace(), etc.
-
-inline bool IsAlpha(char ch) {
-  return isalpha(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsAlNum(char ch) {
-  return isalnum(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsDigit(char ch) {
-  return isdigit(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsLower(char ch) {
-  return islower(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsSpace(char ch) {
-  return isspace(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsUpper(char ch) {
-  return isupper(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsXDigit(char ch) {
-  return isxdigit(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsXDigit(wchar_t ch) {
-  const unsigned char low_byte = static_cast<unsigned char>(ch);
-  return ch == low_byte && isxdigit(low_byte) != 0;
-}
-
-inline char ToLower(char ch) {
-  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
-}
-inline char ToUpper(char ch) {
-  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
-}
-
-inline std::string StripTrailingSpaces(std::string str) {
-  std::string::iterator it = str.end();
-  while (it != str.begin() && IsSpace(*--it))
-    it = str.erase(it);
-  return str;
-}
-
-// The testing::internal::posix namespace holds wrappers for common
-// POSIX functions.  These wrappers hide the differences between
-// Windows/MSVC and POSIX systems.  Since some compilers define these
-// standard functions as macros, the wrapper cannot have the same name
-// as the wrapped function.
-
-namespace posix {
-
-// Functions with a different name on Windows.
-
-#if GTEST_OS_WINDOWS
-
-typedef struct _stat StatStruct;
-
-# ifdef __BORLANDC__
-inline int IsATTY(int fd) { return isatty(fd); }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-# else  // !__BORLANDC__
-#  if GTEST_OS_WINDOWS_MOBILE
-inline int IsATTY(int /* fd */) { return 0; }
-#  else
-inline int IsATTY(int fd) { return _isatty(fd); }
-#  endif  // GTEST_OS_WINDOWS_MOBILE
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return _strdup(src); }
-# endif  // __BORLANDC__
-
-# if GTEST_OS_WINDOWS_MOBILE
-inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
-// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
-// time and thus not defined there.
-# else
-inline int FileNo(FILE* file) { return _fileno(file); }
-inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
-inline int RmDir(const char* dir) { return _rmdir(dir); }
-inline bool IsDir(const StatStruct& st) {
-  return (_S_IFDIR & st.st_mode) != 0;
-}
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-#else
-
-typedef struct stat StatStruct;
-
-inline int FileNo(FILE* file) { return fileno(file); }
-inline int IsATTY(int fd) { return isatty(fd); }
-inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return strcasecmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-inline int RmDir(const char* dir) { return rmdir(dir); }
-inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-
-#endif  // GTEST_OS_WINDOWS
-
-// Functions deprecated by MSVC 8.0.
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
-
-inline const char* StrNCpy(char* dest, const char* src, size_t n) {
-  return strncpy(dest, src, n);
-}
-
-// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
-// StrError() aren't needed on Windows CE at this time and thus not
-// defined there.
-
-#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-inline int ChDir(const char* dir) { return chdir(dir); }
-#endif
-inline FILE* FOpen(const char* path, const char* mode) {
-  return fopen(path, mode);
-}
-#if !GTEST_OS_WINDOWS_MOBILE
-inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
-  return freopen(path, mode, stream);
-}
-inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
-#endif
-inline int FClose(FILE* fp) { return fclose(fp); }
-#if !GTEST_OS_WINDOWS_MOBILE
-inline int Read(int fd, void* buf, unsigned int count) {
-  return static_cast<int>(read(fd, buf, count));
-}
-inline int Write(int fd, const void* buf, unsigned int count) {
-  return static_cast<int>(write(fd, buf, count));
-}
-inline int Close(int fd) { return close(fd); }
-inline const char* StrError(int errnum) { return strerror(errnum); }
-#endif
-inline const char* GetEnv(const char* name) {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT
-  // We are on Windows CE, which has no environment variables.
-  static_cast<void>(name);  // To prevent 'unused argument' warning.
-  return NULL;
-#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
-  // Environment variables which we programmatically clear will be set to the
-  // empty string rather than unset (NULL).  Handle that case.
-  const char* const env = getenv(name);
-  return (env != NULL && env[0] != '\0') ? env : NULL;
-#else
-  return getenv(name);
-#endif
-}
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-#if GTEST_OS_WINDOWS_MOBILE
-// Windows CE has no C library. The abort() function is used in
-// several places in Google Test. This implementation provides a reasonable
-// imitation of standard behaviour.
-void Abort();
-#else
-inline void Abort() { abort(); }
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-}  // namespace posix
-
-// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
-// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
-// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
-// function in order to achieve that.  We use macro definition here because
-// snprintf is a variadic function.
-#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
-// MSVC 2005 and above support variadic macros.
-# define GTEST_SNPRINTF_(buffer, size, format, ...) \
-     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
-#elif defined(_MSC_VER)
-// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
-// complain about _snprintf.
-# define GTEST_SNPRINTF_ _snprintf
-#else
-# define GTEST_SNPRINTF_ snprintf
-#endif
-
-// The maximum number a BiggestInt can represent.  This definition
-// works no matter BiggestInt is represented in one's complement or
-// two's complement.
-//
-// We cannot rely on numeric_limits in STL, as __int64 and long long
-// are not part of standard C++ and numeric_limits doesn't need to be
-// defined for them.
-const BiggestInt kMaxBiggestInt =
-    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
-
-// This template class serves as a compile-time function from size to
-// type.  It maps a size in bytes to a primitive type with that
-// size. e.g.
-//
-//   TypeWithSize<4>::UInt
-//
-// is typedef-ed to be unsigned int (unsigned integer made up of 4
-// bytes).
-//
-// Such functionality should belong to STL, but I cannot find it
-// there.
-//
-// Google Test uses this class in the implementation of floating-point
-// comparison.
-//
-// For now it only handles UInt (unsigned int) as that's all Google Test
-// needs.  Other types can be easily added in the future if need
-// arises.
-template <size_t size>
-class TypeWithSize {
- public:
-  // This prevents the user from using TypeWithSize<N> with incorrect
-  // values of N.
-  typedef void UInt;
-};
-
-// The specialization for size 4.
-template <>
-class TypeWithSize<4> {
- public:
-  // unsigned int has size 4 in both gcc and MSVC.
-  //
-  // As base/basictypes.h doesn't compile on Windows, we cannot use
-  // uint32, uint64, and etc here.
-  typedef int Int;
-  typedef unsigned int UInt;
-};
-
-// The specialization for size 8.
-template <>
-class TypeWithSize<8> {
- public:
-#if GTEST_OS_WINDOWS
-  typedef __int64 Int;
-  typedef unsigned __int64 UInt;
-#else
-  typedef long long Int;  // NOLINT
-  typedef unsigned long long UInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-};
-
-// Integer types of known sizes.
-typedef TypeWithSize<4>::Int Int32;
-typedef TypeWithSize<4>::UInt UInt32;
-typedef TypeWithSize<8>::Int Int64;
-typedef TypeWithSize<8>::UInt UInt64;
-typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
-
-// Utilities for command line flags and environment variables.
-
-// Macro for referencing flags.
-#if !defined(GTEST_FLAG)
-# define GTEST_FLAG(name) FLAGS_gtest_##name
-#endif  // !defined(GTEST_FLAG)
-
-#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
-#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-
-#if !defined(GTEST_DECLARE_bool_)
-# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
-
-// Macros for declaring flags.
-# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
-# define GTEST_DECLARE_int32_(name) \
-    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
-#define GTEST_DECLARE_string_(name) \
-    GTEST_API_ extern ::std::string GTEST_FLAG(name)
-
-// Macros for defining flags.
-#define GTEST_DEFINE_bool_(name, default_val, doc) \
-    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
-#define GTEST_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
-#define GTEST_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
-
-#endif  // !defined(GTEST_DECLARE_bool_)
-
-// Thread annotations
-#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-# define GTEST_LOCK_EXCLUDED_(locks)
-#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-
-// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
-// to *value and returns true; otherwise leaves *value unchanged and returns
-// false.
-// TODO(chandlerc): Find a better way to refactor flag and environment parsing
-// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
-// function.
-bool ParseInt32(const Message& src_text, const char* str, Int32* value);
-
-// Parses a bool/Int32/string from the environment variable
-// corresponding to the given Google Test flag.
-bool BoolFromGTestEnv(const char* flag, bool default_val);
-GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
-const char* StringFromGTestEnv(const char* flag, const char* default_val);
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-
-
-#if GTEST_OS_LINUX
-# include <stdlib.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <unistd.h>
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#include <ctype.h>
-#include <float.h>
-#include <string.h>
-#include <iomanip>
-#include <limits>
-#include <map>
-#include <set>
-#include <string>
-#include <vector>
-
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the Message class.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-
-#include <limits>
-
-
-// Ensures that there is at least one operator<< in the global namespace.
-// See Message& operator<<(...) below for why.
-void operator<<(const testing::internal::Secret&, int);
-
-namespace testing {
-
-// The Message class works like an ostream repeater.
-//
-// Typical usage:
-//
-//   1. You stream a bunch of values to a Message object.
-//      It will remember the text in a stringstream.
-//   2. Then you stream the Message object to an ostream.
-//      This causes the text in the Message to be streamed
-//      to the ostream.
-//
-// For example;
-//
-//   testing::Message foo;
-//   foo << 1 << " != " << 2;
-//   std::cout << foo;
-//
-// will print "1 != 2".
-//
-// Message is not intended to be inherited from.  In particular, its
-// destructor is not virtual.
-//
-// Note that stringstream behaves differently in gcc and in MSVC.  You
-// can stream a NULL char pointer to it in the former, but not in the
-// latter (it causes an access violation if you do).  The Message
-// class hides this difference by treating a NULL char pointer as
-// "(null)".
-class GTEST_API_ Message {
- private:
-  // The type of basic IO manipulators (endl, ends, and flush) for
-  // narrow streams.
-  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
-
- public:
-  // Constructs an empty Message.
-  Message();
-
-  // Copy constructor.
-  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
-    *ss_ << msg.GetString();
-  }
-
-  // Constructs a Message from a C-string.
-  explicit Message(const char* str) : ss_(new ::std::stringstream) {
-    *ss_ << str;
-  }
-
-#if GTEST_OS_SYMBIAN
-  // Streams a value (either a pointer or not) to this object.
-  template <typename T>
-  inline Message& operator <<(const T& value) {
-    StreamHelper(typename internal::is_pointer<T>::type(), value);
-    return *this;
-  }
-#else
-  // Streams a non-pointer value to this object.
-  template <typename T>
-  inline Message& operator <<(const T& val) {
-    // Some libraries overload << for STL containers.  These
-    // overloads are defined in the global namespace instead of ::std.
-    //
-    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
-    // overloads are visible in either the std namespace or the global
-    // namespace, but not other namespaces, including the testing
-    // namespace which Google Test's Message class is in.
-    //
-    // To allow STL containers (and other types that has a << operator
-    // defined in the global namespace) to be used in Google Test
-    // assertions, testing::Message must access the custom << operator
-    // from the global namespace.  With this using declaration,
-    // overloads of << defined in the global namespace and those
-    // visible via Koenig lookup are both exposed in this function.
-    using ::operator <<;
-    *ss_ << val;
-    return *this;
-  }
-
-  // Streams a pointer value to this object.
-  //
-  // This function is an overload of the previous one.  When you
-  // stream a pointer to a Message, this definition will be used as it
-  // is more specialized.  (The C++ Standard, section
-  // [temp.func.order].)  If you stream a non-pointer, then the
-  // previous definition will be used.
-  //
-  // The reason for this overload is that streaming a NULL pointer to
-  // ostream is undefined behavior.  Depending on the compiler, you
-  // may get "0", "(nil)", "(null)", or an access violation.  To
-  // ensure consistent result across compilers, we always treat NULL
-  // as "(null)".
-  template <typename T>
-  inline Message& operator <<(T* const& pointer) {  // NOLINT
-    if (pointer == NULL) {
-      *ss_ << "(null)";
-    } else {
-      *ss_ << pointer;
-    }
-    return *this;
-  }
-#endif  // GTEST_OS_SYMBIAN
-
-  // Since the basic IO manipulators are overloaded for both narrow
-  // and wide streams, we have to provide this specialized definition
-  // of operator <<, even though its body is the same as the
-  // templatized version above.  Without this definition, streaming
-  // endl or other basic IO manipulators to Message will confuse the
-  // compiler.
-  Message& operator <<(BasicNarrowIoManip val) {
-    *ss_ << val;
-    return *this;
-  }
-
-  // Instead of 1/0, we want to see true/false for bool values.
-  Message& operator <<(bool b) {
-    return *this << (b ? "true" : "false");
-  }
-
-  // These two overloads allow streaming a wide C string to a Message
-  // using the UTF-8 encoding.
-  Message& operator <<(const wchar_t* wide_c_str);
-  Message& operator <<(wchar_t* wide_c_str);
-
-#if GTEST_HAS_STD_WSTRING
-  // Converts the given wide string to a narrow string using the UTF-8
-  // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::std::wstring& wstr);
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-  // Converts the given wide string to a narrow string using the UTF-8
-  // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::wstring& wstr);
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-  // Gets the text streamed to this object so far as an std::string.
-  // Each '\0' character in the buffer is replaced with "\\0".
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  std::string GetString() const;
-
- private:
-
-#if GTEST_OS_SYMBIAN
-  // These are needed as the Nokia Symbian Compiler cannot decide between
-  // const T& and const T* in a function template. The Nokia compiler _can_
-  // decide between class template specializations for T and T*, so a
-  // tr1::type_traits-like is_pointer works, and we can overload on that.
-  template <typename T>
-  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
-    if (pointer == NULL) {
-      *ss_ << "(null)";
-    } else {
-      *ss_ << pointer;
-    }
-  }
-  template <typename T>
-  inline void StreamHelper(internal::false_type /*is_pointer*/,
-                           const T& value) {
-    // See the comments in Message& operator <<(const T&) above for why
-    // we need this using statement.
-    using ::operator <<;
-    *ss_ << value;
-  }
-#endif  // GTEST_OS_SYMBIAN
-
-  // We'll hold the text streamed to this object here.
-  const internal::scoped_ptr< ::std::stringstream> ss_;
-
-  // We declare (but don't implement) this to prevent the compiler
-  // from implementing the assignment operator.
-  void operator=(const Message&);
-};
-
-// Streams a Message to an ostream.
-inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
-  return os << sb.GetString();
-}
-
-namespace internal {
-
-// Converts a streamable value to an std::string.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-template <typename T>
-std::string StreamableToString(const T& streamable) {
-  return (Message() << streamable).GetString();
-}
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file declares the String class and functions used internally by
-// Google Test.  They are subject to change without notice. They should not used
-// by code external to Google Test.
-//
-// This header file is #included by <gtest/internal/gtest-internal.h>.
-// It should not be #included by other files.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-
-#ifdef __BORLANDC__
-// string.h is not guaranteed to provide strcpy on C++ Builder.
-# include <mem.h>
-#endif
-
-#include <string.h>
-#include <string>
-
-
-namespace testing {
-namespace internal {
-
-// String - an abstract class holding static string utilities.
-class GTEST_API_ String {
- public:
-  // Static utility methods
-
-  // Clones a 0-terminated C string, allocating memory using new.  The
-  // caller is responsible for deleting the return value using
-  // delete[].  Returns the cloned string, or NULL if the input is
-  // NULL.
-  //
-  // This is different from strdup() in string.h, which allocates
-  // memory using malloc().
-  static const char* CloneCString(const char* c_str);
-
-#if GTEST_OS_WINDOWS_MOBILE
-  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
-  // able to pass strings to Win32 APIs on CE we need to convert them
-  // to 'Unicode', UTF-16.
-
-  // Creates a UTF-16 wide string from the given ANSI string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the wide string, or NULL if the
-  // input is NULL.
-  //
-  // The wide string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static LPCWSTR AnsiToUtf16(const char* c_str);
-
-  // Creates an ANSI string from the given wide string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the ANSI string, or NULL if the
-  // input is NULL.
-  //
-  // The returned string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
-#endif
-
-  // Compares two C strings.  Returns true iff they have the same content.
-  //
-  // Unlike strcmp(), this function can handle NULL argument(s).  A
-  // NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool CStringEquals(const char* lhs, const char* rhs);
-
-  // Converts a wide C string to a String using the UTF-8 encoding.
-  // NULL will be converted to "(null)".  If an error occurred during
-  // the conversion, "(failed to convert from wide string)" is
-  // returned.
-  static std::string ShowWideCString(const wchar_t* wide_c_str);
-
-  // Compares two wide C strings.  Returns true iff they have the same
-  // content.
-  //
-  // Unlike wcscmp(), this function can handle NULL argument(s).  A
-  // NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
-
-  // Compares two C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike strcasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL C string,
-  // including the empty string.
-  static bool CaseInsensitiveCStringEquals(const char* lhs,
-                                           const char* rhs);
-
-  // Compares two wide C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike wcscasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL wide C string,
-  // including the empty string.
-  // NB: The implementations on different platforms slightly differ.
-  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
-  // environment variable. On GNU platform this method uses wcscasecmp
-  // which compares according to LC_CTYPE category of the current locale.
-  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
-  // current locale.
-  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
-                                               const wchar_t* rhs);
-
-  // Returns true iff the given string ends with the given suffix, ignoring
-  // case. Any string is considered to end with an empty suffix.
-  static bool EndsWithCaseInsensitive(
-      const std::string& str, const std::string& suffix);
-
-  // Formats an int value as "%02d".
-  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
-
-  // Formats an int value as "%X".
-  static std::string FormatHexInt(int value);
-
-  // Formats a byte as "%02X".
-  static std::string FormatByte(unsigned char value);
-
- private:
-  String();  // Not meant to be instantiated.
-};  // class String
-
-// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
-// character in the buffer is replaced with "\\0".
-GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: keith.ray@gmail.com (Keith Ray)
-//
-// Google Test filepath utilities
-//
-// This header file declares classes and functions used internally by
-// Google Test.  They are subject to change without notice.
-//
-// This file is #included in <gtest/internal/gtest-internal.h>.
-// Do not include this header file separately!
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-
-
-namespace testing {
-namespace internal {
-
-// FilePath - a class for file and directory pathname manipulation which
-// handles platform-specific conventions (like the pathname separator).
-// Used for helper functions for naming files in a directory for xml output.
-// Except for Set methods, all methods are const or static, which provides an
-// "immutable value object" -- useful for peace of mind.
-// A FilePath with a value ending in a path separator ("like/this/") represents
-// a directory, otherwise it is assumed to represent a file. In either case,
-// it may or may not represent an actual file or directory in the file system.
-// Names are NOT checked for syntax correctness -- no checking for illegal
-// characters, malformed paths, etc.
-
-class GTEST_API_ FilePath {
- public:
-  FilePath() : pathname_("") { }
-  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
-
-  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
-    Normalize();
-  }
-
-  FilePath& operator=(const FilePath& rhs) {
-    Set(rhs);
-    return *this;
-  }
-
-  void Set(const FilePath& rhs) {
-    pathname_ = rhs.pathname_;
-  }
-
-  const std::string& string() const { return pathname_; }
-  const char* c_str() const { return pathname_.c_str(); }
-
-  // Returns the current working directory, or "" if unsuccessful.
-  static FilePath GetCurrentDir();
-
-  // Given directory = "dir", base_name = "test", number = 0,
-  // extension = "xml", returns "dir/test.xml". If number is greater
-  // than zero (e.g., 12), returns "dir/test_12.xml".
-  // On Windows platform, uses \ as the separator rather than /.
-  static FilePath MakeFileName(const FilePath& directory,
-                               const FilePath& base_name,
-                               int number,
-                               const char* extension);
-
-  // Given directory = "dir", relative_path = "test.xml",
-  // returns "dir/test.xml".
-  // On Windows, uses \ as the separator rather than /.
-  static FilePath ConcatPaths(const FilePath& directory,
-                              const FilePath& relative_path);
-
-  // Returns a pathname for a file that does not currently exist. The pathname
-  // will be directory/base_name.extension or
-  // directory/base_name_<number>.extension if directory/base_name.extension
-  // already exists. The number will be incremented until a pathname is found
-  // that does not already exist.
-  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-  // There could be a race condition if two or more processes are calling this
-  // function at the same time -- they could both pick the same filename.
-  static FilePath GenerateUniqueFileName(const FilePath& directory,
-                                         const FilePath& base_name,
-                                         const char* extension);
-
-  // Returns true iff the path is "".
-  bool IsEmpty() const { return pathname_.empty(); }
-
-  // If input name has a trailing separator character, removes it and returns
-  // the name, otherwise return the name string unmodified.
-  // On Windows platform, uses \ as the separator, other platforms use /.
-  FilePath RemoveTrailingPathSeparator() const;
-
-  // Returns a copy of the FilePath with the directory part removed.
-  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
-  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
-  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
-  // returns an empty FilePath ("").
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveDirectoryName() const;
-
-  // RemoveFileName returns the directory path with the filename removed.
-  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveFileName() const;
-
-  // Returns a copy of the FilePath with the case-insensitive extension removed.
-  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-  // FilePath("dir/file"). If a case-insensitive extension is not
-  // found, returns a copy of the original FilePath.
-  FilePath RemoveExtension(const char* extension) const;
-
-  // Creates directories so that path exists. Returns true if successful or if
-  // the directories already exist; returns false if unable to create
-  // directories for any reason. Will also return false if the FilePath does
-  // not represent a directory (that is, it doesn't end with a path separator).
-  bool CreateDirectoriesRecursively() const;
-
-  // Create the directory so that path exists. Returns true if successful or
-  // if the directory already exists; returns false if unable to create the
-  // directory for any reason, including if the parent directory does not
-  // exist. Not named "CreateDirectory" because that's a macro on Windows.
-  bool CreateFolder() const;
-
-  // Returns true if FilePath describes something in the file-system,
-  // either a file, directory, or whatever, and that something exists.
-  bool FileOrDirectoryExists() const;
-
-  // Returns true if pathname describes a directory in the file-system
-  // that exists.
-  bool DirectoryExists() const;
-
-  // Returns true if FilePath ends with a path separator, which indicates that
-  // it is intended to represent a directory. Returns false otherwise.
-  // This does NOT check that a directory (or file) actually exists.
-  bool IsDirectory() const;
-
-  // Returns true if pathname describes a root directory. (Windows has one
-  // root directory per disk drive.)
-  bool IsRootDirectory() const;
-
-  // Returns true if pathname describes an absolute path.
-  bool IsAbsolutePath() const;
-
- private:
-  // Replaces multiple consecutive separators with a single separator.
-  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-  // redundancies that might be in a pathname involving "." or "..".
-  //
-  // A pathname with multiple consecutive separators may occur either through
-  // user error or as a result of some scripts or APIs that generate a pathname
-  // with a trailing separator. On other platforms the same API or script
-  // may NOT generate a pathname with a trailing "/". Then elsewhere that
-  // pathname may have another "/" and pathname components added to it,
-  // without checking for the separator already being there.
-  // The script language and operating system may allow paths like "foo//bar"
-  // but some of the functions in FilePath will not handle that correctly. In
-  // particular, RemoveTrailingPathSeparator() only removes one separator, and
-  // it is called in CreateDirectoriesRecursively() assuming that it will change
-  // a pathname from directory syntax (trailing separator) to filename syntax.
-  //
-  // On Windows this method also replaces the alternate path separator '/' with
-  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
-  // "bar\\foo".
-
-  void Normalize();
-
-  // Returns a pointer to the last occurence of a valid path separator in
-  // the FilePath. On Windows, for example, both '/' and '\' are valid path
-  // separators. Returns NULL if no path separator was found.
-  const char* FindLastPathSeparator() const;
-
-  std::string pathname_;
-};  // class FilePath
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-// This file was GENERATED by command:
-//     pump.py gtest-type-util.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Type utilities needed for implementing typed and type-parameterized
-// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently we support at most 50 types in a list, and at most 50
-// type-parameterized tests in one type-parameterized test case.
-// Please contact googletestframework@googlegroups.com if you need
-// more.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-
-// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
-// libstdc++ (which is where cxxabi.h comes from).
-# if GTEST_HAS_CXXABI_H_
-#  include <cxxabi.h>
-# elif defined(__HP_aCC)
-#  include <acxx_demangle.h>
-# endif  // GTEST_HASH_CXXABI_H_
-
-namespace testing {
-namespace internal {
-
-// GetTypeName<T>() returns a human-readable name of type T.
-// NB: This function is also used in Google Mock, so don't move it inside of
-// the typed-test-only section below.
-template <typename T>
-std::string GetTypeName() {
-# if GTEST_HAS_RTTI
-
-  const char* const name = typeid(T).name();
-#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
-  int status = 0;
-  // gcc's implementation of typeid(T).name() mangles the type name,
-  // so we have to demangle it.
-#   if GTEST_HAS_CXXABI_H_
-  using abi::__cxa_demangle;
-#   endif  // GTEST_HAS_CXXABI_H_
-  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
-  const std::string name_str(status == 0 ? readable_name : name);
-  free(readable_name);
-  return name_str;
-#  else
-  return name;
-#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
-
-# else
-
-  return "<type>";
-
-# endif  // GTEST_HAS_RTTI
-}
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
-// type.  This can be used as a compile-time assertion to ensure that
-// two types are equal.
-
-template <typename T1, typename T2>
-struct AssertTypeEq;
-
-template <typename T>
-struct AssertTypeEq<T, T> {
-  typedef bool type;
-};
-
-// A unique type used as the default value for the arguments of class
-// template Types.  This allows us to simulate variadic templates
-// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
-// support directly.
-struct None {};
-
-// The following family of struct and struct templates are used to
-// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
-// represents a type list with N types (T1, T2, ..., and TN) in it.
-// Except for Types0, every struct in the family has two member types:
-// Head for the first type in the list, and Tail for the rest of the
-// list.
-
-// The empty type list.
-struct Types0 {};
-
-// Type lists of length 1, 2, 3, and so on.
-
-template <typename T1>
-struct Types1 {
-  typedef T1 Head;
-  typedef Types0 Tail;
-};
-template <typename T1, typename T2>
-struct Types2 {
-  typedef T1 Head;
-  typedef Types1<T2> Tail;
-};
-
-template <typename T1, typename T2, typename T3>
-struct Types3 {
-  typedef T1 Head;
-  typedef Types2<T2, T3> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types4 {
-  typedef T1 Head;
-  typedef Types3<T2, T3, T4> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types5 {
-  typedef T1 Head;
-  typedef Types4<T2, T3, T4, T5> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types6 {
-  typedef T1 Head;
-  typedef Types5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types7 {
-  typedef T1 Head;
-  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types8 {
-  typedef T1 Head;
-  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types9 {
-  typedef T1 Head;
-  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types10 {
-  typedef T1 Head;
-  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types11 {
-  typedef T1 Head;
-  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types12 {
-  typedef T1 Head;
-  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types13 {
-  typedef T1 Head;
-  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types14 {
-  typedef T1 Head;
-  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types15 {
-  typedef T1 Head;
-  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types16 {
-  typedef T1 Head;
-  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types17 {
-  typedef T1 Head;
-  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types18 {
-  typedef T1 Head;
-  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types19 {
-  typedef T1 Head;
-  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types20 {
-  typedef T1 Head;
-  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types21 {
-  typedef T1 Head;
-  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types22 {
-  typedef T1 Head;
-  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types23 {
-  typedef T1 Head;
-  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types24 {
-  typedef T1 Head;
-  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types25 {
-  typedef T1 Head;
-  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types26 {
-  typedef T1 Head;
-  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types27 {
-  typedef T1 Head;
-  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types28 {
-  typedef T1 Head;
-  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types29 {
-  typedef T1 Head;
-  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types30 {
-  typedef T1 Head;
-  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types31 {
-  typedef T1 Head;
-  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types32 {
-  typedef T1 Head;
-  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types33 {
-  typedef T1 Head;
-  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types34 {
-  typedef T1 Head;
-  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types35 {
-  typedef T1 Head;
-  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types36 {
-  typedef T1 Head;
-  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types37 {
-  typedef T1 Head;
-  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types38 {
-  typedef T1 Head;
-  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types39 {
-  typedef T1 Head;
-  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types40 {
-  typedef T1 Head;
-  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types41 {
-  typedef T1 Head;
-  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types42 {
-  typedef T1 Head;
-  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types43 {
-  typedef T1 Head;
-  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types44 {
-  typedef T1 Head;
-  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types45 {
-  typedef T1 Head;
-  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types46 {
-  typedef T1 Head;
-  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types47 {
-  typedef T1 Head;
-  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types48 {
-  typedef T1 Head;
-  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types49 {
-  typedef T1 Head;
-  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct Types50 {
-  typedef T1 Head;
-  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-}  // namespace internal
-
-// We don't want to require the users to write TypesN<...> directly,
-// as that would require them to count the length.  Types<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Types<int>
-// will appear as Types<int, None, None, ..., None> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Types<T1, ..., TN>, and Google Test will translate
-// that to TypesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Types template.
-template <typename T1 = internal::None, typename T2 = internal::None,
-    typename T3 = internal::None, typename T4 = internal::None,
-    typename T5 = internal::None, typename T6 = internal::None,
-    typename T7 = internal::None, typename T8 = internal::None,
-    typename T9 = internal::None, typename T10 = internal::None,
-    typename T11 = internal::None, typename T12 = internal::None,
-    typename T13 = internal::None, typename T14 = internal::None,
-    typename T15 = internal::None, typename T16 = internal::None,
-    typename T17 = internal::None, typename T18 = internal::None,
-    typename T19 = internal::None, typename T20 = internal::None,
-    typename T21 = internal::None, typename T22 = internal::None,
-    typename T23 = internal::None, typename T24 = internal::None,
-    typename T25 = internal::None, typename T26 = internal::None,
-    typename T27 = internal::None, typename T28 = internal::None,
-    typename T29 = internal::None, typename T30 = internal::None,
-    typename T31 = internal::None, typename T32 = internal::None,
-    typename T33 = internal::None, typename T34 = internal::None,
-    typename T35 = internal::None, typename T36 = internal::None,
-    typename T37 = internal::None, typename T38 = internal::None,
-    typename T39 = internal::None, typename T40 = internal::None,
-    typename T41 = internal::None, typename T42 = internal::None,
-    typename T43 = internal::None, typename T44 = internal::None,
-    typename T45 = internal::None, typename T46 = internal::None,
-    typename T47 = internal::None, typename T48 = internal::None,
-    typename T49 = internal::None, typename T50 = internal::None>
-struct Types {
-  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Types<internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types0 type;
-};
-template <typename T1>
-struct Types<T1, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types1<T1> type;
-};
-template <typename T1, typename T2>
-struct Types<T1, T2, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types2<T1, T2> type;
-};
-template <typename T1, typename T2, typename T3>
-struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types3<T1, T2, T3> type;
-};
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types4<T1, T2, T3, T4> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types5<T1, T2, T3, T4, T5> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, internal::None, internal::None, internal::None> {
-  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, internal::None, internal::None> {
-  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, T49, internal::None> {
-  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-namespace internal {
-
-# define GTEST_TEMPLATE_ template <typename T> class
-
-// The template "selector" struct TemplateSel<Tmpl> is used to
-// represent Tmpl, which must be a class template with one type
-// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
-// as the type Tmpl<T>.  This allows us to actually instantiate the
-// template "selected" by TemplateSel<Tmpl>.
-//
-// This trick is necessary for simulating typedef for class templates,
-// which C++ doesn't support directly.
-template <GTEST_TEMPLATE_ Tmpl>
-struct TemplateSel {
-  template <typename T>
-  struct Bind {
-    typedef Tmpl<T> type;
-  };
-};
-
-# define GTEST_BIND_(TmplSel, T) \
-  TmplSel::template Bind<T>::type
-
-// A unique struct template used as the default value for the
-// arguments of class template Templates.  This allows us to simulate
-// variadic templates (e.g. Templates<int>, Templates<int, double>,
-// and etc), which C++ doesn't support directly.
-template <typename T>
-struct NoneT {};
-
-// The following family of struct and struct templates are used to
-// represent template lists.  In particular, TemplatesN<T1, T2, ...,
-// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
-// for Templates0, every struct in the family has two member types:
-// Head for the selector of the first template in the list, and Tail
-// for the rest of the list.
-
-// The empty template list.
-struct Templates0 {};
-
-// Template lists of length 1, 2, 3, and so on.
-
-template <GTEST_TEMPLATE_ T1>
-struct Templates1 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates0 Tail;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates2 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates1<T2> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates3 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates2<T2, T3> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates4 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates3<T2, T3, T4> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates5 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates4<T2, T3, T4, T5> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates6 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates7 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates8 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates9 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates10 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates11 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates12 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates13 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates14 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates15 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates16 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates17 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates18 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates19 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates20 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates21 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates22 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates23 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates24 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates25 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates26 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates27 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates28 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates29 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates30 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates31 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates32 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates33 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates34 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates35 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates36 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates37 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates38 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates39 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates40 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates41 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates42 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates43 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates44 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates45 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates46 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates47 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates48 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates49 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
-struct Templates50 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-// We don't want to require the users to write TemplatesN<...> directly,
-// as that would require them to count the length.  Templates<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Templates<list>
-// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Templates<T1, ..., TN>, and Google Test will translate
-// that to TemplatesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Templates template.
-template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
-    GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
-    GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
-    GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
-    GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
-    GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
-    GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
-    GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
-    GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
-    GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
-    GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
-    GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
-    GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
-    GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
-    GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
-    GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
-    GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
-    GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
-    GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
-    GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
-    GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
-    GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
-    GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
-    GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
-    GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
-struct Templates {
-  typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates0 type;
-};
-template <GTEST_TEMPLATE_ T1>
-struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates1<T1> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates2<T1, T2> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates3<T1, T2, T3> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates4<T1, T2, T3, T4> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates5<T1, T2, T3, T4, T5> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates6<T1, T2, T3, T4, T5, T6> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, NoneT, NoneT, NoneT> {
-  typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, NoneT, NoneT> {
-  typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, T49, NoneT> {
-  typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-// The TypeList template makes it possible to use either a single type
-// or a Types<...> list in TYPED_TEST_CASE() and
-// INSTANTIATE_TYPED_TEST_CASE_P().
-
-template <typename T>
-struct TypeList {
-  typedef Types1<T> type;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49, T50> > {
-  typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-// Due to C++ preprocessor weirdness, we need double indirection to
-// concatenate two tokens when one of them is __LINE__.  Writing
-//
-//   foo ## __LINE__
-//
-// will result in the token foo__LINE__, instead of foo followed by
-// the current line number.  For more details, see
-// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
-#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
-#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
-
-class ProtocolMessage;
-namespace proto2 { class Message; }
-
-namespace testing {
-
-// Forward declarations.
-
-class AssertionResult;                 // Result of an assertion.
-class Message;                         // Represents a failure message.
-class Test;                            // Represents a test.
-class TestInfo;                        // Information about a test.
-class TestPartResult;                  // Result of a test part.
-class UnitTest;                        // A collection of test cases.
-
-template <typename T>
-::std::string PrintToString(const T& value);
-
-namespace internal {
-
-struct TraceInfo;                      // Information about a trace point.
-class ScopedTrace;                     // Implements scoped trace.
-class TestInfoImpl;                    // Opaque implementation of TestInfo
-class UnitTestImpl;                    // Opaque implementation of UnitTest
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-GTEST_API_ extern const char kStackTraceMarker[];
-
-// Two overloaded helpers for checking at compile time whether an
-// expression is a null pointer literal (i.e. NULL or any 0-valued
-// compile-time integral constant).  Their return values have
-// different sizes, so we can use sizeof() to test which version is
-// picked by the compiler.  These helpers have no implementations, as
-// we only need their signatures.
-//
-// Given IsNullLiteralHelper(x), the compiler will pick the first
-// version if x can be implicitly converted to Secret*, and pick the
-// second version otherwise.  Since Secret is a secret and incomplete
-// type, the only expression a user can write that has type Secret* is
-// a null pointer literal.  Therefore, we know that x is a null
-// pointer literal if and only if the first version is picked by the
-// compiler.
-char IsNullLiteralHelper(Secret* p);
-char (&IsNullLiteralHelper(...))[2];  // NOLINT
-
-// A compile-time bool constant that is true if and only if x is a
-// null pointer literal (i.e. NULL or any 0-valued compile-time
-// integral constant).
-#ifdef GTEST_ELLIPSIS_NEEDS_POD_
-// We lose support for NULL detection where the compiler doesn't like
-// passing non-POD classes through ellipsis (...).
-# define GTEST_IS_NULL_LITERAL_(x) false
-#else
-# define GTEST_IS_NULL_LITERAL_(x) \
-    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
-#endif  // GTEST_ELLIPSIS_NEEDS_POD_
-
-// Appends the user-supplied message to the Google-Test-generated message.
-GTEST_API_ std::string AppendUserMessage(
-    const std::string& gtest_msg, const Message& user_msg);
-
-#if GTEST_HAS_EXCEPTIONS
-
-// This exception is thrown by (and only by) a failed Google Test
-// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
-// are enabled).  We derive it from std::runtime_error, which is for
-// errors presumably detectable only at run time.  Since
-// std::runtime_error inherits from std::exception, many testing
-// frameworks know how to extract and print the message inside it.
-class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
- public:
-  explicit GoogleTestFailureException(const TestPartResult& failure);
-};
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// A helper class for creating scoped traces in user programs.
-class GTEST_API_ ScopedTrace {
- public:
-  // The c'tor pushes the given source file location and message onto
-  // a trace stack maintained by Google Test.
-  ScopedTrace(const char* file, int line, const Message& message);
-
-  // The d'tor pops the info pushed by the c'tor.
-  //
-  // Note that the d'tor is not virtual in order to be efficient.
-  // Don't inherit from ScopedTrace!
-  ~ScopedTrace();
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
-} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
-                            // c'tor and d'tor.  Therefore it doesn't
-                            // need to be used otherwise.
-
-namespace edit_distance {
-// Returns the optimal edits to go from 'left' to 'right'.
-// All edits cost the same, with replace having lower priority than
-// add/remove.
-// Simple implementation of the Wagner–Fischer algorithm.
-// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
-enum EditType { kMatch, kAdd, kRemove, kReplace };
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<size_t>& left, const std::vector<size_t>& right);
-
-// Same as above, but the input is represented as strings.
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right);
-
-// Create a diff of the input strings in Unified diff format.
-GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                                         const std::vector<std::string>& right,
-                                         size_t context = 2);
-
-}  // namespace edit_distance
-
-// Calculate the diff between 'left' and 'right' and return it in unified diff
-// format.
-// If not null, stores in 'total_line_count' the total number of lines found
-// in left + right.
-GTEST_API_ std::string DiffStrings(const std::string& left,
-                                   const std::string& right,
-                                   size_t* total_line_count);
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   expected_expression: "foo"
-//   actual_expression:   "bar"
-//   expected_value:      "5"
-//   actual_value:        "6"
-//
-// The ignoring_case parameter is true iff the assertion is a
-// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
-// be inserted into the message.
-GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
-                                     const char* actual_expression,
-                                     const std::string& expected_value,
-                                     const std::string& actual_value,
-                                     bool ignoring_case);
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-GTEST_API_ std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value);
-
-// This template class represents an IEEE floating-point number
-// (either single-precision or double-precision, depending on the
-// template parameters).
-//
-// The purpose of this class is to do more sophisticated number
-// comparison.  (Due to round-off error, etc, it's very unlikely that
-// two floating-points will be equal exactly.  Hence a naive
-// comparison by the == operation often doesn't work.)
-//
-// Format of IEEE floating-point:
-//
-//   The most-significant bit being the leftmost, an IEEE
-//   floating-point looks like
-//
-//     sign_bit exponent_bits fraction_bits
-//
-//   Here, sign_bit is a single bit that designates the sign of the
-//   number.
-//
-//   For float, there are 8 exponent bits and 23 fraction bits.
-//
-//   For double, there are 11 exponent bits and 52 fraction bits.
-//
-//   More details can be found at
-//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-template <typename RawType>
-class FloatingPoint {
- public:
-  // Defines the unsigned integer type that has the same size as the
-  // floating point number.
-  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
-
-  // Constants.
-
-  // # of bits in a number.
-  static const size_t kBitCount = 8*sizeof(RawType);
-
-  // # of fraction bits in a number.
-  static const size_t kFractionBitCount =
-    std::numeric_limits<RawType>::digits - 1;
-
-  // # of exponent bits in a number.
-  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
-
-  // The mask for the sign bit.
-  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
-
-  // The mask for the fraction bits.
-  static const Bits kFractionBitMask =
-    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
-
-  // The mask for the exponent bits.
-  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
-
-  // How many ULP's (Units in the Last Place) we want to tolerate when
-  // comparing two numbers.  The larger the value, the more error we
-  // allow.  A 0 value means that two numbers must be exactly the same
-  // to be considered equal.
-  //
-  // The maximum error of a single floating-point operation is 0.5
-  // units in the last place.  On Intel CPU's, all floating-point
-  // calculations are done with 80-bit precision, while double has 64
-  // bits.  Therefore, 4 should be enough for ordinary use.
-  //
-  // See the following article for more details on ULP:
-  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
-  static const size_t kMaxUlps = 4;
-
-  // Constructs a FloatingPoint from a raw floating-point number.
-  //
-  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
-  // around may change its bits, although the new value is guaranteed
-  // to be also a NAN.  Therefore, don't expect this constructor to
-  // preserve the bits in x when x is a NAN.
-  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
-
-  // Static methods
-
-  // Reinterprets a bit pattern as a floating-point number.
-  //
-  // This function is needed to test the AlmostEquals() method.
-  static RawType ReinterpretBits(const Bits bits) {
-    FloatingPoint fp(0);
-    fp.u_.bits_ = bits;
-    return fp.u_.value_;
-  }
-
-  // Returns the floating-point number that represent positive infinity.
-  static RawType Infinity() {
-    return ReinterpretBits(kExponentBitMask);
-  }
-
-  // Returns the maximum representable finite floating-point number.
-  static RawType Max();
-
-  // Non-static methods
-
-  // Returns the bits that represents this number.
-  const Bits &bits() const { return u_.bits_; }
-
-  // Returns the exponent bits of this number.
-  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
-
-  // Returns the fraction bits of this number.
-  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
-
-  // Returns the sign bit of this number.
-  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
-
-  // Returns true iff this is NAN (not a number).
-  bool is_nan() const {
-    // It's a NAN if the exponent bits are all ones and the fraction
-    // bits are not entirely zeros.
-    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
-  }
-
-  // Returns true iff this number is at most kMaxUlps ULP's away from
-  // rhs.  In particular, this function:
-  //
-  //   - returns false if either number is (or both are) NAN.
-  //   - treats really large numbers as almost equal to infinity.
-  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
-  bool AlmostEquals(const FloatingPoint& rhs) const {
-    // The IEEE standard says that any comparison operation involving
-    // a NAN must return false.
-    if (is_nan() || rhs.is_nan()) return false;
-
-    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
-        <= kMaxUlps;
-  }
-
- private:
-  // The data type used to store the actual floating-point number.
-  union FloatingPointUnion {
-    RawType value_;  // The raw floating-point number.
-    Bits bits_;      // The bits that represent the number.
-  };
-
-  // Converts an integer from the sign-and-magnitude representation to
-  // the biased representation.  More precisely, let N be 2 to the
-  // power of (kBitCount - 1), an integer x is represented by the
-  // unsigned number x + N.
-  //
-  // For instance,
-  //
-  //   -N + 1 (the most negative number representable using
-  //          sign-and-magnitude) is represented by 1;
-  //   0      is represented by N; and
-  //   N - 1  (the biggest number representable using
-  //          sign-and-magnitude) is represented by 2N - 1.
-  //
-  // Read http://en.wikipedia.org/wiki/Signed_number_representations
-  // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
-    if (kSignBitMask & sam) {
-      // sam represents a negative number.
-      return ~sam + 1;
-    } else {
-      // sam represents a positive number.
-      return kSignBitMask | sam;
-    }
-  }
-
-  // Given two numbers in the sign-and-magnitude representation,
-  // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
-                                                     const Bits &sam2) {
-    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
-    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
-    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
-  }
-
-  FloatingPointUnion u_;
-};
-
-// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
-// macro defined by <windows.h>.
-template <>
-inline float FloatingPoint<float>::Max() { return FLT_MAX; }
-template <>
-inline double FloatingPoint<double>::Max() { return DBL_MAX; }
-
-// Typedefs the instances of the FloatingPoint template class that we
-// care to use.
-typedef FloatingPoint<float> Float;
-typedef FloatingPoint<double> Double;
-
-// In order to catch the mistake of putting tests that use different
-// test fixture classes in the same test case, we need to assign
-// unique IDs to fixture classes and compare them.  The TypeId type is
-// used to hold such IDs.  The user should treat TypeId as an opaque
-// type: the only operation allowed on TypeId values is to compare
-// them for equality using the == operator.
-typedef const void* TypeId;
-
-template <typename T>
-class TypeIdHelper {
- public:
-  // dummy_ must not have a const type.  Otherwise an overly eager
-  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
-  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
-  static bool dummy_;
-};
-
-template <typename T>
-bool TypeIdHelper<T>::dummy_ = false;
-
-// GetTypeId<T>() returns the ID of type T.  Different values will be
-// returned for different types.  Calling the function twice with the
-// same type argument is guaranteed to return the same ID.
-template <typename T>
-TypeId GetTypeId() {
-  // The compiler is required to allocate a different
-  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
-  // the template.  Therefore, the address of dummy_ is guaranteed to
-  // be unique.
-  return &(TypeIdHelper<T>::dummy_);
-}
-
-// Returns the type ID of ::testing::Test.  Always call this instead
-// of GetTypeId< ::testing::Test>() to get the type ID of
-// ::testing::Test, as the latter may give the wrong result due to a
-// suspected linker bug when compiling Google Test as a Mac OS X
-// framework.
-GTEST_API_ TypeId GetTestTypeId();
-
-// Defines the abstract factory interface that creates instances
-// of a Test object.
-class TestFactoryBase {
- public:
-  virtual ~TestFactoryBase() {}
-
-  // Creates a test instance to run. The instance is both created and destroyed
-  // within TestInfoImpl::Run()
-  virtual Test* CreateTest() = 0;
-
- protected:
-  TestFactoryBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
-};
-
-// This class provides implementation of TeastFactoryBase interface.
-// It is used in TEST and TEST_F macros.
-template <class TestClass>
-class TestFactoryImpl : public TestFactoryBase {
- public:
-  virtual Test* CreateTest() { return new TestClass; }
-};
-
-#if GTEST_OS_WINDOWS
-
-// Predicate-formatters for implementing the HRESULT checking macros
-// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
-// We pass a long instead of HRESULT to avoid causing an
-// include dependency for the HRESULT type.
-GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
-                                            long hr);  // NOLINT
-GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
-                                            long hr);  // NOLINT
-
-#endif  // GTEST_OS_WINDOWS
-
-// Types of SetUpTestCase() and TearDownTestCase() functions.
-typedef void (*SetUpTestCaseFunc)();
-typedef void (*TearDownTestCaseFunc)();
-
-struct CodeLocation {
-  CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {}
-
-  string file;
-  int line;
-};
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_case_name:   name of the test case
-//   name:             name of the test
-//   type_param        the name of the test's type parameter, or NULL if
-//                     this is not a typed or a type-parameterized test.
-//   value_param       text representation of the test's value parameter,
-//                     or NULL if this is not a type-parameterized test.
-//   code_location:    code location where the test is defined
-//   fixture_class_id: ID of the test fixture class
-//   set_up_tc:        pointer to the function that sets up the test case
-//   tear_down_tc:     pointer to the function that tears down the test case
-//   factory:          pointer to the factory that creates a test object.
-//                     The newly created TestInfo instance will assume
-//                     ownership of the factory object.
-GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    const char* test_case_name,
-    const char* name,
-    const char* type_param,
-    const char* value_param,
-    CodeLocation code_location,
-    TypeId fixture_class_id,
-    SetUpTestCaseFunc set_up_tc,
-    TearDownTestCaseFunc tear_down_tc,
-    TestFactoryBase* factory);
-
-// If *pstr starts with the given prefix, modifies *pstr to be right
-// past the prefix and returns true; otherwise leaves *pstr unchanged
-// and returns false.  None of pstr, *pstr, and prefix can be NULL.
-GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// State of the definition of a type-parameterized test case.
-class GTEST_API_ TypedTestCasePState {
- public:
-  TypedTestCasePState() : registered_(false) {}
-
-  // Adds the given test name to defined_test_names_ and return true
-  // if the test case hasn't been registered; otherwise aborts the
-  // program.
-  bool AddTestName(const char* file, int line, const char* case_name,
-                   const char* test_name) {
-    if (registered_) {
-      fprintf(stderr, "%s Test %s must be defined before "
-              "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
-              FormatFileLocation(file, line).c_str(), test_name, case_name);
-      fflush(stderr);
-      posix::Abort();
-    }
-    registered_tests_.insert(
-        ::std::make_pair(test_name, CodeLocation(file, line)));
-    return true;
-  }
-
-  bool TestExists(const std::string& test_name) const {
-    return registered_tests_.count(test_name) > 0;
-  }
-
-  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
-    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
-    GTEST_CHECK_(it != registered_tests_.end());
-    return it->second;
-  }
-
-  // Verifies that registered_tests match the test names in
-  // defined_test_names_; returns registered_tests if successful, or
-  // aborts the program otherwise.
-  const char* VerifyRegisteredTestNames(
-      const char* file, int line, const char* registered_tests);
-
- private:
-  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
-
-  bool registered_;
-  RegisteredTestsMap registered_tests_;
-};
-
-// Skips to the first non-space char after the first comma in 'str';
-// returns NULL if no comma is found in 'str'.
-inline const char* SkipComma(const char* str) {
-  const char* comma = strchr(str, ',');
-  if (comma == NULL) {
-    return NULL;
-  }
-  while (IsSpace(*(++comma))) {}
-  return comma;
-}
-
-// Returns the prefix of 'str' before the first comma in it; returns
-// the entire string if it contains no comma.
-inline std::string GetPrefixUntilComma(const char* str) {
-  const char* comma = strchr(str, ',');
-  return comma == NULL ? str : std::string(str, comma);
-}
-
-// Splits a given string on a given delimiter, populating a given
-// vector with the fields.
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest);
-
-// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
-// registers a list of type-parameterized tests with Google Test.  The
-// return value is insignificant - we just need to return something
-// such that we can call this function in a namespace scope.
-//
-// Implementation note: The GTEST_TEMPLATE_ macro declares a template
-// template parameter.  It's defined in gtest-type-util.h.
-template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
-class TypeParameterizedTest {
- public:
-  // 'index' is the index of the test in the type list 'Types'
-  // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
-  // Types).  Valid values for 'index' are [0, N - 1] where N is the
-  // length of Types.
-  static bool Register(const char* prefix,
-                       CodeLocation code_location,
-                       const char* case_name, const char* test_names,
-                       int index) {
-    typedef typename Types::Head Type;
-    typedef Fixture<Type> FixtureClass;
-    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
-
-    // First, registers the first type-parameterized test in the type
-    // list.
-    MakeAndRegisterTestInfo(
-        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
-         + StreamableToString(index)).c_str(),
-        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
-        GetTypeName<Type>().c_str(),
-        NULL,  // No value parameter.
-        code_location,
-        GetTypeId<FixtureClass>(),
-        TestClass::SetUpTestCase,
-        TestClass::TearDownTestCase,
-        new TestFactoryImpl<TestClass>);
-
-    // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
-        ::Register(prefix, code_location, case_name, test_names, index + 1);
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, class TestSel>
-class TypeParameterizedTest<Fixture, TestSel, Types0> {
- public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
-                       const char* /*case_name*/, const char* /*test_names*/,
-                       int /*index*/) {
-    return true;
-  }
-};
-
-// TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
-// registers *all combinations* of 'Tests' and 'Types' with Google
-// Test.  The return value is insignificant - we just need to return
-// something such that we can call this function in a namespace scope.
-template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
-class TypeParameterizedTestCase {
- public:
-  static bool Register(const char* prefix, CodeLocation code_location,
-                       const TypedTestCasePState* state,
-                       const char* case_name, const char* test_names) {
-    std::string test_name = StripTrailingSpaces(
-        GetPrefixUntilComma(test_names));
-    if (!state->TestExists(test_name)) {
-      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
-              case_name, test_name.c_str(),
-              FormatFileLocation(code_location.file.c_str(),
-                                 code_location.line).c_str());
-      fflush(stderr);
-      posix::Abort();
-    }
-    const CodeLocation& test_location = state->GetCodeLocation(test_name);
-
-    typedef typename Tests::Head Head;
-
-    // First, register the first test in 'Test' for each type in 'Types'.
-    TypeParameterizedTest<Fixture, Head, Types>::Register(
-        prefix, test_location, case_name, test_names, 0);
-
-    // Next, recurses (at compile time) with the tail of the test list.
-    return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
-        ::Register(prefix, code_location, state,
-                   case_name, SkipComma(test_names));
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, typename Types>
-class TypeParameterizedTestCase<Fixture, Templates0, Types> {
- public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
-                       const TypedTestCasePState* /*state*/,
-                       const char* /*case_name*/, const char* /*test_names*/) {
-    return true;
-  }
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
-    UnitTest* unit_test, int skip_count);
-
-// Helpers for suppressing warnings on unreachable code or constant
-// condition.
-
-// Always returns true.
-GTEST_API_ bool AlwaysTrue();
-
-// Always returns false.
-inline bool AlwaysFalse() { return !AlwaysTrue(); }
-
-// Helper for suppressing false warning from Clang on a const char*
-// variable declared in a conditional expression always being NULL in
-// the else branch.
-struct GTEST_API_ ConstCharPtr {
-  ConstCharPtr(const char* str) : value(str) {}
-  operator bool() const { return true; }
-  const char* value;
-};
-
-// A simple Linear Congruential Generator for generating random
-// numbers with a uniform distribution.  Unlike rand() and srand(), it
-// doesn't use global state (and therefore can't interfere with user
-// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
-// but it's good enough for our purposes.
-class GTEST_API_ Random {
- public:
-  static const UInt32 kMaxRange = 1u << 31;
-
-  explicit Random(UInt32 seed) : state_(seed) {}
-
-  void Reseed(UInt32 seed) { state_ = seed; }
-
-  // Generates a random number from [0, range).  Crashes if 'range' is
-  // 0 or greater than kMaxRange.
-  UInt32 Generate(UInt32 range);
-
- private:
-  UInt32 state_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
-};
-
-// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
-// compiler error iff T1 and T2 are different types.
-template <typename T1, typename T2>
-struct CompileAssertTypesEqual;
-
-template <typename T>
-struct CompileAssertTypesEqual<T, T> {
-};
-
-// Removes the reference from a type if it is a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::remove_reference, which is not widely available yet.
-template <typename T>
-struct RemoveReference { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveReference<T&> { typedef T type; };  // NOLINT
-
-// A handy wrapper around RemoveReference that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_REFERENCE_(T) \
-    typename ::testing::internal::RemoveReference<T>::type
-
-// Removes const from a type if it is a const type, otherwise leaves
-// it unchanged.  This is the same as tr1::remove_const, which is not
-// widely available yet.
-template <typename T>
-struct RemoveConst { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveConst<const T> { typedef T type; };  // NOLINT
-
-// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
-// definition to fail to remove the const in 'const int[3]' and 'const
-// char[3][4]'.  The following specialization works around the bug.
-template <typename T, size_t N>
-struct RemoveConst<const T[N]> {
-  typedef typename RemoveConst<T>::type type[N];
-};
-
-#if defined(_MSC_VER) && _MSC_VER < 1400
-// This is the only specialization that allows VC++ 7.1 to remove const in
-// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
-// and thus needs to be conditionally compiled.
-template <typename T, size_t N>
-struct RemoveConst<T[N]> {
-  typedef typename RemoveConst<T>::type type[N];
-};
-#endif
-
-// A handy wrapper around RemoveConst that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_CONST_(T) \
-    typename ::testing::internal::RemoveConst<T>::type
-
-// Turns const U&, U&, const U, and U all into U.
-#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
-    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
-
-// Adds reference to a type if it is not a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::add_reference, which is not widely available yet.
-template <typename T>
-struct AddReference { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddReference<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper around AddReference that works when the argument T
-// depends on template parameters.
-#define GTEST_ADD_REFERENCE_(T) \
-    typename ::testing::internal::AddReference<T>::type
-
-// Adds a reference to const on top of T as necessary.  For example,
-// it transforms
-//
-//   char         ==> const char&
-//   const char   ==> const char&
-//   char&        ==> const char&
-//   const char&  ==> const char&
-//
-// The argument T must depend on some template parameters.
-#define GTEST_REFERENCE_TO_CONST_(T) \
-    GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
-
-// ImplicitlyConvertible<From, To>::value is a compile-time bool
-// constant that's true iff type From can be implicitly converted to
-// type To.
-template <typename From, typename To>
-class ImplicitlyConvertible {
- private:
-  // We need the following helper functions only for their types.
-  // They have no implementations.
-
-  // MakeFrom() is an expression whose type is From.  We cannot simply
-  // use From(), as the type From may not have a public default
-  // constructor.
-  static typename AddReference<From>::type MakeFrom();
-
-  // These two functions are overloaded.  Given an expression
-  // Helper(x), the compiler will pick the first version if x can be
-  // implicitly converted to type To; otherwise it will pick the
-  // second version.
-  //
-  // The first version returns a value of size 1, and the second
-  // version returns a value of size 2.  Therefore, by checking the
-  // size of Helper(x), which can be done at compile time, we can tell
-  // which version of Helper() is used, and hence whether x can be
-  // implicitly converted to type To.
-  static char Helper(To);
-  static char (&Helper(...))[2];  // NOLINT
-
-  // We have to put the 'public' section after the 'private' section,
-  // or MSVC refuses to compile the code.
- public:
-#if defined(__BORLANDC__)
-  // C++Builder cannot use member overload resolution during template
-  // instantiation.  The simplest workaround is to use its C++0x type traits
-  // functions (C++Builder 2009 and above only).
-  static const bool value = __is_convertible(From, To);
-#else
-  // MSVC warns about implicitly converting from double to int for
-  // possible loss of data, so we need to temporarily disable the
-  // warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
-  static const bool value =
-      sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif  // __BORLANDC__
-};
-template <typename From, typename To>
-const bool ImplicitlyConvertible<From, To>::value;
-
-// IsAProtocolMessage<T>::value is a compile-time bool constant that's
-// true iff T is type ProtocolMessage, proto2::Message, or a subclass
-// of those.
-template <typename T>
-struct IsAProtocolMessage
-    : public bool_constant<
-  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
-  ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
-};
-
-// When the compiler sees expression IsContainerTest<C>(0), if C is an
-// STL-style container class, the first overload of IsContainerTest
-// will be viable (since both C::iterator* and C::const_iterator* are
-// valid types and NULL can be implicitly converted to them).  It will
-// be picked over the second overload as 'int' is a perfect match for
-// the type of argument 0.  If C::iterator or C::const_iterator is not
-// a valid type, the first overload is not viable, and the second
-// overload will be picked.  Therefore, we can determine whether C is
-// a container class by checking the type of IsContainerTest<C>(0).
-// The value of the expression is insignificant.
-//
-// Note that we look for both C::iterator and C::const_iterator.  The
-// reason is that C++ injects the name of a class as a member of the
-// class itself (e.g. you can refer to class iterator as either
-// 'iterator' or 'iterator::iterator').  If we look for C::iterator
-// only, for example, we would mistakenly think that a class named
-// iterator is an STL container.
-//
-// Also note that the simpler approach of overloading
-// IsContainerTest(typename C::const_iterator*) and
-// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
-typedef int IsContainer;
-template <class C>
-IsContainer IsContainerTest(int /* dummy */,
-                            typename C::iterator* /* it */ = NULL,
-                            typename C::const_iterator* /* const_it */ = NULL) {
-  return 0;
-}
-
-typedef char IsNotContainer;
-template <class C>
-IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
-
-// EnableIf<condition>::type is void when 'Cond' is true, and
-// undefined when 'Cond' is false.  To use SFINAE to make a function
-// overload only apply when a particular expression is true, add
-// "typename EnableIf<expression>::type* = 0" as the last parameter.
-template<bool> struct EnableIf;
-template<> struct EnableIf<true> { typedef void type; };  // NOLINT
-
-// Utilities for native arrays.
-
-// ArrayEq() compares two k-dimensional native arrays using the
-// elements' operator==, where k can be any integer >= 0.  When k is
-// 0, ArrayEq() degenerates into comparing a single pair of values.
-
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
-  return internal::ArrayEq(lhs, N, rhs);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous ArrayEq() function, arrays with different sizes would
-// lead to different copies of the template code.
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
-  for (size_t i = 0; i != size; i++) {
-    if (!internal::ArrayEq(lhs[i], rhs[i]))
-      return false;
-  }
-  return true;
-}
-
-// Finds the first element in the iterator range [begin, end) that
-// equals elem.  Element may be a native array type itself.
-template <typename Iter, typename Element>
-Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
-  for (Iter it = begin; it != end; ++it) {
-    if (internal::ArrayEq(*it, elem))
-      return it;
-  }
-  return end;
-}
-
-// CopyArray() copies a k-dimensional native array using the elements'
-// operator=, where k can be any integer >= 0.  When k is 0,
-// CopyArray() degenerates into copying a single value.
-
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline void CopyArray(const T& from, U* to) { *to = from; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline void CopyArray(const T(&from)[N], U(*to)[N]) {
-  internal::CopyArray(from, N, *to);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous CopyArray() function, arrays with different sizes
-// would lead to different copies of the template code.
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to) {
-  for (size_t i = 0; i != size; i++) {
-    internal::CopyArray(from[i], to + i);
-  }
-}
-
-// The relation between an NativeArray object (see below) and the
-// native array it represents.
-// We use 2 different structs to allow non-copyable types to be used, as long
-// as RelationToSourceReference() is passed.
-struct RelationToSourceReference {};
-struct RelationToSourceCopy {};
-
-// Adapts a native array to a read-only STL-style container.  Instead
-// of the complete STL container concept, this adaptor only implements
-// members useful for Google Mock's container matchers.  New members
-// should be added as needed.  To simplify the implementation, we only
-// support Element being a raw type (i.e. having no top-level const or
-// reference modifier).  It's the client's responsibility to satisfy
-// this requirement.  Element can be an array type itself (hence
-// multi-dimensional arrays are supported).
-template <typename Element>
-class NativeArray {
- public:
-  // STL-style container typedefs.
-  typedef Element value_type;
-  typedef Element* iterator;
-  typedef const Element* const_iterator;
-
-  // Constructs from a native array. References the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
-    InitRef(array, count);
-  }
-
-  // Constructs from a native array. Copies the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
-    InitCopy(array, count);
-  }
-
-  // Copy constructor.
-  NativeArray(const NativeArray& rhs) {
-    (this->*rhs.clone_)(rhs.array_, rhs.size_);
-  }
-
-  ~NativeArray() {
-    if (clone_ != &NativeArray::InitRef)
-      delete[] array_;
-  }
-
-  // STL-style container methods.
-  size_t size() const { return size_; }
-  const_iterator begin() const { return array_; }
-  const_iterator end() const { return array_ + size_; }
-  bool operator==(const NativeArray& rhs) const {
-    return size() == rhs.size() &&
-        ArrayEq(begin(), size(), rhs.begin());
-  }
-
- private:
-  enum {
-    kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
-        Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value,
-  };
-
-  // Initializes this object with a copy of the input.
-  void InitCopy(const Element* array, size_t a_size) {
-    Element* const copy = new Element[a_size];
-    CopyArray(array, a_size, copy);
-    array_ = copy;
-    size_ = a_size;
-    clone_ = &NativeArray::InitCopy;
-  }
-
-  // Initializes this object with a reference of the input.
-  void InitRef(const Element* array, size_t a_size) {
-    array_ = array;
-    size_ = a_size;
-    clone_ = &NativeArray::InitRef;
-  }
-
-  const Element* array_;
-  size_t size_;
-  void (NativeArray::*clone_)(const Element*, size_t);
-
-  GTEST_DISALLOW_ASSIGN_(NativeArray);
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
-  ::testing::internal::AssertHelper(result_type, file, line, message) \
-    = ::testing::Message()
-
-#define GTEST_MESSAGE_(message, result_type) \
-  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
-
-#define GTEST_FATAL_FAILURE_(message) \
-  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
-
-#define GTEST_NONFATAL_FAILURE_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
-
-#define GTEST_SUCCESS_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
-
-// Suppresses MSVC warnings 4072 (unreachable code) for the code following
-// statement if it returns or throws (or doesn't return or throw in some
-// situations).
-#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
-  if (::testing::internal::AlwaysTrue()) { statement; }
-
-#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
-    bool gtest_caught_expected = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (expected_exception const&) { \
-      gtest_caught_expected = true; \
-    } \
-    catch (...) { \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws a different type."; \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-    } \
-    if (!gtest_caught_expected) { \
-      gtest_msg.value = \
-          "Expected: " #statement " throws an exception of type " \
-          #expected_exception ".\n  Actual: it throws nothing."; \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
-      fail(gtest_msg.value)
-
-#define GTEST_TEST_NO_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail("Expected: " #statement " doesn't throw an exception.\n" \
-           "  Actual: it throws.")
-
-#define GTEST_TEST_ANY_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    bool gtest_caught_any = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      gtest_caught_any = true; \
-    } \
-    if (!gtest_caught_any) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
-      fail("Expected: " #statement " throws an exception.\n" \
-           "  Actual: it doesn't.")
-
-
-// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
-// either a boolean expression or an AssertionResult. text is a textual
-// represenation of expression as it was passed into the EXPECT_TRUE.
-#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar_ = \
-      ::testing::AssertionResult(expression)) \
-    ; \
-  else \
-    fail(::testing::internal::GetBoolAssertionFailureMessage(\
-        gtest_ar_, text, #actual, #expected).c_str())
-
-#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
-      fail("Expected: " #statement " doesn't generate new fatal " \
-           "failures in the current thread.\n" \
-           "  Actual: it does.")
-
-// Expands to the name of the class that implements the given test.
-#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
-  test_case_name##_##test_name##_Test
-
-// Helper macro for defining tests.
-#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
-class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
- public:\
-  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
- private:\
-  virtual void TestBody();\
-  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
-      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
-};\
-\
-::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
-  ::test_info_ =\
-    ::testing::internal::MakeAndRegisterTestInfo(\
-        #test_case_name, #test_name, NULL, NULL, \
-        ::testing::internal::CodeLocation(__FILE__, __LINE__), \
-        (parent_id), \
-        parent_class::SetUpTestCase, \
-        parent_class::TearDownTestCase, \
-        new ::testing::internal::TestFactoryImpl<\
-            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
-void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the public API for death tests.  It is
-// #included by gtest.h so a user doesn't need to include this
-// directly.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines internal utilities needed for implementing
-// death tests.  They are subject to change without notice.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-
-
-#include <stdio.h>
-
-namespace testing {
-namespace internal {
-
-GTEST_DECLARE_string_(internal_run_death_test);
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kDeathTestStyleFlag[] = "death_test_style";
-const char kDeathTestUseFork[] = "death_test_use_fork";
-const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
-
-#if GTEST_HAS_DEATH_TEST
-
-// DeathTest is a class that hides much of the complexity of the
-// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
-// returns a concrete class that depends on the prevailing death test
-// style, as defined by the --gtest_death_test_style and/or
-// --gtest_internal_run_death_test flags.
-
-// In describing the results of death tests, these terms are used with
-// the corresponding definitions:
-//
-// exit status:  The integer exit information in the format specified
-//               by wait(2)
-// exit code:    The integer code passed to exit(3), _exit(2), or
-//               returned from main()
-class GTEST_API_ DeathTest {
- public:
-  // Create returns false if there was an error determining the
-  // appropriate action to take for the current death test; for example,
-  // if the gtest_death_test_style flag is set to an invalid value.
-  // The LastMessage method will return a more detailed message in that
-  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
-  // argument is set.  If the death test should be skipped, the pointer
-  // is set to NULL; otherwise, it is set to the address of a new concrete
-  // DeathTest object that controls the execution of the current test.
-  static bool Create(const char* statement, const RE* regex,
-                     const char* file, int line, DeathTest** test);
-  DeathTest();
-  virtual ~DeathTest() { }
-
-  // A helper class that aborts a death test when it's deleted.
-  class ReturnSentinel {
-   public:
-    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
-    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
-   private:
-    DeathTest* const test_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
-  } GTEST_ATTRIBUTE_UNUSED_;
-
-  // An enumeration of possible roles that may be taken when a death
-  // test is encountered.  EXECUTE means that the death test logic should
-  // be executed immediately.  OVERSEE means that the program should prepare
-  // the appropriate environment for a child process to execute the death
-  // test, then wait for it to complete.
-  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
-
-  // An enumeration of the three reasons that a test might be aborted.
-  enum AbortReason {
-    TEST_ENCOUNTERED_RETURN_STATEMENT,
-    TEST_THREW_EXCEPTION,
-    TEST_DID_NOT_DIE
-  };
-
-  // Assumes one of the above roles.
-  virtual TestRole AssumeRole() = 0;
-
-  // Waits for the death test to finish and returns its status.
-  virtual int Wait() = 0;
-
-  // Returns true if the death test passed; that is, the test process
-  // exited during the test, its exit status matches a user-supplied
-  // predicate, and its stderr output matches a user-supplied regular
-  // expression.
-  // The user-supplied predicate may be a macro expression rather
-  // than a function pointer or functor, or else Wait and Passed could
-  // be combined.
-  virtual bool Passed(bool exit_status_ok) = 0;
-
-  // Signals that the death test did not die as expected.
-  virtual void Abort(AbortReason reason) = 0;
-
-  // Returns a human-readable outcome message regarding the outcome of
-  // the last death test.
-  static const char* LastMessage();
-
-  static void set_last_death_test_message(const std::string& message);
-
- private:
-  // A string containing a description of the outcome of the last death test.
-  static std::string last_death_test_message_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
-};
-
-// Factory interface for death tests.  May be mocked out for testing.
-class DeathTestFactory {
- public:
-  virtual ~DeathTestFactory() { }
-  virtual bool Create(const char* statement, const RE* regex,
-                      const char* file, int line, DeathTest** test) = 0;
-};
-
-// A concrete DeathTestFactory implementation for normal use.
-class DefaultDeathTestFactory : public DeathTestFactory {
- public:
-  virtual bool Create(const char* statement, const RE* regex,
-                      const char* file, int line, DeathTest** test);
-};
-
-// Returns true if exit_status describes a process that was terminated
-// by a signal, or exited normally with a nonzero exit code.
-GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
-
-// Traps C++ exceptions escaping statement and reports them as test
-// failures. Note that trapping SEH exceptions is not implemented here.
-# if GTEST_HAS_EXCEPTIONS
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  try { \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } catch (const ::std::exception& gtest_exception) { \
-    fprintf(\
-        stderr, \
-        "\n%s: Caught std::exception-derived exception escaping the " \
-        "death test statement. Exception message: %s\n", \
-        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
-        gtest_exception.what()); \
-    fflush(stderr); \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  } catch (...) { \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  }
-
-# else
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-
-# endif
-
-// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
-// ASSERT_EXIT*, and EXPECT_EXIT*.
-# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    const ::testing::internal::RE& gtest_regex = (regex); \
-    ::testing::internal::DeathTest* gtest_dt; \
-    if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
-        __FILE__, __LINE__, &gtest_dt)) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
-    } \
-    if (gtest_dt != NULL) { \
-      ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
-          gtest_dt_ptr(gtest_dt); \
-      switch (gtest_dt->AssumeRole()) { \
-        case ::testing::internal::DeathTest::OVERSEE_TEST: \
-          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
-            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
-          } \
-          break; \
-        case ::testing::internal::DeathTest::EXECUTE_TEST: { \
-          ::testing::internal::DeathTest::ReturnSentinel \
-              gtest_sentinel(gtest_dt); \
-          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
-          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
-          break; \
-        } \
-        default: \
-          break; \
-      } \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
-      fail(::testing::internal::DeathTest::LastMessage())
-// The symbol "fail" here expands to something into which a message
-// can be streamed.
-
-// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
-// NDEBUG mode. In this case we need the statements to be executed, the regex is
-// ignored, and the macro must accept a streamed message even though the message
-// is never printed.
-# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } else \
-    ::testing::Message()
-
-// A class representing the parsed contents of the
-// --gtest_internal_run_death_test flag, as it existed when
-// RUN_ALL_TESTS was called.
-class InternalRunDeathTestFlag {
- public:
-  InternalRunDeathTestFlag(const std::string& a_file,
-                           int a_line,
-                           int an_index,
-                           int a_write_fd)
-      : file_(a_file), line_(a_line), index_(an_index),
-        write_fd_(a_write_fd) {}
-
-  ~InternalRunDeathTestFlag() {
-    if (write_fd_ >= 0)
-      posix::Close(write_fd_);
-  }
-
-  const std::string& file() const { return file_; }
-  int line() const { return line_; }
-  int index() const { return index_; }
-  int write_fd() const { return write_fd_; }
-
- private:
-  std::string file_;
-  int line_;
-  int index_;
-  int write_fd_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
-};
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// initialized from the GTEST_FLAG(internal_run_death_test) flag if
-// the flag is specified; otherwise returns NULL.
-InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
-
-#else  // GTEST_HAS_DEATH_TEST
-
-// This macro is used for implementing macros such as
-// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
-// death tests are not supported. Those macros must compile on such systems
-// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
-// systems that support death tests. This allows one to write such a macro
-// on a system that does not support death tests and be sure that it will
-// compile on a death-test supporting system.
-//
-// Parameters:
-//   statement -  A statement that a macro such as EXPECT_DEATH would test
-//                for program termination. This macro has to make sure this
-//                statement is compiled but not executed, to ensure that
-//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
-//                parameter iff EXPECT_DEATH compiles with it.
-//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
-//                the output of statement.  This parameter has to be
-//                compiled but not evaluated by this macro, to ensure that
-//                this macro only accepts expressions that a macro such as
-//                EXPECT_DEATH would accept.
-//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
-//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
-//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
-//                compile inside functions where ASSERT_DEATH doesn't
-//                compile.
-//
-//  The branch that has an always false condition is used to ensure that
-//  statement and regex are compiled (and thus syntactically correct) but
-//  never executed. The unreachable code macro protects the terminator
-//  statement from generating an 'unreachable code' warning in case
-//  statement unconditionally returns or throws. The Message constructor at
-//  the end allows the syntax of streaming additional messages into the
-//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::AlwaysTrue()) { \
-      GTEST_LOG_(WARNING) \
-          << "Death tests are not supported on this platform.\n" \
-          << "Statement '" #statement "' cannot be verified."; \
-    } else if (::testing::internal::AlwaysFalse()) { \
-      ::testing::internal::RE::PartialMatch(".*", (regex)); \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-      terminator; \
-    } else \
-      ::testing::Message()
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-
-namespace testing {
-
-// This flag controls the style of death tests.  Valid values are "threadsafe",
-// meaning that the death test child process will re-execute the test binary
-// from the start, running only a single death test, or "fast",
-// meaning that the child process will execute the test logic immediately
-// after forking.
-GTEST_DECLARE_string_(death_test_style);
-
-#if GTEST_HAS_DEATH_TEST
-
-namespace internal {
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// tests.  IMPORTANT: This is an internal utility.  Using it may break the
-// implementation of death tests.  User code MUST NOT use it.
-GTEST_API_ bool InDeathTestChild();
-
-}  // namespace internal
-
-// The following macros are useful for writing death tests.
-
-// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
-// executed:
-//
-//   1. It generates a warning if there is more than one active
-//   thread.  This is because it's safe to fork() or clone() only
-//   when there is a single thread.
-//
-//   2. The parent process clone()s a sub-process and runs the death
-//   test in it; the sub-process exits with code 0 at the end of the
-//   death test, if it hasn't exited already.
-//
-//   3. The parent process waits for the sub-process to terminate.
-//
-//   4. The parent process checks the exit code and error message of
-//   the sub-process.
-//
-// Examples:
-//
-//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
-//   for (int i = 0; i < 5; i++) {
-//     EXPECT_DEATH(server.ProcessRequest(i),
-//                  "Invalid request .* in ProcessRequest()")
-//                  << "Failed to die on request " << i;
-//   }
-//
-//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
-//
-//   bool KilledBySIGHUP(int exit_code) {
-//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
-//   }
-//
-//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
-//
-// On the regular expressions used in death tests:
-//
-//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
-//   which uses the POSIX extended regex syntax.
-//
-//   On other platforms (e.g. Windows), we only support a simple regex
-//   syntax implemented as part of Google Test.  This limited
-//   implementation should be enough most of the time when writing
-//   death tests; though it lacks many features you can find in PCRE
-//   or POSIX extended regex syntax.  For example, we don't support
-//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
-//   repetition count ("x{5,7}"), among others.
-//
-//   Below is the syntax that we do support.  We chose it to be a
-//   subset of both PCRE and POSIX extended regex, so it's easy to
-//   learn wherever you come from.  In the following: 'A' denotes a
-//   literal character, period (.), or a single \\ escape sequence;
-//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
-//   natural numbers.
-//
-//     c     matches any literal character c
-//     \\d   matches any decimal digit
-//     \\D   matches any character that's not a decimal digit
-//     \\f   matches \f
-//     \\n   matches \n
-//     \\r   matches \r
-//     \\s   matches any ASCII whitespace, including \n
-//     \\S   matches any character that's not a whitespace
-//     \\t   matches \t
-//     \\v   matches \v
-//     \\w   matches any letter, _, or decimal digit
-//     \\W   matches any character that \\w doesn't match
-//     \\c   matches any literal character c, which must be a punctuation
-//     .     matches any single character except \n
-//     A?    matches 0 or 1 occurrences of A
-//     A*    matches 0 or many occurrences of A
-//     A+    matches 1 or many occurrences of A
-//     ^     matches the beginning of a string (not that of each line)
-//     $     matches the end of a string (not that of each line)
-//     xy    matches x followed by y
-//
-//   If you accidentally use PCRE or POSIX extended regex features
-//   not implemented by us, you will get a run-time failure.  In that
-//   case, please try to rewrite your regular expression within the
-//   above syntax.
-//
-//   This implementation is *not* meant to be as highly tuned or robust
-//   as a compiled regex library, but should perform well enough for a
-//   death test, which already incurs significant overhead by launching
-//   a child process.
-//
-// Known caveats:
-//
-//   A "threadsafe" style death test obtains the path to the test
-//   program from argv[0] and re-executes it in the sub-process.  For
-//   simplicity, the current implementation doesn't search the PATH
-//   when launching the sub-process.  This means that the user must
-//   invoke the test program via a path that contains at least one
-//   path separator (e.g. path/to/foo_test and
-//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
-//   is rarely a problem as people usually don't put the test binary
-//   directory in PATH.
-//
-// TODO(wan@google.com): make thread-safe death tests search the PATH.
-
-// Asserts that a given statement causes the program to exit, with an
-// integer exit status that satisfies predicate, and emitting error output
-// that matches regex.
-# define ASSERT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
-
-// Like ASSERT_EXIT, but continues on to successive tests in the
-// test case, if any:
-# define EXPECT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
-
-// Asserts that a given statement causes the program to exit, either by
-// explicitly exiting with a nonzero exit code or being killed by a
-// signal, and emitting error output that matches regex.
-# define ASSERT_DEATH(statement, regex) \
-    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Like ASSERT_DEATH, but continues on to successive tests in the
-// test case, if any:
-# define EXPECT_DEATH(statement, regex) \
-    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
-
-// Tests that an exit code describes a normal exit with a given exit code.
-class GTEST_API_ ExitedWithCode {
- public:
-  explicit ExitedWithCode(int exit_code);
-  bool operator()(int exit_status) const;
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ExitedWithCode& other);
-
-  const int exit_code_;
-};
-
-# if !GTEST_OS_WINDOWS
-// Tests that an exit code describes an exit due to termination by a
-// given signal.
-class GTEST_API_ KilledBySignal {
- public:
-  explicit KilledBySignal(int signum);
-  bool operator()(int exit_status) const;
- private:
-  const int signum_;
-};
-# endif  // !GTEST_OS_WINDOWS
-
-// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
-// The death testing framework causes this to have interesting semantics,
-// since the sideeffects of the call are only visible in opt mode, and not
-// in debug mode.
-//
-// In practice, this can be used to test functions that utilize the
-// LOG(DFATAL) macro using the following style:
-//
-// int DieInDebugOr12(int* sideeffect) {
-//   if (sideeffect) {
-//     *sideeffect = 12;
-//   }
-//   LOG(DFATAL) << "death";
-//   return 12;
-// }
-//
-// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
-//   int sideeffect = 0;
-//   // Only asserts in dbg.
-//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
-//
-// #ifdef NDEBUG
-//   // opt-mode has sideeffect visible.
-//   EXPECT_EQ(12, sideeffect);
-// #else
-//   // dbg-mode no visible sideeffect.
-//   EXPECT_EQ(0, sideeffect);
-// #endif
-// }
-//
-// This will assert that DieInDebugReturn12InOpt() crashes in debug
-// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
-// appropriate fallback value (12 in this case) in opt mode. If you
-// need to test that a function has appropriate side-effects in opt
-// mode, include assertions against the side-effects.  A general
-// pattern for this is:
-//
-// EXPECT_DEBUG_DEATH({
-//   // Side-effects here will have an effect after this statement in
-//   // opt mode, but none in debug mode.
-//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
-// }, "death");
-//
-# ifdef NDEBUG
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-# else
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  EXPECT_DEATH(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  ASSERT_DEATH(statement, regex)
-
-# endif  // NDEBUG for EXPECT_DEBUG_DEATH
-#endif  // GTEST_HAS_DEATH_TEST
-
-// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
-// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
-// death tests are supported; otherwise they just issue a warning.  This is
-// useful when you are combining death test assertions with normal test
-// assertions in one test.
-#if GTEST_HAS_DEATH_TEST
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    EXPECT_DEATH(statement, regex)
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    ASSERT_DEATH(statement, regex)
-#else
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
-#endif
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-// This file was GENERATED by command:
-//     pump.py gtest-param-test.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: vladl@google.com (Vlad Losev)
-//
-// Macros and functions for implementing parameterized tests
-// in Google C++ Testing Framework (Google Test)
-//
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-
-
-// Value-parameterized tests allow you to test your code with different
-// parameters without writing multiple copies of the same test.
-//
-// Here is how you use value-parameterized tests:
-
-#if 0
-
-// To write value-parameterized tests, first you should define a fixture
-// class. It is usually derived from testing::TestWithParam<T> (see below for
-// another inheritance scheme that's sometimes useful in more complicated
-// class hierarchies), where the type of your parameter values.
-// TestWithParam<T> is itself derived from testing::Test. T can be any
-// copyable type. If it's a raw pointer, you are responsible for managing the
-// lifespan of the pointed values.
-
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual class fixture members here.
-};
-
-// Then, use the TEST_P macro to define as many parameterized tests
-// for this fixture as you want. The _P suffix is for "parameterized"
-// or "pattern", whichever you prefer to think.
-
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-
-// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
-// case with any set of parameters you want. Google Test defines a number
-// of functions for generating test parameters. They return what we call
-// (surprise!) parameter generators. Here is a  summary of them, which
-// are all in the testing namespace:
-//
-//
-//  Range(begin, end [, step]) - Yields values {begin, begin+step,
-//                               begin+step+step, ...}. The values do not
-//                               include end. step defaults to 1.
-//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
-//  ValuesIn(container)        - Yields values from a C-style array, an STL
-//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
-//  Bool()                     - Yields sequence {false, true}.
-//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
-//                               for the math savvy) of the values generated
-//                               by the N generators.
-//
-// For more details, see comments at the definitions of these functions below
-// in this file.
-//
-// The following statement will instantiate tests from the FooTest test case
-// each with parameter values "meeny", "miny", and "moe".
-
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        Values("meeny", "miny", "moe"));
-
-// To distinguish different instances of the pattern, (yes, you
-// can instantiate it more then once) the first argument to the
-// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
-// actual test case name. Remember to pick unique prefixes for different
-// instantiations. The tests from the instantiation above will have
-// these names:
-//
-//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
-//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
-//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
-//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
-//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
-//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
-//
-// You can use these names in --gtest_filter.
-//
-// This statement will instantiate all tests from FooTest again, each
-// with parameter values "cat" and "dog":
-
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
-
-// The tests from the instantiation above will have these names:
-//
-//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
-//
-// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
-// in the given test case, whether their definitions come before or
-// AFTER the INSTANTIATE_TEST_CASE_P statement.
-//
-// Please also note that generator expressions (including parameters to the
-// generators) are evaluated in InitGoogleTest(), after main() has started.
-// This allows the user on one hand, to adjust generator parameters in order
-// to dynamically determine a set of tests to run and on the other hand,
-// give the user a chance to inspect the generated tests with Google Test
-// reflection API before RUN_ALL_TESTS() is executed.
-//
-// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
-// for more examples.
-//
-// In the future, we plan to publish the API for defining new parameter
-// generators. But for now this interface remains part of the internal
-// implementation and is subject to change.
-//
-//
-// A parameterized test fixture must be derived from testing::Test and from
-// testing::WithParamInterface<T>, where T is the type of the parameter
-// values. Inheriting from TestWithParam<T> satisfies that requirement because
-// TestWithParam<T> inherits from both Test and WithParamInterface. In more
-// complicated hierarchies, however, it is occasionally useful to inherit
-// separately from Test and WithParamInterface. For example:
-
-class BaseTest : public ::testing::Test {
-  // You can inherit all the usual members for a non-parameterized test
-  // fixture here.
-};
-
-class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
-  // The usual test fixture members go here too.
-};
-
-TEST_F(BaseTest, HasFoo) {
-  // This is an ordinary non-parameterized test.
-}
-
-TEST_P(DerivedTest, DoesBlah) {
-  // GetParam works just the same here as if you inherit from TestWithParam.
-  EXPECT_TRUE(foo.Blah(GetParam()));
-}
-
-#endif  // 0
-
-
-#if !GTEST_OS_SYMBIAN
-# include <utility>
-#endif
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-// Copyright 2008 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Type and function utilities for implementing parameterized tests.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-
-#include <ctype.h>
-
-#include <iterator>
-#include <set>
-#include <utility>
-#include <vector>
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-// Copyright 2003 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: Dan Egnor (egnor@google.com)
-//
-// A "smart" pointer type with reference tracking.  Every pointer to a
-// particular object is kept on a circular linked list.  When the last pointer
-// to an object is destroyed or reassigned, the object is deleted.
-//
-// Used properly, this deletes the object when the last reference goes away.
-// There are several caveats:
-// - Like all reference counting schemes, cycles lead to leaks.
-// - Each smart pointer is actually two pointers (8 bytes instead of 4).
-// - Every time a pointer is assigned, the entire list of pointers to that
-//   object is traversed.  This class is therefore NOT SUITABLE when there
-//   will often be more than two or three pointers to a particular object.
-// - References are only tracked as long as linked_ptr<> objects are copied.
-//   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
-//   will happen (double deletion).
-//
-// A good use of this class is storing object references in STL containers.
-// You can safely put linked_ptr<> in a vector<>.
-// Other uses may not be as good.
-//
-// Note: If you use an incomplete type with linked_ptr<>, the class
-// *containing* linked_ptr<> must have a constructor and destructor (even
-// if they do nothing!).
-//
-// Bill Gibbons suggested we use something like this.
-//
-// Thread Safety:
-//   Unlike other linked_ptr implementations, in this implementation
-//   a linked_ptr object is thread-safe in the sense that:
-//     - it's safe to copy linked_ptr objects concurrently,
-//     - it's safe to copy *from* a linked_ptr and read its underlying
-//       raw pointer (e.g. via get()) concurrently, and
-//     - it's safe to write to two linked_ptrs that point to the same
-//       shared object concurrently.
-// TODO(wan@google.com): rename this to safe_linked_ptr to avoid
-// confusion with normal linked_ptr.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
-
-#include <stdlib.h>
-#include <assert.h>
-
-
-namespace testing {
-namespace internal {
-
-// Protects copying of all linked_ptr objects.
-GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
-
-// This is used internally by all instances of linked_ptr<>.  It needs to be
-// a non-template class because different types of linked_ptr<> can refer to
-// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
-// So, it needs to be possible for different types of linked_ptr to participate
-// in the same circular linked list, so we need a single class type here.
-//
-// DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
-class linked_ptr_internal {
- public:
-  // Create a new circle that includes only this instance.
-  void join_new() {
-    next_ = this;
-  }
-
-  // Many linked_ptr operations may change p.link_ for some linked_ptr
-  // variable p in the same circle as this object.  Therefore we need
-  // to prevent two such operations from occurring concurrently.
-  //
-  // Note that different types of linked_ptr objects can coexist in a
-  // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
-  // linked_ptr<Derived2>).  Therefore we must use a single mutex to
-  // protect all linked_ptr objects.  This can create serious
-  // contention in production code, but is acceptable in a testing
-  // framework.
-
-  // Join an existing circle.
-  void join(linked_ptr_internal const* ptr)
-      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
-    MutexLock lock(&g_linked_ptr_mutex);
-
-    linked_ptr_internal const* p = ptr;
-    while (p->next_ != ptr) {
-      assert(p->next_ != this &&
-             "Trying to join() a linked ring we are already in. "
-             "Is GMock thread safety enabled?");
-      p = p->next_;
-    }
-    p->next_ = this;
-    next_ = ptr;
-  }
-
-  // Leave whatever circle we're part of.  Returns true if we were the
-  // last member of the circle.  Once this is done, you can join() another.
-  bool depart()
-      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
-    MutexLock lock(&g_linked_ptr_mutex);
-
-    if (next_ == this) return true;
-    linked_ptr_internal const* p = next_;
-    while (p->next_ != this) {
-      assert(p->next_ != next_ &&
-             "Trying to depart() a linked ring we are not in. "
-             "Is GMock thread safety enabled?");
-      p = p->next_;
-    }
-    p->next_ = next_;
-    return false;
-  }
-
- private:
-  mutable linked_ptr_internal const* next_;
-};
-
-template <typename T>
-class linked_ptr {
- public:
-  typedef T element_type;
-
-  // Take over ownership of a raw pointer.  This should happen as soon as
-  // possible after the object is created.
-  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
-  ~linked_ptr() { depart(); }
-
-  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
-  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
-  linked_ptr(linked_ptr const& ptr) {  // NOLINT
-    assert(&ptr != this);
-    copy(&ptr);
-  }
-
-  // Assignment releases the old value and acquires the new.
-  template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
-    depart();
-    copy(&ptr);
-    return *this;
-  }
-
-  linked_ptr& operator=(linked_ptr const& ptr) {
-    if (&ptr != this) {
-      depart();
-      copy(&ptr);
-    }
-    return *this;
-  }
-
-  // Smart pointer members.
-  void reset(T* ptr = NULL) {
-    depart();
-    capture(ptr);
-  }
-  T* get() const { return value_; }
-  T* operator->() const { return value_; }
-  T& operator*() const { return *value_; }
-
-  bool operator==(T* p) const { return value_ == p; }
-  bool operator!=(T* p) const { return value_ != p; }
-  template <typename U>
-  bool operator==(linked_ptr<U> const& ptr) const {
-    return value_ == ptr.get();
-  }
-  template <typename U>
-  bool operator!=(linked_ptr<U> const& ptr) const {
-    return value_ != ptr.get();
-  }
-
- private:
-  template <typename U>
-  friend class linked_ptr;
-
-  T* value_;
-  linked_ptr_internal link_;
-
-  void depart() {
-    if (link_.depart()) delete value_;
-  }
-
-  void capture(T* ptr) {
-    value_ = ptr;
-    link_.join_new();
-  }
-
-  template <typename U> void copy(linked_ptr<U> const* ptr) {
-    value_ = ptr->get();
-    if (value_)
-      link_.join(&ptr->link_);
-    else
-      link_.join_new();
-  }
-};
-
-template<typename T> inline
-bool operator==(T* ptr, const linked_ptr<T>& x) {
-  return ptr == x.get();
-}
-
-template<typename T> inline
-bool operator!=(T* ptr, const linked_ptr<T>& x) {
-  return ptr != x.get();
-}
-
-// A function to convert T* into linked_ptr<T>
-// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
-// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
-template <typename T>
-linked_ptr<T> make_linked_ptr(T* ptr) {
-  return linked_ptr<T>(ptr);
-}
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Test - The Google C++ Testing Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// A user can teach this function how to print a class type T by
-// defining either operator<<() or PrintTo() in the namespace that
-// defines T.  More specifically, the FIRST defined function in the
-// following list will be used (assuming T is defined in namespace
-// foo):
-//
-//   1. foo::PrintTo(const T&, ostream*)
-//   2. operator<<(ostream&, const T&) defined in either foo or the
-//      global namespace.
-//
-// If none of the above is defined, it will print the debug string of
-// the value if it is a protocol buffer, or print the raw bytes in the
-// value otherwise.
-//
-// To aid debugging: when T is a reference type, the address of the
-// value is also printed; when T is a (const) char pointer, both the
-// pointer value and the NUL-terminated string it points to are
-// printed.
-//
-// We also provide some convenient wrappers:
-//
-//   // Prints a value to a string.  For a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   std::string ::testing::PrintToString(const T& value);
-//
-//   // Prints a value tersely: for a reference type, the referenced
-//   // value (but not the address) is printed; for a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
-//
-//   // Prints value using the type inferred by the compiler.  The difference
-//   // from UniversalTersePrint() is that this function prints both the
-//   // pointer and the NUL-terminated string for a (const or not) char pointer.
-//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
-//
-//   // Prints the fields of a tuple tersely to a string vector, one
-//   // element for each field. Tuple support must be enabled in
-//   // gtest-port.h.
-//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
-//       const Tuple& value);
-//
-// Known limitation:
-//
-// The print primitives print the elements of an STL-style container
-// using the compiler-inferred type of *iter where iter is a
-// const_iterator of the container.  When const_iterator is an input
-// iterator but not a forward iterator, this inferred type may not
-// match value_type, and the print output may be incorrect.  In
-// practice, this is rarely a problem as for most containers
-// const_iterator is a forward iterator.  We'll fix this if there's an
-// actual need for it.  Note that this fix cannot rely on value_type
-// being defined as many user-defined container types don't have
-// value_type.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#if GTEST_HAS_STD_TUPLE_
-# include <tuple>
-#endif
-
-namespace testing {
-
-// Definitions in the 'internal' and 'internal2' name spaces are
-// subject to change without notice.  DO NOT USE THEM IN USER CODE!
-namespace internal2 {
-
-// Prints the given number of bytes in the given object to the given
-// ostream.
-GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
-                                     size_t count,
-                                     ::std::ostream* os);
-
-// For selecting which printer to use when a given type has neither <<
-// nor PrintTo().
-enum TypeKind {
-  kProtobuf,              // a protobuf type
-  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
-                          // (e.g. a named or unnamed enum type)
-  kOtherType              // anything else
-};
-
-// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
-// by the universal printer to print a value of type T when neither
-// operator<< nor PrintTo() is defined for T, where kTypeKind is the
-// "kind" of T as defined by enum TypeKind.
-template <typename T, TypeKind kTypeKind>
-class TypeWithoutFormatter {
- public:
-  // This default version is called when kTypeKind is kOtherType.
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
-                         sizeof(value), os);
-  }
-};
-
-// We print a protobuf using its ShortDebugString() when the string
-// doesn't exceed this many characters; otherwise we print it using
-// DebugString() for better readability.
-const size_t kProtobufOneLinerMaxLength = 50;
-
-template <typename T>
-class TypeWithoutFormatter<T, kProtobuf> {
- public:
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    const ::testing::internal::string short_str = value.ShortDebugString();
-    const ::testing::internal::string pretty_str =
-        short_str.length() <= kProtobufOneLinerMaxLength ?
-        short_str : ("\n" + value.DebugString());
-    *os << ("<" + pretty_str + ">");
-  }
-};
-
-template <typename T>
-class TypeWithoutFormatter<T, kConvertibleToInteger> {
- public:
-  // Since T has no << operator or PrintTo() but can be implicitly
-  // converted to BiggestInt, we print it as a BiggestInt.
-  //
-  // Most likely T is an enum type (either named or unnamed), in which
-  // case printing it as an integer is the desired behavior.  In case
-  // T is not an enum, printing it as an integer is the best we can do
-  // given that it has no user-defined printer.
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    const internal::BiggestInt kBigInt = value;
-    *os << kBigInt;
-  }
-};
-
-// Prints the given value to the given ostream.  If the value is a
-// protocol message, its debug string is printed; if it's an enum or
-// of a type implicitly convertible to BiggestInt, it's printed as an
-// integer; otherwise the bytes in the value are printed.  This is
-// what UniversalPrinter<T>::Print() does when it knows nothing about
-// type T and T has neither << operator nor PrintTo().
-//
-// A user can override this behavior for a class type Foo by defining
-// a << operator in the namespace where Foo is defined.
-//
-// We put this operator in namespace 'internal2' instead of 'internal'
-// to simplify the implementation, as much code in 'internal' needs to
-// use << in STL, which would conflict with our own << were it defined
-// in 'internal'.
-//
-// Note that this operator<< takes a generic std::basic_ostream<Char,
-// CharTraits> type instead of the more restricted std::ostream.  If
-// we define it to take an std::ostream instead, we'll get an
-// "ambiguous overloads" compiler error when trying to print a type
-// Foo that supports streaming to std::basic_ostream<Char,
-// CharTraits>, as the compiler cannot tell whether
-// operator<<(std::ostream&, const T&) or
-// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
-// specific.
-template <typename Char, typename CharTraits, typename T>
-::std::basic_ostream<Char, CharTraits>& operator<<(
-    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
-  TypeWithoutFormatter<T,
-      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
-       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
-       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
-  return os;
-}
-
-}  // namespace internal2
-}  // namespace testing
-
-// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
-// magic needed for implementing UniversalPrinter won't work.
-namespace testing_internal {
-
-// Used to print a value that is not an STL-style container when the
-// user doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
-  // With the following statement, during unqualified name lookup,
-  // testing::internal2::operator<< appears as if it was declared in
-  // the nearest enclosing namespace that contains both
-  // ::testing_internal and ::testing::internal2, i.e. the global
-  // namespace.  For more details, refer to the C++ Standard section
-  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
-  // testing::internal2::operator<< in case T doesn't come with a <<
-  // operator.
-  //
-  // We cannot write 'using ::testing::internal2::operator<<;', which
-  // gcc 3.3 fails to compile due to a compiler bug.
-  using namespace ::testing::internal2;  // NOLINT
-
-  // Assuming T is defined in namespace foo, in the next statement,
-  // the compiler will consider all of:
-  //
-  //   1. foo::operator<< (thanks to Koenig look-up),
-  //   2. ::operator<< (as the current namespace is enclosed in ::),
-  //   3. testing::internal2::operator<< (thanks to the using statement above).
-  //
-  // The operator<< whose type matches T best will be picked.
-  //
-  // We deliberately allow #2 to be a candidate, as sometimes it's
-  // impossible to define #1 (e.g. when foo is ::std, defining
-  // anything in it is undefined behavior unless you are a compiler
-  // vendor.).
-  *os << value;
-}
-
-}  // namespace testing_internal
-
-namespace testing {
-namespace internal {
-
-// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
-// value of type ToPrint that is an operand of a comparison assertion
-// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
-// the comparison, and is used to help determine the best way to
-// format the value.  In particular, when the value is a C string
-// (char pointer) and the other operand is an STL string object, we
-// want to format the C string as a string, since we know it is
-// compared by value with the string object.  If the value is a char
-// pointer but the other operand is not an STL string object, we don't
-// know whether the pointer is supposed to point to a NUL-terminated
-// string, and thus want to print it as a pointer to be safe.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// The default case.
-template <typename ToPrint, typename OtherOperand>
-class FormatForComparison {
- public:
-  static ::std::string Format(const ToPrint& value) {
-    return ::testing::PrintToString(value);
-  }
-};
-
-// Array.
-template <typename ToPrint, size_t N, typename OtherOperand>
-class FormatForComparison<ToPrint[N], OtherOperand> {
- public:
-  static ::std::string Format(const ToPrint* value) {
-    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
-  }
-};
-
-// By default, print C string as pointers to be safe, as we don't know
-// whether they actually point to a NUL-terminated string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
-  template <typename OtherOperand>                                      \
-  class FormatForComparison<CharType*, OtherOperand> {                  \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(static_cast<const void*>(value)); \
-    }                                                                   \
-  }
-
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
-
-// If a C string is compared with an STL string object, we know it's meant
-// to point to a NUL-terminated string, and thus can print it as a string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
-  template <>                                                           \
-  class FormatForComparison<CharType*, OtherStringType> {               \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(value);                           \
-    }                                                                   \
-  }
-
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
-
-#if GTEST_HAS_GLOBAL_STRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
-#endif
-
-#if GTEST_HAS_GLOBAL_WSTRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
-#endif
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
-#endif
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
-
-// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
-// operand to be used in a failure message.  The type (but not value)
-// of the other operand may affect the format.  This allows us to
-// print a char* as a raw pointer when it is compared against another
-// char* or void*, and print it as a C string when it is compared
-// against an std::string object, for example.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename T1, typename T2>
-std::string FormatForComparisonFailureMessage(
-    const T1& value, const T2& /* other_operand */) {
-  return FormatForComparison<T1, T2>::Format(value);
-}
-
-// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
-// value to the given ostream.  The caller must ensure that
-// 'ostream_ptr' is not NULL, or the behavior is undefined.
-//
-// We define UniversalPrinter as a class template (as opposed to a
-// function template), as we need to partially specialize it for
-// reference types, which cannot be done with function templates.
-template <typename T>
-class UniversalPrinter;
-
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os);
-
-// Used to print an STL-style container when the user doesn't define
-// a PrintTo() for it.
-template <typename C>
-void DefaultPrintTo(IsContainer /* dummy */,
-                    false_type /* is not a pointer */,
-                    const C& container, ::std::ostream* os) {
-  const size_t kMaxCount = 32;  // The maximum number of elements to print.
-  *os << '{';
-  size_t count = 0;
-  for (typename C::const_iterator it = container.begin();
-       it != container.end(); ++it, ++count) {
-    if (count > 0) {
-      *os << ',';
-      if (count == kMaxCount) {  // Enough has been printed.
-        *os << " ...";
-        break;
-      }
-    }
-    *os << ' ';
-    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
-    // handle *it being a native array.
-    internal::UniversalPrint(*it, os);
-  }
-
-  if (count > 0) {
-    *os << ' ';
-  }
-  *os << '}';
-}
-
-// Used to print a pointer that is neither a char pointer nor a member
-// pointer, when the user doesn't define PrintTo() for it.  (A member
-// variable pointer or member function pointer doesn't really point to
-// a location in the address space.  Their representation is
-// implementation-defined.  Therefore they will be printed as raw
-// bytes.)
-template <typename T>
-void DefaultPrintTo(IsNotContainer /* dummy */,
-                    true_type /* is a pointer */,
-                    T* p, ::std::ostream* os) {
-  if (p == NULL) {
-    *os << "NULL";
-  } else {
-    // C++ doesn't allow casting from a function pointer to any object
-    // pointer.
-    //
-    // IsTrue() silences warnings: "Condition is always true",
-    // "unreachable code".
-    if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
-      // T is not a function type.  We just call << to print p,
-      // relying on ADL to pick up user-defined << for their pointer
-      // types, if any.
-      *os << p;
-    } else {
-      // T is a function type, so '*os << p' doesn't do what we want
-      // (it just prints p as bool).  We want to print p as a const
-      // void*.  However, we cannot cast it to const void* directly,
-      // even using reinterpret_cast, as earlier versions of gcc
-      // (e.g. 3.4.5) cannot compile the cast when p is a function
-      // pointer.  Casting to UInt64 first solves the problem.
-      *os << reinterpret_cast<const void*>(
-          reinterpret_cast<internal::UInt64>(p));
-    }
-  }
-}
-
-// Used to print a non-container, non-pointer value when the user
-// doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintTo(IsNotContainer /* dummy */,
-                    false_type /* is not a pointer */,
-                    const T& value, ::std::ostream* os) {
-  ::testing_internal::DefaultPrintNonContainerTo(value, os);
-}
-
-// Prints the given value using the << operator if it has one;
-// otherwise prints the bytes in it.  This is what
-// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
-// or overloaded for type T.
-//
-// A user can override this behavior for a class type Foo by defining
-// an overload of PrintTo() in the namespace where Foo is defined.  We
-// give the user this option as sometimes defining a << operator for
-// Foo is not desirable (e.g. the coding style may prevent doing it,
-// or there is already a << operator but it doesn't do what the user
-// wants).
-template <typename T>
-void PrintTo(const T& value, ::std::ostream* os) {
-  // DefaultPrintTo() is overloaded.  The type of its first two
-  // arguments determine which version will be picked.  If T is an
-  // STL-style container, the version for container will be called; if
-  // T is a pointer, the pointer version will be called; otherwise the
-  // generic version will be called.
-  //
-  // Note that we check for container types here, prior to we check
-  // for protocol message types in our operator<<.  The rationale is:
-  //
-  // For protocol messages, we want to give people a chance to
-  // override Google Mock's format by defining a PrintTo() or
-  // operator<<.  For STL containers, other formats can be
-  // incompatible with Google Mock's format for the container
-  // elements; therefore we check for container types here to ensure
-  // that our format is used.
-  //
-  // The second argument of DefaultPrintTo() is needed to bypass a bug
-  // in Symbian's C++ compiler that prevents it from picking the right
-  // overload between:
-  //
-  //   PrintTo(const T& x, ...);
-  //   PrintTo(T* x, ...);
-  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
-}
-
-// The following list of PrintTo() overloads tells
-// UniversalPrinter<T>::Print() how to print standard types (built-in
-// types, strings, plain arrays, and pointers).
-
-// Overloads for various char types.
-GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
-GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
-inline void PrintTo(char c, ::std::ostream* os) {
-  // When printing a plain char, we always treat it as unsigned.  This
-  // way, the output won't be affected by whether the compiler thinks
-  // char is signed or not.
-  PrintTo(static_cast<unsigned char>(c), os);
-}
-
-// Overloads for other simple built-in types.
-inline void PrintTo(bool x, ::std::ostream* os) {
-  *os << (x ? "true" : "false");
-}
-
-// Overload for wchar_t type.
-// Prints a wchar_t as a symbol if it is printable or as its internal
-// code otherwise and also as its decimal code (except for L'\0').
-// The L'\0' char is printed as "L'\\0'". The decimal code is printed
-// as signed integer when wchar_t is implemented by the compiler
-// as a signed type and is printed as an unsigned integer when wchar_t
-// is implemented as an unsigned type.
-GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
-
-// Overloads for C strings.
-GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
-inline void PrintTo(char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char*>(s), os);
-}
-
-// signed/unsigned char is often used for representing binary data, so
-// we print pointers to it as void* to be safe.
-inline void PrintTo(const signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-
-// MSVC can be configured to define wchar_t as a typedef of unsigned
-// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
-// type.  When wchar_t is a typedef, defining an overload for const
-// wchar_t* would cause unsigned short* be printed as a wide string,
-// possibly causing invalid memory accesses.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-// Overloads for wide C strings
-GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
-inline void PrintTo(wchar_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
-}
-#endif
-
-// Overload for C arrays.  Multi-dimensional arrays are printed
-// properly.
-
-// Prints the given number of elements in an array, without printing
-// the curly braces.
-template <typename T>
-void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
-  UniversalPrint(a[0], os);
-  for (size_t i = 1; i != count; i++) {
-    *os << ", ";
-    UniversalPrint(a[i], os);
-  }
-}
-
-// Overloads for ::string and ::std::string.
-#if GTEST_HAS_GLOBAL_STRING
-GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
-inline void PrintTo(const ::string& s, ::std::ostream* os) {
-  PrintStringTo(s, os);
-}
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
-inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
-  PrintStringTo(s, os);
-}
-
-// Overloads for ::wstring and ::std::wstring.
-#if GTEST_HAS_GLOBAL_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
-inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
-  PrintWideStringTo(s, os);
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
-inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
-  PrintWideStringTo(s, os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-// Helper function for printing a tuple.  T must be instantiated with
-// a tuple type.
-template <typename T>
-void PrintTupleTo(const T& t, ::std::ostream* os);
-#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-
-#if GTEST_HAS_TR1_TUPLE
-// Overload for ::std::tr1::tuple.  Needed for printing function arguments,
-// which are packed as tuples.
-
-// Overloaded PrintTo() for tuples of various arities.  We support
-// tuples of up-to 10 fields.  The following implementation works
-// regardless of whether tr1::tuple is implemented using the
-// non-standard variadic template feature or not.
-
-inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1>
-void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2>
-void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8, typename T9>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8, typename T9, typename T10>
-void PrintTo(
-    const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
-    ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-template <typename... Types>
-void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-#endif  // GTEST_HAS_STD_TUPLE_
-
-// Overload for std::pair.
-template <typename T1, typename T2>
-void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
-  *os << '(';
-  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
-  // a reference type.  The same for printing value.second.
-  UniversalPrinter<T1>::Print(value.first, os);
-  *os << ", ";
-  UniversalPrinter<T2>::Print(value.second, os);
-  *os << ')';
-}
-
-// Implements printing a non-reference type T by letting the compiler
-// pick the right overload of PrintTo() for T.
-template <typename T>
-class UniversalPrinter {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  // Note: we deliberately don't call this PrintTo(), as that name
-  // conflicts with ::testing::internal::PrintTo in the body of the
-  // function.
-  static void Print(const T& value, ::std::ostream* os) {
-    // By default, ::testing::internal::PrintTo() is used for printing
-    // the value.
-    //
-    // Thanks to Koenig look-up, if T is a class and has its own
-    // PrintTo() function defined in its namespace, that function will
-    // be visible here.  Since it is more specific than the generic ones
-    // in ::testing::internal, it will be picked by the compiler in the
-    // following statement - exactly what we want.
-    PrintTo(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-// UniversalPrintArray(begin, len, os) prints an array of 'len'
-// elements, starting at address 'begin'.
-template <typename T>
-void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
-  if (len == 0) {
-    *os << "{}";
-  } else {
-    *os << "{ ";
-    const size_t kThreshold = 18;
-    const size_t kChunkSize = 8;
-    // If the array has more than kThreshold elements, we'll have to
-    // omit some details by printing only the first and the last
-    // kChunkSize elements.
-    // TODO(wan@google.com): let the user control the threshold using a flag.
-    if (len <= kThreshold) {
-      PrintRawArrayTo(begin, len, os);
-    } else {
-      PrintRawArrayTo(begin, kChunkSize, os);
-      *os << ", ..., ";
-      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
-    }
-    *os << " }";
-  }
-}
-// This overload prints a (const) char array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const char* begin, size_t len, ::std::ostream* os);
-
-// This overload prints a (const) wchar_t array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const wchar_t* begin, size_t len, ::std::ostream* os);
-
-// Implements printing an array type T[N].
-template <typename T, size_t N>
-class UniversalPrinter<T[N]> {
- public:
-  // Prints the given array, omitting some elements when there are too
-  // many.
-  static void Print(const T (&a)[N], ::std::ostream* os) {
-    UniversalPrintArray(a, N, os);
-  }
-};
-
-// Implements printing a reference type T&.
-template <typename T>
-class UniversalPrinter<T&> {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  static void Print(const T& value, ::std::ostream* os) {
-    // Prints the address of the value.  We use reinterpret_cast here
-    // as static_cast doesn't compile when T is a function type.
-    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
-
-    // Then prints the value itself.
-    UniversalPrint(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-// Prints a value tersely: for a reference type, the referenced value
-// (but not the address) is printed; for a (const) char pointer, the
-// NUL-terminated string (but not the pointer) is printed.
-
-template <typename T>
-class UniversalTersePrinter {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T>
-class UniversalTersePrinter<T&> {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T, size_t N>
-class UniversalTersePrinter<T[N]> {
- public:
-  static void Print(const T (&value)[N], ::std::ostream* os) {
-    UniversalPrinter<T[N]>::Print(value, os);
-  }
-};
-template <>
-class UniversalTersePrinter<const char*> {
- public:
-  static void Print(const char* str, ::std::ostream* os) {
-    if (str == NULL) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(string(str), os);
-    }
-  }
-};
-template <>
-class UniversalTersePrinter<char*> {
- public:
-  static void Print(char* str, ::std::ostream* os) {
-    UniversalTersePrinter<const char*>::Print(str, os);
-  }
-};
-
-#if GTEST_HAS_STD_WSTRING
-template <>
-class UniversalTersePrinter<const wchar_t*> {
- public:
-  static void Print(const wchar_t* str, ::std::ostream* os) {
-    if (str == NULL) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::wstring(str), os);
-    }
-  }
-};
-#endif
-
-template <>
-class UniversalTersePrinter<wchar_t*> {
- public:
-  static void Print(wchar_t* str, ::std::ostream* os) {
-    UniversalTersePrinter<const wchar_t*>::Print(str, os);
-  }
-};
-
-template <typename T>
-void UniversalTersePrint(const T& value, ::std::ostream* os) {
-  UniversalTersePrinter<T>::Print(value, os);
-}
-
-// Prints a value using the type inferred by the compiler.  The
-// difference between this and UniversalTersePrint() is that for a
-// (const) char pointer, this prints both the pointer and the
-// NUL-terminated string.
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os) {
-  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
-  // UniversalPrinter with T directly.
-  typedef T T1;
-  UniversalPrinter<T1>::Print(value, os);
-}
-
-typedef ::std::vector<string> Strings;
-
-// TuplePolicy<TupleT> must provide:
-// - tuple_size
-//     size of tuple TupleT.
-// - get<size_t I>(const TupleT& t)
-//     static function extracting element I of tuple TupleT.
-// - tuple_element<size_t I>::type
-//     type of element I of tuple TupleT.
-template <typename TupleT>
-struct TuplePolicy;
-
-#if GTEST_HAS_TR1_TUPLE
-template <typename TupleT>
-struct TuplePolicy {
-  typedef TupleT Tuple;
-  static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
-
-  template <size_t I>
-  struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};
-
-  template <size_t I>
-  static typename AddReference<
-      const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
-      const Tuple& tuple) {
-    return ::std::tr1::get<I>(tuple);
-  }
-};
-template <typename TupleT>
-const size_t TuplePolicy<TupleT>::tuple_size;
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-template <typename... Types>
-struct TuplePolicy< ::std::tuple<Types...> > {
-  typedef ::std::tuple<Types...> Tuple;
-  static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
-
-  template <size_t I>
-  struct tuple_element : ::std::tuple_element<I, Tuple> {};
-
-  template <size_t I>
-  static const typename ::std::tuple_element<I, Tuple>::type& get(
-      const Tuple& tuple) {
-    return ::std::get<I>(tuple);
-  }
-};
-template <typename... Types>
-const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
-#endif  // GTEST_HAS_STD_TUPLE_
-
-#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-// This helper template allows PrintTo() for tuples and
-// UniversalTersePrintTupleFieldsToStrings() to be defined by
-// induction on the number of tuple fields.  The idea is that
-// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
-// fields in tuple t, and can be defined in terms of
-// TuplePrefixPrinter<N - 1>.
-//
-// The inductive case.
-template <size_t N>
-struct TuplePrefixPrinter {
-  // Prints the first N fields of a tuple.
-  template <typename Tuple>
-  static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
-    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
-    GTEST_INTENTIONAL_CONST_COND_PUSH_()
-    if (N > 1) {
-    GTEST_INTENTIONAL_CONST_COND_POP_()
-      *os << ", ";
-    }
-    UniversalPrinter<
-        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
-        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
-  }
-
-  // Tersely prints the first N fields of a tuple to a string vector,
-  // one element for each field.
-  template <typename Tuple>
-  static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
-    TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
-    ::std::stringstream ss;
-    UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
-    strings->push_back(ss.str());
-  }
-};
-
-// Base case.
-template <>
-struct TuplePrefixPrinter<0> {
-  template <typename Tuple>
-  static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
-
-  template <typename Tuple>
-  static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
-};
-
-// Helper function for printing a tuple.
-// Tuple must be either std::tr1::tuple or std::tuple type.
-template <typename Tuple>
-void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
-  *os << "(";
-  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t, os);
-  *os << ")";
-}
-
-// Prints the fields of a tuple tersely to a string vector, one
-// element for each field.  See the comment before
-// UniversalTersePrint() for how we define "tersely".
-template <typename Tuple>
-Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
-  Strings result;
-  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
-      TersePrintPrefixToStrings(value, &result);
-  return result;
-}
-#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-
-}  // namespace internal
-
-template <typename T>
-::std::string PrintToString(const T& value) {
-  ::std::stringstream ss;
-  internal::UniversalTersePrinter<T>::Print(value, &ss);
-  return ss.str();
-}
-
-}  // namespace testing
-
-// Include any custom printer added by the local installation.
-// We must include this header at the end to make sure it can use the
-// declarations from this file.
-// Copyright 2015, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// This file provides an injection point for custom printers in a local
-// installation of gTest.
-// It will be included from gtest-printers.h and the overrides in this file
-// will be visible to everyone.
-// See documentation at gtest/gtest-printers.h for details on how to define a
-// custom printer.
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Input to a parameterized test name generator, describing a test parameter.
-// Consists of the parameter value and the integer parameter index.
-template <class ParamType>
-struct TestParamInfo {
-  TestParamInfo(const ParamType& a_param, size_t an_index) :
-    param(a_param),
-    index(an_index) {}
-  ParamType param;
-  size_t index;
-};
-
-// A builtin parameterized test name generator which returns the result of
-// testing::PrintToString.
-struct PrintToStringParamName {
-  template <class ParamType>
-  std::string operator()(const TestParamInfo<ParamType>& info) const {
-    return PrintToString(info.param);
-  }
-};
-
-namespace internal {
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Outputs a message explaining invalid registration of different
-// fixture class for the same test case. This may happen when
-// TEST_P macro is used to define two tests with the same name
-// but in different namespaces.
-GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
-                                          CodeLocation code_location);
-
-template <typename> class ParamGeneratorInterface;
-template <typename> class ParamGenerator;
-
-// Interface for iterating over elements provided by an implementation
-// of ParamGeneratorInterface<T>.
-template <typename T>
-class ParamIteratorInterface {
- public:
-  virtual ~ParamIteratorInterface() {}
-  // A pointer to the base generator instance.
-  // Used only for the purposes of iterator comparison
-  // to make sure that two iterators belong to the same generator.
-  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
-  // Advances iterator to point to the next element
-  // provided by the generator. The caller is responsible
-  // for not calling Advance() on an iterator equal to
-  // BaseGenerator()->End().
-  virtual void Advance() = 0;
-  // Clones the iterator object. Used for implementing copy semantics
-  // of ParamIterator<T>.
-  virtual ParamIteratorInterface* Clone() const = 0;
-  // Dereferences the current iterator and provides (read-only) access
-  // to the pointed value. It is the caller's responsibility not to call
-  // Current() on an iterator equal to BaseGenerator()->End().
-  // Used for implementing ParamGenerator<T>::operator*().
-  virtual const T* Current() const = 0;
-  // Determines whether the given iterator and other point to the same
-  // element in the sequence generated by the generator.
-  // Used for implementing ParamGenerator<T>::operator==().
-  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
-};
-
-// Class iterating over elements provided by an implementation of
-// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
-// and implements the const forward iterator concept.
-template <typename T>
-class ParamIterator {
- public:
-  typedef T value_type;
-  typedef const T& reference;
-  typedef ptrdiff_t difference_type;
-
-  // ParamIterator assumes ownership of the impl_ pointer.
-  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
-  ParamIterator& operator=(const ParamIterator& other) {
-    if (this != &other)
-      impl_.reset(other.impl_->Clone());
-    return *this;
-  }
-
-  const T& operator*() const { return *impl_->Current(); }
-  const T* operator->() const { return impl_->Current(); }
-  // Prefix version of operator++.
-  ParamIterator& operator++() {
-    impl_->Advance();
-    return *this;
-  }
-  // Postfix version of operator++.
-  ParamIterator operator++(int /*unused*/) {
-    ParamIteratorInterface<T>* clone = impl_->Clone();
-    impl_->Advance();
-    return ParamIterator(clone);
-  }
-  bool operator==(const ParamIterator& other) const {
-    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
-  }
-  bool operator!=(const ParamIterator& other) const {
-    return !(*this == other);
-  }
-
- private:
-  friend class ParamGenerator<T>;
-  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
-  scoped_ptr<ParamIteratorInterface<T> > impl_;
-};
-
-// ParamGeneratorInterface<T> is the binary interface to access generators
-// defined in other translation units.
-template <typename T>
-class ParamGeneratorInterface {
- public:
-  typedef T ParamType;
-
-  virtual ~ParamGeneratorInterface() {}
-
-  // Generator interface definition
-  virtual ParamIteratorInterface<T>* Begin() const = 0;
-  virtual ParamIteratorInterface<T>* End() const = 0;
-};
-
-// Wraps ParamGeneratorInterface<T> and provides general generator syntax
-// compatible with the STL Container concept.
-// This class implements copy initialization semantics and the contained
-// ParamGeneratorInterface<T> instance is shared among all copies
-// of the original object. This is possible because that instance is immutable.
-template<typename T>
-class ParamGenerator {
- public:
-  typedef ParamIterator<T> iterator;
-
-  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
-  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
-
-  ParamGenerator& operator=(const ParamGenerator& other) {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  iterator begin() const { return iterator(impl_->Begin()); }
-  iterator end() const { return iterator(impl_->End()); }
-
- private:
-  linked_ptr<const ParamGeneratorInterface<T> > impl_;
-};
-
-// Generates values from a range of two comparable values. Can be used to
-// generate sequences of user-defined types that implement operator+() and
-// operator<().
-// This class is used in the Range() function.
-template <typename T, typename IncrementT>
-class RangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  RangeGenerator(T begin, T end, IncrementT step)
-      : begin_(begin), end_(end),
-        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
-  virtual ~RangeGenerator() {}
-
-  virtual ParamIteratorInterface<T>* Begin() const {
-    return new Iterator(this, begin_, 0, step_);
-  }
-  virtual ParamIteratorInterface<T>* End() const {
-    return new Iterator(this, end_, end_index_, step_);
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
-             IncrementT step)
-        : base_(base), value_(value), index_(index), step_(step) {}
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
-      return base_;
-    }
-    virtual void Advance() {
-      value_ = static_cast<T>(value_ + step_);
-      index_++;
-    }
-    virtual ParamIteratorInterface<T>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const T* Current() const { return &value_; }
-    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const int other_index =
-          CheckedDowncastToActualType<const Iterator>(&other)->index_;
-      return index_ == other_index;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : ParamIteratorInterface<T>(),
-          base_(other.base_), value_(other.value_), index_(other.index_),
-          step_(other.step_) {}
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<T>* const base_;
-    T value_;
-    int index_;
-    const IncrementT step_;
-  };  // class RangeGenerator::Iterator
-
-  static int CalculateEndIndex(const T& begin,
-                               const T& end,
-                               const IncrementT& step) {
-    int end_index = 0;
-    for (T i = begin; i < end; i = static_cast<T>(i + step))
-      end_index++;
-    return end_index;
-  }
-
-  // No implementation - assignment is unsupported.
-  void operator=(const RangeGenerator& other);
-
-  const T begin_;
-  const T end_;
-  const IncrementT step_;
-  // The index for the end() iterator. All the elements in the generated
-  // sequence are indexed (0-based) to aid iterator comparison.
-  const int end_index_;
-};  // class RangeGenerator
-
-
-// Generates values from a pair of STL-style iterators. Used in the
-// ValuesIn() function. The elements are copied from the source range
-// since the source can be located on the stack, and the generator
-// is likely to persist beyond that stack frame.
-template <typename T>
-class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  template <typename ForwardIterator>
-  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
-      : container_(begin, end) {}
-  virtual ~ValuesInIteratorRangeGenerator() {}
-
-  virtual ParamIteratorInterface<T>* Begin() const {
-    return new Iterator(this, container_.begin());
-  }
-  virtual ParamIteratorInterface<T>* End() const {
-    return new Iterator(this, container_.end());
-  }
-
- private:
-  typedef typename ::std::vector<T> ContainerType;
-
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base,
-             typename ContainerType::const_iterator iterator)
-        : base_(base), iterator_(iterator) {}
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
-      return base_;
-    }
-    virtual void Advance() {
-      ++iterator_;
-      value_.reset();
-    }
-    virtual ParamIteratorInterface<T>* Clone() const {
-      return new Iterator(*this);
-    }
-    // We need to use cached value referenced by iterator_ because *iterator_
-    // can return a temporary object (and of type other then T), so just
-    // having "return &*iterator_;" doesn't work.
-    // value_ is updated here and not in Advance() because Advance()
-    // can advance iterator_ beyond the end of the range, and we cannot
-    // detect that fact. The client code, on the other hand, is
-    // responsible for not calling Current() on an out-of-range iterator.
-    virtual const T* Current() const {
-      if (value_.get() == NULL)
-        value_.reset(new T(*iterator_));
-      return value_.get();
-    }
-    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      return iterator_ ==
-          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-          // The explicit constructor call suppresses a false warning
-          // emitted by gcc when supplied with the -Wextra option.
-        : ParamIteratorInterface<T>(),
-          base_(other.base_),
-          iterator_(other.iterator_) {}
-
-    const ParamGeneratorInterface<T>* const base_;
-    typename ContainerType::const_iterator iterator_;
-    // A cached value of *iterator_. We keep it here to allow access by
-    // pointer in the wrapping iterator's operator->().
-    // value_ needs to be mutable to be accessed in Current().
-    // Use of scoped_ptr helps manage cached value's lifetime,
-    // which is bound by the lifespan of the iterator itself.
-    mutable scoped_ptr<const T> value_;
-  };  // class ValuesInIteratorRangeGenerator::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const ValuesInIteratorRangeGenerator& other);
-
-  const ContainerType container_;
-};  // class ValuesInIteratorRangeGenerator
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Default parameterized test name generator, returns a string containing the
-// integer test parameter index.
-template <class ParamType>
-std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  Message name_stream;
-  name_stream << info.index;
-  return name_stream.GetString();
-}
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Parameterized test name overload helpers, which help the
-// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
-// test name generator and user param name generator.
-template <class ParamType, class ParamNameGenFunctor>
-ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
-  return func;
-}
-
-template <class ParamType>
-struct ParamNameGenFunc {
-  typedef std::string Type(const TestParamInfo<ParamType>&);
-};
-
-template <class ParamType>
-typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
-  return DefaultParamName;
-}
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Stores a parameter value and later creates tests parameterized with that
-// value.
-template <class TestClass>
-class ParameterizedTestFactory : public TestFactoryBase {
- public:
-  typedef typename TestClass::ParamType ParamType;
-  explicit ParameterizedTestFactory(ParamType parameter) :
-      parameter_(parameter) {}
-  virtual Test* CreateTest() {
-    TestClass::SetParam(&parameter_);
-    return new TestClass();
-  }
-
- private:
-  const ParamType parameter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// TestMetaFactoryBase is a base class for meta-factories that create
-// test factories for passing into MakeAndRegisterTestInfo function.
-template <class ParamType>
-class TestMetaFactoryBase {
- public:
-  virtual ~TestMetaFactoryBase() {}
-
-  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// TestMetaFactory creates test factories for passing into
-// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
-// ownership of test factory pointer, same factory object cannot be passed
-// into that method twice. But ParameterizedTestCaseInfo is going to call
-// it for each Test/Parameter value combination. Thus it needs meta factory
-// creator class.
-template <class TestCase>
-class TestMetaFactory
-    : public TestMetaFactoryBase<typename TestCase::ParamType> {
- public:
-  typedef typename TestCase::ParamType ParamType;
-
-  TestMetaFactory() {}
-
-  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
-    return new ParameterizedTestFactory<TestCase>(parameter);
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseInfoBase is a generic interface
-// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
-// accumulates test information provided by TEST_P macro invocations
-// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
-// and uses that information to register all resulting test instances
-// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
-// a collection of pointers to the ParameterizedTestCaseInfo objects
-// and calls RegisterTests() on each of them when asked.
-class ParameterizedTestCaseInfoBase {
- public:
-  virtual ~ParameterizedTestCaseInfoBase() {}
-
-  // Base part of test case name for display purposes.
-  virtual const string& GetTestCaseName() const = 0;
-  // Test case id to verify identity.
-  virtual TypeId GetTestCaseTypeId() const = 0;
-  // UnitTest class invokes this method to register tests in this
-  // test case right before running them in RUN_ALL_TESTS macro.
-  // This method should not be called more then once on any single
-  // instance of a ParameterizedTestCaseInfoBase derived class.
-  virtual void RegisterTests() = 0;
-
- protected:
-  ParameterizedTestCaseInfoBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
-// macro invocations for a particular test case and generators
-// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
-// test case. It registers tests with all values generated by all
-// generators when asked.
-template <class TestCase>
-class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
- public:
-  // ParamType and GeneratorCreationFunc are private types but are required
-  // for declarations of public methods AddTestPattern() and
-  // AddTestCaseInstantiation().
-  typedef typename TestCase::ParamType ParamType;
-  // A function that returns an instance of appropriate generator type.
-  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
-  typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
-
-  explicit ParameterizedTestCaseInfo(
-      const char* name, CodeLocation code_location)
-      : test_case_name_(name), code_location_(code_location) {}
-
-  // Test case base name for display purposes.
-  virtual const string& GetTestCaseName() const { return test_case_name_; }
-  // Test case id to verify identity.
-  virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
-  // TEST_P macro uses AddTestPattern() to record information
-  // about a single test in a LocalTestInfo structure.
-  // test_case_name is the base name of the test case (without invocation
-  // prefix). test_base_name is the name of an individual test without
-  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
-  // test case base name and DoBar is test base name.
-  void AddTestPattern(const char* test_case_name,
-                      const char* test_base_name,
-                      TestMetaFactoryBase<ParamType>* meta_factory) {
-    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
-                                                       test_base_name,
-                                                       meta_factory)));
-  }
-  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
-  // about a generator.
-  int AddTestCaseInstantiation(const string& instantiation_name,
-                               GeneratorCreationFunc* func,
-                               ParamNameGeneratorFunc* name_func,
-                               const char* file,
-                               int line) {
-    instantiations_.push_back(
-        InstantiationInfo(instantiation_name, func, name_func, file, line));
-    return 0;  // Return value used only to run this method in namespace scope.
-  }
-  // UnitTest class invokes this method to register tests in this test case
-  // test cases right before running tests in RUN_ALL_TESTS macro.
-  // This method should not be called more then once on any single
-  // instance of a ParameterizedTestCaseInfoBase derived class.
-  // UnitTest has a guard to prevent from calling this method more then once.
-  virtual void RegisterTests() {
-    for (typename TestInfoContainer::iterator test_it = tests_.begin();
-         test_it != tests_.end(); ++test_it) {
-      linked_ptr<TestInfo> test_info = *test_it;
-      for (typename InstantiationContainer::iterator gen_it =
-               instantiations_.begin(); gen_it != instantiations_.end();
-               ++gen_it) {
-        const string& instantiation_name = gen_it->name;
-        ParamGenerator<ParamType> generator((*gen_it->generator)());
-        ParamNameGeneratorFunc* name_func = gen_it->name_func;
-        const char* file = gen_it->file;
-        int line = gen_it->line;
-
-        string test_case_name;
-        if ( !instantiation_name.empty() )
-          test_case_name = instantiation_name + "/";
-        test_case_name += test_info->test_case_base_name;
-
-        size_t i = 0;
-        std::set<std::string> test_param_names;
-        for (typename ParamGenerator<ParamType>::iterator param_it =
-                 generator.begin();
-             param_it != generator.end(); ++param_it, ++i) {
-          Message test_name_stream;
-
-          std::string param_name = name_func(
-              TestParamInfo<ParamType>(*param_it, i));
-
-          GTEST_CHECK_(IsValidParamName(param_name))
-              << "Parameterized test name '" << param_name
-              << "' is invalid, in " << file
-              << " line " << line << std::endl;
-
-          GTEST_CHECK_(test_param_names.count(param_name) == 0)
-              << "Duplicate parameterized test name '" << param_name
-              << "', in " << file << " line " << line << std::endl;
-
-          test_param_names.insert(param_name);
-
-          test_name_stream << test_info->test_base_name << "/" << param_name;
-          MakeAndRegisterTestInfo(
-              test_case_name.c_str(),
-              test_name_stream.GetString().c_str(),
-              NULL,  // No type parameter.
-              PrintToString(*param_it).c_str(),
-              code_location_,
-              GetTestCaseTypeId(),
-              TestCase::SetUpTestCase,
-              TestCase::TearDownTestCase,
-              test_info->test_meta_factory->CreateTestFactory(*param_it));
-        }  // for param_it
-      }  // for gen_it
-    }  // for test_it
-  }  // RegisterTests
-
- private:
-  // LocalTestInfo structure keeps information about a single test registered
-  // with TEST_P macro.
-  struct TestInfo {
-    TestInfo(const char* a_test_case_base_name,
-             const char* a_test_base_name,
-             TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
-        test_case_base_name(a_test_case_base_name),
-        test_base_name(a_test_base_name),
-        test_meta_factory(a_test_meta_factory) {}
-
-    const string test_case_base_name;
-    const string test_base_name;
-    const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
-  };
-  typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
-  // Records data received from INSTANTIATE_TEST_CASE_P macros:
-  //  <Instantiation name, Sequence generator creation function,
-  //     Name generator function, Source file, Source line>
-  struct InstantiationInfo {
-      InstantiationInfo(const std::string &name_in,
-                        GeneratorCreationFunc* generator_in,
-                        ParamNameGeneratorFunc* name_func_in,
-                        const char* file_in,
-                        int line_in)
-          : name(name_in),
-            generator(generator_in),
-            name_func(name_func_in),
-            file(file_in),
-            line(line_in) {}
-
-      std::string name;
-      GeneratorCreationFunc* generator;
-      ParamNameGeneratorFunc* name_func;
-      const char* file;
-      int line;
-  };
-  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
-
-  static bool IsValidParamName(const std::string& name) {
-    // Check for empty string
-    if (name.empty())
-      return false;
-
-    // Check for invalid characters
-    for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!isalnum(name[index]) && name[index] != '_')
-        return false;
-    }
-
-    return true;
-  }
-
-  const string test_case_name_;
-  CodeLocation code_location_;
-  TestInfoContainer tests_;
-  InstantiationContainer instantiations_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
-};  // class ParameterizedTestCaseInfo
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
-// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
-// macros use it to locate their corresponding ParameterizedTestCaseInfo
-// descriptors.
-class ParameterizedTestCaseRegistry {
- public:
-  ParameterizedTestCaseRegistry() {}
-  ~ParameterizedTestCaseRegistry() {
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      delete *it;
-    }
-  }
-
-  // Looks up or creates and returns a structure containing information about
-  // tests and instantiations of a particular test case.
-  template <class TestCase>
-  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      const char* test_case_name,
-      CodeLocation code_location) {
-    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      if ((*it)->GetTestCaseName() == test_case_name) {
-        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
-          // Complain about incorrect usage of Google Test facilities
-          // and terminate the program since we cannot guaranty correct
-          // test case setup and tear-down in this case.
-          ReportInvalidTestCaseType(test_case_name, code_location);
-          posix::Abort();
-        } else {
-          // At this point we are sure that the object we found is of the same
-          // type we are looking for, so we downcast it to that type
-          // without further checks.
-          typed_test_info = CheckedDowncastToActualType<
-              ParameterizedTestCaseInfo<TestCase> >(*it);
-        }
-        break;
-      }
-    }
-    if (typed_test_info == NULL) {
-      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
-          test_case_name, code_location);
-      test_case_infos_.push_back(typed_test_info);
-    }
-    return typed_test_info;
-  }
-  void RegisterTests() {
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      (*it)->RegisterTests();
-    }
-  }
-
- private:
-  typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
-
-  TestCaseInfoContainer test_case_infos_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  //  GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-// This file was GENERATED by command:
-//     pump.py gtest-param-util-generated.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2008 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Type and function utilities for implementing parameterized tests.
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently Google Test supports at most 50 arguments in Values,
-// and at most 10 arguments in Combine. Please contact
-// googletestframework@googlegroups.com if you need more.
-// Please note that the number of arguments to Combine is limited
-// by the maximum arity of the implementation of tuple which is
-// currently set at 10.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Forward declarations of ValuesIn(), which is implemented in
-// include/gtest/gtest-param-test.h.
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end);
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container);
-
-namespace internal {
-
-// Used in the Values() function to provide polymorphic capabilities.
-template <typename T1>
-class ValueArray1 {
- public:
-  explicit ValueArray1(T1 v1) : v1_(v1) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray1& other);
-
-  const T1 v1_;
-};
-
-template <typename T1, typename T2>
-class ValueArray2 {
- public:
-  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray2& other);
-
-  const T1 v1_;
-  const T2 v2_;
-};
-
-template <typename T1, typename T2, typename T3>
-class ValueArray3 {
- public:
-  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray3& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4>
-class ValueArray4 {
- public:
-  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray4& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-class ValueArray5 {
- public:
-  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray5& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-class ValueArray6 {
- public:
-  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray6& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-class ValueArray7 {
- public:
-  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray7& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-class ValueArray8 {
- public:
-  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray8& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-class ValueArray9 {
- public:
-  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray9& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-class ValueArray10 {
- public:
-  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray10& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-class ValueArray11 {
- public:
-  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray11& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-class ValueArray12 {
- public:
-  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray12& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-class ValueArray13 {
- public:
-  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray13& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-class ValueArray14 {
- public:
-  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray14& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-class ValueArray15 {
- public:
-  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray15& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-class ValueArray16 {
- public:
-  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray16& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-class ValueArray17 {
- public:
-  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray17& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-class ValueArray18 {
- public:
-  ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray18& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-class ValueArray19 {
- public:
-  ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray19& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-class ValueArray20 {
- public:
-  ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray20& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-class ValueArray21 {
- public:
-  ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray21& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-class ValueArray22 {
- public:
-  ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray22& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-class ValueArray23 {
- public:
-  ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray23& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-class ValueArray24 {
- public:
-  ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray24& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-class ValueArray25 {
- public:
-  ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-      T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray25& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-class ValueArray26 {
- public:
-  ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray26& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-class ValueArray27 {
- public:
-  ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray27& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-class ValueArray28 {
- public:
-  ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray28& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-class ValueArray29 {
- public:
-  ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray29& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-class ValueArray30 {
- public:
-  ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray30& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-class ValueArray31 {
- public:
-  ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray31& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-class ValueArray32 {
- public:
-  ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray32& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-class ValueArray33 {
- public:
-  ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
-      T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray33& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-class ValueArray34 {
- public:
-  ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray34& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-class ValueArray35 {
- public:
-  ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
-      v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray35& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-class ValueArray36 {
- public:
-  ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
-      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray36& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-class ValueArray37 {
- public:
-  ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
-      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
-      v36_(v36), v37_(v37) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray37& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-class ValueArray38 {
- public:
-  ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray38& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-class ValueArray39 {
- public:
-  ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray39& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-class ValueArray40 {
- public:
-  ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
-      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
-      v40_(v40) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray40& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-class ValueArray41 {
- public:
-  ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
-      T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray41& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-class ValueArray42 {
- public:
-  ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray42& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-class ValueArray43 {
- public:
-  ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
-      v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
-      v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray43& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-class ValueArray44 {
- public:
-  ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
-      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
-      v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
-      v43_(v43), v44_(v44) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray44& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-class ValueArray45 {
- public:
-  ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
-      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
-      v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
-      v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray45& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-class ValueArray46 {
- public:
-  ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
-      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray46& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-class ValueArray47 {
- public:
-  ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
-      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
-      v47_(v47) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray47& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-class ValueArray48 {
- public:
-  ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
-      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
-      v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
-      v46_(v46), v47_(v47), v48_(v48) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray48& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-class ValueArray49 {
- public:
-  ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
-      T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
-      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_), static_cast<T>(v49_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray49& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-  const T49 v49_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-class ValueArray50 {
- public:
-  ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
-      T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
-      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray50& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-  const T49 v49_;
-  const T50 v50_;
-};
-
-# if GTEST_HAS_COMBINE
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Generates values from the Cartesian product of values produced
-// by the argument generators.
-//
-template <typename T1, typename T2>
-class CartesianProductGenerator2
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2> > {
- public:
-  typedef ::testing::tuple<T1, T2> ParamType;
-
-  CartesianProductGenerator2(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2)
-      : g1_(g1), g2_(g2) {}
-  virtual ~CartesianProductGenerator2() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current2_;
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator2::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator2& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-};  // class CartesianProductGenerator2
-
-
-template <typename T1, typename T2, typename T3>
-class CartesianProductGenerator3
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3> ParamType;
-
-  CartesianProductGenerator3(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
-      : g1_(g1), g2_(g2), g3_(g3) {}
-  virtual ~CartesianProductGenerator3() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current3_;
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator3::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator3& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-};  // class CartesianProductGenerator3
-
-
-template <typename T1, typename T2, typename T3, typename T4>
-class CartesianProductGenerator4
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4> ParamType;
-
-  CartesianProductGenerator4(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
-  virtual ~CartesianProductGenerator4() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current4_;
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator4::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator4& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-};  // class CartesianProductGenerator4
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-class CartesianProductGenerator5
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5> ParamType;
-
-  CartesianProductGenerator5(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
-  virtual ~CartesianProductGenerator5() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current5_;
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator5::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator5& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-};  // class CartesianProductGenerator5
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-class CartesianProductGenerator6
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5,
-        T6> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
-
-  CartesianProductGenerator6(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
-  virtual ~CartesianProductGenerator6() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current6_;
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator6::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator6& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-};  // class CartesianProductGenerator6
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-class CartesianProductGenerator7
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
-
-  CartesianProductGenerator7(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
-  virtual ~CartesianProductGenerator7() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current7_;
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator7::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator7& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-};  // class CartesianProductGenerator7
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-class CartesianProductGenerator8
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
-
-  CartesianProductGenerator8(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
-          g8_(g8) {}
-  virtual ~CartesianProductGenerator8() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current8_;
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator8::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator8& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-};  // class CartesianProductGenerator8
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-class CartesianProductGenerator9
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8, T9> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
-
-  CartesianProductGenerator9(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9) {}
-  virtual ~CartesianProductGenerator9() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end(), g9_, g9_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8,
-      const ParamGenerator<T9>& g9,
-      const typename ParamGenerator<T9>::iterator& current9)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
-          begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current9_;
-      if (current9_ == end9_) {
-        current9_ = begin9_;
-        ++current8_;
-      }
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_ &&
-          current9_ == typed_other->current9_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_),
-        begin9_(other.begin9_),
-        end9_(other.end9_),
-        current9_(other.current9_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_,
-            *current9_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_ ||
-          current9_ == end9_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    const typename ParamGenerator<T9>::iterator begin9_;
-    const typename ParamGenerator<T9>::iterator end9_;
-    typename ParamGenerator<T9>::iterator current9_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator9::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator9& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-  const ParamGenerator<T9> g9_;
-};  // class CartesianProductGenerator9
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-class CartesianProductGenerator10
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8, T9, T10> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
-
-  CartesianProductGenerator10(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
-      const ParamGenerator<T10>& g10)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9), g10_(g10) {}
-  virtual ~CartesianProductGenerator10() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end(), g9_, g9_.end(), g10_, g10_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8,
-      const ParamGenerator<T9>& g9,
-      const typename ParamGenerator<T9>::iterator& current9,
-      const ParamGenerator<T10>& g10,
-      const typename ParamGenerator<T10>::iterator& current10)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
-          begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
-          begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current10_;
-      if (current10_ == end10_) {
-        current10_ = begin10_;
-        ++current9_;
-      }
-      if (current9_ == end9_) {
-        current9_ = begin9_;
-        ++current8_;
-      }
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&other);
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_ &&
-          current9_ == typed_other->current9_ &&
-          current10_ == typed_other->current10_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_),
-        begin9_(other.begin9_),
-        end9_(other.end9_),
-        current9_(other.current9_),
-        begin10_(other.begin10_),
-        end10_(other.end10_),
-        current10_(other.current10_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_,
-            *current9_, *current10_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_ ||
-          current9_ == end9_ ||
-          current10_ == end10_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    const typename ParamGenerator<T9>::iterator begin9_;
-    const typename ParamGenerator<T9>::iterator end9_;
-    typename ParamGenerator<T9>::iterator current9_;
-    const typename ParamGenerator<T10>::iterator begin10_;
-    const typename ParamGenerator<T10>::iterator end10_;
-    typename ParamGenerator<T10>::iterator current10_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator10::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator10& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-  const ParamGenerator<T9> g9_;
-  const ParamGenerator<T10> g10_;
-};  // class CartesianProductGenerator10
-
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Helper classes providing Combine() with polymorphic features. They allow
-// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
-// convertible to U.
-//
-template <class Generator1, class Generator2>
-class CartesianProductHolder2 {
- public:
-CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
-      : g1_(g1), g2_(g2) {}
-  template <typename T1, typename T2>
-  operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2> >(
-        new CartesianProductGenerator2<T1, T2>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder2& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-};  // class CartesianProductHolder2
-
-template <class Generator1, class Generator2, class Generator3>
-class CartesianProductHolder3 {
- public:
-CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3)
-      : g1_(g1), g2_(g2), g3_(g3) {}
-  template <typename T1, typename T2, typename T3>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
-        new CartesianProductGenerator3<T1, T2, T3>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder3& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-};  // class CartesianProductHolder3
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4>
-class CartesianProductHolder4 {
- public:
-CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
-  template <typename T1, typename T2, typename T3, typename T4>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
-        new CartesianProductGenerator4<T1, T2, T3, T4>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder4& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-};  // class CartesianProductHolder4
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5>
-class CartesianProductHolder5 {
- public:
-CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
-        new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder5& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-};  // class CartesianProductHolder5
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6>
-class CartesianProductHolder6 {
- public:
-CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
-        new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder6& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-};  // class CartesianProductHolder6
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7>
-class CartesianProductHolder7 {
- public:
-CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-      T7> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
-        new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder7& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-};  // class CartesianProductHolder7
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8>
-class CartesianProductHolder8 {
- public:
-CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
-          g8_(g8) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
-      T8> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
-        new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder8& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-};  // class CartesianProductHolder8
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8, class Generator9>
-class CartesianProductHolder9 {
- public:
-CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8,
-    const Generator9& g9)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8, typename T9>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
-      T9> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
-        T9> >(
-        new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_),
-        static_cast<ParamGenerator<T9> >(g9_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder9& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-  const Generator9 g9_;
-};  // class CartesianProductHolder9
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8, class Generator9, class Generator10>
-class CartesianProductHolder10 {
- public:
-CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8,
-    const Generator9& g9, const Generator10& g10)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9), g10_(g10) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8, typename T9, typename T10>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-      T10> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-        T10> >(
-        new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-            T10>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_),
-        static_cast<ParamGenerator<T9> >(g9_),
-        static_cast<ParamGenerator<T10> >(g10_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder10& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-  const Generator9 g9_;
-  const Generator10 g10_;
-};  // class CartesianProductHolder10
-
-# endif  // GTEST_HAS_COMBINE
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  //  GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Functions producing parameter generators.
-//
-// Google Test uses these generators to produce parameters for value-
-// parameterized tests. When a parameterized test case is instantiated
-// with a particular generator, Google Test creates and runs tests
-// for each element in the sequence produced by the generator.
-//
-// In the following sample, tests from test case FooTest are instantiated
-// each three times with parameter values 3, 5, and 8:
-//
-// class FooTest : public TestWithParam<int> { ... };
-//
-// TEST_P(FooTest, TestThis) {
-// }
-// TEST_P(FooTest, TestThat) {
-// }
-// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
-//
-
-// Range() returns generators providing sequences of values in a range.
-//
-// Synopsis:
-// Range(start, end)
-//   - returns a generator producing a sequence of values {start, start+1,
-//     start+2, ..., }.
-// Range(start, end, step)
-//   - returns a generator producing a sequence of values {start, start+step,
-//     start+step+step, ..., }.
-// Notes:
-//   * The generated sequences never include end. For example, Range(1, 5)
-//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
-//     returns a generator producing {1, 3, 5, 7}.
-//   * start and end must have the same type. That type may be any integral or
-//     floating-point type or a user defined type satisfying these conditions:
-//     * It must be assignable (have operator=() defined).
-//     * It must have operator+() (operator+(int-compatible type) for
-//       two-operand version).
-//     * It must have operator<() defined.
-//     Elements in the resulting sequences will also have that type.
-//   * Condition start < end must be satisfied in order for resulting sequences
-//     to contain any elements.
-//
-template <typename T, typename IncrementT>
-internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
-  return internal::ParamGenerator<T>(
-      new internal::RangeGenerator<T, IncrementT>(start, end, step));
-}
-
-template <typename T>
-internal::ParamGenerator<T> Range(T start, T end) {
-  return Range(start, end, 1);
-}
-
-// ValuesIn() function allows generation of tests with parameters coming from
-// a container.
-//
-// Synopsis:
-// ValuesIn(const T (&array)[N])
-//   - returns a generator producing sequences with elements from
-//     a C-style array.
-// ValuesIn(const Container& container)
-//   - returns a generator producing sequences with elements from
-//     an STL-style container.
-// ValuesIn(Iterator begin, Iterator end)
-//   - returns a generator producing sequences with elements from
-//     a range [begin, end) defined by a pair of STL-style iterators. These
-//     iterators can also be plain C pointers.
-//
-// Please note that ValuesIn copies the values from the containers
-// passed in and keeps them to generate tests in RUN_ALL_TESTS().
-//
-// Examples:
-//
-// This instantiates tests from test case StringTest
-// each with C-string values of "foo", "bar", and "baz":
-//
-// const char* strings[] = {"foo", "bar", "baz"};
-// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
-//
-// This instantiates tests from test case StlStringTest
-// each with STL strings with values "a" and "b":
-//
-// ::std::vector< ::std::string> GetParameterStrings() {
-//   ::std::vector< ::std::string> v;
-//   v.push_back("a");
-//   v.push_back("b");
-//   return v;
-// }
-//
-// INSTANTIATE_TEST_CASE_P(CharSequence,
-//                         StlStringTest,
-//                         ValuesIn(GetParameterStrings()));
-//
-//
-// This will also instantiate tests from CharTest
-// each with parameter values 'a' and 'b':
-//
-// ::std::list<char> GetParameterChars() {
-//   ::std::list<char> list;
-//   list.push_back('a');
-//   list.push_back('b');
-//   return list;
-// }
-// ::std::list<char> l = GetParameterChars();
-// INSTANTIATE_TEST_CASE_P(CharSequence2,
-//                         CharTest,
-//                         ValuesIn(l.begin(), l.end()));
-//
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end) {
-  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
-      ::value_type ParamType;
-  return internal::ParamGenerator<ParamType>(
-      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
-}
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
-  return ValuesIn(array, array + N);
-}
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container) {
-  return ValuesIn(container.begin(), container.end());
-}
-
-// Values() allows generating tests from explicitly specified list of
-// parameters.
-//
-// Synopsis:
-// Values(T v1, T v2, ..., T vN)
-//   - returns a generator producing sequences with elements v1, v2, ..., vN.
-//
-// For example, this instantiates tests from test case BarTest each
-// with values "one", "two", and "three":
-//
-// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
-//
-// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
-// The exact type of values will depend on the type of parameter in BazTest.
-//
-// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
-//
-// Currently, Values() supports from 1 to 50 parameters.
-//
-template <typename T1>
-internal::ValueArray1<T1> Values(T1 v1) {
-  return internal::ValueArray1<T1>(v1);
-}
-
-template <typename T1, typename T2>
-internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
-  return internal::ValueArray2<T1, T2>(v1, v2);
-}
-
-template <typename T1, typename T2, typename T3>
-internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
-  return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
-  return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5) {
-  return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6) {
-  return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7) {
-  return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
-      v6, v7);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
-  return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
-      v5, v6, v7, v8);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
-  return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
-  return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
-    T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11) {
-  return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
-      T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-    T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12) {
-  return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-    T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13) {
-  return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
-  return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
-  return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16) {
-  return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17) {
-  return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18) {
-  return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
-  return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
-  return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
-  return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22) {
-  return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23) {
-  return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24) {
-  return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
-      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
-      v19, v20, v21, v22, v23, v24);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
-    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
-    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
-  return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
-      v18, v19, v20, v21, v22, v23, v24, v25);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-    T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26) {
-  return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-    T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27) {
-  return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
-      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-    T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28) {
-  return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
-      v28);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29) {
-  return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
-      v27, v28, v29);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
-  return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
-      v26, v27, v28, v29, v30);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
-  return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
-      v25, v26, v27, v28, v29, v30, v31);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32) {
-  return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33) {
-  return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
-    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
-    T31 v31, T32 v32, T33 v33, T34 v34) {
-  return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
-      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
-  return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
-      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
-  return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37) {
-  return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36, v37);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37, T38 v38) {
-  return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
-      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
-      v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
-      v33, v34, v35, v36, v37, v38);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37, T38 v38, T39 v39) {
-  return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
-      v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-      v32, v33, v34, v35, v36, v37, v38, v39);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
-    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
-    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
-    T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
-    T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
-  return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
-      v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-    T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
-  return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
-      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
-      v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-    T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42) {
-  return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
-      v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
-      v42);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-    T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42, T43 v43) {
-  return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
-      v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
-      v41, v42, v43);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42, T43 v43, T44 v44) {
-  return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
-      v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
-      v40, v41, v42, v43, v44);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
-    T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
-    T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
-  return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
-      v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
-      v39, v40, v41, v42, v43, v44, v45);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
-  return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
-      v38, v39, v40, v41, v42, v43, v44, v45, v46);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
-  return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
-      v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
-    T48 v48) {
-  return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
-      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
-      v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
-    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
-    T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
-    T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
-    T47 v47, T48 v48, T49 v49) {
-  return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
-      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
-      v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
-    T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
-    T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
-  return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-      v48, v49, v50);
-}
-
-// Bool() allows generating tests with parameters in a set of (false, true).
-//
-// Synopsis:
-// Bool()
-//   - returns a generator producing sequences with elements {false, true}.
-//
-// It is useful when testing code that depends on Boolean flags. Combinations
-// of multiple flags can be tested when several Bool()'s are combined using
-// Combine() function.
-//
-// In the following example all tests in the test case FlagDependentTest
-// will be instantiated twice with parameters false and true.
-//
-// class FlagDependentTest : public testing::TestWithParam<bool> {
-//   virtual void SetUp() {
-//     external_flag = GetParam();
-//   }
-// }
-// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
-//
-inline internal::ParamGenerator<bool> Bool() {
-  return Values(false, true);
-}
-
-# if GTEST_HAS_COMBINE
-// Combine() allows the user to combine two or more sequences to produce
-// values of a Cartesian product of those sequences' elements.
-//
-// Synopsis:
-// Combine(gen1, gen2, ..., genN)
-//   - returns a generator producing sequences with elements coming from
-//     the Cartesian product of elements from the sequences generated by
-//     gen1, gen2, ..., genN. The sequence elements will have a type of
-//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
-//     of elements from sequences produces by gen1, gen2, ..., genN.
-//
-// Combine can have up to 10 arguments. This number is currently limited
-// by the maximum number of elements in the tuple implementation used by Google
-// Test.
-//
-// Example:
-//
-// This will instantiate tests in test case AnimalTest each one with
-// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
-// tuple("dog", BLACK), and tuple("dog", WHITE):
-//
-// enum Color { BLACK, GRAY, WHITE };
-// class AnimalTest
-//     : public testing::TestWithParam<tuple<const char*, Color> > {...};
-//
-// TEST_P(AnimalTest, AnimalLooksNice) {...}
-//
-// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
-//                         Combine(Values("cat", "dog"),
-//                                 Values(BLACK, WHITE)));
-//
-// This will instantiate tests in FlagDependentTest with all variations of two
-// Boolean flags:
-//
-// class FlagDependentTest
-//     : public testing::TestWithParam<tuple<bool, bool> > {
-//   virtual void SetUp() {
-//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
-//     tie(external_flag_1, external_flag_2) = GetParam();
-//   }
-// };
-//
-// TEST_P(FlagDependentTest, TestFeature1) {
-//   // Test your code using external_flag_1 and external_flag_2 here.
-// }
-// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
-//                         Combine(Bool(), Bool()));
-//
-template <typename Generator1, typename Generator2>
-internal::CartesianProductHolder2<Generator1, Generator2> Combine(
-    const Generator1& g1, const Generator2& g2) {
-  return internal::CartesianProductHolder2<Generator1, Generator2>(
-      g1, g2);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3>
-internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3) {
-  return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
-      g1, g2, g3);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4>
-internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
-    Generator4> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4) {
-  return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
-      Generator4>(
-      g1, g2, g3, g4);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5>
-internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
-    Generator4, Generator5> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5) {
-  return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
-      Generator4, Generator5>(
-      g1, g2, g3, g4, g5);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6>
-internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6) {
-  return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6>(
-      g1, g2, g3, g4, g5, g6);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7>
-internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7) {
-  return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7>(
-      g1, g2, g3, g4, g5, g6, g7);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8>
-internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8) {
-  return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8>(
-      g1, g2, g3, g4, g5, g6, g7, g8);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8, typename Generator9>
-internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8,
-    Generator9> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8, const Generator9& g9) {
-  return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
-      g1, g2, g3, g4, g5, g6, g7, g8, g9);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8, typename Generator9,
-    typename Generator10>
-internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
-    Generator10> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8, const Generator9& g9,
-        const Generator10& g10) {
-  return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
-      Generator10>(
-      g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
-}
-# endif  // GTEST_HAS_COMBINE
-
-
-
-# define TEST_P(test_case_name, test_name) \
-  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
-      : public test_case_name { \
-   public: \
-    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
-    virtual void TestBody(); \
-   private: \
-    static int AddToRegistry() { \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestPattern(\
-                      #test_case_name, \
-                      #test_name, \
-                      new ::testing::internal::TestMetaFactory< \
-                          GTEST_TEST_CLASS_NAME_(\
-                              test_case_name, test_name)>()); \
-      return 0; \
-    } \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
-        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
-  }; \
-  int GTEST_TEST_CLASS_NAME_(test_case_name, \
-                             test_name)::gtest_registering_dummy_ = \
-      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
-  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
-
-// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
-// to specify a function or functor that generates custom test name suffixes
-// based on the test parameters. The function should accept one argument of
-// type testing::TestParamInfo<class ParamType>, and return std::string.
-//
-// testing::PrintToStringParamName is a builtin test suffix generator that
-// returns the value of testing::PrintToString(GetParam()). It does not work
-// for std::string or C strings.
-//
-// Note: test names must be non-empty, unique, and may only contain ASCII
-// alphanumeric characters or underscore.
-
-# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
-  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
-      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
-  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
-      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
-    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
-        (__VA_ARGS__)(info); \
-  } \
-  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
-                      #prefix, \
-                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
-                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
-                      __FILE__, __LINE__)
-
-}  // namespace testing
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-// Copyright 2006, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Google C++ Testing Framework definitions useful in production code.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-
-// When you need to test the private or protected members of a class,
-// use the FRIEND_TEST macro to declare your tests as friends of the
-// class.  For example:
-//
-// class MyClass {
-//  private:
-//   void MyMethod();
-//   FRIEND_TEST(MyClassTest, MyMethod);
-// };
-//
-// class MyClassTest : public testing::Test {
-//   // ...
-// };
-//
-// TEST_F(MyClassTest, MyMethod) {
-//   // Can call MyClass::MyMethod() here.
-// }
-
-#define FRIEND_TEST(test_case_name, test_name)\
-friend class test_case_name##_##test_name##_Test
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-
-#include <iosfwd>
-#include <vector>
-
-namespace testing {
-
-// A copyable object representing the result of a test part (i.e. an
-// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
-//
-// Don't inherit from TestPartResult as its destructor is not virtual.
-class GTEST_API_ TestPartResult {
- public:
-  // The possible outcomes of a test part (i.e. an assertion or an
-  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
-  enum Type {
-    kSuccess,          // Succeeded.
-    kNonFatalFailure,  // Failed but the test can continue.
-    kFatalFailure      // Failed and the test should be terminated.
-  };
-
-  // C'tor.  TestPartResult does NOT have a default constructor.
-  // Always use this constructor (with parameters) to create a
-  // TestPartResult object.
-  TestPartResult(Type a_type,
-                 const char* a_file_name,
-                 int a_line_number,
-                 const char* a_message)
-      : type_(a_type),
-        file_name_(a_file_name == NULL ? "" : a_file_name),
-        line_number_(a_line_number),
-        summary_(ExtractSummary(a_message)),
-        message_(a_message) {
-  }
-
-  // Gets the outcome of the test part.
-  Type type() const { return type_; }
-
-  // Gets the name of the source file where the test part took place, or
-  // NULL if it's unknown.
-  const char* file_name() const {
-    return file_name_.empty() ? NULL : file_name_.c_str();
-  }
-
-  // Gets the line in the source file where the test part took place,
-  // or -1 if it's unknown.
-  int line_number() const { return line_number_; }
-
-  // Gets the summary of the failure message.
-  const char* summary() const { return summary_.c_str(); }
-
-  // Gets the message associated with the test part.
-  const char* message() const { return message_.c_str(); }
-
-  // Returns true iff the test part passed.
-  bool passed() const { return type_ == kSuccess; }
-
-  // Returns true iff the test part failed.
-  bool failed() const { return type_ != kSuccess; }
-
-  // Returns true iff the test part non-fatally failed.
-  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
-
-  // Returns true iff the test part fatally failed.
-  bool fatally_failed() const { return type_ == kFatalFailure; }
-
- private:
-  Type type_;
-
-  // Gets the summary of the failure message by omitting the stack
-  // trace in it.
-  static std::string ExtractSummary(const char* message);
-
-  // The name of the source file where the test part took place, or
-  // "" if the source file is unknown.
-  std::string file_name_;
-  // The line in the source file where the test part took place, or -1
-  // if the line number is unknown.
-  int line_number_;
-  std::string summary_;  // The test failure summary.
-  std::string message_;  // The test failure message.
-};
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
-
-// An array of TestPartResult objects.
-//
-// Don't inherit from TestPartResultArray as its destructor is not
-// virtual.
-class GTEST_API_ TestPartResultArray {
- public:
-  TestPartResultArray() {}
-
-  // Appends the given TestPartResult to the array.
-  void Append(const TestPartResult& result);
-
-  // Returns the TestPartResult at the given index (0-based).
-  const TestPartResult& GetTestPartResult(int index) const;
-
-  // Returns the number of TestPartResult objects in the array.
-  int size() const;
-
- private:
-  std::vector<TestPartResult> array_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
-};
-
-// This interface knows how to report a test part result.
-class TestPartResultReporterInterface {
- public:
-  virtual ~TestPartResultReporterInterface() {}
-
-  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
-};
-
-namespace internal {
-
-// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
-// statement generates new fatal failures. To do so it registers itself as the
-// current test part result reporter. Besides checking if fatal failures were
-// reported, it only delegates the reporting to the former result reporter.
-// The original result reporter is restored in the destructor.
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-class GTEST_API_ HasNewFatalFailureHelper
-    : public TestPartResultReporterInterface {
- public:
-  HasNewFatalFailureHelper();
-  virtual ~HasNewFatalFailureHelper();
-  virtual void ReportTestPartResult(const TestPartResult& result);
-  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
- private:
-  bool has_new_fatal_failure_;
-  TestPartResultReporterInterface* original_reporter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-// Copyright 2008 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-
-// This header implements typed tests and type-parameterized tests.
-
-// Typed (aka type-driven) tests repeat the same test for types in a
-// list.  You must know which types you want to test with when writing
-// typed tests. Here's how you do it:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-
-// Next, associate a list of types with the test case, which will be
-// repeated for each type in the list.  The typedef is necessary for
-// the macro to parse correctly.
-typedef testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_CASE(FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   TYPED_TEST_CASE(FooTest, int);
-
-// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
-// tests for this test case as you want.
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  // Since we are inside a derived class template, C++ requires use to
-  // visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the TestFixture::
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the "typename
-  // TestFixture::" prefix.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-
-#endif  // 0
-
-// Type-parameterized tests are abstract test patterns parameterized
-// by a type.  Compared with typed tests, type-parameterized tests
-// allow you to define the test pattern without knowing what the type
-// parameters are.  The defined pattern can be instantiated with
-// different types any number of times, in any number of translation
-// units.
-//
-// If you are designing an interface or concept, you can define a
-// suite of type-parameterized tests to verify properties that any
-// valid implementation of the interface/concept should have.  Then,
-// each implementation can easily instantiate the test suite to verify
-// that it conforms to the requirements, without having to write
-// similar tests repeatedly.  Here's an example:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
-  ...
-};
-
-// Next, declare that you will define a type-parameterized test case
-// (the _P suffix is for "parameterized" or "pattern", whichever you
-// prefer):
-TYPED_TEST_CASE_P(FooTest);
-
-// Then, use TYPED_TEST_P() to define as many type-parameterized tests
-// for this type-parameterized test case as you want.
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-
-// Now the tricky part: you need to register all test patterns before
-// you can instantiate them.  The first argument of the macro is the
-// test case name; the rest are the names of the tests in this test
-// case.
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-
-// Finally, you are free to instantiate the pattern with the types you
-// want.  If you put the above code in a header file, you can #include
-// it in multiple C++ source files and instantiate it multiple times.
-//
-// To distinguish different instances of the pattern, the first
-// argument to the INSTANTIATE_* macro is a prefix that will be added
-// to the actual test case name.  Remember to pick unique prefixes for
-// different instances.
-typedef testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-
-#endif  // 0
-
-
-// Implements typed tests.
-
-#if GTEST_HAS_TYPED_TEST
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the name of the typedef for the type parameters of the
-// given test case.
-# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-# define TYPED_TEST_CASE(CaseName, Types) \
-  typedef ::testing::internal::TypeList< Types >::type \
-      GTEST_TYPE_PARAMS_(CaseName)
-
-# define TYPED_TEST(CaseName, TestName) \
-  template <typename gtest_TypeParam_> \
-  class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
-      : public CaseName<gtest_TypeParam_> { \
-   private: \
-    typedef CaseName<gtest_TypeParam_> TestFixture; \
-    typedef gtest_TypeParam_ TypeParam; \
-    virtual void TestBody(); \
-  }; \
-  bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::internal::TypeParameterizedTest< \
-          CaseName, \
-          ::testing::internal::TemplateSel< \
-              GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
-          GTEST_TYPE_PARAMS_(CaseName)>::Register(\
-              "", ::testing::internal::CodeLocation(__FILE__, __LINE__), \
-              #CaseName, #TestName, 0); \
-  template <typename gtest_TypeParam_> \
-  void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Implements type-parameterized tests.
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the namespace name that the type-parameterized tests for
-// the given type-parameterized test case are defined in.  The exact
-// name of the namespace is subject to change without notice.
-# define GTEST_CASE_NAMESPACE_(TestCaseName) \
-  gtest_case_##TestCaseName##_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the name of the variable used to remember the names of
-// the defined tests in the given test case.
-# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
-  gtest_typed_test_case_p_state_##TestCaseName##_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
-//
-// Expands to the name of the variable used to remember the names of
-// the registered tests in the given test case.
-# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
-  gtest_registered_test_names_##TestCaseName##_
-
-// The variables defined in the type-parameterized test macros are
-// static as typically these macros are used in a .h file that can be
-// #included in multiple translation units linked together.
-# define TYPED_TEST_CASE_P(CaseName) \
-  static ::testing::internal::TypedTestCasePState \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
-
-# define TYPED_TEST_P(CaseName, TestName) \
-  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
-  template <typename gtest_TypeParam_> \
-  class TestName : public CaseName<gtest_TypeParam_> { \
-   private: \
-    typedef CaseName<gtest_TypeParam_> TestFixture; \
-    typedef gtest_TypeParam_ TypeParam; \
-    virtual void TestBody(); \
-  }; \
-  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
-          __FILE__, __LINE__, #CaseName, #TestName); \
-  } \
-  template <typename gtest_TypeParam_> \
-  void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
-
-# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
-  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
-  typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
-  } \
-  static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
-          __FILE__, __LINE__, #__VA_ARGS__)
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
-  bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::internal::TypeParameterizedTestCase<CaseName, \
-          GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
-          ::testing::internal::TypeList< Types >::type>::Register(\
-              #Prefix, \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__), \
-              &GTEST_TYPED_TEST_CASE_P_STATE_(CaseName), \
-              #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-
-// Depending on the platform, different string classes are available.
-// On Linux, in addition to ::std::string, Google also makes use of
-// class ::string, which has the same interface as ::std::string, but
-// has a different implementation.
-//
-// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
-// ::string is available AND is a distinct type to ::std::string, or
-// define it to 0 to indicate otherwise.
-//
-// If ::std::string and ::string are the same class on your platform
-// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
-//
-// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
-// heuristically.
-
-namespace testing {
-
-// Declares the flags.
-
-// This flag temporary enables the disabled tests.
-GTEST_DECLARE_bool_(also_run_disabled_tests);
-
-// This flag brings the debugger on an assertion failure.
-GTEST_DECLARE_bool_(break_on_failure);
-
-// This flag controls whether Google Test catches all test-thrown exceptions
-// and logs them as failures.
-GTEST_DECLARE_bool_(catch_exceptions);
-
-// This flag enables using colors in terminal output. Available values are
-// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
-// to let Google Test decide.
-GTEST_DECLARE_string_(color);
-
-// This flag sets up the filter to select by name using a glob pattern
-// the tests to run. If the filter is not given all tests are executed.
-GTEST_DECLARE_string_(filter);
-
-// This flag causes the Google Test to list tests. None of the tests listed
-// are actually run if the flag is provided.
-GTEST_DECLARE_bool_(list_tests);
-
-// This flag controls whether Google Test emits a detailed XML report to a file
-// in addition to its normal textual output.
-GTEST_DECLARE_string_(output);
-
-// This flags control whether Google Test prints the elapsed time for each
-// test.
-GTEST_DECLARE_bool_(print_time);
-
-// This flag specifies the random number seed.
-GTEST_DECLARE_int32_(random_seed);
-
-// This flag sets how many times the tests are repeated. The default value
-// is 1. If the value is -1 the tests are repeating forever.
-GTEST_DECLARE_int32_(repeat);
-
-// This flag controls whether Google Test includes Google Test internal
-// stack frames in failure stack traces.
-GTEST_DECLARE_bool_(show_internal_stack_frames);
-
-// When this flag is specified, tests' order is randomized on every iteration.
-GTEST_DECLARE_bool_(shuffle);
-
-// This flag specifies the maximum number of stack frames to be
-// printed in a failure message.
-GTEST_DECLARE_int32_(stack_trace_depth);
-
-// When this flag is specified, a failed assertion will throw an
-// exception if exceptions are enabled, or exit the program with a
-// non-zero code otherwise.
-GTEST_DECLARE_bool_(throw_on_failure);
-
-// When this flag is set with a "host:port" string, on supported
-// platforms test results are streamed to the specified port on
-// the specified host machine.
-GTEST_DECLARE_string_(stream_result_to);
-
-// The upper limit for valid stack trace depths.
-const int kMaxStackTraceDepth = 100;
-
-namespace internal {
-
-class AssertHelper;
-class DefaultGlobalTestPartResultReporter;
-class ExecDeathTest;
-class NoExecDeathTest;
-class FinalSuccessChecker;
-class GTestFlagSaver;
-class StreamingListenerTest;
-class TestResultAccessor;
-class TestEventListenersAccessor;
-class TestEventRepeater;
-class UnitTestRecordPropertyTestHelper;
-class WindowsDeathTest;
-class UnitTestImpl* GetUnitTestImpl();
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message);
-
-}  // namespace internal
-
-// The friend relationship of some of these classes is cyclic.
-// If we don't forward declare them the compiler might confuse the classes
-// in friendship clauses with same named classes on the scope.
-class Test;
-class TestCase;
-class TestInfo;
-class UnitTest;
-
-// A class for indicating whether an assertion was successful.  When
-// the assertion wasn't successful, the AssertionResult object
-// remembers a non-empty message that describes how it failed.
-//
-// To create an instance of this class, use one of the factory functions
-// (AssertionSuccess() and AssertionFailure()).
-//
-// This class is useful for two purposes:
-//   1. Defining predicate functions to be used with Boolean test assertions
-//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
-//   2. Defining predicate-format functions to be
-//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
-//
-// For example, if you define IsEven predicate:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
-// will print the message
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false (5 is odd)
-//   Expected: true
-//
-// instead of a more opaque
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false
-//   Expected: true
-//
-// in case IsEven is a simple Boolean predicate.
-//
-// If you expect your predicate to be reused and want to support informative
-// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
-// about half as often as positive ones in our tests), supply messages for
-// both success and failure cases:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess() << n << " is even";
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
-//
-//   Value of: IsEven(Fib(6))
-//     Actual: true (8 is even)
-//   Expected: false
-//
-// NB: Predicates that support negative Boolean assertions have reduced
-// performance in positive ones so be careful not to use them in tests
-// that have lots (tens of thousands) of positive Boolean assertions.
-//
-// To use this class with EXPECT_PRED_FORMAT assertions such as:
-//
-//   // Verifies that Foo() returns an even number.
-//   EXPECT_PRED_FORMAT1(IsEven, Foo());
-//
-// you need to define:
-//
-//   testing::AssertionResult IsEven(const char* expr, int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure()
-//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
-//   }
-//
-// If Foo() returns 5, you will see the following message:
-//
-//   Expected: Foo() is even
-//     Actual: it's 5
-//
-class GTEST_API_ AssertionResult {
- public:
-  // Copy constructor.
-  // Used in EXPECT_TRUE/FALSE(assertion_result).
-  AssertionResult(const AssertionResult& other);
-
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
-
-  // Used in the EXPECT_TRUE/FALSE(bool_expression).
-  //
-  // T must be contextually convertible to bool.
-  //
-  // The second parameter prevents this overload from being considered if
-  // the argument is implicitly convertible to AssertionResult. In that case
-  // we want AssertionResult's copy constructor to be used.
-  template <typename T>
-  explicit AssertionResult(
-      const T& success,
-      typename internal::EnableIf<
-          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
-          /*enabler*/ = NULL)
-      : success_(success) {}
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  // Assignment operator.
-  AssertionResult& operator=(AssertionResult other) {
-    swap(other);
-    return *this;
-  }
-
-  // Returns true iff the assertion succeeded.
-  operator bool() const { return success_; }  // NOLINT
-
-  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-  AssertionResult operator!() const;
-
-  // Returns the text streamed into this AssertionResult. Test assertions
-  // use it when they fail (i.e., the predicate's outcome doesn't match the
-  // assertion's expectation). When nothing has been streamed into the
-  // object, returns an empty string.
-  const char* message() const {
-    return message_.get() != NULL ?  message_->c_str() : "";
-  }
-  // TODO(vladl@google.com): Remove this after making sure no clients use it.
-  // Deprecated; please use message() instead.
-  const char* failure_message() const { return message(); }
-
-  // Streams a custom failure message into this object.
-  template <typename T> AssertionResult& operator<<(const T& value) {
-    AppendMessage(Message() << value);
-    return *this;
-  }
-
-  // Allows streaming basic output manipulators such as endl or flush into
-  // this object.
-  AssertionResult& operator<<(
-      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
-    AppendMessage(Message() << basic_manipulator);
-    return *this;
-  }
-
- private:
-  // Appends the contents of message to message_.
-  void AppendMessage(const Message& a_message) {
-    if (message_.get() == NULL)
-      message_.reset(new ::std::string);
-    message_->append(a_message.GetString().c_str());
-  }
-
-  // Swap the contents of this AssertionResult with other.
-  void swap(AssertionResult& other);
-
-  // Stores result of the assertion predicate.
-  bool success_;
-  // Stores the message describing the condition in case the expectation
-  // construct is not satisfied with the predicate's outcome.
-  // Referenced via a pointer to avoid taking too much stack frame space
-  // with test assertions.
-  internal::scoped_ptr< ::std::string> message_;
-};
-
-// Makes a successful assertion result.
-GTEST_API_ AssertionResult AssertionSuccess();
-
-// Makes a failed assertion result.
-GTEST_API_ AssertionResult AssertionFailure();
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << msg.
-GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
-
-// The abstract class that all tests inherit from.
-//
-// In Google Test, a unit test program contains one or many TestCases, and
-// each TestCase contains one or many Tests.
-//
-// When you define a test using the TEST macro, you don't need to
-// explicitly derive from Test - the TEST macro automatically does
-// this for you.
-//
-// The only time you derive from Test is when defining a test fixture
-// to be used a TEST_F.  For example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     void SetUp() override { ... }
-//     void TearDown() override { ... }
-//     ...
-//   };
-//
-//   TEST_F(FooTest, Bar) { ... }
-//   TEST_F(FooTest, Baz) { ... }
-//
-// Test is not copyable.
-class GTEST_API_ Test {
- public:
-  friend class TestInfo;
-
-  // Defines types for pointers to functions that set up and tear down
-  // a test case.
-  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
-  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
-
-  // The d'tor is virtual as we intend to inherit from Test.
-  virtual ~Test();
-
-  // Sets up the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::SetUpTestCase() before running the first
-  // test in test case Foo.  Hence a sub-class can define its own
-  // SetUpTestCase() method to shadow the one defined in the super
-  // class.
-  static void SetUpTestCase() {}
-
-  // Tears down the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::TearDownTestCase() after running the last
-  // test in test case Foo.  Hence a sub-class can define its own
-  // TearDownTestCase() method to shadow the one defined in the super
-  // class.
-  static void TearDownTestCase() {}
-
-  // Returns true iff the current test has a fatal failure.
-  static bool HasFatalFailure();
-
-  // Returns true iff the current test has a non-fatal failure.
-  static bool HasNonfatalFailure();
-
-  // Returns true iff the current test has a (either fatal or
-  // non-fatal) failure.
-  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
-
-  // Logs a property for the current test, test case, or for the entire
-  // invocation of the test program when used outside of the context of a
-  // test case.  Only the last value for a given key is remembered.  These
-  // are public static so they can be called from utility functions that are
-  // not members of the test fixture.  Calls to RecordProperty made during
-  // lifespan of the test (from the moment its constructor starts to the
-  // moment its destructor finishes) will be output in XML as attributes of
-  // the <testcase> element.  Properties recorded from fixture's
-  // SetUpTestCase or TearDownTestCase are logged as attributes of the
-  // corresponding <testsuite> element.  Calls to RecordProperty made in the
-  // global context (before or after invocation of RUN_ALL_TESTS and from
-  // SetUp/TearDown method of Environment objects registered with Google
-  // Test) will be output as attributes of the <testsuites> element.
-  static void RecordProperty(const std::string& key, const std::string& value);
-  static void RecordProperty(const std::string& key, int value);
-
- protected:
-  // Creates a Test object.
-  Test();
-
-  // Sets up the test fixture.
-  virtual void SetUp();
-
-  // Tears down the test fixture.
-  virtual void TearDown();
-
- private:
-  // Returns true iff the current test has the same fixture class as
-  // the first test in the current test case.
-  static bool HasSameFixtureClass();
-
-  // Runs the test after the test fixture has been set up.
-  //
-  // A sub-class must implement this to define the test logic.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
-  // Instead, use the TEST or TEST_F macro.
-  virtual void TestBody() = 0;
-
-  // Sets up, executes, and tears down the test.
-  void Run();
-
-  // Deletes self.  We deliberately pick an unusual name for this
-  // internal method to avoid clashing with names used in user TESTs.
-  void DeleteSelf_() { delete this; }
-
-  const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
-
-  // Often a user misspells SetUp() as Setup() and spends a long time
-  // wondering why it is never called by Google Test.  The declaration of
-  // the following method is solely for catching such an error at
-  // compile time:
-  //
-  //   - The return type is deliberately chosen to be not void, so it
-  //   will be a conflict if void Setup() is declared in the user's
-  //   test fixture.
-  //
-  //   - This method is private, so it will be another compiler error
-  //   if the method is called from the user's test fixture.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION.
-  //
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
-
-  // We disallow copying Tests.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
-};
-
-typedef internal::TimeInMillis TimeInMillis;
-
-// A copyable object representing a user specified test property which can be
-// output as a key/value string pair.
-//
-// Don't inherit from TestProperty as its destructor is not virtual.
-class TestProperty {
- public:
-  // C'tor.  TestProperty does NOT have a default constructor.
-  // Always use this constructor (with parameters) to create a
-  // TestProperty object.
-  TestProperty(const std::string& a_key, const std::string& a_value) :
-    key_(a_key), value_(a_value) {
-  }
-
-  // Gets the user supplied key.
-  const char* key() const {
-    return key_.c_str();
-  }
-
-  // Gets the user supplied value.
-  const char* value() const {
-    return value_.c_str();
-  }
-
-  // Sets a new value, overriding the one supplied in the constructor.
-  void SetValue(const std::string& new_value) {
-    value_ = new_value;
-  }
-
- private:
-  // The key supplied by the user.
-  std::string key_;
-  // The value supplied by the user.
-  std::string value_;
-};
-
-// The result of a single Test.  This includes a list of
-// TestPartResults, a list of TestProperties, a count of how many
-// death tests there are in the Test, and how much time it took to run
-// the Test.
-//
-// TestResult is not copyable.
-class GTEST_API_ TestResult {
- public:
-  // Creates an empty TestResult.
-  TestResult();
-
-  // D'tor.  Do not inherit from TestResult.
-  ~TestResult();
-
-  // Gets the number of all test parts.  This is the sum of the number
-  // of successful test parts and the number of failed test parts.
-  int total_part_count() const;
-
-  // Returns the number of the test properties.
-  int test_property_count() const;
-
-  // Returns true iff the test passed (i.e. no test part failed).
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the test failed.
-  bool Failed() const;
-
-  // Returns true iff the test fatally failed.
-  bool HasFatalFailure() const;
-
-  // Returns true iff the test has a non-fatal failure.
-  bool HasNonfatalFailure() const;
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test part result among all the results. i can range
-  // from 0 to test_property_count() - 1. If i is not in that range, aborts
-  // the program.
-  const TestPartResult& GetTestPartResult(int i) const;
-
-  // Returns the i-th test property. i can range from 0 to
-  // test_property_count() - 1. If i is not in that range, aborts the
-  // program.
-  const TestProperty& GetTestProperty(int i) const;
-
- private:
-  friend class TestInfo;
-  friend class TestCase;
-  friend class UnitTest;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::ExecDeathTest;
-  friend class internal::TestResultAccessor;
-  friend class internal::UnitTestImpl;
-  friend class internal::WindowsDeathTest;
-
-  // Gets the vector of TestPartResults.
-  const std::vector<TestPartResult>& test_part_results() const {
-    return test_part_results_;
-  }
-
-  // Gets the vector of TestProperties.
-  const std::vector<TestProperty>& test_properties() const {
-    return test_properties_;
-  }
-
-  // Sets the elapsed time.
-  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
-
-  // Adds a test property to the list. The property is validated and may add
-  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
-  // key names). If a property is already recorded for the same key, the
-  // value will be updated, rather than storing multiple values for the same
-  // key.  xml_element specifies the element for which the property is being
-  // recorded and is used for validation.
-  void RecordProperty(const std::string& xml_element,
-                      const TestProperty& test_property);
-
-  // Adds a failure if the key is a reserved attribute of Google Test
-  // testcase tags.  Returns true if the property is valid.
-  // TODO(russr): Validate attribute names are legal and human readable.
-  static bool ValidateTestProperty(const std::string& xml_element,
-                                   const TestProperty& test_property);
-
-  // Adds a test part result to the list.
-  void AddTestPartResult(const TestPartResult& test_part_result);
-
-  // Returns the death test count.
-  int death_test_count() const { return death_test_count_; }
-
-  // Increments the death test count, returning the new count.
-  int increment_death_test_count() { return ++death_test_count_; }
-
-  // Clears the test part results.
-  void ClearTestPartResults();
-
-  // Clears the object.
-  void Clear();
-
-  // Protects mutable state of the property vector and of owned
-  // properties, whose values may be updated.
-  internal::Mutex test_properites_mutex_;
-
-  // The vector of TestPartResults
-  std::vector<TestPartResult> test_part_results_;
-  // The vector of TestProperties
-  std::vector<TestProperty> test_properties_;
-  // Running count of death tests.
-  int death_test_count_;
-  // The elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-  // We disallow copying TestResult.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
-};  // class TestResult
-
-// A TestInfo object stores the following information about a test:
-//
-//   Test case name
-//   Test name
-//   Whether the test should be run
-//   A function pointer that creates the test object when invoked
-//   Test result
-//
-// The constructor of TestInfo registers itself with the UnitTest
-// singleton such that the RUN_ALL_TESTS() macro knows which tests to
-// run.
-class GTEST_API_ TestInfo {
- public:
-  // Destructs a TestInfo object.  This function is not virtual, so
-  // don't inherit from TestInfo.
-  ~TestInfo();
-
-  // Returns the test case name.
-  const char* test_case_name() const { return test_case_name_.c_str(); }
-
-  // Returns the test name.
-  const char* name() const { return name_.c_str(); }
-
-  // Returns the name of the parameter type, or NULL if this is not a typed
-  // or a type-parameterized test.
-  const char* type_param() const {
-    if (type_param_.get() != NULL)
-      return type_param_->c_str();
-    return NULL;
-  }
-
-  // Returns the text representation of the value parameter, or NULL if this
-  // is not a value-parameterized test.
-  const char* value_param() const {
-    if (value_param_.get() != NULL)
-      return value_param_->c_str();
-    return NULL;
-  }
-
-  // Returns the file name where this test is defined.
-  const char* file() const { return location_.file.c_str(); }
-
-  // Returns the line where this test is defined.
-  int line() const { return location_.line; }
-
-  // Returns true if this test should run, that is if the test is not
-  // disabled (or it is disabled but the also_run_disabled_tests flag has
-  // been specified) and its full name matches the user-specified filter.
-  //
-  // Google Test allows the user to filter the tests by their full names.
-  // The full name of a test Bar in test case Foo is defined as
-  // "Foo.Bar".  Only the tests that match the filter will run.
-  //
-  // A filter is a colon-separated list of glob (not regex) patterns,
-  // optionally followed by a '-' and a colon-separated list of
-  // negative patterns (tests to exclude).  A test is run if it
-  // matches one of the positive patterns and does not match any of
-  // the negative patterns.
-  //
-  // For example, *A*:Foo.* is a filter that matches any string that
-  // contains the character 'A' or starts with "Foo.".
-  bool should_run() const { return should_run_; }
-
-  // Returns true iff this test will appear in the XML report.
-  bool is_reportable() const {
-    // For now, the XML report includes all tests matching the filter.
-    // In the future, we may trim tests that are excluded because of
-    // sharding.
-    return matches_filter_;
-  }
-
-  // Returns the result of the test.
-  const TestResult* result() const { return &result_; }
-
- private:
-#if GTEST_HAS_DEATH_TEST
-  friend class internal::DefaultDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-  friend class Test;
-  friend class TestCase;
-  friend class internal::UnitTestImpl;
-  friend class internal::StreamingListenerTest;
-  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      const char* test_case_name,
-      const char* name,
-      const char* type_param,
-      const char* value_param,
-      internal::CodeLocation code_location,
-      internal::TypeId fixture_class_id,
-      Test::SetUpTestCaseFunc set_up_tc,
-      Test::TearDownTestCaseFunc tear_down_tc,
-      internal::TestFactoryBase* factory);
-
-  // Constructs a TestInfo object. The newly constructed instance assumes
-  // ownership of the factory object.
-  TestInfo(const std::string& test_case_name,
-           const std::string& name,
-           const char* a_type_param,   // NULL if not a type-parameterized test
-           const char* a_value_param,  // NULL if not a value-parameterized test
-           internal::CodeLocation a_code_location,
-           internal::TypeId fixture_class_id,
-           internal::TestFactoryBase* factory);
-
-  // Increments the number of death tests encountered in this test so
-  // far.
-  int increment_death_test_count() {
-    return result_.increment_death_test_count();
-  }
-
-  // Creates the test object, runs it, records its result, and then
-  // deletes it.
-  void Run();
-
-  static void ClearTestResult(TestInfo* test_info) {
-    test_info->result_.Clear();
-  }
-
-  // These fields are immutable properties of the test.
-  const std::string test_case_name_;     // Test case name
-  const std::string name_;               // Test name
-  // Name of the parameter type, or NULL if this is not a typed or a
-  // type-parameterized test.
-  const internal::scoped_ptr<const ::std::string> type_param_;
-  // Text representation of the value parameter, or NULL if this is not a
-  // value-parameterized test.
-  const internal::scoped_ptr<const ::std::string> value_param_;
-  internal::CodeLocation location_;
-  const internal::TypeId fixture_class_id_;   // ID of the test fixture class
-  bool should_run_;                 // True iff this test should run
-  bool is_disabled_;                // True iff this test is disabled
-  bool matches_filter_;             // True if this test matches the
-                                    // user-specified filter.
-  internal::TestFactoryBase* const factory_;  // The factory that creates
-                                              // the test object
-
-  // This field is mutable and needs to be reset before running the
-  // test for the second time.
-  TestResult result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
-};
-
-// A test case, which consists of a vector of TestInfos.
-//
-// TestCase is not copyable.
-class GTEST_API_ TestCase {
- public:
-  // Creates a TestCase with the given name.
-  //
-  // TestCase does NOT have a default constructor.  Always use this
-  // constructor to create a TestCase object.
-  //
-  // Arguments:
-  //
-  //   name:         name of the test case
-  //   a_type_param: the name of the test's type parameter, or NULL if
-  //                 this is not a type-parameterized test.
-  //   set_up_tc:    pointer to the function that sets up the test case
-  //   tear_down_tc: pointer to the function that tears down the test case
-  TestCase(const char* name, const char* a_type_param,
-           Test::SetUpTestCaseFunc set_up_tc,
-           Test::TearDownTestCaseFunc tear_down_tc);
-
-  // Destructor of TestCase.
-  virtual ~TestCase();
-
-  // Gets the name of the TestCase.
-  const char* name() const { return name_.c_str(); }
-
-  // Returns the name of the parameter type, or NULL if this is not a
-  // type-parameterized test case.
-  const char* type_param() const {
-    if (type_param_.get() != NULL)
-      return type_param_->c_str();
-    return NULL;
-  }
-
-  // Returns true if any test in this test case should run.
-  bool should_run() const { return should_run_; }
-
-  // Gets the number of successful tests in this test case.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests in this test case.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests in this test case.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Get the number of tests in this test case that should run.
-  int test_to_run_count() const;
-
-  // Gets the number of all tests in this test case.
-  int total_test_count() const;
-
-  // Returns true iff the test case passed.
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the test case failed.
-  bool Failed() const { return failed_test_count() > 0; }
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  const TestInfo* GetTestInfo(int i) const;
-
-  // Returns the TestResult that holds test properties recorded during
-  // execution of SetUpTestCase and TearDownTestCase.
-  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
-
- private:
-  friend class Test;
-  friend class internal::UnitTestImpl;
-
-  // Gets the (mutable) vector of TestInfos in this TestCase.
-  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
-
-  // Gets the (immutable) vector of TestInfos in this TestCase.
-  const std::vector<TestInfo*>& test_info_list() const {
-    return test_info_list_;
-  }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  TestInfo* GetMutableTestInfo(int i);
-
-  // Sets the should_run member.
-  void set_should_run(bool should) { should_run_ = should; }
-
-  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
-  // destruction of the TestCase object.
-  void AddTestInfo(TestInfo * test_info);
-
-  // Clears the results of all tests in this test case.
-  void ClearResult();
-
-  // Clears the results of all tests in the given test case.
-  static void ClearTestCaseResult(TestCase* test_case) {
-    test_case->ClearResult();
-  }
-
-  // Runs every test in this TestCase.
-  void Run();
-
-  // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
-  // for catching exceptions thrown from SetUpTestCase().
-  void RunSetUpTestCase() { (*set_up_tc_)(); }
-
-  // Runs TearDownTestCase() for this TestCase.  This wrapper is
-  // needed for catching exceptions thrown from TearDownTestCase().
-  void RunTearDownTestCase() { (*tear_down_tc_)(); }
-
-  // Returns true iff test passed.
-  static bool TestPassed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Passed();
-  }
-
-  // Returns true iff test failed.
-  static bool TestFailed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Failed();
-  }
-
-  // Returns true iff the test is disabled and will be reported in the XML
-  // report.
-  static bool TestReportableDisabled(const TestInfo* test_info) {
-    return test_info->is_reportable() && test_info->is_disabled_;
-  }
-
-  // Returns true iff test is disabled.
-  static bool TestDisabled(const TestInfo* test_info) {
-    return test_info->is_disabled_;
-  }
-
-  // Returns true iff this test will appear in the XML report.
-  static bool TestReportable(const TestInfo* test_info) {
-    return test_info->is_reportable();
-  }
-
-  // Returns true if the given test should run.
-  static bool ShouldRunTest(const TestInfo* test_info) {
-    return test_info->should_run();
-  }
-
-  // Shuffles the tests in this test case.
-  void ShuffleTests(internal::Random* random);
-
-  // Restores the test order to before the first shuffle.
-  void UnshuffleTests();
-
-  // Name of the test case.
-  std::string name_;
-  // Name of the parameter type, or NULL if this is not a typed or a
-  // type-parameterized test.
-  const internal::scoped_ptr<const ::std::string> type_param_;
-  // The vector of TestInfos in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestInfo*> test_info_list_;
-  // Provides a level of indirection for the test list to allow easy
-  // shuffling and restoring the test order.  The i-th element in this
-  // vector is the index of the i-th test in the shuffled test list.
-  std::vector<int> test_indices_;
-  // Pointer to the function that sets up the test case.
-  Test::SetUpTestCaseFunc set_up_tc_;
-  // Pointer to the function that tears down the test case.
-  Test::TearDownTestCaseFunc tear_down_tc_;
-  // True iff any test in this test case should run.
-  bool should_run_;
-  // Elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-  // Holds test properties recorded during execution of SetUpTestCase and
-  // TearDownTestCase.
-  TestResult ad_hoc_test_result_;
-
-  // We disallow copying TestCases.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
-};
-
-// An Environment object is capable of setting up and tearing down an
-// environment.  You should subclass this to define your own
-// environment(s).
-//
-// An Environment object does the set-up and tear-down in virtual
-// methods SetUp() and TearDown() instead of the constructor and the
-// destructor, as:
-//
-//   1. You cannot safely throw from a destructor.  This is a problem
-//      as in some cases Google Test is used where exceptions are enabled, and
-//      we may want to implement ASSERT_* using exceptions where they are
-//      available.
-//   2. You cannot use ASSERT_* directly in a constructor or
-//      destructor.
-class Environment {
- public:
-  // The d'tor is virtual as we need to subclass Environment.
-  virtual ~Environment() {}
-
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
- private:
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
-};
-
-// The interface for tracing execution of tests. The methods are organized in
-// the order the corresponding events are fired.
-class TestEventListener {
- public:
-  virtual ~TestEventListener() {}
-
-  // Fired before any test activity starts.
-  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
-
-  // Fired before each iteration of tests starts.  There may be more than
-  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
-  // index, starting from 0.
-  virtual void OnTestIterationStart(const UnitTest& unit_test,
-                                    int iteration) = 0;
-
-  // Fired before environment set-up for each iteration of tests starts.
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment set-up for each iteration of tests ends.
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
-
-  // Fired before the test case starts.
-  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
-
-  // Fired before the test starts.
-  virtual void OnTestStart(const TestInfo& test_info) = 0;
-
-  // Fired after a failed assertion or a SUCCEED() invocation.
-  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
-
-  // Fired after the test ends.
-  virtual void OnTestEnd(const TestInfo& test_info) = 0;
-
-  // Fired after the test case ends.
-  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
-
-  // Fired before environment tear-down for each iteration of tests starts.
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment tear-down for each iteration of tests ends.
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
-
-  // Fired after each iteration of tests finishes.
-  virtual void OnTestIterationEnd(const UnitTest& unit_test,
-                                  int iteration) = 0;
-
-  // Fired after all test activities have ended.
-  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
-};
-
-// The convenience class for users who need to override just one or two
-// methods and are not concerned that a possible change to a signature of
-// the methods they override will not be caught during the build.  For
-// comments about each method please see the definition of TestEventListener
-// above.
-class EmptyTestEventListener : public TestEventListener {
- public:
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                                    int /*iteration*/) {}
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
-  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
-  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
-  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                                  int /*iteration*/) {}
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
-};
-
-// TestEventListeners lets users add listeners to track events in Google Test.
-class GTEST_API_ TestEventListeners {
- public:
-  TestEventListeners();
-  ~TestEventListeners();
-
-  // Appends an event listener to the end of the list. Google Test assumes
-  // the ownership of the listener (i.e. it will delete the listener when
-  // the test program finishes).
-  void Append(TestEventListener* listener);
-
-  // Removes the given event listener from the list and returns it.  It then
-  // becomes the caller's responsibility to delete the listener. Returns
-  // NULL if the listener is not found in the list.
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Returns the standard listener responsible for the default console
-  // output.  Can be removed from the listeners list to shut down default
-  // console output.  Note that removing this object from the listener list
-  // with Release transfers its ownership to the caller and makes this
-  // function return NULL the next time.
-  TestEventListener* default_result_printer() const {
-    return default_result_printer_;
-  }
-
-  // Returns the standard listener responsible for the default XML output
-  // controlled by the --gtest_output=xml flag.  Can be removed from the
-  // listeners list by users who want to shut down the default XML output
-  // controlled by this flag and substitute it with custom one.  Note that
-  // removing this object from the listener list with Release transfers its
-  // ownership to the caller and makes this function return NULL the next
-  // time.
-  TestEventListener* default_xml_generator() const {
-    return default_xml_generator_;
-  }
-
- private:
-  friend class TestCase;
-  friend class TestInfo;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::NoExecDeathTest;
-  friend class internal::TestEventListenersAccessor;
-  friend class internal::UnitTestImpl;
-
-  // Returns repeater that broadcasts the TestEventListener events to all
-  // subscribers.
-  TestEventListener* repeater();
-
-  // Sets the default_result_printer attribute to the provided listener.
-  // The listener is also added to the listener list and previous
-  // default_result_printer is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultResultPrinter(TestEventListener* listener);
-
-  // Sets the default_xml_generator attribute to the provided listener.  The
-  // listener is also added to the listener list and previous
-  // default_xml_generator is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultXmlGenerator(TestEventListener* listener);
-
-  // Controls whether events will be forwarded by the repeater to the
-  // listeners in the list.
-  bool EventForwardingEnabled() const;
-  void SuppressEventForwarding();
-
-  // The actual list of listeners.
-  internal::TestEventRepeater* repeater_;
-  // Listener responsible for the standard result output.
-  TestEventListener* default_result_printer_;
-  // Listener responsible for the creation of the XML output file.
-  TestEventListener* default_xml_generator_;
-
-  // We disallow copying TestEventListeners.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
-};
-
-// A UnitTest consists of a vector of TestCases.
-//
-// This is a singleton class.  The only instance of UnitTest is
-// created when UnitTest::GetInstance() is first called.  This
-// instance is never deleted.
-//
-// UnitTest is not copyable.
-//
-// This class is thread-safe as long as the methods are called
-// according to their specification.
-class GTEST_API_ UnitTest {
- public:
-  // Gets the singleton UnitTest object.  The first time this method
-  // is called, a UnitTest object is constructed and returned.
-  // Consecutive calls will return the same object.
-  static UnitTest* GetInstance();
-
-  // Runs all tests in this UnitTest object and prints the result.
-  // Returns 0 if successful, or 1 otherwise.
-  //
-  // This method can only be called from the main thread.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  int Run() GTEST_MUST_USE_RESULT_;
-
-  // Returns the working directory when the first TEST() or TEST_F()
-  // was executed.  The UnitTest object owns the string.
-  const char* original_working_dir() const;
-
-  // Returns the TestCase object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestCase* current_test_case() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Returns the TestInfo object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestInfo* current_test_info() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Returns the random seed used at the start of the current test run.
-  int random_seed() const;
-
-#if GTEST_HAS_PARAM_TEST
-  // Returns the ParameterizedTestCaseRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Gets the number of successful test cases.
-  int successful_test_case_count() const;
-
-  // Gets the number of failed test cases.
-  int failed_test_case_count() const;
-
-  // Gets the number of all test cases.
-  int total_test_case_count() const;
-
-  // Gets the number of all test cases that contain at least one test
-  // that should run.
-  int test_case_to_run_count() const;
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const;
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const;
-
-  // Returns true iff the unit test passed (i.e. all test cases passed).
-  bool Passed() const;
-
-  // Returns true iff the unit test failed (i.e. some test case failed
-  // or something outside of all tests failed).
-  bool Failed() const;
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  const TestCase* GetTestCase(int i) const;
-
-  // Returns the TestResult containing information on test failures and
-  // properties logged outside of individual test cases.
-  const TestResult& ad_hoc_test_result() const;
-
-  // Returns the list of event listeners that can be used to track events
-  // inside Google Test.
-  TestEventListeners& listeners();
-
- private:
-  // Registers and returns a global test environment.  When a test
-  // program is run, all global test environments will be set-up in
-  // the order they were registered.  After all tests in the program
-  // have finished, all global test environments will be torn-down in
-  // the *reverse* order they were registered.
-  //
-  // The UnitTest object takes ownership of the given environment.
-  //
-  // This method can only be called from the main thread.
-  Environment* AddEnvironment(Environment* env);
-
-  // Adds a TestPartResult to the current TestResult object.  All
-  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
-  // eventually call this to report their results.  The user code
-  // should use the assertion macros instead of calling this directly.
-  void AddTestPartResult(TestPartResult::Type result_type,
-                         const char* file_name,
-                         int line_number,
-                         const std::string& message,
-                         const std::string& os_stack_trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Adds a TestProperty to the current TestResult object when invoked from
-  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
-  // from SetUpTestCase or TearDownTestCase, or to the global property set
-  // when invoked elsewhere.  If the result already contains a property with
-  // the same key, the value will be updated.
-  void RecordProperty(const std::string& key, const std::string& value);
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  TestCase* GetMutableTestCase(int i);
-
-  // Accessors for the implementation object.
-  internal::UnitTestImpl* impl() { return impl_; }
-  const internal::UnitTestImpl* impl() const { return impl_; }
-
-  // These classes and funcions are friends as they need to access private
-  // members of UnitTest.
-  friend class Test;
-  friend class internal::AssertHelper;
-  friend class internal::ScopedTrace;
-  friend class internal::StreamingListenerTest;
-  friend class internal::UnitTestRecordPropertyTestHelper;
-  friend Environment* AddGlobalTestEnvironment(Environment* env);
-  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
-  friend void internal::ReportFailureInUnknownLocation(
-      TestPartResult::Type result_type,
-      const std::string& message);
-
-  // Creates an empty UnitTest.
-  UnitTest();
-
-  // D'tor
-  virtual ~UnitTest();
-
-  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-  // Google Test trace stack.
-  void PushGTestTrace(const internal::TraceInfo& trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Pops a trace from the per-thread Google Test trace stack.
-  void PopGTestTrace()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Protects mutable state in *impl_.  This is mutable as some const
-  // methods need to lock it too.
-  mutable internal::Mutex mutex_;
-
-  // Opaque implementation object.  This field is never changed once
-  // the object is constructed.  We don't mark it as const here, as
-  // doing so will cause a warning in the constructor of UnitTest.
-  // Mutable state in *impl_ is protected by mutex_.
-  internal::UnitTestImpl* impl_;
-
-  // We disallow copying UnitTest.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
-};
-
-// A convenient wrapper for adding an environment for the test
-// program.
-//
-// You should call this before RUN_ALL_TESTS() is called, probably in
-// main().  If you use gtest_main, you need to call this before main()
-// starts for it to take effect.  For example, you can define a global
-// variable like this:
-//
-//   testing::Environment* const foo_env =
-//       testing::AddGlobalTestEnvironment(new FooEnvironment);
-//
-// However, we strongly recommend you to write your own main() and
-// call AddGlobalTestEnvironment() there, as relying on initialization
-// of global variables makes the code harder to read and may cause
-// problems when you register multiple environments from different
-// translation units and the environments have dependencies among them
-// (remember that the compiler doesn't guarantee the order in which
-// global variables from different translation units are initialized).
-inline Environment* AddGlobalTestEnvironment(Environment* env) {
-  return UnitTest::GetInstance()->AddEnvironment(env);
-}
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-GTEST_API_ void InitGoogleTest(int* argc, char** argv);
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
-
-namespace internal {
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_* in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQFailure(const char* expected_expression,
-                                   const char* actual_expression,
-                                   const T1& expected, const T2& actual) {
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   FormatForComparisonFailureMessage(expected, actual),
-                   FormatForComparisonFailureMessage(actual, expected),
-                   false);
-}
-
-// The helper function for {ASSERT|EXPECT}_EQ.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQ(const char* expected_expression,
-                            const char* actual_expression,
-                            const T1& expected,
-                            const T2& actual) {
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
-  if (expected == actual) {
-    return AssertionSuccess();
-  }
-GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  return CmpHelperEQFailure(expected_expression, actual_expression, expected,
-                            actual);
-}
-
-// With this overloaded version, we allow anonymous enums to be used
-// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
-// can be implicitly cast to BiggestInt.
-GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
-                                       const char* actual_expression,
-                                       BiggestInt expected,
-                                       BiggestInt actual);
-
-// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
-// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
-// is a null pointer literal.  The following default implementation is
-// for lhs_is_null_literal being false.
-template <bool lhs_is_null_literal>
-class EqHelper {
- public:
-  // This templatized version is for the general case.
-  template <typename T1, typename T2>
-  static AssertionResult Compare(const char* expected_expression,
-                                 const char* actual_expression,
-                                 const T1& expected,
-                                 const T2& actual) {
-    return CmpHelperEQ(expected_expression, actual_expression, expected,
-                       actual);
-  }
-
-  // With this overloaded version, we allow anonymous enums to be used
-  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
-  // enums can be implicitly cast to BiggestInt.
-  //
-  // Even though its body looks the same as the above version, we
-  // cannot merge the two, as it will make anonymous enums unhappy.
-  static AssertionResult Compare(const char* expected_expression,
-                                 const char* actual_expression,
-                                 BiggestInt expected,
-                                 BiggestInt actual) {
-    return CmpHelperEQ(expected_expression, actual_expression, expected,
-                       actual);
-  }
-};
-
-// This specialization is used when the first argument to ASSERT_EQ()
-// is a null pointer literal, like NULL, false, or 0.
-template <>
-class EqHelper<true> {
- public:
-  // We define two overloaded versions of Compare().  The first
-  // version will be picked when the second argument to ASSERT_EQ() is
-  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
-  // EXPECT_EQ(false, a_bool).
-  template <typename T1, typename T2>
-  static AssertionResult Compare(
-      const char* expected_expression,
-      const char* actual_expression,
-      const T1& expected,
-      const T2& actual,
-      // The following line prevents this overload from being considered if T2
-      // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
-      // expands to Compare("", "", NULL, my_ptr), which requires a conversion
-      // to match the Secret* in the other overload, which would otherwise make
-      // this template match better.
-      typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
-    return CmpHelperEQ(expected_expression, actual_expression, expected,
-                       actual);
-  }
-
-  // This version will be picked when the second argument to ASSERT_EQ() is a
-  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
-  template <typename T>
-  static AssertionResult Compare(
-      const char* expected_expression,
-      const char* actual_expression,
-      // We used to have a second template parameter instead of Secret*.  That
-      // template parameter would deduce to 'long', making this a better match
-      // than the first overload even without the first overload's EnableIf.
-      // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
-      // non-pointer argument" (even a deduced integral argument), so the old
-      // implementation caused warnings in user code.
-      Secret* /* expected (NULL) */,
-      T* actual) {
-    // We already know that 'expected' is a null pointer.
-    return CmpHelperEQ(expected_expression, actual_expression,
-                       static_cast<T*>(NULL), actual);
-  }
-};
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_OP in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
-                                   const T1& val1, const T2& val2,
-                                   const char* op) {
-  return AssertionFailure()
-         << "Expected: (" << expr1 << ") " << op << " (" << expr2
-         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
-         << " vs " << FormatForComparisonFailureMessage(val2, val1);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
-// of similar code.
-//
-// For each templatized helper function, we also define an overloaded
-// version for BiggestInt in order to reduce code bloat and allow
-// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
-// with gcc 4.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-template <typename T1, typename T2>\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   const T1& val1, const T2& val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
-  }\
-}\
-GTEST_API_ AssertionResult CmpHelper##op_name(\
-    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// Implements the helper function for {ASSERT|EXPECT}_NE
-GTEST_IMPL_CMP_HELPER_(NE, !=);
-// Implements the helper function for {ASSERT|EXPECT}_LE
-GTEST_IMPL_CMP_HELPER_(LE, <=);
-// Implements the helper function for {ASSERT|EXPECT}_LT
-GTEST_IMPL_CMP_HELPER_(LT, <);
-// Implements the helper function for {ASSERT|EXPECT}_GE
-GTEST_IMPL_CMP_HELPER_(GE, >=);
-// Implements the helper function for {ASSERT|EXPECT}_GT
-GTEST_IMPL_CMP_HELPER_(GT, >);
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
-                                          const char* actual_expression,
-                                          const char* expected,
-                                          const char* actual);
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
-                                              const char* actual_expression,
-                                              const char* expected,
-                                              const char* actual);
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                              const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
-
-// Helper function for *_STREQ on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
-                                          const char* actual_expression,
-                                          const wchar_t* expected,
-                                          const wchar_t* actual);
-
-// Helper function for *_STRNE on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
-
-}  // namespace internal
-
-// IsSubstring() and IsNotSubstring() are intended to be used as the
-// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
-// themselves.  They check whether needle is a substring of haystack
-// (NULL is considered a substring of itself only), and return an
-// appropriate error message when they fail.
-//
-// The {needle,haystack}_expr arguments are the stringified
-// expressions that generated the two real arguments.
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-// Helper template function for comparing floating-points.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename RawType>
-AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
-                                         const char* actual_expression,
-                                         RawType expected,
-                                         RawType actual) {
-  const FloatingPoint<RawType> lhs(expected), rhs(actual);
-
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  ::std::stringstream expected_ss;
-  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-              << expected;
-
-  ::std::stringstream actual_ss;
-  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-            << actual;
-
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   StringStreamToString(&expected_ss),
-                   StringStreamToString(&actual_ss),
-                   false);
-}
-
-// Helper function for implementing ASSERT_NEAR.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
-                                                const char* expr2,
-                                                const char* abs_error_expr,
-                                                double val1,
-                                                double val2,
-                                                double abs_error);
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-// A class that enables one to stream messages to assertion macros
-class GTEST_API_ AssertHelper {
- public:
-  // Constructor.
-  AssertHelper(TestPartResult::Type type,
-               const char* file,
-               int line,
-               const char* message);
-  ~AssertHelper();
-
-  // Message assignment is a semantic trick to enable assertion
-  // streaming; see the GTEST_MESSAGE_ macro below.
-  void operator=(const Message& message) const;
-
- private:
-  // We put our data in a struct so that the size of the AssertHelper class can
-  // be as small as possible.  This is important because gcc is incapable of
-  // re-using stack space even for temporary variables, so every EXPECT_EQ
-  // reserves stack space for another AssertHelper.
-  struct AssertHelperData {
-    AssertHelperData(TestPartResult::Type t,
-                     const char* srcfile,
-                     int line_num,
-                     const char* msg)
-        : type(t), file(srcfile), line(line_num), message(msg) { }
-
-    TestPartResult::Type const type;
-    const char* const file;
-    int const line;
-    std::string const message;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
-  };
-
-  AssertHelperData* const data_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
-};
-
-}  // namespace internal
-
-#if GTEST_HAS_PARAM_TEST
-// The pure interface class that all value-parameterized tests inherit from.
-// A value-parameterized class must inherit from both ::testing::Test and
-// ::testing::WithParamInterface. In most cases that just means inheriting
-// from ::testing::TestWithParam, but more complicated test hierarchies
-// may need to inherit from Test and WithParamInterface at different levels.
-//
-// This interface has support for accessing the test parameter value via
-// the GetParam() method.
-//
-// Use it with one of the parameter generator defining functions, like Range(),
-// Values(), ValuesIn(), Bool(), and Combine().
-//
-// class FooTest : public ::testing::TestWithParam<int> {
-//  protected:
-//   FooTest() {
-//     // Can use GetParam() here.
-//   }
-//   virtual ~FooTest() {
-//     // Can use GetParam() here.
-//   }
-//   virtual void SetUp() {
-//     // Can use GetParam() here.
-//   }
-//   virtual void TearDown {
-//     // Can use GetParam() here.
-//   }
-// };
-// TEST_P(FooTest, DoesBar) {
-//   // Can use GetParam() method here.
-//   Foo foo;
-//   ASSERT_TRUE(foo.DoesBar(GetParam()));
-// }
-// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
-
-template <typename T>
-class WithParamInterface {
- public:
-  typedef T ParamType;
-  virtual ~WithParamInterface() {}
-
-  // The current parameter value. Is also available in the test fixture's
-  // constructor. This member function is non-static, even though it only
-  // references static data, to reduce the opportunity for incorrect uses
-  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
-  // uses a fixture whose parameter type is int.
-  const ParamType& GetParam() const {
-    GTEST_CHECK_(parameter_ != NULL)
-        << "GetParam() can only be called inside a value-parameterized test "
-        << "-- did you intend to write TEST_P instead of TEST_F?";
-    return *parameter_;
-  }
-
- private:
-  // Sets parameter value. The caller is responsible for making sure the value
-  // remains alive and unchanged throughout the current test.
-  static void SetParam(const ParamType* parameter) {
-    parameter_ = parameter;
-  }
-
-  // Static value used for accessing parameter during a test lifetime.
-  static const ParamType* parameter_;
-
-  // TestClass must be a subclass of WithParamInterface<T> and Test.
-  template <class TestClass> friend class internal::ParameterizedTestFactory;
-};
-
-template <typename T>
-const T* WithParamInterface<T>::parameter_ = NULL;
-
-// Most value-parameterized classes can ignore the existence of
-// WithParamInterface, and can just inherit from ::testing::TestWithParam.
-
-template <typename T>
-class TestWithParam : public Test, public WithParamInterface<T> {
-};
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Macros for indicating success/failure in test code.
-
-// ADD_FAILURE unconditionally adds a failure to the current test.
-// SUCCEED generates a success - it doesn't automatically make the
-// current test successful, as a test is only successful when it has
-// no failure.
-//
-// EXPECT_* verifies that a certain condition is satisfied.  If not,
-// it behaves like ADD_FAILURE.  In particular:
-//
-//   EXPECT_TRUE  verifies that a Boolean condition is true.
-//   EXPECT_FALSE verifies that a Boolean condition is false.
-//
-// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
-// that they will also abort the current function on failure.  People
-// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
-// writing data-driven tests often find themselves using ADD_FAILURE
-// and EXPECT_* more.
-
-// Generates a nonfatal failure with a generic message.
-#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
-
-// Generates a nonfatal failure at the given source file location with
-// a generic message.
-#define ADD_FAILURE_AT(file, line) \
-  GTEST_MESSAGE_AT_(file, line, "Failed", \
-                    ::testing::TestPartResult::kNonFatalFailure)
-
-// Generates a fatal failure with a generic message.
-#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
-
-// Define this macro to 1 to omit the definition of FAIL(), which is a
-// generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_FAIL
-# define FAIL() GTEST_FAIL()
-#endif
-
-// Generates a success with a generic message.
-#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
-
-// Define this macro to 1 to omit the definition of SUCCEED(), which
-// is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_SUCCEED
-# define SUCCEED() GTEST_SUCCEED()
-#endif
-
-// Macros for testing exceptions.
-//
-//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
-//         Tests that the statement throws the expected exception.
-//    * {ASSERT|EXPECT}_NO_THROW(statement):
-//         Tests that the statement doesn't throw any exception.
-//    * {ASSERT|EXPECT}_ANY_THROW(statement):
-//         Tests that the statement throws an exception.
-
-#define EXPECT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
-#define ASSERT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
-#define ASSERT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
-
-// Boolean assertions. Condition can be either a Boolean expression or an
-// AssertionResult. For more information on how to use AssertionResult with
-// these macros see comments on that class.
-#define EXPECT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
-                      GTEST_NONFATAL_FAILURE_)
-#define EXPECT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_NONFATAL_FAILURE_)
-#define ASSERT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
-                      GTEST_FATAL_FAILURE_)
-#define ASSERT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_FATAL_FAILURE_)
-
-// Includes the auto-generated header that implements a family of
-// generic predicate assertion macros.
-// Copyright 2006, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-
-// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
-//
-// Implements a family of generic predicate assertion macros.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-// Makes sure this header is not included before gtest.h.
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
-
-// This header implements a family of generic predicate assertion
-// macros:
-//
-//   ASSERT_PRED_FORMAT1(pred_format, v1)
-//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
-//   ...
-//
-// where pred_format is a function or functor that takes n (in the
-// case of ASSERT_PRED_FORMATn) values and their source expression
-// text, and returns a testing::AssertionResult.  See the definition
-// of ASSERT_EQ in gtest.h for an example.
-//
-// If you don't care about formatting, you can use the more
-// restrictive version:
-//
-//   ASSERT_PRED1(pred, v1)
-//   ASSERT_PRED2(pred, v1, v2)
-//   ...
-//
-// where pred is an n-ary function or functor that returns bool,
-// and the values v1, v2, ..., must support the << operator for
-// streaming to std::ostream.
-//
-// We also define the EXPECT_* variations.
-//
-// For now we only support predicates whose arity is at most 5.
-// Please email googletestframework@googlegroups.com if you need
-// support for higher arities.
-
-// GTEST_ASSERT_ is the basic statement to which all of the assertions
-// in this file reduce.  Don't use this in your code.
-
-#define GTEST_ASSERT_(expression, on_failure) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar = (expression)) \
-    ; \
-  else \
-    on_failure(gtest_ar.failure_message())
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1>
-AssertionResult AssertPred1Helper(const char* pred_text,
-                                  const char* e1,
-                                  Pred pred,
-                                  const T1& v1) {
-  if (pred(v1)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, v1), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-#define GTEST_PRED1_(pred, v1, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
-                                             #v1, \
-                                             pred, \
-                                             v1), on_failure)
-
-// Unary predicate assertion macros.
-#define EXPECT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2>
-AssertionResult AssertPred2Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2) {
-  if (pred(v1, v2)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ", "
-                            << e2 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1
-                            << "\n" << e2 << " evaluates to " << v2;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-#define GTEST_PRED2_(pred, v1, v2, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             pred, \
-                                             v1, \
-                                             v2), on_failure)
-
-// Binary predicate assertion macros.
-#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3>
-AssertionResult AssertPred3Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3) {
-  if (pred(v1, v2, v3)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ", "
-                            << e2 << ", "
-                            << e3 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3), on_failure)
-
-// Ternary predicate assertion macros.
-#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4>
-AssertionResult AssertPred4Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4) {
-  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ", "
-                            << e2 << ", "
-                            << e3 << ", "
-                            << e4 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3
-                            << "\n" << e4 << " evaluates to " << v4;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4), on_failure)
-
-// 4-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5>
-AssertionResult AssertPred5Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  const char* e5,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4,
-                                  const T5& v5) {
-  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ", "
-                            << e2 << ", "
-                            << e3 << ", "
-                            << e4 << ", "
-                            << e5 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3
-                            << "\n" << e4 << " evaluates to " << v4
-                            << "\n" << e5 << " evaluates to " << v5;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             #v5, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4, \
-                                             v5), on_failure)
-
-// 5-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-
-
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-// Macros for testing equalities and inequalities.
-//
-//    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
-//    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
-//    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
-//    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
-//    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
-//    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
-//
-// When they are not, Google Test prints both the tested expressions and
-// their actual values.  The values must be compatible built-in types,
-// or you will get a compiler error.  By "compatible" we mean that the
-// values can be compared by the respective operator.
-//
-// Note:
-//
-//   1. It is possible to make a user-defined type work with
-//   {ASSERT|EXPECT}_??(), but that requires overloading the
-//   comparison operators and is thus discouraged by the Google C++
-//   Usage Guide.  Therefore, you are advised to use the
-//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
-//   equal.
-//
-//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
-//   pointers (in particular, C strings).  Therefore, if you use it
-//   with two C strings, you are testing how their locations in memory
-//   are related, not how their content is related.  To compare two C
-//   strings by content, use {ASSERT|EXPECT}_STR*().
-//
-//   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
-//   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
-//   what the actual value is when it fails, and similarly for the
-//   other comparisons.
-//
-//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
-//   evaluate their arguments, which is undefined.
-//
-//   5. These macros evaluate their arguments exactly once.
-//
-// Examples:
-//
-//   EXPECT_NE(5, Foo());
-//   EXPECT_EQ(NULL, a_pointer);
-//   ASSERT_LT(i, array_size);
-//   ASSERT_GT(records.size(), 0) << "There is no record left.";
-
-#define EXPECT_EQ(expected, actual) \
-  EXPECT_PRED_FORMAT2(::testing::internal:: \
-                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
-                      expected, actual)
-#define EXPECT_NE(expected, actual) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
-#define EXPECT_LE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define EXPECT_LT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define EXPECT_GE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define EXPECT_GT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-#define GTEST_ASSERT_EQ(expected, actual) \
-  ASSERT_PRED_FORMAT2(::testing::internal:: \
-                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
-                      expected, actual)
-#define GTEST_ASSERT_NE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
-#define GTEST_ASSERT_LE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define GTEST_ASSERT_LT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define GTEST_ASSERT_GE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define GTEST_ASSERT_GT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
-// ASSERT_XY(), which clashes with some users' own code.
-
-#if !GTEST_DONT_DEFINE_ASSERT_EQ
-# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_NE
-# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LE
-# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LT
-# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GE
-# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GT
-# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
-#endif
-
-// C-string Comparisons.  All tests treat NULL and any non-NULL string
-// as different.  Two NULLs are equal.
-//
-//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
-//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
-//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
-//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
-//
-// For wide or narrow string objects, you can use the
-// {ASSERT|EXPECT}_??() macros.
-//
-// Don't depend on the order in which the arguments are evaluated,
-// which is undefined.
-//
-// These macros evaluate their arguments exactly once.
-
-#define EXPECT_STREQ(expected, actual) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
-#define EXPECT_STRNE(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define EXPECT_STRCASEEQ(expected, actual) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
-#define EXPECT_STRCASENE(s1, s2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-#define ASSERT_STREQ(expected, actual) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
-#define ASSERT_STRNE(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define ASSERT_STRCASEEQ(expected, actual) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
-#define ASSERT_STRCASENE(s1, s2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-// Macros for comparing floating-point numbers.
-//
-//    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
-//         Tests that two float values are almost equal.
-//    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
-//         Tests that two double values are almost equal.
-//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
-//         Tests that v1 and v2 are within the given distance to each other.
-//
-// Google Test uses ULP-based comparison to automatically pick a default
-// error bound that is appropriate for the operands.  See the
-// FloatingPoint template class in gtest-internal.h if you are
-// interested in the implementation details.
-
-#define EXPECT_FLOAT_EQ(expected, actual)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      expected, actual)
-
-#define EXPECT_DOUBLE_EQ(expected, actual)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      expected, actual)
-
-#define ASSERT_FLOAT_EQ(expected, actual)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      expected, actual)
-
-#define ASSERT_DOUBLE_EQ(expected, actual)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      expected, actual)
-
-#define EXPECT_NEAR(val1, val2, abs_error)\
-  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-#define ASSERT_NEAR(val1, val2, abs_error)\
-  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-// These predicate format functions work on floating-point values, and
-// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
-//
-//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
-                                   float val1, float val2);
-GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                                    double val1, double val2);
-
-
-#if GTEST_OS_WINDOWS
-
-// Macros that test for HRESULT failure and success, these are only useful
-// on Windows, and rely on Windows SDK macros and APIs to compile.
-//
-//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
-//
-// When expr unexpectedly fails or succeeds, Google Test prints the
-// expected result and the actual result with both a human-readable
-// string representation of the error, if available, as well as the
-// hex result code.
-# define EXPECT_HRESULT_SUCCEEDED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define ASSERT_HRESULT_SUCCEEDED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define EXPECT_HRESULT_FAILED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-# define ASSERT_HRESULT_FAILED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-#endif  // GTEST_OS_WINDOWS
-
-// Macros that execute statement and check that it doesn't generate new fatal
-// failures in the current thread.
-//
-//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
-//
-// Examples:
-//
-//   EXPECT_NO_FATAL_FAILURE(Process());
-//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
-//
-#define ASSERT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
-#define EXPECT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
-
-// Causes a trace (including the source file path, the current line
-// number, and the given message) to be included in every test failure
-// message generated by code in the current scope.  The effect is
-// undone when the control leaves the current scope.
-//
-// The message argument can be anything streamable to std::ostream.
-//
-// In the implementation, we include the current line number as part
-// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
-// to appear in the same block - as long as they are on different
-// lines.
-#define SCOPED_TRACE(message) \
-  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
-    __FILE__, __LINE__, ::testing::Message() << (message))
-
-// Compile-time assertion for type equality.
-// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
-// the same type.  The value it returns is not interesting.
-//
-// Instead of making StaticAssertTypeEq a class template, we make it a
-// function template that invokes a helper class template.  This
-// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
-// defining objects of that type.
-//
-// CAVEAT:
-//
-// When used inside a method of a class template,
-// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
-// instantiated.  For example, given:
-//
-//   template <typename T> class Foo {
-//    public:
-//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
-//   };
-//
-// the code:
-//
-//   void Test1() { Foo<bool> foo; }
-//
-// will NOT generate a compiler error, as Foo<bool>::Bar() is never
-// actually instantiated.  Instead, you need:
-//
-//   void Test2() { Foo<bool> foo; foo.Bar(); }
-//
-// to cause a compiler error.
-template <typename T1, typename T2>
-bool StaticAssertTypeEq() {
-  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
-  return true;
-}
-
-// Defines a test.
-//
-// The first parameter is the name of the test case, and the second
-// parameter is the name of the test within the test case.
-//
-// The convention is to end the test case name with "Test".  For
-// example, a test case for the Foo class can be named FooTest.
-//
-// Test code should appear between braces after an invocation of
-// this macro.  Example:
-//
-//   TEST(FooTest, InitializesCorrectly) {
-//     Foo foo;
-//     EXPECT_TRUE(foo.StatusIsOK());
-//   }
-
-// Note that we call GetTestTypeId() instead of GetTypeId<
-// ::testing::Test>() here to get the type ID of testing::Test.  This
-// is to work around a suspected linker bug when using Google Test as
-// a framework on Mac OS X.  The bug causes GetTypeId<
-// ::testing::Test>() to return different values depending on whether
-// the call is from the Google Test framework itself or from user test
-// code.  GetTestTypeId() is guaranteed to always return the same
-// value, as it always calls GetTypeId<>() from the Google Test
-// framework.
-#define GTEST_TEST(test_case_name, test_name)\
-  GTEST_TEST_(test_case_name, test_name, \
-              ::testing::Test, ::testing::internal::GetTestTypeId())
-
-// Define this macro to 1 to omit the definition of TEST(), which
-// is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_TEST
-# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
-#endif
-
-// Defines a test that uses a test fixture.
-//
-// The first parameter is the name of the test fixture class, which
-// also doubles as the test case name.  The second parameter is the
-// name of the test within the test case.
-//
-// A test fixture class must be declared earlier.  The user should put
-// his test code between braces after using this macro.  Example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     virtual void SetUp() { b_.AddElement(3); }
-//
-//     Foo a_;
-//     Foo b_;
-//   };
-//
-//   TEST_F(FooTest, InitializesCorrectly) {
-//     EXPECT_TRUE(a_.StatusIsOK());
-//   }
-//
-//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
-//     EXPECT_EQ(0, a_.size());
-//     EXPECT_EQ(1, b_.size());
-//   }
-
-#define TEST_F(test_fixture, test_name)\
-  GTEST_TEST_(test_fixture, test_name, test_fixture, \
-              ::testing::internal::GetTypeId<test_fixture>())
-
-}  // namespace testing
-
-// Use this function in main() to run all tests.  It returns 0 if all
-// tests are successful, or 1 otherwise.
-//
-// RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest().
-//
-// This function was formerly a macro; thus, it is in the global
-// namespace and has an all-caps name.
-int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
-
-inline int RUN_ALL_TESTS() {
-  return ::testing::UnitTest::GetInstance()->Run();
-}
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_

From b863db550b924e00595ce29bb08ffc82f4fe3da0 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005279527
 <generatedunixname89002005279527@meta.com>
Date: Wed, 16 Oct 2024 01:39:12 -0700
Subject: [PATCH 090/235] 
 fbcode/mapillary/opensfm/opensfm/src/third_party/gtest

Reviewed By: bal-a

Differential Revision: D63970962

fbshipit-source-id: 4a3676ec81b973462ea42175094b6eabf8666048
---
 .../src/third_party/gtest/gmock_gtest_all.cc  | 12225 ----------------
 opensfm/src/third_party/gtest/gmock_main.cc   |    68 -
 2 files changed, 12293 deletions(-)
 delete mode 100644 opensfm/src/third_party/gtest/gmock_gtest_all.cc
 delete mode 100644 opensfm/src/third_party/gtest/gmock_main.cc

diff --git a/opensfm/src/third_party/gtest/gmock_gtest_all.cc b/opensfm/src/third_party/gtest/gmock_gtest_all.cc
deleted file mode 100644
index 2fc3e3cfb..000000000
--- a/opensfm/src/third_party/gtest/gmock_gtest_all.cc
+++ /dev/null
@@ -1,12225 +0,0 @@
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-// Google C++ Testing Framework (Google Test)
-//
-// Sometimes it's desirable to build Google Test by compiling a single file.
-// This file serves this purpose.
-
-// This line ensures that gtest.h can be compiled on its own, even
-// when it's fused.
-#include "gtest/gtest.h"
-
-// The following lines pull in the real gtest *.cc files.
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Utilities for testing Google Test itself and code that uses Google Test
-// (e.g. frameworks built on top of Google Test).
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-
-
-namespace testing {
-
-// This helper class can be used to mock out Google Test failure reporting
-// so that we can test Google Test or code that builds on Google Test.
-//
-// An object of this class appends a TestPartResult object to the
-// TestPartResultArray object given in the constructor whenever a Google Test
-// failure is reported. It can either intercept only failures that are
-// generated in the same thread that created this object or it can intercept
-// all generated failures. The scope of this mock object can be controlled with
-// the second argument to the two arguments constructor.
-class GTEST_API_ ScopedFakeTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  // The two possible mocking modes of this object.
-  enum InterceptMode {
-    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
-    INTERCEPT_ALL_THREADS           // Intercepts all failures.
-  };
-
-  // The c'tor sets this object as the test part result reporter used
-  // by Google Test.  The 'result' parameter specifies where to report the
-  // results. This reporter will only catch failures generated in the current
-  // thread. DEPRECATED
-  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
-
-  // Same as above, but you can choose the interception scope of this object.
-  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
-                                   TestPartResultArray* result);
-
-  // The d'tor restores the previous test part result reporter.
-  virtual ~ScopedFakeTestPartResultReporter();
-
-  // Appends the TestPartResult object to the TestPartResultArray
-  // received in the constructor.
-  //
-  // This method is from the TestPartResultReporterInterface
-  // interface.
-  virtual void ReportTestPartResult(const TestPartResult& result);
- private:
-  void Init();
-
-  const InterceptMode intercept_mode_;
-  TestPartResultReporterInterface* old_reporter_;
-  TestPartResultArray* const result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
-};
-
-namespace internal {
-
-// A helper class for implementing EXPECT_FATAL_FAILURE() and
-// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
-// TestPartResultArray contains exactly one failure that has the given
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-class GTEST_API_ SingleFailureChecker {
- public:
-  // The constructor remembers the arguments.
-  SingleFailureChecker(const TestPartResultArray* results,
-                       TestPartResult::Type type,
-                       const string& substr);
-  ~SingleFailureChecker();
- private:
-  const TestPartResultArray* const results_;
-  const TestPartResult::Type type_;
-  const string substr_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-// A set of macros for testing Google Test assertions or code that's expected
-// to generate Google Test fatal failures.  It verifies that the given
-// statement will cause exactly one fatal Google Test failure with 'substr'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - 'statement' cannot reference local non-static variables or
-//     non-static members of the current object.
-//   - 'statement' cannot return a value.
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
-// gtest_unittest.cc will fail to compile if we do that.
-#define EXPECT_FATAL_FAILURE(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ALL_THREADS, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-// A macro for testing Google Test assertions or code that's expected to
-// generate Google Test non-fatal failures.  It asserts that the given
-// statement will cause exactly one non-fatal Google Test failure with 'substr'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// 'statement' is allowed to reference local variables and members of
-// the current object.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  If we do that, the code won't compile when the user gives
-// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
-// expands to code containing an unprotected comma.  The
-// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
-// catches that.
-//
-// For the same reason, we have to write
-//   if (::testing::internal::AlwaysTrue()) { statement; }
-// instead of
-//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-// to avoid an MSVC warning on unreachable code.
-#define EXPECT_NONFATAL_FAILURE(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
-          &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-
-#include <ctype.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-#include <algorithm>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <map>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <vector>
-
-#if GTEST_OS_LINUX
-
-// TODO(kenton@google.com): Use autoconf to detect availability of
-// gettimeofday().
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-# include <fcntl.h>  // NOLINT
-# include <limits.h>  // NOLINT
-# include <sched.h>  // NOLINT
-// Declares vsnprintf().  This header is not available on Windows.
-# include <strings.h>  // NOLINT
-# include <sys/mman.h>  // NOLINT
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-# include <string>
-
-#elif GTEST_OS_SYMBIAN
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-# include <sys/time.h>  // NOLINT
-
-#elif GTEST_OS_ZOS
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-# include <sys/time.h>  // NOLINT
-
-// On z/OS we additionally need strings.h for strcasecmp.
-# include <strings.h>  // NOLINT
-
-#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
-
-# include <windows.h>  // NOLINT
-# undef min
-
-#elif GTEST_OS_WINDOWS  // We are on Windows proper.
-
-# include <io.h>  // NOLINT
-# include <sys/timeb.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-# include <sys/stat.h>  // NOLINT
-
-# if GTEST_OS_WINDOWS_MINGW
-// MinGW has gettimeofday() but not _ftime64().
-// TODO(kenton@google.com): Use autoconf to detect availability of
-//   gettimeofday().
-// TODO(kenton@google.com): There are other ways to get the time on
-//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
-//   supports these.  consider using them instead.
-#  define GTEST_HAS_GETTIMEOFDAY_ 1
-#  include <sys/time.h>  // NOLINT
-# endif  // GTEST_OS_WINDOWS_MINGW
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <windows.h>  // NOLINT
-# undef min
-
-#else
-
-// Assume other platforms have gettimeofday().
-// TODO(kenton@google.com): Use autoconf to detect availability of
-//   gettimeofday().
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-# include <sys/socket.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-#endif
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-
-// Utility functions and classes used by the Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// This file contains purely Google Test's internal implementation.  Please
-// DO NOT #INCLUDE IT IN A USER PROGRAM.
-
-#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
-#define GTEST_SRC_GTEST_INTERNAL_INL_H_
-
-// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
-// part of Google Test's implementation; otherwise it's undefined.
-#if !GTEST_IMPLEMENTATION_
-// If this file is included from the user's code, just say no.
-# error "gtest-internal-inl.h is part of Google Test's internal implementation."
-# error "It must not be included except by Google Test itself."
-#endif  // GTEST_IMPLEMENTATION_
-
-#ifndef _WIN32_WCE
-# include <errno.h>
-#endif  // !_WIN32_WCE
-#include <stddef.h>
-#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
-#include <string.h>  // For memmove.
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-#endif
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-
-namespace testing {
-
-// Declares the flags.
-//
-// We don't want the users to modify this flag in the code, but want
-// Google Test's own unit tests to be able to access it. Therefore we
-// declare it here as opposed to in gtest.h.
-GTEST_DECLARE_bool_(death_test_use_fork);
-
-namespace internal {
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
-const char kBreakOnFailureFlag[] = "break_on_failure";
-const char kCatchExceptionsFlag[] = "catch_exceptions";
-const char kColorFlag[] = "color";
-const char kFilterFlag[] = "filter";
-const char kListTestsFlag[] = "list_tests";
-const char kOutputFlag[] = "output";
-const char kPrintTimeFlag[] = "print_time";
-const char kRandomSeedFlag[] = "random_seed";
-const char kRepeatFlag[] = "repeat";
-const char kShuffleFlag[] = "shuffle";
-const char kStackTraceDepthFlag[] = "stack_trace_depth";
-const char kStreamResultToFlag[] = "stream_result_to";
-const char kThrowOnFailureFlag[] = "throw_on_failure";
-const char kFlagfileFlag[] = "flagfile";
-
-// A valid random seed must be in [1, kMaxRandomSeed].
-const int kMaxRandomSeed = 99999;
-
-// g_help_flag is true iff the --help flag or an equivalent form is
-// specified on the command line.
-GTEST_API_ extern bool g_help_flag;
-
-// Returns the current time in milliseconds.
-GTEST_API_ TimeInMillis GetTimeInMillis();
-
-// Returns true iff Google Test should use colors in the output.
-GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
-
-// Formats the given time in milliseconds as seconds.
-GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
-
-// Converts the given time in milliseconds to a date string in the ISO 8601
-// format, without the timezone information.  N.B.: due to the use the
-// non-reentrant localtime() function, this function is not thread safe.  Do
-// not use it in any code that can be called from multiple threads.
-GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
-
-// Parses a string for an Int32 flag, in the form of "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-GTEST_API_ bool ParseInt32Flag(
-    const char* str, const char* flag, Int32* value);
-
-// Returns a random seed in range [1, kMaxRandomSeed] based on the
-// given --gtest_random_seed flag value.
-inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
-  const unsigned int raw_seed = (random_seed_flag == 0) ?
-      static_cast<unsigned int>(GetTimeInMillis()) :
-      static_cast<unsigned int>(random_seed_flag);
-
-  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
-  // it's easy to type.
-  const int normalized_seed =
-      static_cast<int>((raw_seed - 1U) %
-                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
-  return normalized_seed;
-}
-
-// Returns the first valid random seed after 'seed'.  The behavior is
-// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
-// considered to be 1.
-inline int GetNextRandomSeed(int seed) {
-  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
-      << "Invalid random seed " << seed << " - must be in [1, "
-      << kMaxRandomSeed << "].";
-  const int next_seed = seed + 1;
-  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
-}
-
-// This class saves the values of all Google Test flags in its c'tor, and
-// restores them in its d'tor.
-class GTestFlagSaver {
- public:
-  // The c'tor.
-  GTestFlagSaver() {
-    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
-    break_on_failure_ = GTEST_FLAG(break_on_failure);
-    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
-    color_ = GTEST_FLAG(color);
-    death_test_style_ = GTEST_FLAG(death_test_style);
-    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    filter_ = GTEST_FLAG(filter);
-    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
-    list_tests_ = GTEST_FLAG(list_tests);
-    output_ = GTEST_FLAG(output);
-    print_time_ = GTEST_FLAG(print_time);
-    random_seed_ = GTEST_FLAG(random_seed);
-    repeat_ = GTEST_FLAG(repeat);
-    shuffle_ = GTEST_FLAG(shuffle);
-    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
-    stream_result_to_ = GTEST_FLAG(stream_result_to);
-    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
-  }
-
-  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
-  ~GTestFlagSaver() {
-    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
-    GTEST_FLAG(break_on_failure) = break_on_failure_;
-    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
-    GTEST_FLAG(color) = color_;
-    GTEST_FLAG(death_test_style) = death_test_style_;
-    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
-    GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
-    GTEST_FLAG(list_tests) = list_tests_;
-    GTEST_FLAG(output) = output_;
-    GTEST_FLAG(print_time) = print_time_;
-    GTEST_FLAG(random_seed) = random_seed_;
-    GTEST_FLAG(repeat) = repeat_;
-    GTEST_FLAG(shuffle) = shuffle_;
-    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
-    GTEST_FLAG(stream_result_to) = stream_result_to_;
-    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
-  }
-
- private:
-  // Fields for saving the original values of flags.
-  bool also_run_disabled_tests_;
-  bool break_on_failure_;
-  bool catch_exceptions_;
-  std::string color_;
-  std::string death_test_style_;
-  bool death_test_use_fork_;
-  std::string filter_;
-  std::string internal_run_death_test_;
-  bool list_tests_;
-  std::string output_;
-  bool print_time_;
-  internal::Int32 random_seed_;
-  internal::Int32 repeat_;
-  bool shuffle_;
-  internal::Int32 stack_trace_depth_;
-  std::string stream_result_to_;
-  bool throw_on_failure_;
-} GTEST_ATTRIBUTE_UNUSED_;
-
-// Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type UInt32 because wchar_t may not be
-// wide enough to contain a code point.
-// If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
-// to "(Invalid Unicode 0xXXXXXXXX)".
-GTEST_API_ std::string CodePointToUtf8(UInt32 code_point);
-
-// Converts a wide string to a narrow string in UTF-8 encoding.
-// The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
-//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
-// Parameter str points to a null-terminated wide string.
-// Parameter num_chars may additionally limit the number
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded();
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (e.g., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-GTEST_API_ bool ShouldShard(const char* total_shards_str,
-                            const char* shard_index_str,
-                            bool in_subprocess_for_death_test);
-
-// Parses the environment variable var as an Int32. If it is unset,
-// returns default_val. If it is not an Int32, prints an error and
-// and aborts.
-GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff the test should be run on this shard. The test id is
-// some arbitrary but unique non-negative integer assigned to each test
-// method. Assumes that 0 <= shard_index < total_shards.
-GTEST_API_ bool ShouldRunTestOnShard(
-    int total_shards, int shard_index, int test_id);
-
-// STL container utilities.
-
-// Returns the number of elements in the given container that satisfy
-// the given predicate.
-template <class Container, typename Predicate>
-inline int CountIf(const Container& c, Predicate predicate) {
-  // Implemented as an explicit loop since std::count_if() in libCstd on
-  // Solaris has a non-standard signature.
-  int count = 0;
-  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
-    if (predicate(*it))
-      ++count;
-  }
-  return count;
-}
-
-// Applies a function/functor to each element in the container.
-template <class Container, typename Functor>
-void ForEach(const Container& c, Functor functor) {
-  std::for_each(c.begin(), c.end(), functor);
-}
-
-// Returns the i-th element of the vector, or default_value if i is not
-// in range [0, v.size()).
-template <typename E>
-inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
-  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
-}
-
-// Performs an in-place shuffle of a range of the vector's elements.
-// 'begin' and 'end' are element indices as an STL-style range;
-// i.e. [begin, end) are shuffled, where 'end' == size() means to
-// shuffle to the end of the vector.
-template <typename E>
-void ShuffleRange(internal::Random* random, int begin, int end,
-                  std::vector<E>* v) {
-  const int size = static_cast<int>(v->size());
-  GTEST_CHECK_(0 <= begin && begin <= size)
-      << "Invalid shuffle range start " << begin << ": must be in range [0, "
-      << size << "].";
-  GTEST_CHECK_(begin <= end && end <= size)
-      << "Invalid shuffle range finish " << end << ": must be in range ["
-      << begin << ", " << size << "].";
-
-  // Fisher-Yates shuffle, from
-  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
-  for (int range_width = end - begin; range_width >= 2; range_width--) {
-    const int last_in_range = begin + range_width - 1;
-    const int selected = begin + random->Generate(range_width);
-    std::swap((*v)[selected], (*v)[last_in_range]);
-  }
-}
-
-// Performs an in-place shuffle of the vector's elements.
-template <typename E>
-inline void Shuffle(internal::Random* random, std::vector<E>* v) {
-  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
-}
-
-// A function for deleting an object.  Handy for being used as a
-// functor.
-template <typename T>
-static void Delete(T* x) {
-  delete x;
-}
-
-// A predicate that checks the key of a TestProperty against a known key.
-//
-// TestPropertyKeyIs is copyable.
-class TestPropertyKeyIs {
- public:
-  // Constructor.
-  //
-  // TestPropertyKeyIs has NO default constructor.
-  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
-
-  // Returns true iff the test name of test property matches on key_.
-  bool operator()(const TestProperty& test_property) const {
-    return test_property.key() == key_;
-  }
-
- private:
-  std::string key_;
-};
-
-// Class UnitTestOptions.
-//
-// This class contains functions for processing options the user
-// specifies when running the tests.  It has only static members.
-//
-// In most cases, the user can specify an option using either an
-// environment variable or a command line flag.  E.g. you can set the
-// test filter using either GTEST_FILTER or --gtest_filter.  If both
-// the variable and the flag are present, the latter overrides the
-// former.
-class GTEST_API_ UnitTestOptions {
- public:
-  // Functions for processing the gtest_output flag.
-
-  // Returns the output format, or "" for normal printed output.
-  static std::string GetOutputFormat();
-
-  // Returns the absolute path of the requested output file, or the
-  // default (test_detail.xml in the original working directory) if
-  // none was explicitly specified.
-  static std::string GetAbsolutePathToOutputFile();
-
-  // Functions for processing the gtest_filter flag.
-
-  // Returns true iff the wildcard pattern matches the string.  The
-  // first ':' or '\0' character in pattern marks the end of it.
-  //
-  // This recursive algorithm isn't very efficient, but is clear and
-  // works well enough for matching test names, which are short.
-  static bool PatternMatchesString(const char *pattern, const char *str);
-
-  // Returns true iff the user-specified filter matches the test case
-  // name and the test name.
-  static bool FilterMatchesTest(const std::string &test_case_name,
-                                const std::string &test_name);
-
-#if GTEST_OS_WINDOWS
-  // Function for supporting the gtest_catch_exception flag.
-
-  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-  // This function is useful as an __except condition.
-  static int GTestShouldProcessSEH(DWORD exception_code);
-#endif  // GTEST_OS_WINDOWS
-
-  // Returns true if "name" matches the ':' separated list of glob-style
-  // filters in "filter".
-  static bool MatchesFilter(const std::string& name, const char* filter);
-};
-
-// Returns the current application's name, removing directory path if that
-// is present.  Used by UnitTestOptions::GetOutputFile.
-GTEST_API_ FilePath GetCurrentExecutableName();
-
-// The role interface for getting the OS stack trace as a string.
-class OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetterInterface() {}
-  virtual ~OsStackTraceGetterInterface() {}
-
-  // Returns the current OS stack trace as an std::string.  Parameters:
-  //
-  //   max_depth  - the maximum number of stack frames to be included
-  //                in the trace.
-  //   skip_count - the number of top frames to be skipped; doesn't count
-  //                against max_depth.
-  virtual string CurrentStackTrace(int max_depth, int skip_count) = 0;
-
-  // UponLeavingGTest() should be called immediately before Google Test calls
-  // user code. It saves some information about the current stack that
-  // CurrentStackTrace() will use to find and hide Google Test stack frames.
-  virtual void UponLeavingGTest() = 0;
-
-  // This string is inserted in place of stack frames that are part of
-  // Google Test's implementation.
-  static const char* const kElidedFramesMarker;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
-};
-
-// A working implementation of the OsStackTraceGetterInterface interface.
-class OsStackTraceGetter : public OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetter() {}
-
-  virtual string CurrentStackTrace(int max_depth, int skip_count);
-  virtual void UponLeavingGTest();
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
-};
-
-// Information about a Google Test trace point.
-struct TraceInfo {
-  const char* file;
-  int line;
-  std::string message;
-};
-
-// This is the default global test part result reporter used in UnitTestImpl.
-// This class should only be used by UnitTestImpl.
-class DefaultGlobalTestPartResultReporter
-  : public TestPartResultReporterInterface {
- public:
-  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. Reports the test part
-  // result in the current test.
-  virtual void ReportTestPartResult(const TestPartResult& result);
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
-};
-
-// This is the default per thread test part result reporter used in
-// UnitTestImpl. This class should only be used by UnitTestImpl.
-class DefaultPerThreadTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. The implementation just
-  // delegates to the current global test part result reporter of *unit_test_.
-  virtual void ReportTestPartResult(const TestPartResult& result);
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
-};
-
-// The private implementation of the UnitTest class.  We don't protect
-// the methods under a mutex, as this class is not accessible by a
-// user and the UnitTest class that delegates work to this class does
-// proper locking.
-class GTEST_API_ UnitTestImpl {
- public:
-  explicit UnitTestImpl(UnitTest* parent);
-  virtual ~UnitTestImpl();
-
-  // There are two different ways to register your own TestPartResultReporter.
-  // You can register your own repoter to listen either only for test results
-  // from the current thread or for results from all threads.
-  // By default, each per-thread test result repoter just passes a new
-  // TestPartResult to the global test result reporter, which registers the
-  // test part result for the currently running test.
-
-  // Returns the global test part result reporter.
-  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
-
-  // Sets the global test part result reporter.
-  void SetGlobalTestPartResultReporter(
-      TestPartResultReporterInterface* reporter);
-
-  // Returns the test part result reporter for the current thread.
-  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
-
-  // Sets the test part result reporter for the current thread.
-  void SetTestPartResultReporterForCurrentThread(
-      TestPartResultReporterInterface* reporter);
-
-  // Gets the number of successful test cases.
-  int successful_test_case_count() const;
-
-  // Gets the number of failed test cases.
-  int failed_test_case_count() const;
-
-  // Gets the number of all test cases.
-  int total_test_case_count() const;
-
-  // Gets the number of all test cases that contain at least one test
-  // that should run.
-  int test_case_to_run_count() const;
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const { return start_timestamp_; }
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns true iff the unit test passed (i.e. all test cases passed).
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the unit test failed (i.e. some test case failed
-  // or something outside of all tests failed).
-  bool Failed() const {
-    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
-  }
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  const TestCase* GetTestCase(int i) const {
-    const int index = GetElementOr(test_case_indices_, i, -1);
-    return index < 0 ? NULL : test_cases_[i];
-  }
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  TestCase* GetMutableTestCase(int i) {
-    const int index = GetElementOr(test_case_indices_, i, -1);
-    return index < 0 ? NULL : test_cases_[index];
-  }
-
-  // Provides access to the event listener list.
-  TestEventListeners* listeners() { return &listeners_; }
-
-  // Returns the TestResult for the test that's currently running, or
-  // the TestResult for the ad hoc test if no test is running.
-  TestResult* current_test_result();
-
-  // Returns the TestResult for the ad hoc test.
-  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
-
-  // Sets the OS stack trace getter.
-  //
-  // Does nothing if the input and the current OS stack trace getter
-  // are the same; otherwise, deletes the old getter and makes the
-  // input the current getter.
-  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
-
-  // Returns the current OS stack trace getter if it is not NULL;
-  // otherwise, creates an OsStackTraceGetter, makes it the current
-  // getter, and returns it.
-  OsStackTraceGetterInterface* os_stack_trace_getter();
-
-  // Returns the current OS stack trace as an std::string.
-  //
-  // The maximum number of stack frames to be included is specified by
-  // the gtest_stack_trace_depth flag.  The skip_count parameter
-  // specifies the number of top frames to be skipped, which doesn't
-  // count against the number of frames to be included.
-  //
-  // For example, if Foo() calls Bar(), which in turn calls
-  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
-
-  // Finds and returns a TestCase with the given name.  If one doesn't
-  // exist, creates one and returns it.
-  //
-  // Arguments:
-  //
-  //   test_case_name: name of the test case
-  //   type_param:     the name of the test's type parameter, or NULL if
-  //                   this is not a typed or a type-parameterized test.
-  //   set_up_tc:      pointer to the function that sets up the test case
-  //   tear_down_tc:   pointer to the function that tears down the test case
-  TestCase* GetTestCase(const char* test_case_name,
-                        const char* type_param,
-                        Test::SetUpTestCaseFunc set_up_tc,
-                        Test::TearDownTestCaseFunc tear_down_tc);
-
-  // Adds a TestInfo to the unit test.
-  //
-  // Arguments:
-  //
-  //   set_up_tc:    pointer to the function that sets up the test case
-  //   tear_down_tc: pointer to the function that tears down the test case
-  //   test_info:    the TestInfo object
-  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
-                   Test::TearDownTestCaseFunc tear_down_tc,
-                   TestInfo* test_info) {
-    // In order to support thread-safe death tests, we need to
-    // remember the original working directory when the test program
-    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
-    // the user may have changed the current directory before calling
-    // RUN_ALL_TESTS().  Therefore we capture the current directory in
-    // AddTestInfo(), which is called to register a TEST or TEST_F
-    // before main() is reached.
-    if (original_working_dir_.IsEmpty()) {
-      original_working_dir_.Set(FilePath::GetCurrentDir());
-      GTEST_CHECK_(!original_working_dir_.IsEmpty())
-          << "Failed to get the current working directory.";
-    }
-
-    GetTestCase(test_info->test_case_name(),
-                test_info->type_param(),
-                set_up_tc,
-                tear_down_tc)->AddTestInfo(test_info);
-  }
-
-#if GTEST_HAS_PARAM_TEST
-  // Returns ParameterizedTestCaseRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
-    return parameterized_test_registry_;
-  }
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Sets the TestCase object for the test that's currently running.
-  void set_current_test_case(TestCase* a_current_test_case) {
-    current_test_case_ = a_current_test_case;
-  }
-
-  // Sets the TestInfo object for the test that's currently running.  If
-  // current_test_info is NULL, the assertion results will be stored in
-  // ad_hoc_test_result_.
-  void set_current_test_info(TestInfo* a_current_test_info) {
-    current_test_info_ = a_current_test_info;
-  }
-
-  // Registers all parameterized tests defined using TEST_P and
-  // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter
-  // combination. This method can be called more then once; it has guards
-  // protecting from registering the tests more then once.  If
-  // value-parameterized tests are disabled, RegisterParameterizedTests is
-  // present but does nothing.
-  void RegisterParameterizedTests();
-
-  // Runs all tests in this UnitTest object, prints the result, and
-  // returns true if all tests are successful.  If any exception is
-  // thrown during a test, this test is considered to be failed, but
-  // the rest of the tests will still be run.
-  bool RunAllTests();
-
-  // Clears the results of all tests, except the ad hoc tests.
-  void ClearNonAdHocTestResult() {
-    ForEach(test_cases_, TestCase::ClearTestCaseResult);
-  }
-
-  // Clears the results of ad-hoc test assertions.
-  void ClearAdHocTestResult() {
-    ad_hoc_test_result_.Clear();
-  }
-
-  // Adds a TestProperty to the current TestResult object when invoked in a
-  // context of a test or a test case, or to the global property set. If the
-  // result already contains a property with the same key, the value will be
-  // updated.
-  void RecordProperty(const TestProperty& test_property);
-
-  enum ReactionToSharding {
-    HONOR_SHARDING_PROTOCOL,
-    IGNORE_SHARDING_PROTOCOL
-  };
-
-  // Matches the full name of each test against the user-specified
-  // filter to decide whether the test should run, then records the
-  // result in each TestCase and TestInfo object.
-  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
-  // based on sharding variables in the environment.
-  // Returns the number of tests that should run.
-  int FilterTests(ReactionToSharding shard_tests);
-
-  // Prints the names of the tests matching the user-specified filter flag.
-  void ListTestsMatchingFilter();
-
-  const TestCase* current_test_case() const { return current_test_case_; }
-  TestInfo* current_test_info() { return current_test_info_; }
-  const TestInfo* current_test_info() const { return current_test_info_; }
-
-  // Returns the vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*>& environments() { return environments_; }
-
-  // Getters for the per-thread Google Test trace stack.
-  std::vector<TraceInfo>& gtest_trace_stack() {
-    return *(gtest_trace_stack_.pointer());
-  }
-  const std::vector<TraceInfo>& gtest_trace_stack() const {
-    return gtest_trace_stack_.get();
-  }
-
-#if GTEST_HAS_DEATH_TEST
-  void InitDeathTestSubprocessControlInfo() {
-    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
-  }
-  // Returns a pointer to the parsed --gtest_internal_run_death_test
-  // flag, or NULL if that flag was not specified.
-  // This information is useful only in a death test child process.
-  // Must not be called before a call to InitGoogleTest.
-  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
-    return internal_run_death_test_flag_.get();
-  }
-
-  // Returns a pointer to the current death test factory.
-  internal::DeathTestFactory* death_test_factory() {
-    return death_test_factory_.get();
-  }
-
-  void SuppressTestEventsIfInSubprocess();
-
-  friend class ReplaceDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // Initializes the event listener performing XML output as specified by
-  // UnitTestOptions. Must not be called before InitGoogleTest.
-  void ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-  // Initializes the event listener for streaming test results to a socket.
-  // Must not be called before InitGoogleTest.
-  void ConfigureStreamingOutput();
-#endif
-
-  // Performs initialization dependent upon flag values obtained in
-  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-  // this function is also called from RunAllTests.  Since this function can be
-  // called more than once, it has to be idempotent.
-  void PostFlagParsingInit();
-
-  // Gets the random seed used at the start of the current test iteration.
-  int random_seed() const { return random_seed_; }
-
-  // Gets the random number generator.
-  internal::Random* random() { return &random_; }
-
-  // Shuffles all test cases, and the tests within each test case,
-  // making sure that death tests are still run first.
-  void ShuffleTests();
-
-  // Restores the test cases and tests to their order before the first shuffle.
-  void UnshuffleTests();
-
-  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
-  // UnitTest::Run() starts.
-  bool catch_exceptions() const { return catch_exceptions_; }
-
- private:
-  friend class ::testing::UnitTest;
-
-  // Used by UnitTest::Run() to capture the state of
-  // GTEST_FLAG(catch_exceptions) at the moment it starts.
-  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
-
-  // The UnitTest object that owns this implementation object.
-  UnitTest* const parent_;
-
-  // The working directory when the first TEST() or TEST_F() was
-  // executed.
-  internal::FilePath original_working_dir_;
-
-  // The default test part result reporters.
-  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
-  DefaultPerThreadTestPartResultReporter
-      default_per_thread_test_part_result_reporter_;
-
-  // Points to (but doesn't own) the global test part result reporter.
-  TestPartResultReporterInterface* global_test_part_result_repoter_;
-
-  // Protects read and write access to global_test_part_result_reporter_.
-  internal::Mutex global_test_part_result_reporter_mutex_;
-
-  // Points to (but doesn't own) the per-thread test part result reporter.
-  internal::ThreadLocal<TestPartResultReporterInterface*>
-      per_thread_test_part_result_reporter_;
-
-  // The vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*> environments_;
-
-  // The vector of TestCases in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestCase*> test_cases_;
-
-  // Provides a level of indirection for the test case list to allow
-  // easy shuffling and restoring the test case order.  The i-th
-  // element of this vector is the index of the i-th test case in the
-  // shuffled order.
-  std::vector<int> test_case_indices_;
-
-#if GTEST_HAS_PARAM_TEST
-  // ParameterizedTestRegistry object used to register value-parameterized
-  // tests.
-  internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
-
-  // Indicates whether RegisterParameterizedTests() has been called already.
-  bool parameterized_tests_registered_;
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Index of the last death test case registered.  Initially -1.
-  int last_death_test_case_;
-
-  // This points to the TestCase for the currently running test.  It
-  // changes as Google Test goes through one test case after another.
-  // When no test is running, this is set to NULL and Google Test
-  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
-  TestCase* current_test_case_;
-
-  // This points to the TestInfo for the currently running test.  It
-  // changes as Google Test goes through one test after another.  When
-  // no test is running, this is set to NULL and Google Test stores
-  // assertion results in ad_hoc_test_result_.  Initially NULL.
-  TestInfo* current_test_info_;
-
-  // Normally, a user only writes assertions inside a TEST or TEST_F,
-  // or inside a function called by a TEST or TEST_F.  Since Google
-  // Test keeps track of which test is current running, it can
-  // associate such an assertion with the test it belongs to.
-  //
-  // If an assertion is encountered when no TEST or TEST_F is running,
-  // Google Test attributes the assertion result to an imaginary "ad hoc"
-  // test, and records the result in ad_hoc_test_result_.
-  TestResult ad_hoc_test_result_;
-
-  // The list of event listeners that can be used to track events inside
-  // Google Test.
-  TestEventListeners listeners_;
-
-  // The OS stack trace getter.  Will be deleted when the UnitTest
-  // object is destructed.  By default, an OsStackTraceGetter is used,
-  // but the user can set this field to use a custom getter if that is
-  // desired.
-  OsStackTraceGetterInterface* os_stack_trace_getter_;
-
-  // True iff PostFlagParsingInit() has been called.
-  bool post_flag_parse_init_performed_;
-
-  // The random number seed used at the beginning of the test run.
-  int random_seed_;
-
-  // Our random number generator.
-  internal::Random random_;
-
-  // The time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp_;
-
-  // How long the test took to run, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-#if GTEST_HAS_DEATH_TEST
-  // The decomposed components of the gtest_internal_run_death_test flag,
-  // parsed when RUN_ALL_TESTS is called.
-  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
-  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
-  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
-
-  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
-  // starts.
-  bool catch_exceptions_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
-};  // class UnitTestImpl
-
-// Convenience function for accessing the global UnitTest
-// implementation object.
-inline UnitTestImpl* GetUnitTestImpl() {
-  return UnitTest::GetInstance()->impl();
-}
-
-#if GTEST_USES_SIMPLE_RE
-
-// Internal helper functions for implementing the simple regular
-// expression matcher.
-GTEST_API_ bool IsInSet(char ch, const char* str);
-GTEST_API_ bool IsAsciiDigit(char ch);
-GTEST_API_ bool IsAsciiPunct(char ch);
-GTEST_API_ bool IsRepeat(char ch);
-GTEST_API_ bool IsAsciiWhiteSpace(char ch);
-GTEST_API_ bool IsAsciiWordChar(char ch);
-GTEST_API_ bool IsValidEscape(char ch);
-GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
-GTEST_API_ bool ValidateRegex(const char* regex);
-GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
-GTEST_API_ bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char ch, char repeat, const char* regex, const char* str);
-GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
-
-#endif  // GTEST_USES_SIMPLE_RE
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
-
-#if GTEST_HAS_DEATH_TEST
-
-// Returns the message describing the last system error, regardless of the
-// platform.
-GTEST_API_ std::string GetLastErrnoDescription();
-
-// Attempts to parse a string into a positive integer pointed to by the
-// number parameter.  Returns true if that is possible.
-// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
-// it here.
-template <typename Integer>
-bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
-  // Fail fast if the given string does not begin with a digit;
-  // this bypasses strtoXXX's "optional leading whitespace and plus
-  // or minus sign" semantics, which are undesirable here.
-  if (str.empty() || !IsDigit(str[0])) {
-    return false;
-  }
-  errno = 0;
-
-  char* end;
-  // BiggestConvertible is the largest integer type that system-provided
-  // string-to-number conversion routines can return.
-
-# if GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  // MSVC and C++ Builder define __int64 instead of the standard long long.
-  typedef unsigned __int64 BiggestConvertible;
-  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
-
-# else
-
-  typedef unsigned long long BiggestConvertible;  // NOLINT
-  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
-
-# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  const bool parse_success = *end == '\0' && errno == 0;
-
-  // TODO(vladl@google.com): Convert this to compile time assertion when it is
-  // available.
-  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
-
-  const Integer result = static_cast<Integer>(parsed);
-  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
-    *number = result;
-    return true;
-  }
-  return false;
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// TestResult contains some private methods that should be hidden from
-// Google Test user but are required for testing. This class allow our tests
-// to access them.
-//
-// This class is supplied only for the purpose of testing Google Test's own
-// constructs. Do not use it in user tests, either directly or indirectly.
-class TestResultAccessor {
- public:
-  static void RecordProperty(TestResult* test_result,
-                             const std::string& xml_element,
-                             const TestProperty& property) {
-    test_result->RecordProperty(xml_element, property);
-  }
-
-  static void ClearTestPartResults(TestResult* test_result) {
-    test_result->ClearTestPartResults();
-  }
-
-  static const std::vector<testing::TestPartResult>& test_part_results(
-      const TestResult& test_result) {
-    return test_result.test_part_results();
-  }
-};
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Streams test results to the given port on the given host machine.
-class StreamingListener : public EmptyTestEventListener {
- public:
-  // Abstract base class for writing strings to a socket.
-  class AbstractSocketWriter {
-   public:
-    virtual ~AbstractSocketWriter() {}
-
-    // Sends a string to the socket.
-    virtual void Send(const string& message) = 0;
-
-    // Closes the socket.
-    virtual void CloseConnection() {}
-
-    // Sends a string and a newline to the socket.
-    void SendLn(const string& message) {
-      Send(message + "\n");
-    }
-  };
-
-  // Concrete class for actually writing strings to a socket.
-  class SocketWriter : public AbstractSocketWriter {
-   public:
-    SocketWriter(const string& host, const string& port)
-        : sockfd_(-1), host_name_(host), port_num_(port) {
-      MakeConnection();
-    }
-
-    virtual ~SocketWriter() {
-      if (sockfd_ != -1)
-        CloseConnection();
-    }
-
-    // Sends a string to the socket.
-    virtual void Send(const string& message) {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "Send() can be called only when there is a connection.";
-
-      const int len = static_cast<int>(message.length());
-      if (write(sockfd_, message.c_str(), len) != len) {
-        GTEST_LOG_(WARNING)
-            << "stream_result_to: failed to stream to "
-            << host_name_ << ":" << port_num_;
-      }
-    }
-
-   private:
-    // Creates a client socket and connects to the server.
-    void MakeConnection();
-
-    // Closes the socket.
-    void CloseConnection() {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "CloseConnection() can be called only when there is a connection.";
-
-      close(sockfd_);
-      sockfd_ = -1;
-    }
-
-    int sockfd_;  // socket file descriptor
-    const string host_name_;
-    const string port_num_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
-  };  // class SocketWriter
-
-  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
-  static string UrlEncode(const char* str);
-
-  StreamingListener(const string& host, const string& port)
-      : socket_writer_(new SocketWriter(host, port)) { Start(); }
-
-  explicit StreamingListener(AbstractSocketWriter* socket_writer)
-      : socket_writer_(socket_writer) { Start(); }
-
-  void OnTestProgramStart(const UnitTest& /* unit_test */) {
-    SendLn("event=TestProgramStart");
-  }
-
-  void OnTestProgramEnd(const UnitTest& unit_test) {
-    // Note that Google Test current only report elapsed time for each
-    // test iteration, not for the entire test program.
-    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
-
-    // Notify the streaming server to stop.
-    socket_writer_->CloseConnection();
-  }
-
-  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
-    SendLn("event=TestIterationStart&iteration=" +
-           StreamableToString(iteration));
-  }
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
-    SendLn("event=TestIterationEnd&passed=" +
-           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
-           StreamableToString(unit_test.elapsed_time()) + "ms");
-  }
-
-  void OnTestCaseStart(const TestCase& test_case) {
-    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
-  }
-
-  void OnTestCaseEnd(const TestCase& test_case) {
-    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
-           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
-           + "ms");
-  }
-
-  void OnTestStart(const TestInfo& test_info) {
-    SendLn(std::string("event=TestStart&name=") + test_info.name());
-  }
-
-  void OnTestEnd(const TestInfo& test_info) {
-    SendLn("event=TestEnd&passed=" +
-           FormatBool((test_info.result())->Passed()) +
-           "&elapsed_time=" +
-           StreamableToString((test_info.result())->elapsed_time()) + "ms");
-  }
-
-  void OnTestPartResult(const TestPartResult& test_part_result) {
-    const char* file_name = test_part_result.file_name();
-    if (file_name == NULL)
-      file_name = "";
-    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
-           "&line=" + StreamableToString(test_part_result.line_number()) +
-           "&message=" + UrlEncode(test_part_result.message()));
-  }
-
- private:
-  // Sends the given message and a newline to the socket.
-  void SendLn(const string& message) { socket_writer_->SendLn(message); }
-
-  // Called at the start of streaming to notify the receiver what
-  // protocol we are using.
-  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
-
-  string FormatBool(bool value) { return value ? "1" : "0"; }
-
-  const scoped_ptr<AbstractSocketWriter> socket_writer_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
-};  // class StreamingListener
-
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
-#undef GTEST_IMPLEMENTATION_
-
-#if GTEST_OS_WINDOWS
-# define vsnprintf _vsnprintf
-#endif  // GTEST_OS_WINDOWS
-
-namespace testing {
-
-using internal::CountIf;
-using internal::ForEach;
-using internal::GetElementOr;
-using internal::Shuffle;
-
-// Constants.
-
-// A test whose test case name or test name matches this filter is
-// disabled and not run.
-static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
-
-// A test case whose name matches this filter is considered a death
-// test case and will be run before test cases whose name doesn't
-// match this filter.
-static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
-
-// A test filter that matches everything.
-static const char kUniversalFilter[] = "*";
-
-// The default output file for XML output.
-static const char kDefaultOutputFile[] = "test_detail.xml";
-
-// The environment variable name for the test shard index.
-static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
-// The environment variable name for the total number of test shards.
-static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
-// The environment variable name for the test shard status file.
-static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
-
-namespace internal {
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-const char kStackTraceMarker[] = "\nStack trace:\n";
-
-// g_help_flag is true iff the --help flag or an equivalent form is
-// specified on the command line.
-bool g_help_flag = false;
-
-}  // namespace internal
-
-static const char* GetDefaultFilter() {
-#ifdef GTEST_TEST_FILTER_ENV_VAR_
-  const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
-  if (testbridge_test_only != NULL) {
-    return testbridge_test_only;
-  }
-#endif  // GTEST_TEST_FILTER_ENV_VAR_
-  return kUniversalFilter;
-}
-
-GTEST_DEFINE_bool_(
-    also_run_disabled_tests,
-    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
-    "Run disabled tests too, in addition to the tests normally being run.");
-
-GTEST_DEFINE_bool_(
-    break_on_failure,
-    internal::BoolFromGTestEnv("break_on_failure", false),
-    "True iff a failed assertion should be a debugger break-point.");
-
-GTEST_DEFINE_bool_(
-    catch_exceptions,
-    internal::BoolFromGTestEnv("catch_exceptions", true),
-    "True iff " GTEST_NAME_
-    " should catch exceptions and treat them as test failures.");
-
-GTEST_DEFINE_string_(
-    color,
-    internal::StringFromGTestEnv("color", "auto"),
-    "Whether to use colors in the output.  Valid values: yes, no, "
-    "and auto.  'auto' means to use colors if the output is "
-    "being sent to a terminal and the TERM environment variable "
-    "is set to a terminal type that supports colors.");
-
-GTEST_DEFINE_string_(
-    filter,
-    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
-    "A colon-separated list of glob (not regex) patterns "
-    "for filtering the tests to run, optionally followed by a "
-    "'-' and a : separated list of negative patterns (tests to "
-    "exclude).  A test is run if it matches one of the positive "
-    "patterns and does not match any of the negative patterns.");
-
-GTEST_DEFINE_bool_(list_tests, false,
-                   "List all tests without running them.");
-
-GTEST_DEFINE_string_(
-    output,
-    internal::StringFromGTestEnv("output", ""),
-    "A format (currently must be \"xml\"), optionally followed "
-    "by a colon and an output file name or directory. A directory "
-    "is indicated by a trailing pathname separator. "
-    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
-    "If a directory is specified, output files will be created "
-    "within that directory, with file-names based on the test "
-    "executable's name and, if necessary, made unique by adding "
-    "digits.");
-
-GTEST_DEFINE_bool_(
-    print_time,
-    internal::BoolFromGTestEnv("print_time", true),
-    "True iff " GTEST_NAME_
-    " should display elapsed time in text output.");
-
-GTEST_DEFINE_int32_(
-    random_seed,
-    internal::Int32FromGTestEnv("random_seed", 0),
-    "Random number seed to use when shuffling test orders.  Must be in range "
-    "[1, 99999], or 0 to use a seed based on the current time.");
-
-GTEST_DEFINE_int32_(
-    repeat,
-    internal::Int32FromGTestEnv("repeat", 1),
-    "How many times to repeat each test.  Specify a negative number "
-    "for repeating forever.  Useful for shaking out flaky tests.");
-
-GTEST_DEFINE_bool_(
-    show_internal_stack_frames, false,
-    "True iff " GTEST_NAME_ " should include internal stack frames when "
-    "printing test failure stack traces.");
-
-GTEST_DEFINE_bool_(
-    shuffle,
-    internal::BoolFromGTestEnv("shuffle", false),
-    "True iff " GTEST_NAME_
-    " should randomize tests' order on every run.");
-
-GTEST_DEFINE_int32_(
-    stack_trace_depth,
-    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
-    "The maximum number of stack frames to print when an "
-    "assertion fails.  The valid range is 0 through 100, inclusive.");
-
-GTEST_DEFINE_string_(
-    stream_result_to,
-    internal::StringFromGTestEnv("stream_result_to", ""),
-    "This flag specifies the host name and the port number on which to stream "
-    "test results. Example: \"localhost:555\". The flag is effective only on "
-    "Linux.");
-
-GTEST_DEFINE_bool_(
-    throw_on_failure,
-    internal::BoolFromGTestEnv("throw_on_failure", false),
-    "When this flag is specified, a failed assertion will throw an exception "
-    "if exceptions are enabled or exit the program with a non-zero code "
-    "otherwise.");
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-GTEST_DEFINE_string_(
-    flagfile,
-    internal::StringFromGTestEnv("flagfile", ""),
-    "This flag specifies the flagfile to read command-line flags from.");
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-namespace internal {
-
-// Generates a random number from [0, range), using a Linear
-// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
-// than kMaxRange.
-UInt32 Random::Generate(UInt32 range) {
-  // These constants are the same as are used in glibc's rand(3).
-  state_ = (1103515245U*state_ + 12345U) % kMaxRange;
-
-  GTEST_CHECK_(range > 0)
-      << "Cannot generate a number in the range [0, 0).";
-  GTEST_CHECK_(range <= kMaxRange)
-      << "Generation of a number in [0, " << range << ") was requested, "
-      << "but this can only generate numbers in [0, " << kMaxRange << ").";
-
-  // Converting via modulus introduces a bit of downward bias, but
-  // it's simple, and a linear congruential generator isn't too good
-  // to begin with.
-  return state_ % range;
-}
-
-// GTestIsInitialized() returns true iff the user has initialized
-// Google Test.  Useful for catching the user mistake of not initializing
-// Google Test before calling RUN_ALL_TESTS().
-static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
-
-// Iterates over a vector of TestCases, keeping a running sum of the
-// results of calling a given int-returning method on each.
-// Returns the sum.
-static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
-                               int (TestCase::*method)() const) {
-  int sum = 0;
-  for (size_t i = 0; i < case_list.size(); i++) {
-    sum += (case_list[i]->*method)();
-  }
-  return sum;
-}
-
-// Returns true iff the test case passed.
-static bool TestCasePassed(const TestCase* test_case) {
-  return test_case->should_run() && test_case->Passed();
-}
-
-// Returns true iff the test case failed.
-static bool TestCaseFailed(const TestCase* test_case) {
-  return test_case->should_run() && test_case->Failed();
-}
-
-// Returns true iff test_case contains at least one test that should
-// run.
-static bool ShouldRunTestCase(const TestCase* test_case) {
-  return test_case->should_run();
-}
-
-// AssertHelper constructor.
-AssertHelper::AssertHelper(TestPartResult::Type type,
-                           const char* file,
-                           int line,
-                           const char* message)
-    : data_(new AssertHelperData(type, file, line, message)) {
-}
-
-AssertHelper::~AssertHelper() {
-  delete data_;
-}
-
-// Message assignment, for assertion streaming support.
-void AssertHelper::operator=(const Message& message) const {
-  UnitTest::GetInstance()->
-    AddTestPartResult(data_->type, data_->file, data_->line,
-                      AppendUserMessage(data_->message, message),
-                      UnitTest::GetInstance()->impl()
-                      ->CurrentOsStackTraceExceptTop(1)
-                      // Skips the stack frame for this function itself.
-                      );  // NOLINT
-}
-
-// Mutex for linked pointers.
-GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
-
-// A copy of all command line arguments.  Set by InitGoogleTest().
-::std::vector<testing::internal::string> g_argvs;
-
-const ::std::vector<testing::internal::string>& GetArgvs() {
-#if defined(GTEST_CUSTOM_GET_ARGVS_)
-  return GTEST_CUSTOM_GET_ARGVS_();
-#else  // defined(GTEST_CUSTOM_GET_ARGVS_)
-  return g_argvs;
-#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
-}
-
-// Returns the current application's name, removing directory path if that
-// is present.
-FilePath GetCurrentExecutableName() {
-  FilePath result;
-
-#if GTEST_OS_WINDOWS
-  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
-#else
-  result.Set(FilePath(GetArgvs()[0]));
-#endif  // GTEST_OS_WINDOWS
-
-  return result.RemoveDirectoryName();
-}
-
-// Functions for processing the gtest_output flag.
-
-// Returns the output format, or "" for normal printed output.
-std::string UnitTestOptions::GetOutputFormat() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  if (gtest_output_flag == NULL) return std::string("");
-
-  const char* const colon = strchr(gtest_output_flag, ':');
-  return (colon == NULL) ?
-      std::string(gtest_output_flag) :
-      std::string(gtest_output_flag, colon - gtest_output_flag);
-}
-
-// Returns the name of the requested output file, or the default if none
-// was explicitly specified.
-std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  if (gtest_output_flag == NULL)
-    return "";
-
-  const char* const colon = strchr(gtest_output_flag, ':');
-  if (colon == NULL)
-    return internal::FilePath::ConcatPaths(
-        internal::FilePath(
-            UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(kDefaultOutputFile)).string();
-
-  internal::FilePath output_name(colon + 1);
-  if (!output_name.IsAbsolutePath())
-    // TODO(wan@google.com): on Windows \some\path is not an absolute
-    // path (as its meaning depends on the current drive), yet the
-    // following logic for turning it into an absolute path is wrong.
-    // Fix it.
-    output_name = internal::FilePath::ConcatPaths(
-        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(colon + 1));
-
-  if (!output_name.IsDirectory())
-    return output_name.string();
-
-  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
-      output_name, internal::GetCurrentExecutableName(),
-      GetOutputFormat().c_str()));
-  return result.string();
-}
-
-// Returns true iff the wildcard pattern matches the string.  The
-// first ':' or '\0' character in pattern marks the end of it.
-//
-// This recursive algorithm isn't very efficient, but is clear and
-// works well enough for matching test names, which are short.
-bool UnitTestOptions::PatternMatchesString(const char *pattern,
-                                           const char *str) {
-  switch (*pattern) {
-    case '\0':
-    case ':':  // Either ':' or '\0' marks the end of the pattern.
-      return *str == '\0';
-    case '?':  // Matches any single character.
-      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
-    case '*':  // Matches any string (possibly empty) of characters.
-      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
-          PatternMatchesString(pattern + 1, str);
-    default:  // Non-special character.  Matches itself.
-      return *pattern == *str &&
-          PatternMatchesString(pattern + 1, str + 1);
-  }
-}
-
-bool UnitTestOptions::MatchesFilter(
-    const std::string& name, const char* filter) {
-  const char *cur_pattern = filter;
-  for (;;) {
-    if (PatternMatchesString(cur_pattern, name.c_str())) {
-      return true;
-    }
-
-    // Finds the next pattern in the filter.
-    cur_pattern = strchr(cur_pattern, ':');
-
-    // Returns if no more pattern can be found.
-    if (cur_pattern == NULL) {
-      return false;
-    }
-
-    // Skips the pattern separater (the ':' character).
-    cur_pattern++;
-  }
-}
-
-// Returns true iff the user-specified filter matches the test case
-// name and the test name.
-bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
-                                        const std::string &test_name) {
-  const std::string& full_name = test_case_name + "." + test_name.c_str();
-
-  // Split --gtest_filter at '-', if there is one, to separate into
-  // positive filter and negative filter portions
-  const char* const p = GTEST_FLAG(filter).c_str();
-  const char* const dash = strchr(p, '-');
-  std::string positive;
-  std::string negative;
-  if (dash == NULL) {
-    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
-    negative = "";
-  } else {
-    positive = std::string(p, dash);   // Everything up to the dash
-    negative = std::string(dash + 1);  // Everything after the dash
-    if (positive.empty()) {
-      // Treat '-test1' as the same as '*-test1'
-      positive = kUniversalFilter;
-    }
-  }
-
-  // A filter is a colon-separated list of patterns.  It matches a
-  // test if any pattern in it matches the test.
-  return (MatchesFilter(full_name, positive.c_str()) &&
-          !MatchesFilter(full_name, negative.c_str()));
-}
-
-#if GTEST_HAS_SEH
-// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-// This function is useful as an __except condition.
-int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
-  // Google Test should handle a SEH exception if:
-  //   1. the user wants it to, AND
-  //   2. this is not a breakpoint exception, AND
-  //   3. this is not a C++ exception (VC++ implements them via SEH,
-  //      apparently).
-  //
-  // SEH exception code for C++ exceptions.
-  // (see http://support.microsoft.com/kb/185294 for more information).
-  const DWORD kCxxExceptionCode = 0xe06d7363;
-
-  bool should_handle = true;
-
-  if (!GTEST_FLAG(catch_exceptions))
-    should_handle = false;
-  else if (exception_code == EXCEPTION_BREAKPOINT)
-    should_handle = false;
-  else if (exception_code == kCxxExceptionCode)
-    should_handle = false;
-
-  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
-}
-#endif  // GTEST_HAS_SEH
-
-}  // namespace internal
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results. Intercepts only failures from the current thread.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    TestPartResultArray* result)
-    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
-      result_(result) {
-  Init();
-}
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    InterceptMode intercept_mode, TestPartResultArray* result)
-    : intercept_mode_(intercept_mode),
-      result_(result) {
-  Init();
-}
-
-void ScopedFakeTestPartResultReporter::Init() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    old_reporter_ = impl->GetGlobalTestPartResultReporter();
-    impl->SetGlobalTestPartResultReporter(this);
-  } else {
-    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
-    impl->SetTestPartResultReporterForCurrentThread(this);
-  }
-}
-
-// The d'tor restores the test part result reporter used by Google Test
-// before.
-ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    impl->SetGlobalTestPartResultReporter(old_reporter_);
-  } else {
-    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
-  }
-}
-
-// Increments the test part result count and remembers the result.
-// This method is from the TestPartResultReporterInterface interface.
-void ScopedFakeTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  result_->Append(result);
-}
-
-namespace internal {
-
-// Returns the type ID of ::testing::Test.  We should always call this
-// instead of GetTypeId< ::testing::Test>() to get the type ID of
-// testing::Test.  This is to work around a suspected linker bug when
-// using Google Test as a framework on Mac OS X.  The bug causes
-// GetTypeId< ::testing::Test>() to return different values depending
-// on whether the call is from the Google Test framework itself or
-// from user test code.  GetTestTypeId() is guaranteed to always
-// return the same value, as it always calls GetTypeId<>() from the
-// gtest.cc, which is within the Google Test framework.
-TypeId GetTestTypeId() {
-  return GetTypeId<Test>();
-}
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
-
-// This predicate-formatter checks that 'results' contains a test part
-// failure of the given type and that the failure message contains the
-// given substring.
-AssertionResult HasOneFailure(const char* /* results_expr */,
-                              const char* /* type_expr */,
-                              const char* /* substr_expr */,
-                              const TestPartResultArray& results,
-                              TestPartResult::Type type,
-                              const string& substr) {
-  const std::string expected(type == TestPartResult::kFatalFailure ?
-                        "1 fatal failure" :
-                        "1 non-fatal failure");
-  Message msg;
-  if (results.size() != 1) {
-    msg << "Expected: " << expected << "\n"
-        << "  Actual: " << results.size() << " failures";
-    for (int i = 0; i < results.size(); i++) {
-      msg << "\n" << results.GetTestPartResult(i);
-    }
-    return AssertionFailure() << msg;
-  }
-
-  const TestPartResult& r = results.GetTestPartResult(0);
-  if (r.type() != type) {
-    return AssertionFailure() << "Expected: " << expected << "\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  if (strstr(r.message(), substr.c_str()) == NULL) {
-    return AssertionFailure() << "Expected: " << expected << " containing \""
-                              << substr << "\"\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  return AssertionSuccess();
-}
-
-// The constructor of SingleFailureChecker remembers where to look up
-// test part results, what type of failure we expect, and what
-// substring the failure message should contain.
-SingleFailureChecker:: SingleFailureChecker(
-    const TestPartResultArray* results,
-    TestPartResult::Type type,
-    const string& substr)
-    : results_(results),
-      type_(type),
-      substr_(substr) {}
-
-// The destructor of SingleFailureChecker verifies that the given
-// TestPartResultArray contains exactly one failure that has the given
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-SingleFailureChecker::~SingleFailureChecker() {
-  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
-}
-
-DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->current_test_result()->AddTestPartResult(result);
-  unit_test_->listeners()->repeater()->OnTestPartResult(result);
-}
-
-DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
-}
-
-// Returns the global test part result reporter.
-TestPartResultReporterInterface*
-UnitTestImpl::GetGlobalTestPartResultReporter() {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  return global_test_part_result_repoter_;
-}
-
-// Sets the global test part result reporter.
-void UnitTestImpl::SetGlobalTestPartResultReporter(
-    TestPartResultReporterInterface* reporter) {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  global_test_part_result_repoter_ = reporter;
-}
-
-// Returns the test part result reporter for the current thread.
-TestPartResultReporterInterface*
-UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
-  return per_thread_test_part_result_reporter_.get();
-}
-
-// Sets the test part result reporter for the current thread.
-void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
-    TestPartResultReporterInterface* reporter) {
-  per_thread_test_part_result_reporter_.set(reporter);
-}
-
-// Gets the number of successful test cases.
-int UnitTestImpl::successful_test_case_count() const {
-  return CountIf(test_cases_, TestCasePassed);
-}
-
-// Gets the number of failed test cases.
-int UnitTestImpl::failed_test_case_count() const {
-  return CountIf(test_cases_, TestCaseFailed);
-}
-
-// Gets the number of all test cases.
-int UnitTestImpl::total_test_case_count() const {
-  return static_cast<int>(test_cases_.size());
-}
-
-// Gets the number of all test cases that contain at least one test
-// that should run.
-int UnitTestImpl::test_case_to_run_count() const {
-  return CountIf(test_cases_, ShouldRunTestCase);
-}
-
-// Gets the number of successful tests.
-int UnitTestImpl::successful_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
-}
-
-// Gets the number of failed tests.
-int UnitTestImpl::failed_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
-}
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int UnitTestImpl::reportable_disabled_test_count() const {
-  return SumOverTestCaseList(test_cases_,
-                             &TestCase::reportable_disabled_test_count);
-}
-
-// Gets the number of disabled tests.
-int UnitTestImpl::disabled_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTestImpl::reportable_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
-}
-
-// Gets the number of all tests.
-int UnitTestImpl::total_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
-}
-
-// Gets the number of tests that should run.
-int UnitTestImpl::test_to_run_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
-  return os_stack_trace_getter()->CurrentStackTrace(
-      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
-      skip_count + 1
-      // Skips the user-specified number of frames plus this function
-      // itself.
-      );  // NOLINT
-}
-
-// Returns the current time in milliseconds.
-TimeInMillis GetTimeInMillis() {
-#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
-  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
-  // http://analogous.blogspot.com/2005/04/epoch.html
-  const TimeInMillis kJavaEpochToWinFileTimeDelta =
-    static_cast<TimeInMillis>(116444736UL) * 100000UL;
-  const DWORD kTenthMicrosInMilliSecond = 10000;
-
-  SYSTEMTIME now_systime;
-  FILETIME now_filetime;
-  ULARGE_INTEGER now_int64;
-  // TODO(kenton@google.com): Shouldn't this just use
-  //   GetSystemTimeAsFileTime()?
-  GetSystemTime(&now_systime);
-  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
-    now_int64.LowPart = now_filetime.dwLowDateTime;
-    now_int64.HighPart = now_filetime.dwHighDateTime;
-    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
-      kJavaEpochToWinFileTimeDelta;
-    return now_int64.QuadPart;
-  }
-  return 0;
-#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
-  __timeb64 now;
-
-  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
-  // (deprecated function) there.
-  // TODO(kenton@google.com): Use GetTickCount()?  Or use
-  //   SystemTimeToFileTime()
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-  _ftime64(&now);
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
-#elif GTEST_HAS_GETTIMEOFDAY_
-  struct timeval now;
-  gettimeofday(&now, NULL);
-  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
-#else
-# error "Don't know how to get the current time on your system."
-#endif
-}
-
-// Utilities
-
-// class String.
-
-#if GTEST_OS_WINDOWS_MOBILE
-// Creates a UTF-16 wide string from the given ANSI string, allocating
-// memory using new. The caller is responsible for deleting the return
-// value using delete[]. Returns the wide string, or NULL if the
-// input is NULL.
-LPCWSTR String::AnsiToUtf16(const char* ansi) {
-  if (!ansi) return NULL;
-  const int length = strlen(ansi);
-  const int unicode_length =
-      MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                          NULL, 0);
-  WCHAR* unicode = new WCHAR[unicode_length + 1];
-  MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                      unicode, unicode_length);
-  unicode[unicode_length] = 0;
-  return unicode;
-}
-
-// Creates an ANSI string from the given wide string, allocating
-// memory using new. The caller is responsible for deleting the return
-// value using delete[]. Returns the ANSI string, or NULL if the
-// input is NULL.
-const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
-  if (!utf16_str) return NULL;
-  const int ansi_length =
-      WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
-                          NULL, 0, NULL, NULL);
-  char* ansi = new char[ansi_length + 1];
-  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
-                      ansi, ansi_length, NULL, NULL);
-  ansi[ansi_length] = 0;
-  return ansi;
-}
-
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Compares two C strings.  Returns true iff they have the same content.
-//
-// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
-// C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::CStringEquals(const char * lhs, const char * rhs) {
-  if ( lhs == NULL ) return rhs == NULL;
-
-  if ( rhs == NULL ) return false;
-
-  return strcmp(lhs, rhs) == 0;
-}
-
-#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
-
-// Converts an array of wide chars to a narrow string using the UTF-8
-// encoding, and streams the result to the given Message object.
-static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
-                                     Message* msg) {
-  for (size_t i = 0; i != length; ) {  // NOLINT
-    if (wstr[i] != L'\0') {
-      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
-      while (i != length && wstr[i] != L'\0')
-        i++;
-    } else {
-      *msg << '\0';
-      i++;
-    }
-  }
-}
-
-#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
-
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest) {
-  ::std::vector< ::std::string> parsed;
-  ::std::string::size_type pos = 0;
-  while (::testing::internal::AlwaysTrue()) {
-    const ::std::string::size_type colon = str.find(delimiter, pos);
-    if (colon == ::std::string::npos) {
-      parsed.push_back(str.substr(pos));
-      break;
-    } else {
-      parsed.push_back(str.substr(pos, colon - pos));
-      pos = colon + 1;
-    }
-  }
-  dest->swap(parsed);
-}
-
-}  // namespace internal
-
-// Constructs an empty Message.
-// We allocate the stringstream separately because otherwise each use of
-// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
-// stack frame leading to huge stack frames in some cases; gcc does not reuse
-// the stack space.
-Message::Message() : ss_(new ::std::stringstream) {
-  // By default, we want there to be enough precision when printing
-  // a double to a Message.
-  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
-}
-
-// These two overloads allow streaming a wide C string to a Message
-// using the UTF-8 encoding.
-Message& Message::operator <<(const wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-Message& Message::operator <<(wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-
-#if GTEST_HAS_STD_WSTRING
-// Converts the given wide string to a narrow string using the UTF-8
-// encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::std::wstring& wstr) {
-  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
-  return *this;
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-// Converts the given wide string to a narrow string using the UTF-8
-// encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::wstring& wstr) {
-  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
-  return *this;
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// Gets the text streamed to this object so far as an std::string.
-// Each '\0' character in the buffer is replaced with "\\0".
-std::string Message::GetString() const {
-  return internal::StringStreamToString(ss_.get());
-}
-
-// AssertionResult constructors.
-// Used in EXPECT_TRUE/FALSE(assertion_result).
-AssertionResult::AssertionResult(const AssertionResult& other)
-    : success_(other.success_),
-      message_(other.message_.get() != NULL ?
-               new ::std::string(*other.message_) :
-               static_cast< ::std::string*>(NULL)) {
-}
-
-// Swaps two AssertionResults.
-void AssertionResult::swap(AssertionResult& other) {
-  using std::swap;
-  swap(success_, other.success_);
-  swap(message_, other.message_);
-}
-
-// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-AssertionResult AssertionResult::operator!() const {
-  AssertionResult negation(!success_);
-  if (message_.get() != NULL)
-    negation << *message_;
-  return negation;
-}
-
-// Makes a successful assertion result.
-AssertionResult AssertionSuccess() {
-  return AssertionResult(true);
-}
-
-// Makes a failed assertion result.
-AssertionResult AssertionFailure() {
-  return AssertionResult(false);
-}
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << message.
-AssertionResult AssertionFailure(const Message& message) {
-  return AssertionFailure() << message;
-}
-
-namespace internal {
-
-namespace edit_distance {
-std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
-                                            const std::vector<size_t>& right) {
-  std::vector<std::vector<double> > costs(
-      left.size() + 1, std::vector<double>(right.size() + 1));
-  std::vector<std::vector<EditType> > best_move(
-      left.size() + 1, std::vector<EditType>(right.size() + 1));
-
-  // Populate for empty right.
-  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
-    costs[l_i][0] = static_cast<double>(l_i);
-    best_move[l_i][0] = kRemove;
-  }
-  // Populate for empty left.
-  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
-    costs[0][r_i] = static_cast<double>(r_i);
-    best_move[0][r_i] = kAdd;
-  }
-
-  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
-    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
-      if (left[l_i] == right[r_i]) {
-        // Found a match. Consume it.
-        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
-        best_move[l_i + 1][r_i + 1] = kMatch;
-        continue;
-      }
-
-      const double add = costs[l_i + 1][r_i];
-      const double remove = costs[l_i][r_i + 1];
-      const double replace = costs[l_i][r_i];
-      if (add < remove && add < replace) {
-        costs[l_i + 1][r_i + 1] = add + 1;
-        best_move[l_i + 1][r_i + 1] = kAdd;
-      } else if (remove < add && remove < replace) {
-        costs[l_i + 1][r_i + 1] = remove + 1;
-        best_move[l_i + 1][r_i + 1] = kRemove;
-      } else {
-        // We make replace a little more expensive than add/remove to lower
-        // their priority.
-        costs[l_i + 1][r_i + 1] = replace + 1.00001;
-        best_move[l_i + 1][r_i + 1] = kReplace;
-      }
-    }
-  }
-
-  // Reconstruct the best path. We do it in reverse order.
-  std::vector<EditType> best_path;
-  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
-    EditType move = best_move[l_i][r_i];
-    best_path.push_back(move);
-    l_i -= move != kAdd;
-    r_i -= move != kRemove;
-  }
-  std::reverse(best_path.begin(), best_path.end());
-  return best_path;
-}
-
-namespace {
-
-// Helper class to convert string into ids with deduplication.
-class InternalStrings {
- public:
-  size_t GetId(const std::string& str) {
-    IdMap::iterator it = ids_.find(str);
-    if (it != ids_.end()) return it->second;
-    size_t id = ids_.size();
-    return ids_[str] = id;
-  }
-
- private:
-  typedef std::map<std::string, size_t> IdMap;
-  IdMap ids_;
-};
-
-}  // namespace
-
-std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right) {
-  std::vector<size_t> left_ids, right_ids;
-  {
-    InternalStrings intern_table;
-    for (size_t i = 0; i < left.size(); ++i) {
-      left_ids.push_back(intern_table.GetId(left[i]));
-    }
-    for (size_t i = 0; i < right.size(); ++i) {
-      right_ids.push_back(intern_table.GetId(right[i]));
-    }
-  }
-  return CalculateOptimalEdits(left_ids, right_ids);
-}
-
-namespace {
-
-// Helper class that holds the state for one hunk and prints it out to the
-// stream.
-// It reorders adds/removes when possible to group all removes before all
-// adds. It also adds the hunk header before printint into the stream.
-class Hunk {
- public:
-  Hunk(size_t left_start, size_t right_start)
-      : left_start_(left_start),
-        right_start_(right_start),
-        adds_(),
-        removes_(),
-        common_() {}
-
-  void PushLine(char edit, const char* line) {
-    switch (edit) {
-      case ' ':
-        ++common_;
-        FlushEdits();
-        hunk_.push_back(std::make_pair(' ', line));
-        break;
-      case '-':
-        ++removes_;
-        hunk_removes_.push_back(std::make_pair('-', line));
-        break;
-      case '+':
-        ++adds_;
-        hunk_adds_.push_back(std::make_pair('+', line));
-        break;
-    }
-  }
-
-  void PrintTo(std::ostream* os) {
-    PrintHeader(os);
-    FlushEdits();
-    for (std::list<std::pair<char, const char*> >::const_iterator it =
-             hunk_.begin();
-         it != hunk_.end(); ++it) {
-      *os << it->first << it->second << "\n";
-    }
-  }
-
-  bool has_edits() const { return adds_ || removes_; }
-
- private:
-  void FlushEdits() {
-    hunk_.splice(hunk_.end(), hunk_removes_);
-    hunk_.splice(hunk_.end(), hunk_adds_);
-  }
-
-  // Print a unified diff header for one hunk.
-  // The format is
-  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
-  // where the left/right parts are ommitted if unnecessary.
-  void PrintHeader(std::ostream* ss) const {
-    *ss << "@@ ";
-    if (removes_) {
-      *ss << "-" << left_start_ << "," << (removes_ + common_);
-    }
-    if (removes_ && adds_) {
-      *ss << " ";
-    }
-    if (adds_) {
-      *ss << "+" << right_start_ << "," << (adds_ + common_);
-    }
-    *ss << " @@\n";
-  }
-
-  size_t left_start_, right_start_;
-  size_t adds_, removes_, common_;
-  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
-};
-
-}  // namespace
-
-// Create a list of diff hunks in Unified diff format.
-// Each hunk has a header generated by PrintHeader above plus a body with
-// lines prefixed with ' ' for no change, '-' for deletion and '+' for
-// addition.
-// 'context' represents the desired unchanged prefix/suffix around the diff.
-// If two hunks are close enough that their contexts overlap, then they are
-// joined into one hunk.
-std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                              const std::vector<std::string>& right,
-                              size_t context) {
-  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
-
-  size_t l_i = 0, r_i = 0, edit_i = 0;
-  std::stringstream ss;
-  while (edit_i < edits.size()) {
-    // Find first edit.
-    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
-      ++l_i;
-      ++r_i;
-      ++edit_i;
-    }
-
-    // Find the first line to include in the hunk.
-    const size_t prefix_context = std::min(l_i, context);
-    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
-    for (size_t i = prefix_context; i > 0; --i) {
-      hunk.PushLine(' ', left[l_i - i].c_str());
-    }
-
-    // Iterate the edits until we found enough suffix for the hunk or the input
-    // is over.
-    size_t n_suffix = 0;
-    for (; edit_i < edits.size(); ++edit_i) {
-      if (n_suffix >= context) {
-        // Continue only if the next hunk is very close.
-        std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
-        while (it != edits.end() && *it == kMatch) ++it;
-        if (it == edits.end() || (it - edits.begin()) - edit_i >= context) {
-          // There is no next edit or it is too far away.
-          break;
-        }
-      }
-
-      EditType edit = edits[edit_i];
-      // Reset count when a non match is found.
-      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
-
-      if (edit == kMatch || edit == kRemove || edit == kReplace) {
-        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
-      }
-      if (edit == kAdd || edit == kReplace) {
-        hunk.PushLine('+', right[r_i].c_str());
-      }
-
-      // Advance indices, depending on edit type.
-      l_i += edit != kAdd;
-      r_i += edit != kRemove;
-    }
-
-    if (!hunk.has_edits()) {
-      // We are done. We don't want this hunk.
-      break;
-    }
-
-    hunk.PrintTo(&ss);
-  }
-  return ss.str();
-}
-
-}  // namespace edit_distance
-
-namespace {
-
-// The string representation of the values received in EqFailure() are already
-// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
-// characters the same.
-std::vector<std::string> SplitEscapedString(const std::string& str) {
-  std::vector<std::string> lines;
-  size_t start = 0, end = str.size();
-  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
-    ++start;
-    --end;
-  }
-  bool escaped = false;
-  for (size_t i = start; i + 1 < end; ++i) {
-    if (escaped) {
-      escaped = false;
-      if (str[i] == 'n') {
-        lines.push_back(str.substr(start, i - start - 1));
-        start = i + 1;
-      }
-    } else {
-      escaped = str[i] == '\\';
-    }
-  }
-  lines.push_back(str.substr(start, end - start));
-  return lines;
-}
-
-}  // namespace
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   expected_expression: "foo"
-//   actual_expression:   "bar"
-//   expected_value:      "5"
-//   actual_value:        "6"
-//
-// The ignoring_case parameter is true iff the assertion is a
-// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
-// be inserted into the message.
-AssertionResult EqFailure(const char* expected_expression,
-                          const char* actual_expression,
-                          const std::string& expected_value,
-                          const std::string& actual_value,
-                          bool ignoring_case) {
-  Message msg;
-  msg << "Value of: " << actual_expression;
-  if (actual_value != actual_expression) {
-    msg << "\n  Actual: " << actual_value;
-  }
-
-  msg << "\nExpected: " << expected_expression;
-  if (ignoring_case) {
-    msg << " (ignoring case)";
-  }
-  if (expected_value != expected_expression) {
-    msg << "\nWhich is: " << expected_value;
-  }
-
-  if (!expected_value.empty() && !actual_value.empty()) {
-    const std::vector<std::string> expected_lines =
-        SplitEscapedString(expected_value);
-    const std::vector<std::string> actual_lines =
-        SplitEscapedString(actual_value);
-    if (expected_lines.size() > 1 || actual_lines.size() > 1) {
-      msg << "\nWith diff:\n"
-          << edit_distance::CreateUnifiedDiff(expected_lines, actual_lines);
-    }
-  }
-
-  return AssertionFailure() << msg;
-}
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value) {
-  const char* actual_message = assertion_result.message();
-  Message msg;
-  msg << "Value of: " << expression_text
-      << "\n  Actual: " << actual_predicate_value;
-  if (actual_message[0] != '\0')
-    msg << " (" << actual_message << ")";
-  msg << "\nExpected: " << expected_predicate_value;
-  return msg.GetString();
-}
-
-// Helper function for implementing ASSERT_NEAR.
-AssertionResult DoubleNearPredFormat(const char* expr1,
-                                     const char* expr2,
-                                     const char* abs_error_expr,
-                                     double val1,
-                                     double val2,
-                                     double abs_error) {
-  const double diff = fabs(val1 - val2);
-  if (diff <= abs_error) return AssertionSuccess();
-
-  // TODO(wan): do not print the value of an expression if it's
-  // already a literal.
-  return AssertionFailure()
-      << "The difference between " << expr1 << " and " << expr2
-      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
-      << expr1 << " evaluates to " << val1 << ",\n"
-      << expr2 << " evaluates to " << val2 << ", and\n"
-      << abs_error_expr << " evaluates to " << abs_error << ".";
-}
-
-
-// Helper template for implementing FloatLE() and DoubleLE().
-template <typename RawType>
-AssertionResult FloatingPointLE(const char* expr1,
-                                const char* expr2,
-                                RawType val1,
-                                RawType val2) {
-  // Returns success if val1 is less than val2,
-  if (val1 < val2) {
-    return AssertionSuccess();
-  }
-
-  // or if val1 is almost equal to val2.
-  const FloatingPoint<RawType> lhs(val1), rhs(val2);
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  // Note that the above two checks will both fail if either val1 or
-  // val2 is NaN, as the IEEE floating-point standard requires that
-  // any predicate involving a NaN must return false.
-
-  ::std::stringstream val1_ss;
-  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val1;
-
-  ::std::stringstream val2_ss;
-  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val2;
-
-  return AssertionFailure()
-      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
-      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
-      << StringStreamToString(&val2_ss);
-}
-
-}  // namespace internal
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult FloatLE(const char* expr1, const char* expr2,
-                        float val1, float val2) {
-  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
-}
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                         double val1, double val2) {
-  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
-}
-
-namespace internal {
-
-// The helper function for {ASSERT|EXPECT}_EQ with int or enum
-// arguments.
-AssertionResult CmpHelperEQ(const char* expected_expression,
-                            const char* actual_expression,
-                            BiggestInt expected,
-                            BiggestInt actual) {
-  if (expected == actual) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   FormatForComparisonFailureMessage(expected, actual),
-                   FormatForComparisonFailureMessage(actual, expected),
-                   false);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
-// just to avoid copy-and-paste of similar code.
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   BiggestInt val1, BiggestInt val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return AssertionFailure() \
-        << "Expected: (" << expr1 << ") " #op " (" << expr2\
-        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
-        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
-  }\
-}
-
-// Implements the helper function for {ASSERT|EXPECT}_NE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(NE, !=)
-// Implements the helper function for {ASSERT|EXPECT}_LE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LE, <=)
-// Implements the helper function for {ASSERT|EXPECT}_LT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LT, < )
-// Implements the helper function for {ASSERT|EXPECT}_GE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GE, >=)
-// Implements the helper function for {ASSERT|EXPECT}_GT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GT, > )
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-AssertionResult CmpHelperSTREQ(const char* expected_expression,
-                               const char* actual_expression,
-                               const char* expected,
-                               const char* actual) {
-  if (String::CStringEquals(expected, actual)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   PrintToString(expected),
-                   PrintToString(actual),
-                   false);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
-                                   const char* actual_expression,
-                                   const char* expected,
-                                   const char* actual) {
-  if (String::CaseInsensitiveCStringEquals(expected, actual)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   PrintToString(expected),
-                   PrintToString(actual),
-                   true);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const char* s1,
-                               const char* s2) {
-  if (!String::CStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                              << s2_expression << "), actual: \""
-                              << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                   const char* s2_expression,
-                                   const char* s1,
-                                   const char* s2) {
-  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure()
-        << "Expected: (" << s1_expression << ") != ("
-        << s2_expression << ") (ignoring case), actual: \""
-        << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-}  // namespace internal
-
-namespace {
-
-// Helper functions for implementing IsSubString() and IsNotSubstring().
-
-// This group of overloaded functions return true iff needle is a
-// substring of haystack.  NULL is considered a substring of itself
-// only.
-
-bool IsSubstringPred(const char* needle, const char* haystack) {
-  if (needle == NULL || haystack == NULL)
-    return needle == haystack;
-
-  return strstr(haystack, needle) != NULL;
-}
-
-bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
-  if (needle == NULL || haystack == NULL)
-    return needle == haystack;
-
-  return wcsstr(haystack, needle) != NULL;
-}
-
-// StringType here can be either ::std::string or ::std::wstring.
-template <typename StringType>
-bool IsSubstringPred(const StringType& needle,
-                     const StringType& haystack) {
-  return haystack.find(needle) != StringType::npos;
-}
-
-// This function implements either IsSubstring() or IsNotSubstring(),
-// depending on the value of the expected_to_be_substring parameter.
-// StringType here can be const char*, const wchar_t*, ::std::string,
-// or ::std::wstring.
-template <typename StringType>
-AssertionResult IsSubstringImpl(
-    bool expected_to_be_substring,
-    const char* needle_expr, const char* haystack_expr,
-    const StringType& needle, const StringType& haystack) {
-  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
-    return AssertionSuccess();
-
-  const bool is_wide_string = sizeof(needle[0]) > 1;
-  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
-  return AssertionFailure()
-      << "Value of: " << needle_expr << "\n"
-      << "  Actual: " << begin_string_quote << needle << "\"\n"
-      << "Expected: " << (expected_to_be_substring ? "" : "not ")
-      << "a substring of " << haystack_expr << "\n"
-      << "Which is: " << begin_string_quote << haystack << "\"";
-}
-
-}  // namespace
-
-// IsSubstring() and IsNotSubstring() check whether needle is a
-// substring of haystack (NULL is considered a substring of itself
-// only), and return an appropriate error message when they fail.
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-#if GTEST_HAS_STD_WSTRING
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-
-namespace {
-
-// Helper function for IsHRESULT{SuccessFailure} predicates
-AssertionResult HRESULTFailureHelper(const char* expr,
-                                     const char* expected,
-                                     long hr) {  // NOLINT
-# if GTEST_OS_WINDOWS_MOBILE
-
-  // Windows CE doesn't support FormatMessage.
-  const char error_text[] = "";
-
-# else
-
-  // Looks up the human-readable system message for the HRESULT code
-  // and since we're not passing any params to FormatMessage, we don't
-  // want inserts expanded.
-  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS;
-  const DWORD kBufSize = 4096;
-  // Gets the system's human readable message string for this HRESULT.
-  char error_text[kBufSize] = { '\0' };
-  DWORD message_length = ::FormatMessageA(kFlags,
-                                          0,  // no source, we're asking system
-                                          hr,  // the error
-                                          0,  // no line width restrictions
-                                          error_text,  // output buffer
-                                          kBufSize,  // buf size
-                                          NULL);  // no arguments for inserts
-  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
-  for (; message_length && IsSpace(error_text[message_length - 1]);
-          --message_length) {
-    error_text[message_length - 1] = '\0';
-  }
-
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-  const std::string error_hex("0x" + String::FormatHexInt(hr));
-  return ::testing::AssertionFailure()
-      << "Expected: " << expr << " " << expected << ".\n"
-      << "  Actual: " << error_hex << " " << error_text << "\n";
-}
-
-}  // namespace
-
-AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
-  if (SUCCEEDED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "succeeds", hr);
-}
-
-AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
-  if (FAILED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "fails", hr);
-}
-
-#endif  // GTEST_OS_WINDOWS
-
-// Utility functions for encoding Unicode text (wide strings) in
-// UTF-8.
-
-// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
-// like this:
-//
-// Code-point length   Encoding
-//   0 -  7 bits       0xxxxxxx
-//   8 - 11 bits       110xxxxx 10xxxxxx
-//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
-//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-
-// The maximum code-point a one-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
-
-// The maximum code-point a two-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
-
-// The maximum code-point a three-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
-
-// The maximum code-point a four-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
-
-// Chops off the n lowest bits from a bit pattern.  Returns the n
-// lowest bits.  As a side effect, the original bit pattern will be
-// shifted to the right by n bits.
-inline UInt32 ChopLowBits(UInt32* bits, int n) {
-  const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
-  *bits >>= n;
-  return low_bits;
-}
-
-// Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type UInt32 because wchar_t may not be
-// wide enough to contain a code point.
-// If the code_point is not a valid Unicode code point
-// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
-// to "(Invalid Unicode 0xXXXXXXXX)".
-std::string CodePointToUtf8(UInt32 code_point) {
-  if (code_point > kMaxCodePoint4) {
-    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
-  }
-
-  char str[5];  // Big enough for the largest valid code point.
-  if (code_point <= kMaxCodePoint1) {
-    str[1] = '\0';
-    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
-  } else if (code_point <= kMaxCodePoint2) {
-    str[2] = '\0';
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
-  } else if (code_point <= kMaxCodePoint3) {
-    str[3] = '\0';
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
-  } else {  // code_point <= kMaxCodePoint4
-    str[4] = '\0';
-    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
-  }
-  return str;
-}
-
-// The following two functions only make sense if the the system
-// uses UTF-16 for wide string encoding. All supported systems
-// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
-
-// Determines if the arguments constitute UTF-16 surrogate pair
-// and thus should be combined into a single Unicode code point
-// using CreateCodePointFromUtf16SurrogatePair.
-inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
-  return sizeof(wchar_t) == 2 &&
-      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
-}
-
-// Creates a Unicode code point from UTF16 surrogate pair.
-inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
-                                                    wchar_t second) {
-  const UInt32 mask = (1 << 10) - 1;
-  return (sizeof(wchar_t) == 2) ?
-      (((first & mask) << 10) | (second & mask)) + 0x10000 :
-      // This function should not be called when the condition is
-      // false, but we provide a sensible default in case it is.
-      static_cast<UInt32>(first);
-}
-
-// Converts a wide string to a narrow string in UTF-8 encoding.
-// The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
-//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
-// Parameter str points to a null-terminated wide string.
-// Parameter num_chars may additionally limit the number
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
-  if (num_chars == -1)
-    num_chars = static_cast<int>(wcslen(str));
-
-  ::std::stringstream stream;
-  for (int i = 0; i < num_chars; ++i) {
-    UInt32 unicode_code_point;
-
-    if (str[i] == L'\0') {
-      break;
-    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
-      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
-                                                                 str[i + 1]);
-      i++;
-    } else {
-      unicode_code_point = static_cast<UInt32>(str[i]);
-    }
-
-    stream << CodePointToUtf8(unicode_code_point);
-  }
-  return StringStreamToString(&stream);
-}
-
-// Converts a wide C string to an std::string using the UTF-8 encoding.
-// NULL will be converted to "(null)".
-std::string String::ShowWideCString(const wchar_t * wide_c_str) {
-  if (wide_c_str == NULL)  return "(null)";
-
-  return internal::WideStringToUtf8(wide_c_str, -1);
-}
-
-// Compares two wide C strings.  Returns true iff they have the same
-// content.
-//
-// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
-// C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
-  if (lhs == NULL) return rhs == NULL;
-
-  if (rhs == NULL) return false;
-
-  return wcscmp(lhs, rhs) == 0;
-}
-
-// Helper function for *_STREQ on wide strings.
-AssertionResult CmpHelperSTREQ(const char* expected_expression,
-                               const char* actual_expression,
-                               const wchar_t* expected,
-                               const wchar_t* actual) {
-  if (String::WideCStringEquals(expected, actual)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(expected_expression,
-                   actual_expression,
-                   PrintToString(expected),
-                   PrintToString(actual),
-                   false);
-}
-
-// Helper function for *_STRNE on wide strings.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const wchar_t* s1,
-                               const wchar_t* s2) {
-  if (!String::WideCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  }
-
-  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                            << s2_expression << "), actual: "
-                            << PrintToString(s1)
-                            << " vs " << PrintToString(s2);
-}
-
-// Compares two C strings, ignoring case.  Returns true iff they have
-// the same content.
-//
-// Unlike strcasecmp(), this function can handle NULL argument(s).  A
-// NULL C string is considered different to any non-NULL C string,
-// including the empty string.
-bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
-  if (lhs == NULL)
-    return rhs == NULL;
-  if (rhs == NULL)
-    return false;
-  return posix::StrCaseCmp(lhs, rhs) == 0;
-}
-
-  // Compares two wide C strings, ignoring case.  Returns true iff they
-  // have the same content.
-  //
-  // Unlike wcscasecmp(), this function can handle NULL argument(s).
-  // A NULL C string is considered different to any non-NULL wide C string,
-  // including the empty string.
-  // NB: The implementations on different platforms slightly differ.
-  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
-  // environment variable. On GNU platform this method uses wcscasecmp
-  // which compares according to LC_CTYPE category of the current locale.
-  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
-  // current locale.
-bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
-                                              const wchar_t* rhs) {
-  if (lhs == NULL) return rhs == NULL;
-
-  if (rhs == NULL) return false;
-
-#if GTEST_OS_WINDOWS
-  return _wcsicmp(lhs, rhs) == 0;
-#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
-  return wcscasecmp(lhs, rhs) == 0;
-#else
-  // Android, Mac OS X and Cygwin don't define wcscasecmp.
-  // Other unknown OSes may not define it either.
-  wint_t left, right;
-  do {
-    left = towlower(*lhs++);
-    right = towlower(*rhs++);
-  } while (left && left == right);
-  return left == right;
-#endif  // OS selector
-}
-
-// Returns true iff str ends with the given suffix, ignoring case.
-// Any string is considered to end with an empty suffix.
-bool String::EndsWithCaseInsensitive(
-    const std::string& str, const std::string& suffix) {
-  const size_t str_len = str.length();
-  const size_t suffix_len = suffix.length();
-  return (str_len >= suffix_len) &&
-         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
-                                      suffix.c_str());
-}
-
-// Formats an int value as "%02d".
-std::string String::FormatIntWidth2(int value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << value;
-  return ss.str();
-}
-
-// Formats an int value as "%X".
-std::string String::FormatHexInt(int value) {
-  std::stringstream ss;
-  ss << std::hex << std::uppercase << value;
-  return ss.str();
-}
-
-// Formats a byte as "%02X".
-std::string String::FormatByte(unsigned char value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
-     << static_cast<unsigned int>(value);
-  return ss.str();
-}
-
-// Converts the buffer in a stringstream to an std::string, converting NUL
-// bytes to "\\0" along the way.
-std::string StringStreamToString(::std::stringstream* ss) {
-  const ::std::string& str = ss->str();
-  const char* const start = str.c_str();
-  const char* const end = start + str.length();
-
-  std::string result;
-  result.reserve(2 * (end - start));
-  for (const char* ch = start; ch != end; ++ch) {
-    if (*ch == '\0') {
-      result += "\\0";  // Replaces NUL with "\\0";
-    } else {
-      result += *ch;
-    }
-  }
-
-  return result;
-}
-
-// Appends the user-supplied message to the Google-Test-generated message.
-std::string AppendUserMessage(const std::string& gtest_msg,
-                              const Message& user_msg) {
-  // Appends the user message if it's non-empty.
-  const std::string user_msg_string = user_msg.GetString();
-  if (user_msg_string.empty()) {
-    return gtest_msg;
-  }
-
-  return gtest_msg + "\n" + user_msg_string;
-}
-
-}  // namespace internal
-
-// class TestResult
-
-// Creates an empty TestResult.
-TestResult::TestResult()
-    : death_test_count_(0),
-      elapsed_time_(0) {
-}
-
-// D'tor.
-TestResult::~TestResult() {
-}
-
-// Returns the i-th test part result among all the results. i can
-// range from 0 to total_part_count() - 1. If i is not in that range,
-// aborts the program.
-const TestPartResult& TestResult::GetTestPartResult(int i) const {
-  if (i < 0 || i >= total_part_count())
-    internal::posix::Abort();
-  return test_part_results_.at(i);
-}
-
-// Returns the i-th test property. i can range from 0 to
-// test_property_count() - 1. If i is not in that range, aborts the
-// program.
-const TestProperty& TestResult::GetTestProperty(int i) const {
-  if (i < 0 || i >= test_property_count())
-    internal::posix::Abort();
-  return test_properties_.at(i);
-}
-
-// Clears the test part results.
-void TestResult::ClearTestPartResults() {
-  test_part_results_.clear();
-}
-
-// Adds a test part result to the list.
-void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
-  test_part_results_.push_back(test_part_result);
-}
-
-// Adds a test property to the list. If a property with the same key as the
-// supplied property is already represented, the value of this test_property
-// replaces the old value for that key.
-void TestResult::RecordProperty(const std::string& xml_element,
-                                const TestProperty& test_property) {
-  if (!ValidateTestProperty(xml_element, test_property)) {
-    return;
-  }
-  internal::MutexLock lock(&test_properites_mutex_);
-  const std::vector<TestProperty>::iterator property_with_matching_key =
-      std::find_if(test_properties_.begin(), test_properties_.end(),
-                   internal::TestPropertyKeyIs(test_property.key()));
-  if (property_with_matching_key == test_properties_.end()) {
-    test_properties_.push_back(test_property);
-    return;
-  }
-  property_with_matching_key->SetValue(test_property.value());
-}
-
-// The list of reserved attributes used in the <testsuites> element of XML
-// output.
-static const char* const kReservedTestSuitesAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "random_seed",
-  "tests",
-  "time",
-  "timestamp"
-};
-
-// The list of reserved attributes used in the <testsuite> element of XML
-// output.
-static const char* const kReservedTestSuiteAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "tests",
-  "time"
-};
-
-// The list of reserved attributes used in the <testcase> element of XML output.
-static const char* const kReservedTestCaseAttributes[] = {
-  "classname",
-  "name",
-  "status",
-  "time",
-  "type_param",
-  "value_param"
-};
-
-template <int kSize>
-std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
-  return std::vector<std::string>(array, array + kSize);
-}
-
-static std::vector<std::string> GetReservedAttributesForElement(
-    const std::string& xml_element) {
-  if (xml_element == "testsuites") {
-    return ArrayAsVector(kReservedTestSuitesAttributes);
-  } else if (xml_element == "testsuite") {
-    return ArrayAsVector(kReservedTestSuiteAttributes);
-  } else if (xml_element == "testcase") {
-    return ArrayAsVector(kReservedTestCaseAttributes);
-  } else {
-    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
-  }
-  // This code is unreachable but some compilers may not realizes that.
-  return std::vector<std::string>();
-}
-
-static std::string FormatWordList(const std::vector<std::string>& words) {
-  Message word_list;
-  for (size_t i = 0; i < words.size(); ++i) {
-    if (i > 0 && words.size() > 2) {
-      word_list << ", ";
-    }
-    if (i == words.size() - 1) {
-      word_list << "and ";
-    }
-    word_list << "'" << words[i] << "'";
-  }
-  return word_list.GetString();
-}
-
-bool ValidateTestPropertyName(const std::string& property_name,
-                              const std::vector<std::string>& reserved_names) {
-  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
-          reserved_names.end()) {
-    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
-                  << " (" << FormatWordList(reserved_names)
-                  << " are reserved by " << GTEST_NAME_ << ")";
-    return false;
-  }
-  return true;
-}
-
-// Adds a failure if the key is a reserved attribute of the element named
-// xml_element.  Returns true if the property is valid.
-bool TestResult::ValidateTestProperty(const std::string& xml_element,
-                                      const TestProperty& test_property) {
-  return ValidateTestPropertyName(test_property.key(),
-                                  GetReservedAttributesForElement(xml_element));
-}
-
-// Clears the object.
-void TestResult::Clear() {
-  test_part_results_.clear();
-  test_properties_.clear();
-  death_test_count_ = 0;
-  elapsed_time_ = 0;
-}
-
-// Returns true iff the test failed.
-bool TestResult::Failed() const {
-  for (int i = 0; i < total_part_count(); ++i) {
-    if (GetTestPartResult(i).failed())
-      return true;
-  }
-  return false;
-}
-
-// Returns true iff the test part fatally failed.
-static bool TestPartFatallyFailed(const TestPartResult& result) {
-  return result.fatally_failed();
-}
-
-// Returns true iff the test fatally failed.
-bool TestResult::HasFatalFailure() const {
-  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
-}
-
-// Returns true iff the test part non-fatally failed.
-static bool TestPartNonfatallyFailed(const TestPartResult& result) {
-  return result.nonfatally_failed();
-}
-
-// Returns true iff the test has a non-fatal failure.
-bool TestResult::HasNonfatalFailure() const {
-  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
-}
-
-// Gets the number of all test parts.  This is the sum of the number
-// of successful test parts and the number of failed test parts.
-int TestResult::total_part_count() const {
-  return static_cast<int>(test_part_results_.size());
-}
-
-// Returns the number of the test properties.
-int TestResult::test_property_count() const {
-  return static_cast<int>(test_properties_.size());
-}
-
-// class Test
-
-// Creates a Test object.
-
-// The c'tor saves the states of all flags.
-Test::Test()
-    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
-}
-
-// The d'tor restores the states of all flags.  The actual work is
-// done by the d'tor of the gtest_flag_saver_ field, and thus not
-// visible here.
-Test::~Test() {
-}
-
-// Sets up the test fixture.
-//
-// A sub-class may override this.
-void Test::SetUp() {
-}
-
-// Tears down the test fixture.
-//
-// A sub-class may override this.
-void Test::TearDown() {
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, const std::string& value) {
-  UnitTest::GetInstance()->RecordProperty(key, value);
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, int value) {
-  Message value_message;
-  value_message << value;
-  RecordProperty(key, value_message.GetString().c_str());
-}
-
-namespace internal {
-
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message) {
-  // This function is a friend of UnitTest and as such has access to
-  // AddTestPartResult.
-  UnitTest::GetInstance()->AddTestPartResult(
-      result_type,
-      NULL,  // No info about the source file where the exception occurred.
-      -1,    // We have no info on which line caused the exception.
-      message,
-      "");   // No stack trace, either.
-}
-
-}  // namespace internal
-
-// Google Test requires all tests in the same test case to use the same test
-// fixture class.  This function checks if the current test has the
-// same fixture class as the first test in the current test case.  If
-// yes, it returns true; otherwise it generates a Google Test failure and
-// returns false.
-bool Test::HasSameFixtureClass() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  const TestCase* const test_case = impl->current_test_case();
-
-  // Info about the first test in the current test case.
-  const TestInfo* const first_test_info = test_case->test_info_list()[0];
-  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
-  const char* const first_test_name = first_test_info->name();
-
-  // Info about the current test.
-  const TestInfo* const this_test_info = impl->current_test_info();
-  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
-  const char* const this_test_name = this_test_info->name();
-
-  if (this_fixture_id != first_fixture_id) {
-    // Is the first test defined using TEST?
-    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
-    // Is this test defined using TEST?
-    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
-
-    if (first_is_TEST || this_is_TEST) {
-      // Both TEST and TEST_F appear in same test case, which is incorrect.
-      // Tell the user how to fix this.
-
-      // Gets the name of the TEST and the name of the TEST_F.  Note
-      // that first_is_TEST and this_is_TEST cannot both be true, as
-      // the fixture IDs are different for the two tests.
-      const char* const TEST_name =
-          first_is_TEST ? first_test_name : this_test_name;
-      const char* const TEST_F_name =
-          first_is_TEST ? this_test_name : first_test_name;
-
-      ADD_FAILURE()
-          << "All tests in the same test case must use the same test fixture\n"
-          << "class, so mixing TEST_F and TEST in the same test case is\n"
-          << "illegal.  In test case " << this_test_info->test_case_name()
-          << ",\n"
-          << "test " << TEST_F_name << " is defined using TEST_F but\n"
-          << "test " << TEST_name << " is defined using TEST.  You probably\n"
-          << "want to change the TEST to TEST_F or move it to another test\n"
-          << "case.";
-    } else {
-      // Two fixture classes with the same name appear in two different
-      // namespaces, which is not allowed. Tell the user how to fix this.
-      ADD_FAILURE()
-          << "All tests in the same test case must use the same test fixture\n"
-          << "class.  However, in test case "
-          << this_test_info->test_case_name() << ",\n"
-          << "you defined test " << first_test_name
-          << " and test " << this_test_name << "\n"
-          << "using two different test fixture classes.  This can happen if\n"
-          << "the two classes are from different namespaces or translation\n"
-          << "units and have the same name.  You should probably rename one\n"
-          << "of the classes to put the tests into different test cases.";
-    }
-    return false;
-  }
-
-  return true;
-}
-
-#if GTEST_HAS_SEH
-
-// Adds an "exception thrown" fatal failure to the current test.  This
-// function returns its result via an output parameter pointer because VC++
-// prohibits creation of objects with destructors on stack in functions
-// using __try (see error C2712).
-static std::string* FormatSehExceptionMessage(DWORD exception_code,
-                                              const char* location) {
-  Message message;
-  message << "SEH exception with code 0x" << std::setbase(16) <<
-    exception_code << std::setbase(10) << " thrown in " << location << ".";
-
-  return new std::string(message.GetString());
-}
-
-#endif  // GTEST_HAS_SEH
-
-namespace internal {
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Adds an "exception thrown" fatal failure to the current test.
-static std::string FormatCxxExceptionMessage(const char* description,
-                                             const char* location) {
-  Message message;
-  if (description != NULL) {
-    message << "C++ exception with description \"" << description << "\"";
-  } else {
-    message << "Unknown C++ exception";
-  }
-  message << " thrown in " << location << ".";
-
-  return message.GetString();
-}
-
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result);
-
-GoogleTestFailureException::GoogleTestFailureException(
-    const TestPartResult& failure)
-    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// We put these helper functions in the internal namespace as IBM's xlC
-// compiler rejects the code if they were declared static.
-
-// Runs the given method and handles SEH exceptions it throws, when
-// SEH is supported; returns the 0-value for type Result in case of an
-// SEH exception.  (Microsoft compilers cannot handle SEH and C++
-// exceptions in the same function.  Therefore, we provide a separate
-// wrapper function for handling SEH exceptions.)
-template <class T, typename Result>
-Result HandleSehExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-#if GTEST_HAS_SEH
-  __try {
-    return (object->*method)();
-  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
-      GetExceptionCode())) {
-    // We create the exception message on the heap because VC++ prohibits
-    // creation of objects with destructors on stack in functions using __try
-    // (see error C2712).
-    std::string* exception_message = FormatSehExceptionMessage(
-        GetExceptionCode(), location);
-    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
-                                             *exception_message);
-    delete exception_message;
-    return static_cast<Result>(0);
-  }
-#else
-  (void)location;
-  return (object->*method)();
-#endif  // GTEST_HAS_SEH
-}
-
-// Runs the given method and catches and reports C++ and/or SEH-style
-// exceptions, if they are supported; returns the 0-value for type
-// Result in case of an SEH exception.
-template <class T, typename Result>
-Result HandleExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-  // NOTE: The user code can affect the way in which Google Test handles
-  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
-  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
-  // after the exception is caught and either report or re-throw the
-  // exception based on the flag's value:
-  //
-  // try {
-  //   // Perform the test method.
-  // } catch (...) {
-  //   if (GTEST_FLAG(catch_exceptions))
-  //     // Report the exception as failure.
-  //   else
-  //     throw;  // Re-throws the original exception.
-  // }
-  //
-  // However, the purpose of this flag is to allow the program to drop into
-  // the debugger when the exception is thrown. On most platforms, once the
-  // control enters the catch block, the exception origin information is
-  // lost and the debugger will stop the program at the point of the
-  // re-throw in this function -- instead of at the point of the original
-  // throw statement in the code under test.  For this reason, we perform
-  // the check early, sacrificing the ability to affect Google Test's
-  // exception handling in the method where the exception is thrown.
-  if (internal::GetUnitTestImpl()->catch_exceptions()) {
-#if GTEST_HAS_EXCEPTIONS
-    try {
-      return HandleSehExceptionsInMethodIfSupported(object, method, location);
-    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
-      // This exception type can only be thrown by a failed Google
-      // Test assertion with the intention of letting another testing
-      // framework catch it.  Therefore we just re-throw it.
-      throw;
-    } catch (const std::exception& e) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(e.what(), location));
-    } catch (...) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(NULL, location));
-    }
-    return static_cast<Result>(0);
-#else
-    return HandleSehExceptionsInMethodIfSupported(object, method, location);
-#endif  // GTEST_HAS_EXCEPTIONS
-  } else {
-    return (object->*method)();
-  }
-}
-
-}  // namespace internal
-
-// Runs the test and updates the test result.
-void Test::Run() {
-  if (!HasSameFixtureClass()) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
-  // We will run the test only if SetUp() was successful.
-  if (!HasFatalFailure()) {
-    impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        this, &Test::TestBody, "the test body");
-  }
-
-  // However, we want to clean up as much as possible.  Hence we will
-  // always call TearDown(), even if SetUp() or the test body has
-  // failed.
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &Test::TearDown, "TearDown()");
-}
-
-// Returns true iff the current test has a fatal failure.
-bool Test::HasFatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
-}
-
-// Returns true iff the current test has a non-fatal failure.
-bool Test::HasNonfatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->
-      HasNonfatalFailure();
-}
-
-// class TestInfo
-
-// Constructs a TestInfo object. It assumes ownership of the test factory
-// object.
-TestInfo::TestInfo(const std::string& a_test_case_name,
-                   const std::string& a_name,
-                   const char* a_type_param,
-                   const char* a_value_param,
-                   internal::CodeLocation a_code_location,
-                   internal::TypeId fixture_class_id,
-                   internal::TestFactoryBase* factory)
-    : test_case_name_(a_test_case_name),
-      name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
-      value_param_(a_value_param ? new std::string(a_value_param) : NULL),
-      location_(a_code_location),
-      fixture_class_id_(fixture_class_id),
-      should_run_(false),
-      is_disabled_(false),
-      matches_filter_(false),
-      factory_(factory),
-      result_() {}
-
-// Destructs a TestInfo object.
-TestInfo::~TestInfo() { delete factory_; }
-
-namespace internal {
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_case_name:   name of the test case
-//   name:             name of the test
-//   type_param:       the name of the test's type parameter, or NULL if
-//                     this is not a typed or a type-parameterized test.
-//   value_param:      text representation of the test's value parameter,
-//                     or NULL if this is not a value-parameterized test.
-//   code_location:    code location where the test is defined
-//   fixture_class_id: ID of the test fixture class
-//   set_up_tc:        pointer to the function that sets up the test case
-//   tear_down_tc:     pointer to the function that tears down the test case
-//   factory:          pointer to the factory that creates a test object.
-//                     The newly created TestInfo instance will assume
-//                     ownership of the factory object.
-TestInfo* MakeAndRegisterTestInfo(
-    const char* test_case_name,
-    const char* name,
-    const char* type_param,
-    const char* value_param,
-    CodeLocation code_location,
-    TypeId fixture_class_id,
-    SetUpTestCaseFunc set_up_tc,
-    TearDownTestCaseFunc tear_down_tc,
-    TestFactoryBase* factory) {
-  TestInfo* const test_info =
-      new TestInfo(test_case_name, name, type_param, value_param,
-                   code_location, fixture_class_id, factory);
-  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
-  return test_info;
-}
-
-#if GTEST_HAS_PARAM_TEST
-void ReportInvalidTestCaseType(const char* test_case_name,
-                               CodeLocation code_location) {
-  Message errors;
-  errors
-      << "Attempted redefinition of test case " << test_case_name << ".\n"
-      << "All tests in the same test case must use the same test fixture\n"
-      << "class.  However, in test case " << test_case_name << ", you tried\n"
-      << "to define a test using a fixture class different from the one\n"
-      << "used earlier. This can happen if the two fixture classes are\n"
-      << "from different namespaces and have the same name. You should\n"
-      << "probably rename one of the classes to put the tests into different\n"
-      << "test cases.";
-
-  fprintf(stderr, "%s %s",
-          FormatFileLocation(code_location.file.c_str(),
-                             code_location.line).c_str(),
-          errors.GetString().c_str());
-}
-#endif  // GTEST_HAS_PARAM_TEST
-
-}  // namespace internal
-
-namespace {
-
-// A predicate that checks the test name of a TestInfo against a known
-// value.
-//
-// This is used for implementation of the TestCase class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestNameIs is copyable.
-class TestNameIs {
- public:
-  // Constructor.
-  //
-  // TestNameIs has NO default constructor.
-  explicit TestNameIs(const char* name)
-      : name_(name) {}
-
-  // Returns true iff the test name of test_info matches name_.
-  bool operator()(const TestInfo * test_info) const {
-    return test_info && test_info->name() == name_;
-  }
-
- private:
-  std::string name_;
-};
-
-}  // namespace
-
-namespace internal {
-
-// This method expands all parameterized tests registered with macros TEST_P
-// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
-// This will be done just once during the program runtime.
-void UnitTestImpl::RegisterParameterizedTests() {
-#if GTEST_HAS_PARAM_TEST
-  if (!parameterized_tests_registered_) {
-    parameterized_test_registry_.RegisterTests();
-    parameterized_tests_registered_ = true;
-  }
-#endif
-}
-
-}  // namespace internal
-
-// Creates the test object, runs it, records its result, and then
-// deletes it.
-void TestInfo::Run() {
-  if (!should_run_) return;
-
-  // Tells UnitTest where to store test result.
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_info(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Notifies the unit test event listeners that a test is about to start.
-  repeater->OnTestStart(*this);
-
-  const TimeInMillis start = internal::GetTimeInMillis();
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-
-  // Creates the test object.
-  Test* const test = internal::HandleExceptionsInMethodIfSupported(
-      factory_, &internal::TestFactoryBase::CreateTest,
-      "the test fixture's constructor");
-
-  // Runs the test only if the test object was created and its
-  // constructor didn't generate a fatal failure.
-  if ((test != NULL) && !Test::HasFatalFailure()) {
-    // This doesn't throw as all user code that can throw are wrapped into
-    // exception handling code.
-    test->Run();
-  }
-
-  // Deletes the test object.
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      test, &Test::DeleteSelf_, "the test fixture's destructor");
-
-  result_.set_elapsed_time(internal::GetTimeInMillis() - start);
-
-  // Notifies the unit test event listener that a test has just finished.
-  repeater->OnTestEnd(*this);
-
-  // Tells UnitTest to stop associating assertion results to this
-  // test.
-  impl->set_current_test_info(NULL);
-}
-
-// class TestCase
-
-// Gets the number of successful tests in this test case.
-int TestCase::successful_test_count() const {
-  return CountIf(test_info_list_, TestPassed);
-}
-
-// Gets the number of failed tests in this test case.
-int TestCase::failed_test_count() const {
-  return CountIf(test_info_list_, TestFailed);
-}
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int TestCase::reportable_disabled_test_count() const {
-  return CountIf(test_info_list_, TestReportableDisabled);
-}
-
-// Gets the number of disabled tests in this test case.
-int TestCase::disabled_test_count() const {
-  return CountIf(test_info_list_, TestDisabled);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int TestCase::reportable_test_count() const {
-  return CountIf(test_info_list_, TestReportable);
-}
-
-// Get the number of tests in this test case that should run.
-int TestCase::test_to_run_count() const {
-  return CountIf(test_info_list_, ShouldRunTest);
-}
-
-// Gets the number of all tests.
-int TestCase::total_test_count() const {
-  return static_cast<int>(test_info_list_.size());
-}
-
-// Creates a TestCase with the given name.
-//
-// Arguments:
-//
-//   name:         name of the test case
-//   a_type_param: the name of the test case's type parameter, or NULL if
-//                 this is not a typed or a type-parameterized test case.
-//   set_up_tc:    pointer to the function that sets up the test case
-//   tear_down_tc: pointer to the function that tears down the test case
-TestCase::TestCase(const char* a_name, const char* a_type_param,
-                   Test::SetUpTestCaseFunc set_up_tc,
-                   Test::TearDownTestCaseFunc tear_down_tc)
-    : name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
-      set_up_tc_(set_up_tc),
-      tear_down_tc_(tear_down_tc),
-      should_run_(false),
-      elapsed_time_(0) {
-}
-
-// Destructor of TestCase.
-TestCase::~TestCase() {
-  // Deletes every Test in the collection.
-  ForEach(test_info_list_, internal::Delete<TestInfo>);
-}
-
-// Returns the i-th test among all the tests. i can range from 0 to
-// total_test_count() - 1. If i is not in that range, returns NULL.
-const TestInfo* TestCase::GetTestInfo(int i) const {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? NULL : test_info_list_[index];
-}
-
-// Returns the i-th test among all the tests. i can range from 0 to
-// total_test_count() - 1. If i is not in that range, returns NULL.
-TestInfo* TestCase::GetMutableTestInfo(int i) {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? NULL : test_info_list_[index];
-}
-
-// Adds a test to this test case.  Will delete the test upon
-// destruction of the TestCase object.
-void TestCase::AddTestInfo(TestInfo * test_info) {
-  test_info_list_.push_back(test_info);
-  test_indices_.push_back(static_cast<int>(test_indices_.size()));
-}
-
-// Runs every test in this TestCase.
-void TestCase::Run() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_case(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  repeater->OnTestCaseStart(*this);
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
-
-  const internal::TimeInMillis start = internal::GetTimeInMillis();
-  for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Run();
-  }
-  elapsed_time_ = internal::GetTimeInMillis() - start;
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
-
-  repeater->OnTestCaseEnd(*this);
-  impl->set_current_test_case(NULL);
-}
-
-// Clears the results of all tests in this test case.
-void TestCase::ClearResult() {
-  ad_hoc_test_result_.Clear();
-  ForEach(test_info_list_, TestInfo::ClearTestResult);
-}
-
-// Shuffles the tests in this test case.
-void TestCase::ShuffleTests(internal::Random* random) {
-  Shuffle(random, &test_indices_);
-}
-
-// Restores the test order to before the first shuffle.
-void TestCase::UnshuffleTests() {
-  for (size_t i = 0; i < test_indices_.size(); i++) {
-    test_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Formats a countable noun.  Depending on its quantity, either the
-// singular form or the plural form is used. e.g.
-//
-// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
-// FormatCountableNoun(5, "book", "books") returns "5 books".
-static std::string FormatCountableNoun(int count,
-                                       const char * singular_form,
-                                       const char * plural_form) {
-  return internal::StreamableToString(count) + " " +
-      (count == 1 ? singular_form : plural_form);
-}
-
-// Formats the count of tests.
-static std::string FormatTestCount(int test_count) {
-  return FormatCountableNoun(test_count, "test", "tests");
-}
-
-// Formats the count of test cases.
-static std::string FormatTestCaseCount(int test_case_count) {
-  return FormatCountableNoun(test_case_count, "test case", "test cases");
-}
-
-// Converts a TestPartResult::Type enum to human-friendly string
-// representation.  Both kNonFatalFailure and kFatalFailure are translated
-// to "Failure", as the user usually doesn't care about the difference
-// between the two when viewing the test result.
-static const char * TestPartResultTypeToString(TestPartResult::Type type) {
-  switch (type) {
-    case TestPartResult::kSuccess:
-      return "Success";
-
-    case TestPartResult::kNonFatalFailure:
-    case TestPartResult::kFatalFailure:
-#ifdef _MSC_VER
-      return "error: ";
-#else
-      return "Failure\n";
-#endif
-    default:
-      return "Unknown result type";
-  }
-}
-
-namespace internal {
-
-// Prints a TestPartResult to an std::string.
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result) {
-  return (Message()
-          << internal::FormatFileLocation(test_part_result.file_name(),
-                                          test_part_result.line_number())
-          << " " << TestPartResultTypeToString(test_part_result.type())
-          << test_part_result.message()).GetString();
-}
-
-// Prints a TestPartResult.
-static void PrintTestPartResult(const TestPartResult& test_part_result) {
-  const std::string& result =
-      PrintTestPartResultToString(test_part_result);
-  printf("%s\n", result.c_str());
-  fflush(stdout);
-  // If the test program runs in Visual Studio or a debugger, the
-  // following statements add the test part result message to the Output
-  // window such that the user can double-click on it to jump to the
-  // corresponding source code location; otherwise they do nothing.
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  // We don't call OutputDebugString*() on Windows Mobile, as printing
-  // to stdout is done by OutputDebugString() there already - we don't
-  // want the same message printed twice.
-  ::OutputDebugStringA(result.c_str());
-  ::OutputDebugStringA("\n");
-#endif
-}
-
-// class PrettyUnitTestResultPrinter
-
-enum GTestColor {
-  COLOR_DEFAULT,
-  COLOR_RED,
-  COLOR_GREEN,
-  COLOR_YELLOW
-};
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-// Returns the character attribute for the given color.
-WORD GetColorAttribute(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:    return FOREGROUND_RED;
-    case COLOR_GREEN:  return FOREGROUND_GREEN;
-    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
-    default:           return 0;
-  }
-}
-
-#else
-
-// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
-// an invalid input.
-const char* GetAnsiColorCode(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:     return "1";
-    case COLOR_GREEN:   return "2";
-    case COLOR_YELLOW:  return "3";
-    default:            return NULL;
-  };
-}
-
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-
-// Returns true iff Google Test should use colors in the output.
-bool ShouldUseColor(bool stdout_is_tty) {
-  const char* const gtest_color = GTEST_FLAG(color).c_str();
-
-  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
-#if GTEST_OS_WINDOWS
-    // On Windows the TERM variable is usually not set, but the
-    // console there does support colors.
-    return stdout_is_tty;
-#else
-    // On non-Windows platforms, we rely on the TERM variable.
-    const char* const term = posix::GetEnv("TERM");
-    const bool term_supports_color =
-        String::CStringEquals(term, "xterm") ||
-        String::CStringEquals(term, "xterm-color") ||
-        String::CStringEquals(term, "xterm-256color") ||
-        String::CStringEquals(term, "screen") ||
-        String::CStringEquals(term, "screen-256color") ||
-        String::CStringEquals(term, "rxvt-unicode") ||
-        String::CStringEquals(term, "rxvt-unicode-256color") ||
-        String::CStringEquals(term, "linux") ||
-        String::CStringEquals(term, "cygwin");
-    return stdout_is_tty && term_supports_color;
-#endif  // GTEST_OS_WINDOWS
-  }
-
-  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
-      String::CStringEquals(gtest_color, "1");
-  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
-  // value is neither one of these nor "auto", we treat it as "no" to
-  // be conservative.
-}
-
-// Helpers for printing colored strings to stdout. Note that on Windows, we
-// cannot simply emit special characters and have the terminal change colors.
-// This routine must actually emit the characters rather than return a string
-// that would be colored when printed, as can be done on Linux.
-void ColoredPrintf(GTestColor color, const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
-    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  const bool use_color = AlwaysFalse();
-#else
-  static const bool in_color_mode =
-      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
-  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
-#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
-  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
-
-  if (!use_color) {
-    vprintf(fmt, args);
-    va_end(args);
-    return;
-  }
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-
-  // Gets the current text color.
-  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
-  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
-  const WORD old_color_attrs = buffer_info.wAttributes;
-
-  // We need to flush the stream buffers into the console before each
-  // SetConsoleTextAttribute call lest it affect the text that is already
-  // printed but has not yet reached the console.
-  fflush(stdout);
-  SetConsoleTextAttribute(stdout_handle,
-                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
-  vprintf(fmt, args);
-
-  fflush(stdout);
-  // Restores the text color.
-  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
-#else
-  printf("\033[0;3%sm", GetAnsiColorCode(color));
-  vprintf(fmt, args);
-  printf("\033[m");  // Resets the terminal to default.
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  va_end(args);
-}
-
-// Text printed in Google Test's text output and --gunit_list_tests
-// output to label the type parameter and value parameter for a test.
-static const char kTypeParamLabel[] = "TypeParam";
-static const char kValueParamLabel[] = "GetParam()";
-
-void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
-  const char* const type_param = test_info.type_param();
-  const char* const value_param = test_info.value_param();
-
-  if (type_param != NULL || value_param != NULL) {
-    printf(", where ");
-    if (type_param != NULL) {
-      printf("%s = %s", kTypeParamLabel, type_param);
-      if (value_param != NULL)
-        printf(" and ");
-    }
-    if (value_param != NULL) {
-      printf("%s = %s", kValueParamLabel, value_param);
-    }
-  }
-}
-
-// This class implements the TestEventListener interface.
-//
-// Class PrettyUnitTestResultPrinter is copyable.
-class PrettyUnitTestResultPrinter : public TestEventListener {
- public:
-  PrettyUnitTestResultPrinter() {}
-  static void PrintTestName(const char * test_case, const char * test) {
-    printf("%s.%s", test_case, test);
-  }
-
-  // The following methods override what's in the TestEventListener class.
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestCaseStart(const TestCase& test_case);
-  virtual void OnTestStart(const TestInfo& test_info);
-  virtual void OnTestPartResult(const TestPartResult& result);
-  virtual void OnTestEnd(const TestInfo& test_info);
-  virtual void OnTestCaseEnd(const TestCase& test_case);
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
-
- private:
-  static void PrintFailedTests(const UnitTest& unit_test);
-};
-
-  // Fired before each iteration of tests starts.
-void PrettyUnitTestResultPrinter::OnTestIterationStart(
-    const UnitTest& unit_test, int iteration) {
-  if (GTEST_FLAG(repeat) != 1)
-    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
-
-  const char* const filter = GTEST_FLAG(filter).c_str();
-
-  // Prints the filter if it's not *.  This reminds the user that some
-  // tests may be skipped.
-  if (!String::CStringEquals(filter, kUniversalFilter)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
-  }
-
-  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
-    const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: This is test shard %d of %s.\n",
-                  static_cast<int>(shard_index) + 1,
-                  internal::posix::GetEnv(kTestTotalShards));
-  }
-
-  if (GTEST_FLAG(shuffle)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: Randomizing tests' orders with a seed of %d .\n",
-                  unit_test.random_seed());
-  }
-
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("Running %s from %s.\n",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment set-up.\n");
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
-  const std::string counts =
-      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s", counts.c_str(), test_case.name());
-  if (test_case.type_param() == NULL) {
-    printf("\n");
-  } else {
-    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
-  }
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
-  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
-  PrintTestName(test_info.test_case_name(), test_info.name());
-  printf("\n");
-  fflush(stdout);
-}
-
-// Called after an assertion failure.
-void PrettyUnitTestResultPrinter::OnTestPartResult(
-    const TestPartResult& result) {
-  // If the test part succeeded, we don't need to do anything.
-  if (result.type() == TestPartResult::kSuccess)
-    return;
-
-  // Print failure message from the assertion (e.g. expected this and got that).
-  PrintTestPartResult(result);
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
-  if (test_info.result()->Passed()) {
-    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
-  } else {
-    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-  }
-  PrintTestName(test_info.test_case_name(), test_info.name());
-  if (test_info.result()->Failed())
-    PrintFullTestCommentIfPresent(test_info);
-
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms)\n", internal::StreamableToString(
-           test_info.result()->elapsed_time()).c_str());
-  } else {
-    printf("\n");
-  }
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
-  if (!GTEST_FLAG(print_time)) return;
-
-  const std::string counts =
-      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s (%s ms total)\n\n",
-         counts.c_str(), test_case.name(),
-         internal::StreamableToString(test_case.elapsed_time()).c_str());
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment tear-down\n");
-  fflush(stdout);
-}
-
-// Internal helper for printing the list of failed tests.
-void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
-  const int failed_test_count = unit_test.failed_test_count();
-  if (failed_test_count == 0) {
-    return;
-  }
-
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-    const TestCase& test_case = *unit_test.GetTestCase(i);
-    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
-      continue;
-    }
-    for (int j = 0; j < test_case.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_case.GetTestInfo(j);
-      if (!test_info.should_run() || test_info.result()->Passed()) {
-        continue;
-      }
-      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-      printf("%s.%s", test_case.name(), test_info.name());
-      PrintFullTestCommentIfPresent(test_info);
-      printf("\n");
-    }
-  }
-}
-
-void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                     int /*iteration*/) {
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("%s from %s ran.",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms total)",
-           internal::StreamableToString(unit_test.elapsed_time()).c_str());
-  }
-  printf("\n");
-  ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
-  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
-
-  int num_failures = unit_test.failed_test_count();
-  if (!unit_test.Passed()) {
-    const int failed_test_count = unit_test.failed_test_count();
-    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
-    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
-    PrintFailedTests(unit_test);
-    printf("\n%2d FAILED %s\n", num_failures,
-                        num_failures == 1 ? "TEST" : "TESTS");
-  }
-
-  int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
-    if (!num_failures) {
-      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
-    }
-    ColoredPrintf(COLOR_YELLOW,
-                  "  YOU HAVE %d DISABLED %s\n\n",
-                  num_disabled,
-                  num_disabled == 1 ? "TEST" : "TESTS");
-  }
-  // Ensure that Google Test output is printed before, e.g., heapchecker output.
-  fflush(stdout);
-}
-
-// End PrettyUnitTestResultPrinter
-
-// class TestEventRepeater
-//
-// This class forwards events to other event listeners.
-class TestEventRepeater : public TestEventListener {
- public:
-  TestEventRepeater() : forwarding_enabled_(true) {}
-  virtual ~TestEventRepeater();
-  void Append(TestEventListener *listener);
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled() const { return forwarding_enabled_; }
-  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
-
-  virtual void OnTestProgramStart(const UnitTest& unit_test);
-  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
-  virtual void OnTestCaseStart(const TestCase& test_case);
-  virtual void OnTestStart(const TestInfo& test_info);
-  virtual void OnTestPartResult(const TestPartResult& result);
-  virtual void OnTestEnd(const TestInfo& test_info);
-  virtual void OnTestCaseEnd(const TestCase& test_case);
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-  virtual void OnTestProgramEnd(const UnitTest& unit_test);
-
- private:
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled_;
-  // The list of listeners that receive events.
-  std::vector<TestEventListener*> listeners_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
-};
-
-TestEventRepeater::~TestEventRepeater() {
-  ForEach(listeners_, Delete<TestEventListener>);
-}
-
-void TestEventRepeater::Append(TestEventListener *listener) {
-  listeners_.push_back(listener);
-}
-
-// TODO(vladl@google.com): Factor the search functionality into Vector::Find.
-TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
-  for (size_t i = 0; i < listeners_.size(); ++i) {
-    if (listeners_[i] == listener) {
-      listeners_.erase(listeners_.begin() + i);
-      return listener;
-    }
-  }
-
-  return NULL;
-}
-
-// Since most methods are very similar, use macros to reduce boilerplate.
-// This defines a member that forwards the call to all listeners.
-#define GTEST_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (size_t i = 0; i < listeners_.size(); i++) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
-// This defines a member that forwards the call to all listeners in reverse
-// order.
-#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
-
-GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
-GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
-GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
-GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
-GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
-GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
-
-#undef GTEST_REPEATER_METHOD_
-#undef GTEST_REVERSE_REPEATER_METHOD_
-
-void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
-                                             int iteration) {
-  if (forwarding_enabled_) {
-    for (size_t i = 0; i < listeners_.size(); i++) {
-      listeners_[i]->OnTestIterationStart(unit_test, iteration);
-    }
-  }
-}
-
-void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
-                                           int iteration) {
-  if (forwarding_enabled_) {
-    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
-      listeners_[i]->OnTestIterationEnd(unit_test, iteration);
-    }
-  }
-}
-
-// End TestEventRepeater
-
-// This class generates an XML output file.
-class XmlUnitTestResultPrinter : public EmptyTestEventListener {
- public:
-  explicit XmlUnitTestResultPrinter(const char* output_file);
-
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-
- private:
-  // Is c a whitespace character that is normalized to a space character
-  // when it appears in an XML attribute value?
-  static bool IsNormalizableWhitespace(char c) {
-    return c == 0x9 || c == 0xA || c == 0xD;
-  }
-
-  // May c appear in a well-formed XML document?
-  static bool IsValidXmlCharacter(char c) {
-    return IsNormalizableWhitespace(c) || c >= 0x20;
-  }
-
-  // Returns an XML-escaped copy of the input string str.  If
-  // is_attribute is true, the text is meant to appear as an attribute
-  // value, and normalizable whitespace is preserved by replacing it
-  // with character references.
-  static std::string EscapeXml(const std::string& str, bool is_attribute);
-
-  // Returns the given string with all characters invalid in XML removed.
-  static std::string RemoveInvalidXmlCharacters(const std::string& str);
-
-  // Convenience wrapper around EscapeXml when str is an attribute value.
-  static std::string EscapeXmlAttribute(const std::string& str) {
-    return EscapeXml(str, true);
-  }
-
-  // Convenience wrapper around EscapeXml when str is not an attribute value.
-  static std::string EscapeXmlText(const char* str) {
-    return EscapeXml(str, false);
-  }
-
-  // Verifies that the given attribute belongs to the given element and
-  // streams the attribute as XML.
-  static void OutputXmlAttribute(std::ostream* stream,
-                                 const std::string& element_name,
-                                 const std::string& name,
-                                 const std::string& value);
-
-  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
-
-  // Streams an XML representation of a TestInfo object.
-  static void OutputXmlTestInfo(::std::ostream* stream,
-                                const char* test_case_name,
-                                const TestInfo& test_info);
-
-  // Prints an XML representation of a TestCase object
-  static void PrintXmlTestCase(::std::ostream* stream,
-                               const TestCase& test_case);
-
-  // Prints an XML summary of unit_test to output stream out.
-  static void PrintXmlUnitTest(::std::ostream* stream,
-                               const UnitTest& unit_test);
-
-  // Produces a string representing the test properties in a result as space
-  // delimited XML attributes based on the property key="value" pairs.
-  // When the std::string is not empty, it includes a space at the beginning,
-  // to delimit this attribute from prior attributes.
-  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
-
-  // The output file.
-  const std::string output_file_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
-};
-
-// Creates a new XmlUnitTestResultPrinter.
-XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
-    : output_file_(output_file) {
-  if (output_file_.c_str() == NULL || output_file_.empty()) {
-    fprintf(stderr, "XML output file may not be null\n");
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-}
-
-// Called after the unit test ends.
-void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
-  FILE* xmlout = NULL;
-  FilePath output_file(output_file_);
-  FilePath output_dir(output_file.RemoveFileName());
-
-  if (output_dir.CreateDirectoriesRecursively()) {
-    xmlout = posix::FOpen(output_file_.c_str(), "w");
-  }
-  if (xmlout == NULL) {
-    // TODO(wan): report the reason of the failure.
-    //
-    // We don't do it for now as:
-    //
-    //   1. There is no urgent need for it.
-    //   2. It's a bit involved to make the errno variable thread-safe on
-    //      all three operating systems (Linux, Windows, and Mac OS).
-    //   3. To interpret the meaning of errno in a thread-safe way,
-    //      we need the strerror_r() function, which is not available on
-    //      Windows.
-    fprintf(stderr,
-            "Unable to open file \"%s\"\n",
-            output_file_.c_str());
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-  std::stringstream stream;
-  PrintXmlUnitTest(&stream, unit_test);
-  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
-  fclose(xmlout);
-}
-
-// Returns an XML-escaped copy of the input string str.  If is_attribute
-// is true, the text is meant to appear as an attribute value, and
-// normalizable whitespace is preserved by replacing it with character
-// references.
-//
-// Invalid XML characters in str, if any, are stripped from the output.
-// It is expected that most, if not all, of the text processed by this
-// module will consist of ordinary English text.
-// If this module is ever modified to produce version 1.1 XML output,
-// most invalid characters can be retained using character references.
-// TODO(wan): It might be nice to have a minimally invasive, human-readable
-// escaping scheme for invalid characters, rather than dropping them.
-std::string XmlUnitTestResultPrinter::EscapeXml(
-    const std::string& str, bool is_attribute) {
-  Message m;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    const char ch = str[i];
-    switch (ch) {
-      case '<':
-        m << "&lt;";
-        break;
-      case '>':
-        m << "&gt;";
-        break;
-      case '&':
-        m << "&amp;";
-        break;
-      case '\'':
-        if (is_attribute)
-          m << "&apos;";
-        else
-          m << '\'';
-        break;
-      case '"':
-        if (is_attribute)
-          m << "&quot;";
-        else
-          m << '"';
-        break;
-      default:
-        if (IsValidXmlCharacter(ch)) {
-          if (is_attribute && IsNormalizableWhitespace(ch))
-            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
-              << ";";
-          else
-            m << ch;
-        }
-        break;
-    }
-  }
-
-  return m.GetString();
-}
-
-// Returns the given string with all characters invalid in XML removed.
-// Currently invalid characters are dropped from the string. An
-// alternative is to replace them with certain characters such as . or ?.
-std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
-    const std::string& str) {
-  std::string output;
-  output.reserve(str.size());
-  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-    if (IsValidXmlCharacter(*it))
-      output.push_back(*it);
-
-  return output;
-}
-
-// The following routines generate an XML representation of a UnitTest
-// object.
-//
-// This is how Google Test concepts map to the DTD:
-//
-// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
-//   <testsuite name="testcase-name">  <-- corresponds to a TestCase object
-//     <testcase name="test-name">     <-- corresponds to a TestInfo object
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//                                     <-- individual assertion failures
-//     </testcase>
-//   </testsuite>
-// </testsuites>
-
-// Formats the given time in milliseconds as seconds.
-std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
-  ::std::stringstream ss;
-  ss << (static_cast<double>(ms) * 1e-3);
-  return ss.str();
-}
-
-static bool PortableLocaltime(time_t seconds, struct tm* out) {
-#if defined(_MSC_VER)
-  return localtime_s(out, &seconds) == 0;
-#elif defined(__MINGW32__) || defined(__MINGW64__)
-  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
-  // Windows' localtime(), which has a thread-local tm buffer.
-  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
-  if (tm_ptr == NULL)
-    return false;
-  *out = *tm_ptr;
-  return true;
-#else
-  return localtime_r(&seconds, out) != NULL;
-#endif
-}
-
-// Converts the given epoch time in milliseconds to a date string in the ISO
-// 8601 format, without the timezone information.
-std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
-  struct tm time_struct;
-  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
-    return "";
-  // YYYY-MM-DDThh:mm:ss
-  return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec);
-}
-
-// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
-                                                     const char* data) {
-  const char* segment = data;
-  *stream << "<![CDATA[";
-  for (;;) {
-    const char* const next_segment = strstr(segment, "]]>");
-    if (next_segment != NULL) {
-      stream->write(
-          segment, static_cast<std::streamsize>(next_segment - segment));
-      *stream << "]]>]]&gt;<![CDATA[";
-      segment = next_segment + strlen("]]>");
-    } else {
-      *stream << segment;
-      break;
-    }
-  }
-  *stream << "]]>";
-}
-
-void XmlUnitTestResultPrinter::OutputXmlAttribute(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Attribute " << name << " is not allowed for element <" << element_name
-      << ">.";
-
-  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
-}
-
-// Prints an XML representation of a TestInfo object.
-// TODO(wan): There is also value in printing properties with the plain printer.
-void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
-                                                 const char* test_case_name,
-                                                 const TestInfo& test_info) {
-  const TestResult& result = *test_info.result();
-  const std::string kTestcase = "testcase";
-
-  *stream << "    <testcase";
-  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
-
-  if (test_info.value_param() != NULL) {
-    OutputXmlAttribute(stream, kTestcase, "value_param",
-                       test_info.value_param());
-  }
-  if (test_info.type_param() != NULL) {
-    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
-  }
-
-  OutputXmlAttribute(stream, kTestcase, "status",
-                     test_info.should_run() ? "run" : "notrun");
-  OutputXmlAttribute(stream, kTestcase, "time",
-                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
-  *stream << TestPropertiesAsXmlAttributes(result);
-
-  int failures = 0;
-  for (int i = 0; i < result.total_part_count(); ++i) {
-    const TestPartResult& part = result.GetTestPartResult(i);
-    if (part.failed()) {
-      if (++failures == 1) {
-        *stream << ">\n";
-      }
-      const string location = internal::FormatCompilerIndependentFileLocation(
-          part.file_name(), part.line_number());
-      const string summary = location + "\n" + part.summary();
-      *stream << "      <failure message=\""
-              << EscapeXmlAttribute(summary.c_str())
-              << "\" type=\"\">";
-      const string detail = location + "\n" + part.message();
-      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
-      *stream << "</failure>\n";
-    }
-  }
-
-  if (failures == 0)
-    *stream << " />\n";
-  else
-    *stream << "    </testcase>\n";
-}
-
-// Prints an XML representation of a TestCase object
-void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
-                                                const TestCase& test_case) {
-  const std::string kTestsuite = "testsuite";
-  *stream << "  <" << kTestsuite;
-  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
-  OutputXmlAttribute(stream, kTestsuite, "tests",
-                     StreamableToString(test_case.reportable_test_count()));
-  OutputXmlAttribute(stream, kTestsuite, "failures",
-                     StreamableToString(test_case.failed_test_count()));
-  OutputXmlAttribute(
-      stream, kTestsuite, "disabled",
-      StreamableToString(test_case.reportable_disabled_test_count()));
-  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
-  OutputXmlAttribute(stream, kTestsuite, "time",
-                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
-  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
-          << ">\n";
-
-  for (int i = 0; i < test_case.total_test_count(); ++i) {
-    if (test_case.GetTestInfo(i)->is_reportable())
-      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
-  }
-  *stream << "  </" << kTestsuite << ">\n";
-}
-
-// Prints an XML summary of unit_test to output stream out.
-void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
-                                                const UnitTest& unit_test) {
-  const std::string kTestsuites = "testsuites";
-
-  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  *stream << "<" << kTestsuites;
-
-  OutputXmlAttribute(stream, kTestsuites, "tests",
-                     StreamableToString(unit_test.reportable_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "failures",
-                     StreamableToString(unit_test.failed_test_count()));
-  OutputXmlAttribute(
-      stream, kTestsuites, "disabled",
-      StreamableToString(unit_test.reportable_disabled_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
-  OutputXmlAttribute(
-      stream, kTestsuites, "timestamp",
-      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
-  OutputXmlAttribute(stream, kTestsuites, "time",
-                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
-
-  if (GTEST_FLAG(shuffle)) {
-    OutputXmlAttribute(stream, kTestsuites, "random_seed",
-                       StreamableToString(unit_test.random_seed()));
-  }
-
-  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
-
-  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
-  *stream << ">\n";
-
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
-      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
-  }
-  *stream << "</" << kTestsuites << ">\n";
-}
-
-// Produces a string representing the test properties in a result as space
-// delimited XML attributes based on the property key="value" pairs.
-std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
-    const TestResult& result) {
-  Message attributes;
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    attributes << " " << property.key() << "="
-        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
-  }
-  return attributes.GetString();
-}
-
-// End XmlUnitTestResultPrinter
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
-// replaces them by "%xx" where xx is their hexadecimal value. For
-// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
-// in both time and space -- important as the input str may contain an
-// arbitrarily long test failure message and stack trace.
-string StreamingListener::UrlEncode(const char* str) {
-  string result;
-  result.reserve(strlen(str) + 1);
-  for (char ch = *str; ch != '\0'; ch = *++str) {
-    switch (ch) {
-      case '%':
-      case '=':
-      case '&':
-      case '\n':
-        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
-        break;
-      default:
-        result.push_back(ch);
-        break;
-    }
-  }
-  return result;
-}
-
-void StreamingListener::SocketWriter::MakeConnection() {
-  GTEST_CHECK_(sockfd_ == -1)
-      << "MakeConnection() can't be called when there is already a connection.";
-
-  addrinfo hints;
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
-  hints.ai_socktype = SOCK_STREAM;
-  addrinfo* servinfo = NULL;
-
-  // Use the getaddrinfo() to get a linked list of IP addresses for
-  // the given host name.
-  const int error_num = getaddrinfo(
-      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
-  if (error_num != 0) {
-    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
-                        << gai_strerror(error_num);
-  }
-
-  // Loop through all the results and connect to the first we can.
-  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
-       cur_addr = cur_addr->ai_next) {
-    sockfd_ = socket(
-        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
-    if (sockfd_ != -1) {
-      // Connect the client socket to the server socket.
-      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
-        close(sockfd_);
-        sockfd_ = -1;
-      }
-    }
-  }
-
-  freeaddrinfo(servinfo);  // all done with this structure
-
-  if (sockfd_ == -1) {
-    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
-                        << host_name_ << ":" << port_num_;
-  }
-}
-
-// End of class Streaming Listener
-#endif  // GTEST_CAN_STREAM_RESULTS__
-
-// Class ScopedTrace
-
-// Pushes the given source file location and message onto a per-thread
-// trace stack maintained by Google Test.
-ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  TraceInfo trace;
-  trace.file = file;
-  trace.line = line;
-  trace.message = message.GetString();
-
-  UnitTest::GetInstance()->PushGTestTrace(trace);
-}
-
-// Pops the info pushed by the c'tor.
-ScopedTrace::~ScopedTrace()
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  UnitTest::GetInstance()->PopGTestTrace();
-}
-
-
-// class OsStackTraceGetter
-
-const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
-    "... " GTEST_NAME_ " internal frames ...";
-
-string OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/,
-                                             int /*skip_count*/) {
-  return "";
-}
-
-void OsStackTraceGetter::UponLeavingGTest() {}
-
-// A helper class that creates the premature-exit file in its
-// constructor and deletes the file in its destructor.
-class ScopedPrematureExitFile {
- public:
-  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
-      : premature_exit_filepath_(premature_exit_filepath) {
-    // If a path to the premature-exit file is specified...
-    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
-      // create the file with a single "0" character in it.  I/O
-      // errors are ignored as there's nothing better we can do and we
-      // don't want to fail the test because of this.
-      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
-      fwrite("0", 1, 1, pfile);
-      fclose(pfile);
-    }
-  }
-
-  ~ScopedPrematureExitFile() {
-    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
-      remove(premature_exit_filepath_);
-    }
-  }
-
- private:
-  const char* const premature_exit_filepath_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
-};
-
-}  // namespace internal
-
-// class TestEventListeners
-
-TestEventListeners::TestEventListeners()
-    : repeater_(new internal::TestEventRepeater()),
-      default_result_printer_(NULL),
-      default_xml_generator_(NULL) {
-}
-
-TestEventListeners::~TestEventListeners() { delete repeater_; }
-
-// Returns the standard listener responsible for the default console
-// output.  Can be removed from the listeners list to shut down default
-// console output.  Note that removing this object from the listener list
-// with Release transfers its ownership to the user.
-void TestEventListeners::Append(TestEventListener* listener) {
-  repeater_->Append(listener);
-}
-
-// Removes the given event listener from the list and returns it.  It then
-// becomes the caller's responsibility to delete the listener. Returns
-// NULL if the listener is not found in the list.
-TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
-  if (listener == default_result_printer_)
-    default_result_printer_ = NULL;
-  else if (listener == default_xml_generator_)
-    default_xml_generator_ = NULL;
-  return repeater_->Release(listener);
-}
-
-// Returns repeater that broadcasts the TestEventListener events to all
-// subscribers.
-TestEventListener* TestEventListeners::repeater() { return repeater_; }
-
-// Sets the default_result_printer attribute to the provided listener.
-// The listener is also added to the listener list and previous
-// default_result_printer is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
-  if (default_result_printer_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_result_printer_);
-    default_result_printer_ = listener;
-    if (listener != NULL)
-      Append(listener);
-  }
-}
-
-// Sets the default_xml_generator attribute to the provided listener.  The
-// listener is also added to the listener list and previous
-// default_xml_generator is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
-  if (default_xml_generator_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_xml_generator_);
-    default_xml_generator_ = listener;
-    if (listener != NULL)
-      Append(listener);
-  }
-}
-
-// Controls whether events will be forwarded by the repeater to the
-// listeners in the list.
-bool TestEventListeners::EventForwardingEnabled() const {
-  return repeater_->forwarding_enabled();
-}
-
-void TestEventListeners::SuppressEventForwarding() {
-  repeater_->set_forwarding_enabled(false);
-}
-
-// class UnitTest
-
-// Gets the singleton UnitTest object.  The first time this method is
-// called, a UnitTest object is constructed and returned.  Consecutive
-// calls will return the same object.
-//
-// We don't protect this under mutex_ as a user is not supposed to
-// call this before main() starts, from which point on the return
-// value will never change.
-UnitTest* UnitTest::GetInstance() {
-  // When compiled with MSVC 7.1 in optimized mode, destroying the
-  // UnitTest object upon exiting the program messes up the exit code,
-  // causing successful tests to appear failed.  We have to use a
-  // different implementation in this case to bypass the compiler bug.
-  // This implementation makes the compiler happy, at the cost of
-  // leaking the UnitTest object.
-
-  // CodeGear C++Builder insists on a public destructor for the
-  // default implementation.  Use this implementation to keep good OO
-  // design with private destructor.
-
-#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
-  static UnitTest* const instance = new UnitTest;
-  return instance;
-#else
-  static UnitTest instance;
-  return &instance;
-#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
-}
-
-// Gets the number of successful test cases.
-int UnitTest::successful_test_case_count() const {
-  return impl()->successful_test_case_count();
-}
-
-// Gets the number of failed test cases.
-int UnitTest::failed_test_case_count() const {
-  return impl()->failed_test_case_count();
-}
-
-// Gets the number of all test cases.
-int UnitTest::total_test_case_count() const {
-  return impl()->total_test_case_count();
-}
-
-// Gets the number of all test cases that contain at least one test
-// that should run.
-int UnitTest::test_case_to_run_count() const {
-  return impl()->test_case_to_run_count();
-}
-
-// Gets the number of successful tests.
-int UnitTest::successful_test_count() const {
-  return impl()->successful_test_count();
-}
-
-// Gets the number of failed tests.
-int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int UnitTest::reportable_disabled_test_count() const {
-  return impl()->reportable_disabled_test_count();
-}
-
-// Gets the number of disabled tests.
-int UnitTest::disabled_test_count() const {
-  return impl()->disabled_test_count();
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTest::reportable_test_count() const {
-  return impl()->reportable_test_count();
-}
-
-// Gets the number of all tests.
-int UnitTest::total_test_count() const { return impl()->total_test_count(); }
-
-// Gets the number of tests that should run.
-int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
-
-// Gets the time of the test program start, in ms from the start of the
-// UNIX epoch.
-internal::TimeInMillis UnitTest::start_timestamp() const {
-    return impl()->start_timestamp();
-}
-
-// Gets the elapsed time, in milliseconds.
-internal::TimeInMillis UnitTest::elapsed_time() const {
-  return impl()->elapsed_time();
-}
-
-// Returns true iff the unit test passed (i.e. all test cases passed).
-bool UnitTest::Passed() const { return impl()->Passed(); }
-
-// Returns true iff the unit test failed (i.e. some test case failed
-// or something outside of all tests failed).
-bool UnitTest::Failed() const { return impl()->Failed(); }
-
-// Gets the i-th test case among all the test cases. i can range from 0 to
-// total_test_case_count() - 1. If i is not in that range, returns NULL.
-const TestCase* UnitTest::GetTestCase(int i) const {
-  return impl()->GetTestCase(i);
-}
-
-// Returns the TestResult containing information on test failures and
-// properties logged outside of individual test cases.
-const TestResult& UnitTest::ad_hoc_test_result() const {
-  return *impl()->ad_hoc_test_result();
-}
-
-// Gets the i-th test case among all the test cases. i can range from 0 to
-// total_test_case_count() - 1. If i is not in that range, returns NULL.
-TestCase* UnitTest::GetMutableTestCase(int i) {
-  return impl()->GetMutableTestCase(i);
-}
-
-// Returns the list of event listeners that can be used to track events
-// inside Google Test.
-TestEventListeners& UnitTest::listeners() {
-  return *impl()->listeners();
-}
-
-// Registers and returns a global test environment.  When a test
-// program is run, all global test environments will be set-up in the
-// order they were registered.  After all tests in the program have
-// finished, all global test environments will be torn-down in the
-// *reverse* order they were registered.
-//
-// The UnitTest object takes ownership of the given environment.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-Environment* UnitTest::AddEnvironment(Environment* env) {
-  if (env == NULL) {
-    return NULL;
-  }
-
-  impl_->environments().push_back(env);
-  return env;
-}
-
-// Adds a TestPartResult to the current TestResult object.  All Google Test
-// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
-// this to report their results.  The user code should use the
-// assertion macros instead of calling this directly.
-void UnitTest::AddTestPartResult(
-    TestPartResult::Type result_type,
-    const char* file_name,
-    int line_number,
-    const std::string& message,
-    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
-  Message msg;
-  msg << message;
-
-  internal::MutexLock lock(&mutex_);
-  if (impl_->gtest_trace_stack().size() > 0) {
-    msg << "\n" << GTEST_NAME_ << " trace:";
-
-    for (int i = static_cast<int>(impl_->gtest_trace_stack().size());
-         i > 0; --i) {
-      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
-      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
-          << " " << trace.message;
-    }
-  }
-
-  if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) {
-    msg << internal::kStackTraceMarker << os_stack_trace;
-  }
-
-  const TestPartResult result =
-    TestPartResult(result_type, file_name, line_number,
-                   msg.GetString().c_str());
-  impl_->GetTestPartResultReporterForCurrentThread()->
-      ReportTestPartResult(result);
-
-  if (result_type != TestPartResult::kSuccess) {
-    // gtest_break_on_failure takes precedence over
-    // gtest_throw_on_failure.  This allows a user to set the latter
-    // in the code (perhaps in order to use Google Test assertions
-    // with another testing framework) and specify the former on the
-    // command line for debugging.
-    if (GTEST_FLAG(break_on_failure)) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-      // Using DebugBreak on Windows allows gtest to still break into a debugger
-      // when a failure happens and both the --gtest_break_on_failure and
-      // the --gtest_catch_exceptions flags are specified.
-      DebugBreak();
-#else
-      // Dereference NULL through a volatile pointer to prevent the compiler
-      // from removing. We use this rather than abort() or __builtin_trap() for
-      // portability: Symbian doesn't implement abort() well, and some debuggers
-      // don't correctly trap abort().
-      *static_cast<volatile int*>(NULL) = 1;
-#endif  // GTEST_OS_WINDOWS
-    } else if (GTEST_FLAG(throw_on_failure)) {
-#if GTEST_HAS_EXCEPTIONS
-      throw internal::GoogleTestFailureException(result);
-#else
-      // We cannot call abort() as it generates a pop-up in debug mode
-      // that cannot be suppressed in VC 7.1 or below.
-      exit(1);
-#endif
-    }
-  }
-}
-
-// Adds a TestProperty to the current TestResult object when invoked from
-// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
-// from SetUpTestCase or TearDownTestCase, or to the global property set
-// when invoked elsewhere.  If the result already contains a property with
-// the same key, the value will be updated.
-void UnitTest::RecordProperty(const std::string& key,
-                              const std::string& value) {
-  impl_->RecordProperty(TestProperty(key, value));
-}
-
-// Runs all tests in this UnitTest object and prints the result.
-// Returns 0 if successful, or 1 otherwise.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-int UnitTest::Run() {
-  const bool in_death_test_child_process =
-      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
-
-  // Google Test implements this protocol for catching that a test
-  // program exits before returning control to Google Test:
-  //
-  //   1. Upon start, Google Test creates a file whose absolute path
-  //      is specified by the environment variable
-  //      TEST_PREMATURE_EXIT_FILE.
-  //   2. When Google Test has finished its work, it deletes the file.
-  //
-  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
-  // running a Google-Test-based test program and check the existence
-  // of the file at the end of the test execution to see if it has
-  // exited prematurely.
-
-  // If we are in the child process of a death test, don't
-  // create/delete the premature exit file, as doing so is unnecessary
-  // and will confuse the parent process.  Otherwise, create/delete
-  // the file upon entering/leaving this function.  If the program
-  // somehow exits before this function has a chance to return, the
-  // premature-exit file will be left undeleted, causing a test runner
-  // that understands the premature-exit-file protocol to report the
-  // test as having failed.
-  const internal::ScopedPrematureExitFile premature_exit_file(
-      in_death_test_child_process ?
-      NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
-
-  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
-  // used for the duration of the program.
-  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
-
-#if GTEST_HAS_SEH
-  // Either the user wants Google Test to catch exceptions thrown by the
-  // tests or this is executing in the context of death test child
-  // process. In either case the user does not want to see pop-up dialogs
-  // about crashes - they are expected.
-  if (impl()->catch_exceptions() || in_death_test_child_process) {
-# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-    // SetErrorMode doesn't exist on CE.
-    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
-                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-# endif  // !GTEST_OS_WINDOWS_MOBILE
-
-# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
-    // Death test children can be terminated with _abort().  On Windows,
-    // _abort() can show a dialog with a warning message.  This forces the
-    // abort message to go to stderr instead.
-    _set_error_mode(_OUT_TO_STDERR);
-# endif
-
-# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
-    // In the debug version, Visual Studio pops up a separate dialog
-    // offering a choice to debug the aborted program. We need to suppress
-    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
-    // executed. Google Test will notify the user of any unexpected
-    // failure via stderr.
-    //
-    // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
-    // Users of prior VC versions shall suffer the agony and pain of
-    // clicking through the countless debug dialogs.
-    // TODO(vladl@google.com): find a way to suppress the abort dialog() in the
-    // debug mode when compiled with VC 7.1 or lower.
-    if (!GTEST_FLAG(break_on_failure))
-      _set_abort_behavior(
-          0x0,                                    // Clear the following flags:
-          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
-# endif
-  }
-#endif  // GTEST_HAS_SEH
-
-  return internal::HandleExceptionsInMethodIfSupported(
-      impl(),
-      &internal::UnitTestImpl::RunAllTests,
-      "auxiliary test code (environments or event listeners)") ? 0 : 1;
-}
-
-// Returns the working directory when the first TEST() or TEST_F() was
-// executed.
-const char* UnitTest::original_working_dir() const {
-  return impl_->original_working_dir_.c_str();
-}
-
-// Returns the TestCase object for the test that's currently running,
-// or NULL if no test is running.
-const TestCase* UnitTest::current_test_case() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_case();
-}
-
-// Returns the TestInfo object for the test that's currently running,
-// or NULL if no test is running.
-const TestInfo* UnitTest::current_test_info() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_info();
-}
-
-// Returns the random seed used at the start of the current test run.
-int UnitTest::random_seed() const { return impl_->random_seed(); }
-
-#if GTEST_HAS_PARAM_TEST
-// Returns ParameterizedTestCaseRegistry object used to keep track of
-// value-parameterized tests and instantiate and register them.
-internal::ParameterizedTestCaseRegistry&
-    UnitTest::parameterized_test_registry()
-        GTEST_LOCK_EXCLUDED_(mutex_) {
-  return impl_->parameterized_test_registry();
-}
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Creates an empty UnitTest.
-UnitTest::UnitTest() {
-  impl_ = new internal::UnitTestImpl(this);
-}
-
-// Destructor of UnitTest.
-UnitTest::~UnitTest() {
-  delete impl_;
-}
-
-// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-// Google Test trace stack.
-void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().push_back(trace);
-}
-
-// Pops a trace from the per-thread Google Test trace stack.
-void UnitTest::PopGTestTrace()
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().pop_back();
-}
-
-namespace internal {
-
-UnitTestImpl::UnitTestImpl(UnitTest* parent)
-    : parent_(parent),
-      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
-      default_global_test_part_result_reporter_(this),
-      default_per_thread_test_part_result_reporter_(this),
-      GTEST_DISABLE_MSC_WARNINGS_POP_()
-      global_test_part_result_repoter_(
-          &default_global_test_part_result_reporter_),
-      per_thread_test_part_result_reporter_(
-          &default_per_thread_test_part_result_reporter_),
-#if GTEST_HAS_PARAM_TEST
-      parameterized_test_registry_(),
-      parameterized_tests_registered_(false),
-#endif  // GTEST_HAS_PARAM_TEST
-      last_death_test_case_(-1),
-      current_test_case_(NULL),
-      current_test_info_(NULL),
-      ad_hoc_test_result_(),
-      os_stack_trace_getter_(NULL),
-      post_flag_parse_init_performed_(false),
-      random_seed_(0),  // Will be overridden by the flag before first use.
-      random_(0),  // Will be reseeded before first use.
-      start_timestamp_(0),
-      elapsed_time_(0),
-#if GTEST_HAS_DEATH_TEST
-      death_test_factory_(new DefaultDeathTestFactory),
-#endif
-      // Will be overridden by the flag before first use.
-      catch_exceptions_(false) {
-  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
-}
-
-UnitTestImpl::~UnitTestImpl() {
-  // Deletes every TestCase.
-  ForEach(test_cases_, internal::Delete<TestCase>);
-
-  // Deletes every Environment.
-  ForEach(environments_, internal::Delete<Environment>);
-
-  delete os_stack_trace_getter_;
-}
-
-// Adds a TestProperty to the current TestResult object when invoked in a
-// context of a test, to current test case's ad_hoc_test_result when invoke
-// from SetUpTestCase/TearDownTestCase, or to the global property set
-// otherwise.  If the result already contains a property with the same key,
-// the value will be updated.
-void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
-  std::string xml_element;
-  TestResult* test_result;  // TestResult appropriate for property recording.
-
-  if (current_test_info_ != NULL) {
-    xml_element = "testcase";
-    test_result = &(current_test_info_->result_);
-  } else if (current_test_case_ != NULL) {
-    xml_element = "testsuite";
-    test_result = &(current_test_case_->ad_hoc_test_result_);
-  } else {
-    xml_element = "testsuites";
-    test_result = &ad_hoc_test_result_;
-  }
-  test_result->RecordProperty(xml_element, test_property);
-}
-
-#if GTEST_HAS_DEATH_TEST
-// Disables event forwarding if the control is currently in a death test
-// subprocess. Must not be called before InitGoogleTest.
-void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
-  if (internal_run_death_test_flag_.get() != NULL)
-    listeners()->SuppressEventForwarding();
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Initializes event listeners performing XML output as specified by
-// UnitTestOptions. Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureXmlOutput() {
-  const std::string& output_format = UnitTestOptions::GetOutputFormat();
-  if (output_format == "xml") {
-    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
-  } else if (output_format != "") {
-    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
-           output_format.c_str());
-    fflush(stdout);
-  }
-}
-
-#if GTEST_CAN_STREAM_RESULTS_
-// Initializes event listeners for streaming test results in string form.
-// Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureStreamingOutput() {
-  const std::string& target = GTEST_FLAG(stream_result_to);
-  if (!target.empty()) {
-    const size_t pos = target.find(':');
-    if (pos != std::string::npos) {
-      listeners()->Append(new StreamingListener(target.substr(0, pos),
-                                                target.substr(pos+1)));
-    } else {
-      printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
-             target.c_str());
-      fflush(stdout);
-    }
-  }
-}
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-// Performs initialization dependent upon flag values obtained in
-// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-// this function is also called from RunAllTests.  Since this function can be
-// called more than once, it has to be idempotent.
-void UnitTestImpl::PostFlagParsingInit() {
-  // Ensures that this function does not execute more than once.
-  if (!post_flag_parse_init_performed_) {
-    post_flag_parse_init_performed_ = true;
-
-#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-    // Register to send notifications about key process state changes.
-    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
-#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-
-#if GTEST_HAS_DEATH_TEST
-    InitDeathTestSubprocessControlInfo();
-    SuppressTestEventsIfInSubprocess();
-#endif  // GTEST_HAS_DEATH_TEST
-
-    // Registers parameterized tests. This makes parameterized tests
-    // available to the UnitTest reflection API without running
-    // RUN_ALL_TESTS.
-    RegisterParameterizedTests();
-
-    // Configures listeners for XML output. This makes it possible for users
-    // to shut down the default XML output before invoking RUN_ALL_TESTS.
-    ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-    // Configures listeners for streaming test results to the specified server.
-    ConfigureStreamingOutput();
-#endif  // GTEST_CAN_STREAM_RESULTS_
-  }
-}
-
-// A predicate that checks the name of a TestCase against a known
-// value.
-//
-// This is used for implementation of the UnitTest class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestCaseNameIs is copyable.
-class TestCaseNameIs {
- public:
-  // Constructor.
-  explicit TestCaseNameIs(const std::string& name)
-      : name_(name) {}
-
-  // Returns true iff the name of test_case matches name_.
-  bool operator()(const TestCase* test_case) const {
-    return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
-  }
-
- private:
-  std::string name_;
-};
-
-// Finds and returns a TestCase with the given name.  If one doesn't
-// exist, creates one and returns it.  It's the CALLER'S
-// RESPONSIBILITY to ensure that this function is only called WHEN THE
-// TESTS ARE NOT SHUFFLED.
-//
-// Arguments:
-//
-//   test_case_name: name of the test case
-//   type_param:     the name of the test case's type parameter, or NULL if
-//                   this is not a typed or a type-parameterized test case.
-//   set_up_tc:      pointer to the function that sets up the test case
-//   tear_down_tc:   pointer to the function that tears down the test case
-TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
-                                    const char* type_param,
-                                    Test::SetUpTestCaseFunc set_up_tc,
-                                    Test::TearDownTestCaseFunc tear_down_tc) {
-  // Can we find a TestCase with the given name?
-  const std::vector<TestCase*>::const_iterator test_case =
-      std::find_if(test_cases_.begin(), test_cases_.end(),
-                   TestCaseNameIs(test_case_name));
-
-  if (test_case != test_cases_.end())
-    return *test_case;
-
-  // No.  Let's create one.
-  TestCase* const new_test_case =
-      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
-
-  // Is this a death test case?
-  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
-                                               kDeathTestCaseFilter)) {
-    // Yes.  Inserts the test case after the last death test case
-    // defined so far.  This only works when the test cases haven't
-    // been shuffled.  Otherwise we may end up running a death test
-    // after a non-death test.
-    ++last_death_test_case_;
-    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
-                       new_test_case);
-  } else {
-    // No.  Appends to the end of the list.
-    test_cases_.push_back(new_test_case);
-  }
-
-  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
-  return new_test_case;
-}
-
-// Helpers for setting up / tearing down the given environment.  They
-// are for use in the ForEach() function.
-static void SetUpEnvironment(Environment* env) { env->SetUp(); }
-static void TearDownEnvironment(Environment* env) { env->TearDown(); }
-
-// Runs all tests in this UnitTest object, prints the result, and
-// returns true if all tests are successful.  If any exception is
-// thrown during a test, the test is considered to be failed, but the
-// rest of the tests will still be run.
-//
-// When parameterized tests are enabled, it expands and registers
-// parameterized tests first in RegisterParameterizedTests().
-// All other functions called from RunAllTests() may safely assume that
-// parameterized tests are ready to be counted and run.
-bool UnitTestImpl::RunAllTests() {
-  // Makes sure InitGoogleTest() was called.
-  if (!GTestIsInitialized()) {
-    printf("%s",
-           "\nThis test program did NOT call ::testing::InitGoogleTest "
-           "before calling RUN_ALL_TESTS().  Please fix it.\n");
-    return false;
-  }
-
-  // Do not run any test if the --help flag was specified.
-  if (g_help_flag)
-    return true;
-
-  // Repeats the call to the post-flag parsing initialization in case the
-  // user didn't call InitGoogleTest.
-  PostFlagParsingInit();
-
-  // Even if sharding is not on, test runners may want to use the
-  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
-  // protocol.
-  internal::WriteToShardStatusFileIfNeeded();
-
-  // True iff we are in a subprocess for running a thread-safe-style
-  // death test.
-  bool in_subprocess_for_death_test = false;
-
-#if GTEST_HAS_DEATH_TEST
-  in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
-# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-  if (in_subprocess_for_death_test) {
-    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
-  }
-# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-#endif  // GTEST_HAS_DEATH_TEST
-
-  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
-                                        in_subprocess_for_death_test);
-
-  // Compares the full test names with the filter to decide which
-  // tests to run.
-  const bool has_tests_to_run = FilterTests(should_shard
-                                              ? HONOR_SHARDING_PROTOCOL
-                                              : IGNORE_SHARDING_PROTOCOL) > 0;
-
-  // Lists the tests and exits if the --gtest_list_tests flag was specified.
-  if (GTEST_FLAG(list_tests)) {
-    // This must be called *after* FilterTests() has been called.
-    ListTestsMatchingFilter();
-    return true;
-  }
-
-  random_seed_ = GTEST_FLAG(shuffle) ?
-      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
-
-  // True iff at least one test has failed.
-  bool failed = false;
-
-  TestEventListener* repeater = listeners()->repeater();
-
-  start_timestamp_ = GetTimeInMillis();
-  repeater->OnTestProgramStart(*parent_);
-
-  // How many times to repeat the tests?  We don't want to repeat them
-  // when we are inside the subprocess of a death test.
-  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
-  // Repeats forever if the repeat count is negative.
-  const bool forever = repeat < 0;
-  for (int i = 0; forever || i != repeat; i++) {
-    // We want to preserve failures generated by ad-hoc test
-    // assertions executed before RUN_ALL_TESTS().
-    ClearNonAdHocTestResult();
-
-    const TimeInMillis start = GetTimeInMillis();
-
-    // Shuffles test cases and tests if requested.
-    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
-      random()->Reseed(random_seed_);
-      // This should be done before calling OnTestIterationStart(),
-      // such that a test event listener can see the actual test order
-      // in the event.
-      ShuffleTests();
-    }
-
-    // Tells the unit test event listeners that the tests are about to start.
-    repeater->OnTestIterationStart(*parent_, i);
-
-    // Runs each test case if there is at least one test to run.
-    if (has_tests_to_run) {
-      // Sets up all environments beforehand.
-      repeater->OnEnvironmentsSetUpStart(*parent_);
-      ForEach(environments_, SetUpEnvironment);
-      repeater->OnEnvironmentsSetUpEnd(*parent_);
-
-      // Runs the tests only if there was no fatal failure during global
-      // set-up.
-      if (!Test::HasFatalFailure()) {
-        for (int test_index = 0; test_index < total_test_case_count();
-             test_index++) {
-          GetMutableTestCase(test_index)->Run();
-        }
-      }
-
-      // Tears down all environments in reverse order afterwards.
-      repeater->OnEnvironmentsTearDownStart(*parent_);
-      std::for_each(environments_.rbegin(), environments_.rend(),
-                    TearDownEnvironment);
-      repeater->OnEnvironmentsTearDownEnd(*parent_);
-    }
-
-    elapsed_time_ = GetTimeInMillis() - start;
-
-    // Tells the unit test event listener that the tests have just finished.
-    repeater->OnTestIterationEnd(*parent_, i);
-
-    // Gets the result and clears it.
-    if (!Passed()) {
-      failed = true;
-    }
-
-    // Restores the original test order after the iteration.  This
-    // allows the user to quickly repro a failure that happens in the
-    // N-th iteration without repeating the first (N - 1) iterations.
-    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
-    // case the user somehow changes the value of the flag somewhere
-    // (it's always safe to unshuffle the tests).
-    UnshuffleTests();
-
-    if (GTEST_FLAG(shuffle)) {
-      // Picks a new random seed for each iteration.
-      random_seed_ = GetNextRandomSeed(random_seed_);
-    }
-  }
-
-  repeater->OnTestProgramEnd(*parent_);
-
-  return !failed;
-}
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded() {
-  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
-  if (test_shard_file != NULL) {
-    FILE* const file = posix::FOpen(test_shard_file, "w");
-    if (file == NULL) {
-      ColoredPrintf(COLOR_RED,
-                    "Could not write to the test shard status file \"%s\" "
-                    "specified by the %s environment variable.\n",
-                    test_shard_file, kTestShardStatusFile);
-      fflush(stdout);
-      exit(EXIT_FAILURE);
-    }
-    fclose(file);
-  }
-}
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (i.e., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-bool ShouldShard(const char* total_shards_env,
-                 const char* shard_index_env,
-                 bool in_subprocess_for_death_test) {
-  if (in_subprocess_for_death_test) {
-    return false;
-  }
-
-  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
-  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
-
-  if (total_shards == -1 && shard_index == -1) {
-    return false;
-  } else if (total_shards == -1 && shard_index != -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestShardIndex << " = " << shard_index
-      << ", but have left " << kTestTotalShards << " unset.\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (total_shards != -1 && shard_index == -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestTotalShards << " = " << total_shards
-      << ", but have left " << kTestShardIndex << " unset.\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (shard_index < 0 || shard_index >= total_shards) {
-    const Message msg = Message()
-      << "Invalid environment variables: we require 0 <= "
-      << kTestShardIndex << " < " << kTestTotalShards
-      << ", but you have " << kTestShardIndex << "=" << shard_index
-      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  }
-
-  return total_shards > 1;
-}
-
-// Parses the environment variable var as an Int32. If it is unset,
-// returns default_val. If it is not an Int32, prints an error
-// and aborts.
-Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
-  const char* str_val = posix::GetEnv(var);
-  if (str_val == NULL) {
-    return default_val;
-  }
-
-  Int32 result;
-  if (!ParseInt32(Message() << "The value of environment variable " << var,
-                  str_val, &result)) {
-    exit(EXIT_FAILURE);
-  }
-  return result;
-}
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff the test should be run on this shard. The test id is
-// some arbitrary but unique non-negative integer assigned to each test
-// method. Assumes that 0 <= shard_index < total_shards.
-bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
-  return (test_id % total_shards) == shard_index;
-}
-
-// Compares the name of each test with the user-specified filter to
-// decide whether the test should be run, then records the result in
-// each TestCase and TestInfo object.
-// If shard_tests == true, further filters tests based on sharding
-// variables in the environment - see
-// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
-// Returns the number of tests that should run.
-int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
-  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
-  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
-
-  // num_runnable_tests are the number of tests that will
-  // run across all shards (i.e., match filter and are not disabled).
-  // num_selected_tests are the number of tests to be run on
-  // this shard.
-  int num_runnable_tests = 0;
-  int num_selected_tests = 0;
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    TestCase* const test_case = test_cases_[i];
-    const std::string &test_case_name = test_case->name();
-    test_case->set_should_run(false);
-
-    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
-      TestInfo* const test_info = test_case->test_info_list()[j];
-      const std::string test_name(test_info->name());
-      // A test is disabled if test case name or test name matches
-      // kDisableTestFilter.
-      const bool is_disabled =
-          internal::UnitTestOptions::MatchesFilter(test_case_name,
-                                                   kDisableTestFilter) ||
-          internal::UnitTestOptions::MatchesFilter(test_name,
-                                                   kDisableTestFilter);
-      test_info->is_disabled_ = is_disabled;
-
-      const bool matches_filter =
-          internal::UnitTestOptions::FilterMatchesTest(test_case_name,
-                                                       test_name);
-      test_info->matches_filter_ = matches_filter;
-
-      const bool is_runnable =
-          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
-          matches_filter;
-
-      const bool is_selected = is_runnable &&
-          (shard_tests == IGNORE_SHARDING_PROTOCOL ||
-           ShouldRunTestOnShard(total_shards, shard_index,
-                                num_runnable_tests));
-
-      num_runnable_tests += is_runnable;
-      num_selected_tests += is_selected;
-
-      test_info->should_run_ = is_selected;
-      test_case->set_should_run(test_case->should_run() || is_selected);
-    }
-  }
-  return num_selected_tests;
-}
-
-// Prints the given C-string on a single line by replacing all '\n'
-// characters with string "\\n".  If the output takes more than
-// max_length characters, only prints the first max_length characters
-// and "...".
-static void PrintOnOneLine(const char* str, int max_length) {
-  if (str != NULL) {
-    for (int i = 0; *str != '\0'; ++str) {
-      if (i >= max_length) {
-        printf("...");
-        break;
-      }
-      if (*str == '\n') {
-        printf("\\n");
-        i += 2;
-      } else {
-        printf("%c", *str);
-        ++i;
-      }
-    }
-  }
-}
-
-// Prints the names of the tests matching the user-specified filter flag.
-void UnitTestImpl::ListTestsMatchingFilter() {
-  // Print at most this many characters for each type/value parameter.
-  const int kMaxParamLength = 250;
-
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    const TestCase* const test_case = test_cases_[i];
-    bool printed_test_case_name = false;
-
-    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
-      const TestInfo* const test_info =
-          test_case->test_info_list()[j];
-      if (test_info->matches_filter_) {
-        if (!printed_test_case_name) {
-          printed_test_case_name = true;
-          printf("%s.", test_case->name());
-          if (test_case->type_param() != NULL) {
-            printf("  # %s = ", kTypeParamLabel);
-            // We print the type parameter on a single line to make
-            // the output easy to parse by a program.
-            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
-          }
-          printf("\n");
-        }
-        printf("  %s", test_info->name());
-        if (test_info->value_param() != NULL) {
-          printf("  # %s = ", kValueParamLabel);
-          // We print the value parameter on a single line to make the
-          // output easy to parse by a program.
-          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
-        }
-        printf("\n");
-      }
-    }
-  }
-  fflush(stdout);
-}
-
-// Sets the OS stack trace getter.
-//
-// Does nothing if the input and the current OS stack trace getter are
-// the same; otherwise, deletes the old getter and makes the input the
-// current getter.
-void UnitTestImpl::set_os_stack_trace_getter(
-    OsStackTraceGetterInterface* getter) {
-  if (os_stack_trace_getter_ != getter) {
-    delete os_stack_trace_getter_;
-    os_stack_trace_getter_ = getter;
-  }
-}
-
-// Returns the current OS stack trace getter if it is not NULL;
-// otherwise, creates an OsStackTraceGetter, makes it the current
-// getter, and returns it.
-OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
-  if (os_stack_trace_getter_ == NULL) {
-#ifdef GTEST_OS_STACK_TRACE_GETTER_
-    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
-#else
-    os_stack_trace_getter_ = new OsStackTraceGetter;
-#endif  // GTEST_OS_STACK_TRACE_GETTER_
-  }
-
-  return os_stack_trace_getter_;
-}
-
-// Returns the TestResult for the test that's currently running, or
-// the TestResult for the ad hoc test if no test is running.
-TestResult* UnitTestImpl::current_test_result() {
-  return current_test_info_ ?
-      &(current_test_info_->result_) : &ad_hoc_test_result_;
-}
-
-// Shuffles all test cases, and the tests within each test case,
-// making sure that death tests are still run first.
-void UnitTestImpl::ShuffleTests() {
-  // Shuffles the death test cases.
-  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
-
-  // Shuffles the non-death test cases.
-  ShuffleRange(random(), last_death_test_case_ + 1,
-               static_cast<int>(test_cases_.size()), &test_case_indices_);
-
-  // Shuffles the tests inside each test case.
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    test_cases_[i]->ShuffleTests(random());
-  }
-}
-
-// Restores the test cases and tests to their order before the first shuffle.
-void UnitTestImpl::UnshuffleTests() {
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    // Unshuffles the tests in each test case.
-    test_cases_[i]->UnshuffleTests();
-    // Resets the index of each test case.
-    test_case_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
-                                            int skip_count) {
-  // We pass skip_count + 1 to skip this wrapper function in addition
-  // to what the user really wants to skip.
-  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
-}
-
-// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
-// suppress unreachable code warnings.
-namespace {
-class ClassUniqueToAlwaysTrue {};
-}
-
-bool IsTrue(bool condition) { return condition; }
-
-bool AlwaysTrue() {
-#if GTEST_HAS_EXCEPTIONS
-  // This condition is always false so AlwaysTrue() never actually throws,
-  // but it makes the compiler think that it may throw.
-  if (IsTrue(false))
-    throw ClassUniqueToAlwaysTrue();
-#endif  // GTEST_HAS_EXCEPTIONS
-  return true;
-}
-
-// If *pstr starts with the given prefix, modifies *pstr to be right
-// past the prefix and returns true; otherwise leaves *pstr unchanged
-// and returns false.  None of pstr, *pstr, and prefix can be NULL.
-bool SkipPrefix(const char* prefix, const char** pstr) {
-  const size_t prefix_len = strlen(prefix);
-  if (strncmp(*pstr, prefix, prefix_len) == 0) {
-    *pstr += prefix_len;
-    return true;
-  }
-  return false;
-}
-
-// Parses a string as a command line flag.  The string should have
-// the format "--flag=value".  When def_optional is true, the "=value"
-// part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-const char* ParseFlagValue(const char* str,
-                           const char* flag,
-                           bool def_optional) {
-  // str and flag must not be NULL.
-  if (str == NULL || flag == NULL) return NULL;
-
-  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
-  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
-  const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
-
-  // Skips the flag name.
-  const char* flag_end = str + flag_len;
-
-  // When def_optional is true, it's OK to not have a "=value" part.
-  if (def_optional && (flag_end[0] == '\0')) {
-    return flag_end;
-  }
-
-  // If def_optional is true and there are more characters after the
-  // flag name, or if def_optional is false, there must be a '=' after
-  // the flag name.
-  if (flag_end[0] != '=') return NULL;
-
-  // Returns the string after "=".
-  return flag_end + 1;
-}
-
-// Parses a string for a bool flag, in the form of either
-// "--flag=value" or "--flag".
-//
-// In the former case, the value is taken as true as long as it does
-// not start with '0', 'f', or 'F'.
-//
-// In the latter case, the value is taken as true.
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, true);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Converts the string value to a bool.
-  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
-  return true;
-}
-
-// Parses a string for an Int32 flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Sets *value to the value of the flag.
-  return ParseInt32(Message() << "The value of flag --" << flag,
-                    value_str, value);
-}
-
-// Parses a string for a string flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Sets *value to the value of the flag.
-  *value = value_str;
-  return true;
-}
-
-// Determines whether a string has a prefix that Google Test uses for its
-// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
-// If Google Test detects that a command line flag has its prefix but is not
-// recognized, it will print its help message. Flags starting with
-// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
-// internal flags and do not trigger the help message.
-static bool HasGoogleTestFlagPrefix(const char* str) {
-  return (SkipPrefix("--", &str) ||
-          SkipPrefix("-", &str) ||
-          SkipPrefix("/", &str)) &&
-         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
-         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
-          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
-}
-
-// Prints a string containing code-encoded text.  The following escape
-// sequences can be used in the string to control the text color:
-//
-//   @@    prints a single '@' character.
-//   @R    changes the color to red.
-//   @G    changes the color to green.
-//   @Y    changes the color to yellow.
-//   @D    changes to the default terminal text color.
-//
-// TODO(wan@google.com): Write tests for this once we add stdout
-// capturing to Google Test.
-static void PrintColorEncoded(const char* str) {
-  GTestColor color = COLOR_DEFAULT;  // The current color.
-
-  // Conceptually, we split the string into segments divided by escape
-  // sequences.  Then we print one segment at a time.  At the end of
-  // each iteration, the str pointer advances to the beginning of the
-  // next segment.
-  for (;;) {
-    const char* p = strchr(str, '@');
-    if (p == NULL) {
-      ColoredPrintf(color, "%s", str);
-      return;
-    }
-
-    ColoredPrintf(color, "%s", std::string(str, p).c_str());
-
-    const char ch = p[1];
-    str = p + 2;
-    if (ch == '@') {
-      ColoredPrintf(color, "@");
-    } else if (ch == 'D') {
-      color = COLOR_DEFAULT;
-    } else if (ch == 'R') {
-      color = COLOR_RED;
-    } else if (ch == 'G') {
-      color = COLOR_GREEN;
-    } else if (ch == 'Y') {
-      color = COLOR_YELLOW;
-    } else {
-      --str;
-    }
-  }
-}
-
-static const char kColorEncodedHelpMessage[] =
-"This program contains tests written using " GTEST_NAME_ ". You can use the\n"
-"following command line flags to control its behavior:\n"
-"\n"
-"Test Selection:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n"
-"      List the names of all tests instead of running them. The name of\n"
-"      TEST(Foo, Bar) is \"Foo.Bar\".\n"
-"  @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS"
-    "[@G-@YNEGATIVE_PATTERNS]@D\n"
-"      Run only the tests whose name matches one of the positive patterns but\n"
-"      none of the negative patterns. '?' matches any single character; '*'\n"
-"      matches any substring; ':' separates two patterns.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n"
-"      Run all disabled tests too.\n"
-"\n"
-"Test Execution:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n"
-"      Run the tests repeatedly; use a negative count to repeat forever.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n"
-"      Randomize tests' orders on every iteration.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n"
-"      Random number seed to use for shuffling test orders (between 1 and\n"
-"      99999, or 0 to use a seed based on the current time).\n"
-"\n"
-"Test Output:\n"
-"  @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
-"      Enable/disable colored output. The default is @Gauto@D.\n"
-"  -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n"
-"      Don't print the elapsed time of each test.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
-    GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
-"      Generate an XML report in the given directory or with the given file\n"
-"      name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n"
-#if GTEST_CAN_STREAM_RESULTS_
-"  @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n"
-"      Stream test results to the given server.\n"
-#endif  // GTEST_CAN_STREAM_RESULTS_
-"\n"
-"Assertion Behavior:\n"
-#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-"  @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
-"      Set the default death test style.\n"
-#endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-"  @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n"
-"      Turn assertion failures into debugger break-points.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n"
-"      Turn assertion failures into C++ exceptions.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n"
-"      Do not report exceptions as test failures. Instead, allow them\n"
-"      to crash the program or throw a pop-up (on Windows).\n"
-"\n"
-"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set "
-    "the corresponding\n"
-"environment variable of a flag (all letters in upper-case). For example, to\n"
-"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_
-    "color=no@D or set\n"
-"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n"
-"\n"
-"For more information, please read the " GTEST_NAME_ " documentation at\n"
-"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n"
-"(not one in your own code or tests), please report it to\n"
-"@G<" GTEST_DEV_EMAIL_ ">@D.\n";
-
-bool ParseGoogleTestFlag(const char* const arg) {
-  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
-                       &GTEST_FLAG(also_run_disabled_tests)) ||
-      ParseBoolFlag(arg, kBreakOnFailureFlag,
-                    &GTEST_FLAG(break_on_failure)) ||
-      ParseBoolFlag(arg, kCatchExceptionsFlag,
-                    &GTEST_FLAG(catch_exceptions)) ||
-      ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
-      ParseStringFlag(arg, kDeathTestStyleFlag,
-                      &GTEST_FLAG(death_test_style)) ||
-      ParseBoolFlag(arg, kDeathTestUseFork,
-                    &GTEST_FLAG(death_test_use_fork)) ||
-      ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
-      ParseStringFlag(arg, kInternalRunDeathTestFlag,
-                      &GTEST_FLAG(internal_run_death_test)) ||
-      ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
-      ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
-      ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-      ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
-      ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
-      ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
-      ParseInt32Flag(arg, kStackTraceDepthFlag,
-                     &GTEST_FLAG(stack_trace_depth)) ||
-      ParseStringFlag(arg, kStreamResultToFlag,
-                      &GTEST_FLAG(stream_result_to)) ||
-      ParseBoolFlag(arg, kThrowOnFailureFlag,
-                    &GTEST_FLAG(throw_on_failure));
-}
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-void LoadFlagsFromFile(const std::string& path) {
-  FILE* flagfile = posix::FOpen(path.c_str(), "r");
-  if (!flagfile) {
-    fprintf(stderr,
-            "Unable to open file \"%s\"\n",
-            GTEST_FLAG(flagfile).c_str());
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-  std::string contents(ReadEntireFile(flagfile));
-  posix::FClose(flagfile);
-  std::vector<std::string> lines;
-  SplitString(contents, '\n', &lines);
-  for (size_t i = 0; i < lines.size(); ++i) {
-    if (lines[i].empty())
-      continue;
-    if (!ParseGoogleTestFlag(lines[i].c_str()))
-      g_help_flag = true;
-  }
-}
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.  The type parameter CharType can be
-// instantiated to either char or wchar_t.
-template <typename CharType>
-void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
-  for (int i = 1; i < *argc; i++) {
-    const std::string arg_string = StreamableToString(argv[i]);
-    const char* const arg = arg_string.c_str();
-
-    using internal::ParseBoolFlag;
-    using internal::ParseInt32Flag;
-    using internal::ParseStringFlag;
-
-    bool remove_flag = false;
-    if (ParseGoogleTestFlag(arg)) {
-      remove_flag = true;
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
-      LoadFlagsFromFile(GTEST_FLAG(flagfile));
-      remove_flag = true;
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (arg_string == "--help" || arg_string == "-h" ||
-               arg_string == "-?" || arg_string == "/?" ||
-               HasGoogleTestFlagPrefix(arg)) {
-      // Both help flag and unrecognized Google Test flags (excluding
-      // internal ones) trigger help display.
-      g_help_flag = true;
-    }
-
-    if (remove_flag) {
-      // Shift the remainder of the argv list left by one.  Note
-      // that argv has (*argc + 1) elements, the last one always being
-      // NULL.  The following loop moves the trailing NULL element as
-      // well.
-      for (int j = i; j != *argc; j++) {
-        argv[j] = argv[j + 1];
-      }
-
-      // Decrements the argument count.
-      (*argc)--;
-
-      // We also need to decrement the iterator as we just removed
-      // an element.
-      i--;
-    }
-  }
-
-  if (g_help_flag) {
-    // We print the help here instead of in RUN_ALL_TESTS(), as the
-    // latter may not be called at all if the user is using Google
-    // Test with another testing framework.
-    PrintColorEncoded(kColorEncodedHelpMessage);
-  }
-}
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-}
-void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-}
-
-// The internal implementation of InitGoogleTest().
-//
-// The type parameter CharType can be instantiated to either char or
-// wchar_t.
-template <typename CharType>
-void InitGoogleTestImpl(int* argc, CharType** argv) {
-  // We don't want to run the initialization code twice.
-  if (GTestIsInitialized()) return;
-
-  if (*argc <= 0) return;
-
-  g_argvs.clear();
-  for (int i = 0; i != *argc; i++) {
-    g_argvs.push_back(StreamableToString(argv[i]));
-  }
-
-  ParseGoogleTestFlagsOnly(argc, argv);
-  GetUnitTestImpl()->PostFlagParsingInit();
-}
-
-}  // namespace internal
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-void InitGoogleTest(int* argc, char** argv) {
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-void InitGoogleTest(int* argc, wchar_t** argv) {
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-}  // namespace testing
-// Copyright 2005, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
-//
-// This file implements death tests.
-
-
-#if GTEST_HAS_DEATH_TEST
-
-# if GTEST_OS_MAC
-#  include <crt_externs.h>
-# endif  // GTEST_OS_MAC
-
-# include <errno.h>
-# include <fcntl.h>
-# include <limits.h>
-
-# if GTEST_OS_LINUX
-#  include <signal.h>
-# endif  // GTEST_OS_LINUX
-
-# include <stdarg.h>
-
-# if GTEST_OS_WINDOWS
-#  include <windows.h>
-# else
-#  include <sys/mman.h>
-#  include <sys/wait.h>
-# endif  // GTEST_OS_WINDOWS
-
-# if GTEST_OS_QNX
-#  include <spawn.h>
-# endif  // GTEST_OS_QNX
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-
-// Constants.
-
-// The default death test style.
-static const char kDefaultDeathTestStyle[] = "fast";
-
-GTEST_DEFINE_string_(
-    death_test_style,
-    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
-    "Indicates how to run a death test in a forked child process: "
-    "\"threadsafe\" (child process re-executes the test binary "
-    "from the beginning, running only the specific death test) or "
-    "\"fast\" (child process runs the death test immediately "
-    "after forking).");
-
-GTEST_DEFINE_bool_(
-    death_test_use_fork,
-    internal::BoolFromGTestEnv("death_test_use_fork", false),
-    "Instructs to use fork()/_exit() instead of clone() in death tests. "
-    "Ignored and always uses fork() on POSIX systems where clone() is not "
-    "implemented. Useful when running under valgrind or similar tools if "
-    "those do not support clone(). Valgrind 3.3.1 will just fail if "
-    "it sees an unsupported combination of clone() flags. "
-    "It is not recommended to use this flag w/o valgrind though it will "
-    "work in 99% of the cases. Once valgrind is fixed, this flag will "
-    "most likely be removed.");
-
-namespace internal {
-GTEST_DEFINE_string_(
-    internal_run_death_test, "",
-    "Indicates the file, line number, temporal index of "
-    "the single death test to run, and a file descriptor to "
-    "which a success code may be sent, all separated by "
-    "the '|' characters.  This flag is specified if and only if the current "
-    "process is a sub-process launched for running a thread-safe "
-    "death test.  FOR INTERNAL USE ONLY.");
-}  // namespace internal
-
-#if GTEST_HAS_DEATH_TEST
-
-namespace internal {
-
-// Valid only for fast death tests. Indicates the code is running in the
-// child process of a fast style death test.
-# if !GTEST_OS_WINDOWS
-static bool g_in_fast_death_test_child = false;
-# endif
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// tests.  IMPORTANT: This is an internal utility.  Using it may break the
-// implementation of death tests.  User code MUST NOT use it.
-bool InDeathTestChild() {
-# if GTEST_OS_WINDOWS
-
-  // On Windows, death tests are thread-safe regardless of the value of the
-  // death_test_style flag.
-  return !GTEST_FLAG(internal_run_death_test).empty();
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe")
-    return !GTEST_FLAG(internal_run_death_test).empty();
-  else
-    return g_in_fast_death_test_child;
-#endif
-}
-
-}  // namespace internal
-
-// ExitedWithCode constructor.
-ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
-}
-
-// ExitedWithCode function-call operator.
-bool ExitedWithCode::operator()(int exit_status) const {
-# if GTEST_OS_WINDOWS
-
-  return exit_status == exit_code_;
-
-# else
-
-  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
-
-# endif  // GTEST_OS_WINDOWS
-}
-
-# if !GTEST_OS_WINDOWS
-// KilledBySignal constructor.
-KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
-}
-
-// KilledBySignal function-call operator.
-bool KilledBySignal::operator()(int exit_status) const {
-#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  {
-    bool result;
-    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
-      return result;
-    }
-  }
-#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
-}
-# endif  // !GTEST_OS_WINDOWS
-
-namespace internal {
-
-// Utilities needed for death tests.
-
-// Generates a textual description of a given exit code, in the format
-// specified by wait(2).
-static std::string ExitSummary(int exit_code) {
-  Message m;
-
-# if GTEST_OS_WINDOWS
-
-  m << "Exited with exit status " << exit_code;
-
-# else
-
-  if (WIFEXITED(exit_code)) {
-    m << "Exited with exit status " << WEXITSTATUS(exit_code);
-  } else if (WIFSIGNALED(exit_code)) {
-    m << "Terminated by signal " << WTERMSIG(exit_code);
-  }
-#  ifdef WCOREDUMP
-  if (WCOREDUMP(exit_code)) {
-    m << " (core dumped)";
-  }
-#  endif
-# endif  // GTEST_OS_WINDOWS
-
-  return m.GetString();
-}
-
-// Returns true if exit_status describes a process that was terminated
-// by a signal, or exited normally with a nonzero exit code.
-bool ExitedUnsuccessfully(int exit_status) {
-  return !ExitedWithCode(0)(exit_status);
-}
-
-# if !GTEST_OS_WINDOWS
-// Generates a textual failure message when a death test finds more than
-// one thread running, or cannot determine the number of threads, prior
-// to executing the given statement.  It is the responsibility of the
-// caller not to pass a thread_count of 1.
-static std::string DeathTestThreadWarning(size_t thread_count) {
-  Message msg;
-  msg << "Death tests use fork(), which is unsafe particularly"
-      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
-  if (thread_count == 0)
-    msg << "couldn't detect the number of threads.";
-  else
-    msg << "detected " << thread_count << " threads.";
-  return msg.GetString();
-}
-# endif  // !GTEST_OS_WINDOWS
-
-// Flag characters for reporting a death test that did not die.
-static const char kDeathTestLived = 'L';
-static const char kDeathTestReturned = 'R';
-static const char kDeathTestThrew = 'T';
-static const char kDeathTestInternalError = 'I';
-
-// An enumeration describing all of the possible ways that a death test can
-// conclude.  DIED means that the process died while executing the test
-// code; LIVED means that process lived beyond the end of the test code;
-// RETURNED means that the test statement attempted to execute a return
-// statement, which is not allowed; THREW means that the test statement
-// returned control by throwing an exception.  IN_PROGRESS means the test
-// has not yet concluded.
-// TODO(vladl@google.com): Unify names and possibly values for
-// AbortReason, DeathTestOutcome, and flag characters above.
-enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
-
-// Routine for aborting the program which is safe to call from an
-// exec-style death test child process, in which case the error
-// message is propagated back to the parent process.  Otherwise, the
-// message is simply printed to stderr.  In either case, the program
-// then exits with status 1.
-void DeathTestAbort(const std::string& message) {
-  // On a POSIX system, this function may be called from a threadsafe-style
-  // death test child process, which operates on a very small stack.  Use
-  // the heap for any additional non-minuscule memory requirements.
-  const InternalRunDeathTestFlag* const flag =
-      GetUnitTestImpl()->internal_run_death_test_flag();
-  if (flag != NULL) {
-    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
-    fputc(kDeathTestInternalError, parent);
-    fprintf(parent, "%s", message.c_str());
-    fflush(parent);
-    _exit(1);
-  } else {
-    fprintf(stderr, "%s", message.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-
-// A replacement for CHECK that calls DeathTestAbort if the assertion
-// fails.
-# define GTEST_DEATH_TEST_CHECK_(expression) \
-  do { \
-    if (!::testing::internal::IsTrue(expression)) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
-// evaluating any system call that fulfills two conditions: it must return
-// -1 on failure, and set errno to EINTR when it is interrupted and
-// should be tried again.  The macro expands to a loop that repeatedly
-// evaluates the expression as long as it evaluates to -1 and sets
-// errno to EINTR.  If the expression evaluates to -1 but errno is
-// something other than EINTR, DeathTestAbort is called.
-# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
-  do { \
-    int gtest_retval; \
-    do { \
-      gtest_retval = (expression); \
-    } while (gtest_retval == -1 && errno == EINTR); \
-    if (gtest_retval == -1) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression + " != -1"); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// Returns the message describing the last system error in errno.
-std::string GetLastErrnoDescription() {
-    return errno == 0 ? "" : posix::StrError(errno);
-}
-
-// This is called from a death test parent process to read a failure
-// message from the death test child process and log it with the FATAL
-// severity. On Windows, the message is read from a pipe handle. On other
-// platforms, it is read from a file descriptor.
-static void FailFromInternalError(int fd) {
-  Message error;
-  char buffer[256];
-  int num_read;
-
-  do {
-    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
-      buffer[num_read] = '\0';
-      error << buffer;
-    }
-  } while (num_read == -1 && errno == EINTR);
-
-  if (num_read == 0) {
-    GTEST_LOG_(FATAL) << error.GetString();
-  } else {
-    const int last_error = errno;
-    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
-                      << GetLastErrnoDescription() << " [" << last_error << "]";
-  }
-}
-
-// Death test constructor.  Increments the running death test count
-// for the current test.
-DeathTest::DeathTest() {
-  TestInfo* const info = GetUnitTestImpl()->current_test_info();
-  if (info == NULL) {
-    DeathTestAbort("Cannot run a death test outside of a TEST or "
-                   "TEST_F construct");
-  }
-}
-
-// Creates and returns a death test by dispatching to the current
-// death test factory.
-bool DeathTest::Create(const char* statement, const RE* regex,
-                       const char* file, int line, DeathTest** test) {
-  return GetUnitTestImpl()->death_test_factory()->Create(
-      statement, regex, file, line, test);
-}
-
-const char* DeathTest::LastMessage() {
-  return last_death_test_message_.c_str();
-}
-
-void DeathTest::set_last_death_test_message(const std::string& message) {
-  last_death_test_message_ = message;
-}
-
-std::string DeathTest::last_death_test_message_;
-
-// Provides cross platform implementation for some death functionality.
-class DeathTestImpl : public DeathTest {
- protected:
-  DeathTestImpl(const char* a_statement, const RE* a_regex)
-      : statement_(a_statement),
-        regex_(a_regex),
-        spawned_(false),
-        status_(-1),
-        outcome_(IN_PROGRESS),
-        read_fd_(-1),
-        write_fd_(-1) {}
-
-  // read_fd_ is expected to be closed and cleared by a derived class.
-  ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
-
-  void Abort(AbortReason reason);
-  virtual bool Passed(bool status_ok);
-
-  const char* statement() const { return statement_; }
-  const RE* regex() const { return regex_; }
-  bool spawned() const { return spawned_; }
-  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
-  int status() const { return status_; }
-  void set_status(int a_status) { status_ = a_status; }
-  DeathTestOutcome outcome() const { return outcome_; }
-  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
-  int read_fd() const { return read_fd_; }
-  void set_read_fd(int fd) { read_fd_ = fd; }
-  int write_fd() const { return write_fd_; }
-  void set_write_fd(int fd) { write_fd_ = fd; }
-
-  // Called in the parent process only. Reads the result code of the death
-  // test child process via a pipe, interprets it to set the outcome_
-  // member, and closes read_fd_.  Outputs diagnostics and terminates in
-  // case of unexpected codes.
-  void ReadAndInterpretStatusByte();
-
- private:
-  // The textual content of the code this object is testing.  This class
-  // doesn't own this string and should not attempt to delete it.
-  const char* const statement_;
-  // The regular expression which test output must match.  DeathTestImpl
-  // doesn't own this object and should not attempt to delete it.
-  const RE* const regex_;
-  // True if the death test child process has been successfully spawned.
-  bool spawned_;
-  // The exit status of the child process.
-  int status_;
-  // How the death test concluded.
-  DeathTestOutcome outcome_;
-  // Descriptor to the read end of the pipe to the child process.  It is
-  // always -1 in the child process.  The child keeps its write end of the
-  // pipe in write_fd_.
-  int read_fd_;
-  // Descriptor to the child's write end of the pipe to the parent process.
-  // It is always -1 in the parent process.  The parent keeps its end of the
-  // pipe in read_fd_.
-  int write_fd_;
-};
-
-// Called in the parent process only. Reads the result code of the death
-// test child process via a pipe, interprets it to set the outcome_
-// member, and closes read_fd_.  Outputs diagnostics and terminates in
-// case of unexpected codes.
-void DeathTestImpl::ReadAndInterpretStatusByte() {
-  char flag;
-  int bytes_read;
-
-  // The read() here blocks until data is available (signifying the
-  // failure of the death test) or until the pipe is closed (signifying
-  // its success), so it's okay to call this in the parent before
-  // the child process has exited.
-  do {
-    bytes_read = posix::Read(read_fd(), &flag, 1);
-  } while (bytes_read == -1 && errno == EINTR);
-
-  if (bytes_read == 0) {
-    set_outcome(DIED);
-  } else if (bytes_read == 1) {
-    switch (flag) {
-      case kDeathTestReturned:
-        set_outcome(RETURNED);
-        break;
-      case kDeathTestThrew:
-        set_outcome(THREW);
-        break;
-      case kDeathTestLived:
-        set_outcome(LIVED);
-        break;
-      case kDeathTestInternalError:
-        FailFromInternalError(read_fd());  // Does not return.
-        break;
-      default:
-        GTEST_LOG_(FATAL) << "Death test child process reported "
-                          << "unexpected status byte ("
-                          << static_cast<unsigned int>(flag) << ")";
-    }
-  } else {
-    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
-                      << GetLastErrnoDescription();
-  }
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
-  set_read_fd(-1);
-}
-
-// Signals that the death test code which should have exited, didn't.
-// Should be called only in a death test child process.
-// Writes a status byte to the child's status file descriptor, then
-// calls _exit(1).
-void DeathTestImpl::Abort(AbortReason reason) {
-  // The parent process considers the death test to be a failure if
-  // it finds any data in our pipe.  So, here we write a single flag byte
-  // to the pipe, then exit.
-  const char status_ch =
-      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
-      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
-
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
-  // We are leaking the descriptor here because on some platforms (i.e.,
-  // when built as Windows DLL), destructors of global objects will still
-  // run after calling _exit(). On such systems, write_fd_ will be
-  // indirectly closed from the destructor of UnitTestImpl, causing double
-  // close if it is also closed here. On debug configurations, double close
-  // may assert. As there are no in-process buffers to flush here, we are
-  // relying on the OS to close the descriptor after the process terminates
-  // when the destructors are not run.
-  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
-}
-
-// Returns an indented copy of stderr output for a death test.
-// This makes distinguishing death test output lines from regular log lines
-// much easier.
-static ::std::string FormatDeathTestOutput(const ::std::string& output) {
-  ::std::string ret;
-  for (size_t at = 0; ; ) {
-    const size_t line_end = output.find('\n', at);
-    ret += "[  DEATH   ] ";
-    if (line_end == ::std::string::npos) {
-      ret += output.substr(at);
-      break;
-    }
-    ret += output.substr(at, line_end + 1 - at);
-    at = line_end + 1;
-  }
-  return ret;
-}
-
-// Assesses the success or failure of a death test, using both private
-// members which have previously been set, and one argument:
-//
-// Private data members:
-//   outcome:  An enumeration describing how the death test
-//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
-//             fails in the latter three cases.
-//   status:   The exit status of the child process. On *nix, it is in the
-//             in the format specified by wait(2). On Windows, this is the
-//             value supplied to the ExitProcess() API or a numeric code
-//             of the exception that terminated the program.
-//   regex:    A regular expression object to be applied to
-//             the test's captured standard error output; the death test
-//             fails if it does not match.
-//
-// Argument:
-//   status_ok: true if exit_status is acceptable in the context of
-//              this particular death test, which fails if it is false
-//
-// Returns true iff all of the above conditions are met.  Otherwise, the
-// first failing condition, in the order given above, is the one that is
-// reported. Also sets the last death test message string.
-bool DeathTestImpl::Passed(bool status_ok) {
-  if (!spawned())
-    return false;
-
-  const std::string error_message = GetCapturedStderr();
-
-  bool success = false;
-  Message buffer;
-
-  buffer << "Death test: " << statement() << "\n";
-  switch (outcome()) {
-    case LIVED:
-      buffer << "    Result: failed to die.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case THREW:
-      buffer << "    Result: threw an exception.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case RETURNED:
-      buffer << "    Result: illegal return in test statement.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case DIED:
-      if (status_ok) {
-        const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
-        if (matched) {
-          success = true;
-        } else {
-          buffer << "    Result: died but not with expected error.\n"
-                 << "  Expected: " << regex()->pattern() << "\n"
-                 << "Actual msg:\n" << FormatDeathTestOutput(error_message);
-        }
-      } else {
-        buffer << "    Result: died but not with expected exit code:\n"
-               << "            " << ExitSummary(status()) << "\n"
-               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
-      }
-      break;
-    case IN_PROGRESS:
-    default:
-      GTEST_LOG_(FATAL)
-          << "DeathTest::Passed somehow called before conclusion of test";
-  }
-
-  DeathTest::set_last_death_test_message(buffer.GetString());
-  return success;
-}
-
-# if GTEST_OS_WINDOWS
-// WindowsDeathTest implements death tests on Windows. Due to the
-// specifics of starting new processes on Windows, death tests there are
-// always threadsafe, and Google Test considers the
-// --gtest_death_test_style=fast setting to be equivalent to
-// --gtest_death_test_style=threadsafe there.
-//
-// A few implementation notes:  Like the Linux version, the Windows
-// implementation uses pipes for child-to-parent communication. But due to
-// the specifics of pipes on Windows, some extra steps are required:
-//
-// 1. The parent creates a communication pipe and stores handles to both
-//    ends of it.
-// 2. The parent starts the child and provides it with the information
-//    necessary to acquire the handle to the write end of the pipe.
-// 3. The child acquires the write end of the pipe and signals the parent
-//    using a Windows event.
-// 4. Now the parent can release the write end of the pipe on its side. If
-//    this is done before step 3, the object's reference count goes down to
-//    0 and it is destroyed, preventing the child from acquiring it. The
-//    parent now has to release it, or read operations on the read end of
-//    the pipe will not return when the child terminates.
-// 5. The parent reads child's output through the pipe (outcome code and
-//    any possible error messages) from the pipe, and its stderr and then
-//    determines whether to fail the test.
-//
-// Note: to distinguish Win32 API calls from the local method and function
-// calls, the former are explicitly resolved in the global namespace.
-//
-class WindowsDeathTest : public DeathTestImpl {
- public:
-  WindowsDeathTest(const char* a_statement,
-                   const RE* a_regex,
-                   const char* file,
-                   int line)
-      : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
-
-  // All of these virtual functions are inherited from DeathTest.
-  virtual int Wait();
-  virtual TestRole AssumeRole();
-
- private:
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-  // Handle to the write end of the pipe to the child process.
-  AutoHandle write_handle_;
-  // Child process handle.
-  AutoHandle child_handle_;
-  // Event the child process uses to signal the parent that it has
-  // acquired the handle to the write end of the pipe. After seeing this
-  // event the parent can release its own handles to make sure its
-  // ReadFile() calls return when the child terminates.
-  AutoHandle event_handle_;
-};
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int WindowsDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  // Wait until the child either signals that it has acquired the write end
-  // of the pipe or it dies.
-  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
-  switch (::WaitForMultipleObjects(2,
-                                   wait_handles,
-                                   FALSE,  // Waits for any of the handles.
-                                   INFINITE)) {
-    case WAIT_OBJECT_0:
-    case WAIT_OBJECT_0 + 1:
-      break;
-    default:
-      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
-  }
-
-  // The child has acquired the write end of the pipe or exited.
-  // We release the handle on our side and continue.
-  write_handle_.Reset();
-  event_handle_.Reset();
-
-  ReadAndInterpretStatusByte();
-
-  // Waits for the child process to exit if it haven't already. This
-  // returns immediately if the child has already exited, regardless of
-  // whether previous calls to WaitForMultipleObjects synchronized on this
-  // handle or not.
-  GTEST_DEATH_TEST_CHECK_(
-      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
-                                             INFINITE));
-  DWORD status_code;
-  GTEST_DEATH_TEST_CHECK_(
-      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
-  child_handle_.Reset();
-  set_status(static_cast<int>(status_code));
-  return status();
-}
-
-// The AssumeRole process for a Windows death test.  It creates a child
-// process with the same executable as the current process to run the
-// death test.  The child process is given the --gtest_filter and
-// --gtest_internal_run_death_test flags such that it knows to run the
-// current death test only.
-DeathTest::TestRole WindowsDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != NULL) {
-    // ParseInternalRunDeathTestFlag() has performed all the necessary
-    // processing.
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  // WindowsDeathTest uses an anonymous pipe to communicate results of
-  // a death test.
-  SECURITY_ATTRIBUTES handles_are_inheritable = {
-    sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
-  HANDLE read_handle, write_handle;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
-                   0)  // Default buffer size.
-      != FALSE);
-  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
-                                O_RDONLY));
-  write_handle_.Reset(write_handle);
-  event_handle_.Reset(::CreateEvent(
-      &handles_are_inheritable,
-      TRUE,    // The event will automatically reset to non-signaled state.
-      FALSE,   // The initial state is non-signalled.
-      NULL));  // The even is unnamed.
-  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
-  const std::string filter_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
-      info->test_case_name() + "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
-      "=" + file_ + "|" + StreamableToString(line_) + "|" +
-      StreamableToString(death_test_index) + "|" +
-      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
-      // size_t has the same width as pointers on both 32-bit and 64-bit
-      // Windows platforms.
-      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
-      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
-      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
-
-  char executable_path[_MAX_PATH + 1];  // NOLINT
-  GTEST_DEATH_TEST_CHECK_(
-      _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
-                                            executable_path,
-                                            _MAX_PATH));
-
-  std::string command_line =
-      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
-      internal_flag + "\"";
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // Flush the log buffers since the log streams are shared with the child.
-  FlushInfoLog();
-
-  // The child process will share the standard handles with the parent.
-  STARTUPINFOA startup_info;
-  memset(&startup_info, 0, sizeof(STARTUPINFO));
-  startup_info.dwFlags = STARTF_USESTDHANDLES;
-  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
-  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
-  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
-
-  PROCESS_INFORMATION process_info;
-  GTEST_DEATH_TEST_CHECK_(::CreateProcessA(
-      executable_path,
-      const_cast<char*>(command_line.c_str()),
-      NULL,   // Retuned process handle is not inheritable.
-      NULL,   // Retuned thread handle is not inheritable.
-      TRUE,   // Child inherits all inheritable handles (for write_handle_).
-      0x0,    // Default creation flags.
-      NULL,   // Inherit the parent's environment.
-      UnitTest::GetInstance()->original_working_dir(),
-      &startup_info,
-      &process_info) != FALSE);
-  child_handle_.Reset(process_info.hProcess);
-  ::CloseHandle(process_info.hThread);
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-# else  // We are not on Windows.
-
-// ForkingDeathTest provides implementations for most of the abstract
-// methods of the DeathTest interface.  Only the AssumeRole method is
-// left undefined.
-class ForkingDeathTest : public DeathTestImpl {
- public:
-  ForkingDeathTest(const char* statement, const RE* regex);
-
-  // All of these virtual functions are inherited from DeathTest.
-  virtual int Wait();
-
- protected:
-  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
-
- private:
-  // PID of child process during death test; 0 in the child process itself.
-  pid_t child_pid_;
-};
-
-// Constructs a ForkingDeathTest.
-ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
-    : DeathTestImpl(a_statement, a_regex),
-      child_pid_(-1) {}
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int ForkingDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  ReadAndInterpretStatusByte();
-
-  int status_value;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
-  set_status(status_value);
-  return status_value;
-}
-
-// A concrete death test class that forks, then immediately runs the test
-// in the child process.
-class NoExecDeathTest : public ForkingDeathTest {
- public:
-  NoExecDeathTest(const char* a_statement, const RE* a_regex) :
-      ForkingDeathTest(a_statement, a_regex) { }
-  virtual TestRole AssumeRole();
-};
-
-// The AssumeRole process for a fork-and-run death test.  It implements a
-// straightforward fork, with a simple pipe to transmit the status byte.
-DeathTest::TestRole NoExecDeathTest::AssumeRole() {
-  const size_t thread_count = GetThreadCount();
-  if (thread_count != 1) {
-    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-
-  DeathTest::set_last_death_test_message("");
-  CaptureStderr();
-  // When we fork the process below, the log file buffers are copied, but the
-  // file descriptors are shared.  We flush all log files here so that closing
-  // the file descriptors in the child process doesn't throw off the
-  // synchronization between descriptors and buffers in the parent process.
-  // This is as close to the fork as possible to avoid a race condition in case
-  // there are multiple threads running before the death test, and another
-  // thread writes to the log file.
-  FlushInfoLog();
-
-  const pid_t child_pid = fork();
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  set_child_pid(child_pid);
-  if (child_pid == 0) {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
-    set_write_fd(pipe_fd[1]);
-    // Redirects all logging to stderr in the child process to prevent
-    // concurrent writes to the log files.  We capture stderr in the parent
-    // process and append the child process' output to a log.
-    LogToStderr();
-    // Event forwarding to the listeners of event listener API mush be shut
-    // down in death test subprocesses.
-    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
-    g_in_fast_death_test_child = true;
-    return EXECUTE_TEST;
-  } else {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-    set_read_fd(pipe_fd[0]);
-    set_spawned(true);
-    return OVERSEE_TEST;
-  }
-}
-
-// A concrete death test class that forks and re-executes the main
-// program from the beginning, with command-line flags set that cause
-// only this specific death test to be run.
-class ExecDeathTest : public ForkingDeathTest {
- public:
-  ExecDeathTest(const char* a_statement, const RE* a_regex,
-                const char* file, int line) :
-      ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
-  virtual TestRole AssumeRole();
- private:
-  static ::std::vector<testing::internal::string>
-  GetArgvsForDeathTestChildProcess() {
-    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
-#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    ::std::vector<testing::internal::string> extra_args =
-        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
-    args.insert(args.end(), extra_args.begin(), extra_args.end());
-#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    return args;
-  }
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-};
-
-// Utility class for accumulating command-line arguments.
-class Arguments {
- public:
-  Arguments() {
-    args_.push_back(NULL);
-  }
-
-  ~Arguments() {
-    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
-         ++i) {
-      free(*i);
-    }
-  }
-  void AddArgument(const char* argument) {
-    args_.insert(args_.end() - 1, posix::StrDup(argument));
-  }
-
-  template <typename Str>
-  void AddArguments(const ::std::vector<Str>& arguments) {
-    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
-      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
-    }
-  }
-  char* const* Argv() {
-    return &args_[0];
-  }
-
- private:
-  std::vector<char*> args_;
-};
-
-// A struct that encompasses the arguments to the child process of a
-// threadsafe-style death test process.
-struct ExecDeathTestArgs {
-  char* const* argv;  // Command-line arguments for the child's call to exec
-  int close_fd;       // File descriptor to close; the read end of a pipe
-};
-
-#  if GTEST_OS_MAC
-inline char** GetEnviron() {
-  // When Google Test is built as a framework on MacOS X, the environ variable
-  // is unavailable. Apple's documentation (man environ) recommends using
-  // _NSGetEnviron() instead.
-  return *_NSGetEnviron();
-}
-#  else
-// Some POSIX platforms expect you to declare environ. extern "C" makes
-// it reside in the global namespace.
-extern "C" char** environ;
-inline char** GetEnviron() { return environ; }
-#  endif  // GTEST_OS_MAC
-
-#  if !GTEST_OS_QNX
-// The main function for a threadsafe-style death test child process.
-// This function is called in a clone()-ed process and thus must avoid
-// any potentially unsafe operations like malloc or libc functions.
-static int ExecDeathTestChildMain(void* child_arg) {
-  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
-
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  // We can safely call execve() as it's a direct system call.  We
-  // cannot use execvp() as it's a libc function and thus potentially
-  // unsafe.  Since execve() doesn't search the PATH, the user must
-  // invoke the test program via a valid path that contains at least
-  // one path separator.
-  execve(args->argv[0], args->argv, GetEnviron());
-  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
-                 original_dir + " failed: " +
-                 GetLastErrnoDescription());
-  return EXIT_FAILURE;
-}
-#  endif  // !GTEST_OS_QNX
-
-// Two utility routines that together determine the direction the stack
-// grows.
-// This could be accomplished more elegantly by a single recursive
-// function, but we want to guard against the unlikely possibility of
-// a smart compiler optimizing the recursion away.
-//
-// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
-// StackLowerThanAddress into StackGrowsDown, which then doesn't give
-// correct answer.
-void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
-void StackLowerThanAddress(const void* ptr, bool* result) {
-  int dummy;
-  *result = (&dummy < ptr);
-}
-
-// Make sure AddressSanitizer does not tamper with the stack here.
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-bool StackGrowsDown() {
-  int dummy;
-  bool result;
-  StackLowerThanAddress(&dummy, &result);
-  return result;
-}
-
-// Spawns a child process with the same executable as the current process in
-// a thread-safe manner and instructs it to run the death test.  The
-// implementation uses fork(2) + exec.  On systems where clone(2) is
-// available, it is used instead, being slightly more thread-safe.  On QNX,
-// fork supports only single-threaded environments, so this function uses
-// spawn(2) there instead.  The function dies with an error message if
-// anything goes wrong.
-static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
-  ExecDeathTestArgs args = { argv, close_fd };
-  pid_t child_pid = -1;
-
-#  if GTEST_OS_QNX
-  // Obtains the current directory and sets it to be closed in the child
-  // process.
-  const int cwd_fd = open(".", O_RDONLY);
-  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  int fd_flags;
-  // Set close_fd to be closed after spawn.
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
-                                        fd_flags | FD_CLOEXEC));
-  struct inheritance inherit = {0};
-  // spawn is a system call.
-  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
-  // Restores the current working directory.
-  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
-
-#  else   // GTEST_OS_QNX
-#   if GTEST_OS_LINUX
-  // When a SIGPROF signal is received while fork() or clone() are executing,
-  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
-  // it after the call to fork()/clone() is complete.
-  struct sigaction saved_sigprof_action;
-  struct sigaction ignore_sigprof_action;
-  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
-  sigemptyset(&ignore_sigprof_action.sa_mask);
-  ignore_sigprof_action.sa_handler = SIG_IGN;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
-      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
-#   endif  // GTEST_OS_LINUX
-
-#   if GTEST_HAS_CLONE
-  const bool use_fork = GTEST_FLAG(death_test_use_fork);
-
-  if (!use_fork) {
-    static const bool stack_grows_down = StackGrowsDown();
-    const size_t stack_size = getpagesize();
-    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
-    void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
-                             MAP_ANON | MAP_PRIVATE, -1, 0);
-    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
-
-    // Maximum stack alignment in bytes:  For a downward-growing stack, this
-    // amount is subtracted from size of the stack space to get an address
-    // that is within the stack space and is aligned on all systems we care
-    // about.  As far as I know there is no ABI with stack alignment greater
-    // than 64.  We assume stack and stack_size already have alignment of
-    // kMaxStackAlignment.
-    const size_t kMaxStackAlignment = 64;
-    void* const stack_top =
-        static_cast<char*>(stack) +
-            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
-    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
-        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
-
-    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
-
-    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
-  }
-#   else
-  const bool use_fork = true;
-#   endif  // GTEST_HAS_CLONE
-
-  if (use_fork && (child_pid = fork()) == 0) {
-      ExecDeathTestChildMain(&args);
-      _exit(0);
-  }
-#  endif  // GTEST_OS_QNX
-#  if GTEST_OS_LINUX
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(
-      sigaction(SIGPROF, &saved_sigprof_action, NULL));
-#  endif  // GTEST_OS_LINUX
-
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  return child_pid;
-}
-
-// The AssumeRole process for a fork-and-exec death test.  It re-executes the
-// main program from the beginning, setting the --gtest_filter
-// and --gtest_internal_run_death_test flags to cause only the current
-// death test to be re-run.
-DeathTest::TestRole ExecDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != NULL) {
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-  // Clear the close-on-exec flag on the write end of the pipe, lest
-  // it be closed when the child process does an exec:
-  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
-
-  const std::string filter_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
-      + info->test_case_name() + "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|" + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index) + "|"
-      + StreamableToString(pipe_fd[1]);
-  Arguments args;
-  args.AddArguments(GetArgvsForDeathTestChildProcess());
-  args.AddArgument(filter_flag.c_str());
-  args.AddArgument(internal_flag.c_str());
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // See the comment in NoExecDeathTest::AssumeRole for why the next line
-  // is necessary.
-  FlushInfoLog();
-
-  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-  set_child_pid(child_pid);
-  set_read_fd(pipe_fd[0]);
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-# endif  // !GTEST_OS_WINDOWS
-
-// Creates a concrete DeathTest-derived class that depends on the
-// --gtest_death_test_style flag, and sets the pointer pointed to
-// by the "test" argument to its address.  If the test should be
-// skipped, sets that pointer to NULL.  Returns true, unless the
-// flag is set to an invalid value.
-bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
-                                     const char* file, int line,
-                                     DeathTest** test) {
-  UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const int death_test_index = impl->current_test_info()
-      ->increment_death_test_count();
-
-  if (flag != NULL) {
-    if (death_test_index > flag->index()) {
-      DeathTest::set_last_death_test_message(
-          "Death test count (" + StreamableToString(death_test_index)
-          + ") somehow exceeded expected maximum ("
-          + StreamableToString(flag->index()) + ")");
-      return false;
-    }
-
-    if (!(flag->file() == file && flag->line() == line &&
-          flag->index() == death_test_index)) {
-      *test = NULL;
-      return true;
-    }
-  }
-
-# if GTEST_OS_WINDOWS
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
-    *test = new WindowsDeathTest(statement, regex, file, line);
-  }
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe") {
-    *test = new ExecDeathTest(statement, regex, file, line);
-  } else if (GTEST_FLAG(death_test_style) == "fast") {
-    *test = new NoExecDeathTest(statement, regex);
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
-    DeathTest::set_last_death_test_message(
-        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
-        + "\" encountered");
-    return false;
-  }
-
-  return true;
-}
-
-# if GTEST_OS_WINDOWS
-// Recreates the pipe and event handles from the provided parameters,
-// signals the event, and returns a file descriptor wrapped around the pipe
-// handle. This function is called in the child process only.
-int GetStatusFileDescriptor(unsigned int parent_process_id,
-                            size_t write_handle_as_size_t,
-                            size_t event_handle_as_size_t) {
-  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
-                                                   FALSE,  // Non-inheritable.
-                                                   parent_process_id));
-  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
-    DeathTestAbort("Unable to open parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  // TODO(vladl@google.com): Replace the following check with a
-  // compile-time assertion when available.
-  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
-
-  const HANDLE write_handle =
-      reinterpret_cast<HANDLE>(write_handle_as_size_t);
-  HANDLE dup_write_handle;
-
-  // The newly initialized handle is accessible only in in the parent
-  // process. To obtain one accessible within the child, we need to use
-  // DuplicateHandle.
-  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
-                         ::GetCurrentProcess(), &dup_write_handle,
-                         0x0,    // Requested privileges ignored since
-                                 // DUPLICATE_SAME_ACCESS is used.
-                         FALSE,  // Request non-inheritable handler.
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
-  HANDLE dup_event_handle;
-
-  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
-                         ::GetCurrentProcess(), &dup_event_handle,
-                         0x0,
-                         FALSE,
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the event handle " +
-                   StreamableToString(event_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const int write_fd =
-      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
-  if (write_fd == -1) {
-    DeathTestAbort("Unable to convert pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " to a file descriptor");
-  }
-
-  // Signals the parent that the write end of the pipe has been acquired
-  // so the parent can release its own write end.
-  ::SetEvent(dup_event_handle);
-
-  return write_fd;
-}
-# endif  // GTEST_OS_WINDOWS
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// initialized from the GTEST_FLAG(internal_run_death_test) flag if
-// the flag is specified; otherwise returns NULL.
-InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
-  if (GTEST_FLAG(internal_run_death_test) == "") return NULL;
-
-  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
-  // can use it here.
-  int line = -1;
-  int index = -1;
-  ::std::vector< ::std::string> fields;
-  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
-  int write_fd = -1;
-
-# if GTEST_OS_WINDOWS
-
-  unsigned int parent_process_id = 0;
-  size_t write_handle_as_size_t = 0;
-  size_t event_handle_as_size_t = 0;
-
-  if (fields.size() != 6
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &parent_process_id)
-      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
-      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
-                   GTEST_FLAG(internal_run_death_test));
-  }
-  write_fd = GetStatusFileDescriptor(parent_process_id,
-                                     write_handle_as_size_t,
-                                     event_handle_as_size_t);
-# else
-
-  if (fields.size() != 4
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &write_fd)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
-}
-
-}  // namespace internal
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Authors: keith.ray@gmail.com (Keith Ray)
-
-
-#include <stdlib.h>
-
-#if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
-#elif GTEST_OS_WINDOWS
-# include <direct.h>
-# include <io.h>
-#elif GTEST_OS_SYMBIAN
-// Symbian OpenC has PATH_MAX in sys/syslimits.h
-# include <sys/syslimits.h>
-#else
-# include <limits.h>
-# include <climits>  // Some Linux distributions define PATH_MAX here.
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_MAX_ _MAX_PATH
-#elif defined(PATH_MAX)
-# define GTEST_PATH_MAX_ PATH_MAX
-#elif defined(_XOPEN_PATH_MAX)
-# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
-#else
-# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
-#endif  // GTEST_OS_WINDOWS
-
-
-namespace testing {
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-// On Windows, '\\' is the standard path separator, but many tools and the
-// Windows API also accept '/' as an alternate path separator. Unless otherwise
-// noted, a file path can contain either kind of path separators, or a mixture
-// of them.
-const char kPathSeparator = '\\';
-const char kAlternatePathSeparator = '/';
-const char kAlternatePathSeparatorString[] = "/";
-# if GTEST_OS_WINDOWS_MOBILE
-// Windows CE doesn't have a current directory. You should not use
-// the current directory in tests on Windows CE, but this at least
-// provides a reasonable fallback.
-const char kCurrentDirectoryString[] = "\\";
-// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
-const DWORD kInvalidFileAttributes = 0xffffffff;
-# else
-const char kCurrentDirectoryString[] = ".\\";
-# endif  // GTEST_OS_WINDOWS_MOBILE
-#else
-const char kPathSeparator = '/';
-const char kCurrentDirectoryString[] = "./";
-#endif  // GTEST_OS_WINDOWS
-
-// Returns whether the given character is a valid path separator.
-static bool IsPathSeparator(char c) {
-#if GTEST_HAS_ALT_PATH_SEP_
-  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
-#else
-  return c == kPathSeparator;
-#endif
-}
-
-// Returns the current working directory, or "" if unsuccessful.
-FilePath FilePath::GetCurrentDir() {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  // Windows CE doesn't have a current directory, so we just return
-  // something reasonable.
-  return FilePath(kCurrentDirectoryString);
-#elif GTEST_OS_WINDOWS
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
-#else
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  char* result = getcwd(cwd, sizeof(cwd));
-# if GTEST_OS_NACL
-  // getcwd will likely fail in NaCl due to the sandbox, so return something
-  // reasonable. The user may have provided a shim implementation for getcwd,
-  // however, so fallback only when failure is detected.
-  return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
-# endif  // GTEST_OS_NACL
-  return FilePath(result == NULL ? "" : cwd);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns a copy of the FilePath with the case-insensitive extension removed.
-// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-// FilePath("dir/file"). If a case-insensitive extension is not
-// found, returns a copy of the original FilePath.
-FilePath FilePath::RemoveExtension(const char* extension) const {
-  const std::string dot_extension = std::string(".") + extension;
-  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
-    return FilePath(pathname_.substr(
-        0, pathname_.length() - dot_extension.length()));
-  }
-  return *this;
-}
-
-// Returns a pointer to the last occurence of a valid path separator in
-// the FilePath. On Windows, for example, both '/' and '\' are valid path
-// separators. Returns NULL if no path separator was found.
-const char* FilePath::FindLastPathSeparator() const {
-  const char* const last_sep = strrchr(c_str(), kPathSeparator);
-#if GTEST_HAS_ALT_PATH_SEP_
-  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
-  // Comparing two pointers of which only one is NULL is undefined.
-  if (last_alt_sep != NULL &&
-      (last_sep == NULL || last_alt_sep > last_sep)) {
-    return last_alt_sep;
-  }
-#endif
-  return last_sep;
-}
-
-// Returns a copy of the FilePath with the directory part removed.
-// Example: FilePath("path/to/file").RemoveDirectoryName() returns
-// FilePath("file"). If there is no directory part ("just_a_file"), it returns
-// the FilePath unmodified. If there is no file part ("just_a_dir/") it
-// returns an empty FilePath ("").
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveDirectoryName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  return last_sep ? FilePath(last_sep + 1) : *this;
-}
-
-// RemoveFileName returns the directory path with the filename removed.
-// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveFileName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  std::string dir;
-  if (last_sep) {
-    dir = std::string(c_str(), last_sep + 1 - c_str());
-  } else {
-    dir = kCurrentDirectoryString;
-  }
-  return FilePath(dir);
-}
-
-// Helper functions for naming files in a directory for xml output.
-
-// Given directory = "dir", base_name = "test", number = 0,
-// extension = "xml", returns "dir/test.xml". If number is greater
-// than zero (e.g., 12), returns "dir/test_12.xml".
-// On Windows platform, uses \ as the separator rather than /.
-FilePath FilePath::MakeFileName(const FilePath& directory,
-                                const FilePath& base_name,
-                                int number,
-                                const char* extension) {
-  std::string file;
-  if (number == 0) {
-    file = base_name.string() + "." + extension;
-  } else {
-    file = base_name.string() + "_" + StreamableToString(number)
-        + "." + extension;
-  }
-  return ConcatPaths(directory, FilePath(file));
-}
-
-// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
-// On Windows, uses \ as the separator rather than /.
-FilePath FilePath::ConcatPaths(const FilePath& directory,
-                               const FilePath& relative_path) {
-  if (directory.IsEmpty())
-    return relative_path;
-  const FilePath dir(directory.RemoveTrailingPathSeparator());
-  return FilePath(dir.string() + kPathSeparator + relative_path.string());
-}
-
-// Returns true if pathname describes something findable in the file-system,
-// either a file, directory, or whatever.
-bool FilePath::FileOrDirectoryExists() const {
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  return attributes != kInvalidFileAttributes;
-#else
-  posix::StatStruct file_stat;
-  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns true if pathname describes a directory in the file-system
-// that exists.
-bool FilePath::DirectoryExists() const {
-  bool result = false;
-#if GTEST_OS_WINDOWS
-  // Don't strip off trailing separator if path is a root directory on
-  // Windows (like "C:\\").
-  const FilePath& path(IsRootDirectory() ? *this :
-                                           RemoveTrailingPathSeparator());
-#else
-  const FilePath& path(*this);
-#endif
-
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  if ((attributes != kInvalidFileAttributes) &&
-      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
-    result = true;
-  }
-#else
-  posix::StatStruct file_stat;
-  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
-      posix::IsDir(file_stat);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  return result;
-}
-
-// Returns true if pathname describes a root directory. (Windows has one
-// root directory per disk drive.)
-bool FilePath::IsRootDirectory() const {
-#if GTEST_OS_WINDOWS
-  // TODO(wan@google.com): on Windows a network share like
-  // \\server\share can be a root directory, although it cannot be the
-  // current directory.  Handle this properly.
-  return pathname_.length() == 3 && IsAbsolutePath();
-#else
-  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
-#endif
-}
-
-// Returns true if pathname describes an absolute path.
-bool FilePath::IsAbsolutePath() const {
-  const char* const name = pathname_.c_str();
-#if GTEST_OS_WINDOWS
-  return pathname_.length() >= 3 &&
-     ((name[0] >= 'a' && name[0] <= 'z') ||
-      (name[0] >= 'A' && name[0] <= 'Z')) &&
-     name[1] == ':' &&
-     IsPathSeparator(name[2]);
-#else
-  return IsPathSeparator(name[0]);
-#endif
-}
-
-// Returns a pathname for a file that does not currently exist. The pathname
-// will be directory/base_name.extension or
-// directory/base_name_<number>.extension if directory/base_name.extension
-// already exists. The number will be incremented until a pathname is found
-// that does not already exist.
-// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-// There could be a race condition if two or more processes are calling this
-// function at the same time -- they could both pick the same filename.
-FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
-                                          const FilePath& base_name,
-                                          const char* extension) {
-  FilePath full_pathname;
-  int number = 0;
-  do {
-    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
-  } while (full_pathname.FileOrDirectoryExists());
-  return full_pathname;
-}
-
-// Returns true if FilePath ends with a path separator, which indicates that
-// it is intended to represent a directory. Returns false otherwise.
-// This does NOT check that a directory (or file) actually exists.
-bool FilePath::IsDirectory() const {
-  return !pathname_.empty() &&
-         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
-}
-
-// Create directories so that path exists. Returns true if successful or if
-// the directories already exist; returns false if unable to create directories
-// for any reason.
-bool FilePath::CreateDirectoriesRecursively() const {
-  if (!this->IsDirectory()) {
-    return false;
-  }
-
-  if (pathname_.length() == 0 || this->DirectoryExists()) {
-    return true;
-  }
-
-  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
-  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
-}
-
-// Create the directory so that path exists. Returns true if successful or
-// if the directory already exists; returns false if unable to create the
-// directory for any reason, including if the parent directory does not
-// exist. Not named "CreateDirectory" because that's a macro on Windows.
-bool FilePath::CreateFolder() const {
-#if GTEST_OS_WINDOWS_MOBILE
-  FilePath removed_sep(this->RemoveTrailingPathSeparator());
-  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
-  int result = CreateDirectory(unicode, NULL) ? 0 : -1;
-  delete [] unicode;
-#elif GTEST_OS_WINDOWS
-  int result = _mkdir(pathname_.c_str());
-#else
-  int result = mkdir(pathname_.c_str(), 0777);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  if (result == -1) {
-    return this->DirectoryExists();  // An error is OK if the directory exists.
-  }
-  return true;  // No error.
-}
-
-// If input name has a trailing separator character, remove it and return the
-// name, otherwise return the name string unmodified.
-// On Windows platform, uses \ as the separator, other platforms use /.
-FilePath FilePath::RemoveTrailingPathSeparator() const {
-  return IsDirectory()
-      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
-      : *this;
-}
-
-// Removes any redundant separators that might be in the pathname.
-// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-// redundancies that might be in a pathname involving "." or "..".
-// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share).
-void FilePath::Normalize() {
-  if (pathname_.c_str() == NULL) {
-    pathname_ = "";
-    return;
-  }
-  const char* src = pathname_.c_str();
-  char* const dest = new char[pathname_.length() + 1];
-  char* dest_ptr = dest;
-  memset(dest_ptr, 0, pathname_.length() + 1);
-
-  while (*src != '\0') {
-    *dest_ptr = *src;
-    if (!IsPathSeparator(*src)) {
-      src++;
-    } else {
-#if GTEST_HAS_ALT_PATH_SEP_
-      if (*dest_ptr == kAlternatePathSeparator) {
-        *dest_ptr = kPathSeparator;
-      }
-#endif
-      while (IsPathSeparator(*src))
-        src++;
-    }
-    dest_ptr++;
-  }
-  *dest_ptr = '\0';
-  pathname_ = dest;
-  delete[] dest;
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-#include <limits.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fstream>
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <io.h>
-# include <sys/stat.h>
-# include <map>  // Used in ThreadLocal.
-#else
-# include <unistd.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_MAC
-# include <mach/mach_init.h>
-# include <mach/task.h>
-# include <mach/vm_map.h>
-#endif  // GTEST_OS_MAC
-
-#if GTEST_OS_QNX
-# include <devctl.h>
-# include <fcntl.h>
-# include <sys/procfs.h>
-#endif  // GTEST_OS_QNX
-
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-namespace internal {
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
-const int kStdOutFileno = 1;
-const int kStdErrFileno = 2;
-#else
-const int kStdOutFileno = STDOUT_FILENO;
-const int kStdErrFileno = STDERR_FILENO;
-#endif  // _MSC_VER
-
-#if GTEST_OS_LINUX
-
-namespace {
-template <typename T>
-T ReadProcFileField(const string& filename, int field) {
-  std::string dummy;
-  std::ifstream file(filename.c_str());
-  while (field-- > 0) {
-    file >> dummy;
-  }
-  T output = 0;
-  file >> output;
-  return output;
-}
-}  // namespace
-
-// Returns the number of active threads, or 0 when there is an error.
-size_t GetThreadCount() {
-  const string filename =
-      (Message() << "/proc/" << getpid() << "/stat").GetString();
-  return ReadProcFileField<int>(filename, 19);
-}
-
-#elif GTEST_OS_MAC
-
-size_t GetThreadCount() {
-  const task_t task = mach_task_self();
-  mach_msg_type_number_t thread_count;
-  thread_act_array_t thread_list;
-  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
-  if (status == KERN_SUCCESS) {
-    // task_threads allocates resources in thread_list and we need to free them
-    // to avoid leaks.
-    vm_deallocate(task,
-                  reinterpret_cast<vm_address_t>(thread_list),
-                  sizeof(thread_t) * thread_count);
-    return static_cast<size_t>(thread_count);
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_QNX
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  const int fd = open("/proc/self/as", O_RDONLY);
-  if (fd < 0) {
-    return 0;
-  }
-  procfs_info process_info;
-  const int status =
-      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
-  close(fd);
-  if (status == EOK) {
-    return static_cast<size_t>(process_info.num_threads);
-  } else {
-    return 0;
-  }
-}
-
-#else
-
-size_t GetThreadCount() {
-  // There's no portable way to detect the number of threads, so we just
-  // return 0 to indicate that we cannot detect it.
-  return 0;
-}
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-void SleepMilliseconds(int n) {
-  ::Sleep(n);
-}
-
-AutoHandle::AutoHandle()
-    : handle_(INVALID_HANDLE_VALUE) {}
-
-AutoHandle::AutoHandle(Handle handle)
-    : handle_(handle) {}
-
-AutoHandle::~AutoHandle() {
-  Reset();
-}
-
-AutoHandle::Handle AutoHandle::Get() const {
-  return handle_;
-}
-
-void AutoHandle::Reset() {
-  Reset(INVALID_HANDLE_VALUE);
-}
-
-void AutoHandle::Reset(HANDLE handle) {
-  // Resetting with the same handle we already own is invalid.
-  if (handle_ != handle) {
-    if (IsCloseable()) {
-      ::CloseHandle(handle_);
-    }
-    handle_ = handle;
-  } else {
-    GTEST_CHECK_(!IsCloseable())
-        << "Resetting a valid handle to itself is likely a programmer error "
-            "and thus not allowed.";
-  }
-}
-
-bool AutoHandle::IsCloseable() const {
-  // Different Windows APIs may use either of these values to represent an
-  // invalid handle.
-  return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
-}
-
-Notification::Notification()
-    : event_(::CreateEvent(NULL,   // Default security attributes.
-                           TRUE,   // Do not reset automatically.
-                           FALSE,  // Initially unset.
-                           NULL)) {  // Anonymous event.
-  GTEST_CHECK_(event_.Get() != NULL);
-}
-
-void Notification::Notify() {
-  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
-}
-
-void Notification::WaitForNotification() {
-  GTEST_CHECK_(
-      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
-}
-
-Mutex::Mutex()
-    : owner_thread_id_(0),
-      type_(kDynamic),
-      critical_section_init_phase_(0),
-      critical_section_(new CRITICAL_SECTION) {
-  ::InitializeCriticalSection(critical_section_);
-}
-
-Mutex::~Mutex() {
-  // Static mutexes are leaked intentionally. It is not thread-safe to try
-  // to clean them up.
-  // TODO(yukawa): Switch to Slim Reader/Writer (SRW) Locks, which requires
-  // nothing to clean it up but is available only on Vista and later.
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa904937.aspx
-  if (type_ == kDynamic) {
-    ::DeleteCriticalSection(critical_section_);
-    delete critical_section_;
-    critical_section_ = NULL;
-  }
-}
-
-void Mutex::Lock() {
-  ThreadSafeLazyInit();
-  ::EnterCriticalSection(critical_section_);
-  owner_thread_id_ = ::GetCurrentThreadId();
-}
-
-void Mutex::Unlock() {
-  ThreadSafeLazyInit();
-  // We don't protect writing to owner_thread_id_ here, as it's the
-  // caller's responsibility to ensure that the current thread holds the
-  // mutex when this is called.
-  owner_thread_id_ = 0;
-  ::LeaveCriticalSection(critical_section_);
-}
-
-// Does nothing if the current thread holds the mutex. Otherwise, crashes
-// with high probability.
-void Mutex::AssertHeld() {
-  ThreadSafeLazyInit();
-  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
-      << "The current thread is not holding the mutex @" << this;
-}
-
-// Initializes owner_thread_id_ and critical_section_ in static mutexes.
-void Mutex::ThreadSafeLazyInit() {
-  // Dynamic mutexes are initialized in the constructor.
-  if (type_ == kStatic) {
-    switch (
-        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
-      case 0:
-        // If critical_section_init_phase_ was 0 before the exchange, we
-        // are the first to test it and need to perform the initialization.
-        owner_thread_id_ = 0;
-        critical_section_ = new CRITICAL_SECTION;
-        ::InitializeCriticalSection(critical_section_);
-        // Updates the critical_section_init_phase_ to 2 to signal
-        // initialization complete.
-        GTEST_CHECK_(::InterlockedCompareExchange(
-                          &critical_section_init_phase_, 2L, 1L) ==
-                      1L);
-        break;
-      case 1:
-        // Somebody else is already initializing the mutex; spin until they
-        // are done.
-        while (::InterlockedCompareExchange(&critical_section_init_phase_,
-                                            2L,
-                                            2L) != 2L) {
-          // Possibly yields the rest of the thread's time slice to other
-          // threads.
-          ::Sleep(0);
-        }
-        break;
-
-      case 2:
-        break;  // The mutex is already initialized and ready for use.
-
-      default:
-        GTEST_CHECK_(false)
-            << "Unexpected value of critical_section_init_phase_ "
-            << "while initializing a static mutex.";
-    }
-  }
-}
-
-namespace {
-
-class ThreadWithParamSupport : public ThreadWithParamBase {
- public:
-  static HANDLE CreateThread(Runnable* runnable,
-                             Notification* thread_can_start) {
-    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
-    DWORD thread_id;
-    // TODO(yukawa): Consider to use _beginthreadex instead.
-    HANDLE thread_handle = ::CreateThread(
-        NULL,    // Default security.
-        0,       // Default stack size.
-        &ThreadWithParamSupport::ThreadMain,
-        param,   // Parameter to ThreadMainStatic
-        0x0,     // Default creation flags.
-        &thread_id);  // Need a valid pointer for the call to work under Win98.
-    GTEST_CHECK_(thread_handle != NULL) << "CreateThread failed with error "
-                                        << ::GetLastError() << ".";
-    if (thread_handle == NULL) {
-      delete param;
-    }
-    return thread_handle;
-  }
-
- private:
-  struct ThreadMainParam {
-    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
-        : runnable_(runnable),
-          thread_can_start_(thread_can_start) {
-    }
-    scoped_ptr<Runnable> runnable_;
-    // Does not own.
-    Notification* thread_can_start_;
-  };
-
-  static DWORD WINAPI ThreadMain(void* ptr) {
-    // Transfers ownership.
-    scoped_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
-    if (param->thread_can_start_ != NULL)
-      param->thread_can_start_->WaitForNotification();
-    param->runnable_->Run();
-    return 0;
-  }
-
-  // Prohibit instantiation.
-  ThreadWithParamSupport();
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
-};
-
-}  // namespace
-
-ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
-                                         Notification* thread_can_start)
-      : thread_(ThreadWithParamSupport::CreateThread(runnable,
-                                                     thread_can_start)) {
-}
-
-ThreadWithParamBase::~ThreadWithParamBase() {
-  Join();
-}
-
-void ThreadWithParamBase::Join() {
-  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
-      << "Failed to join the thread with error " << ::GetLastError() << ".";
-}
-
-// Maps a thread to a set of ThreadIdToThreadLocals that have values
-// instantiated on that thread and notifies them when the thread exits.  A
-// ThreadLocal instance is expected to persist until all threads it has
-// values on have terminated.
-class ThreadLocalRegistryImpl {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-    DWORD current_thread = ::GetCurrentThreadId();
-    MutexLock lock(&mutex_);
-    ThreadIdToThreadLocals* const thread_to_thread_locals =
-        GetThreadLocalsMapLocked();
-    ThreadIdToThreadLocals::iterator thread_local_pos =
-        thread_to_thread_locals->find(current_thread);
-    if (thread_local_pos == thread_to_thread_locals->end()) {
-      thread_local_pos = thread_to_thread_locals->insert(
-          std::make_pair(current_thread, ThreadLocalValues())).first;
-      StartWatcherThreadFor(current_thread);
-    }
-    ThreadLocalValues& thread_local_values = thread_local_pos->second;
-    ThreadLocalValues::iterator value_pos =
-        thread_local_values.find(thread_local_instance);
-    if (value_pos == thread_local_values.end()) {
-      value_pos =
-          thread_local_values
-              .insert(std::make_pair(
-                  thread_local_instance,
-                  linked_ptr<ThreadLocalValueHolderBase>(
-                      thread_local_instance->NewValueForCurrentThread())))
-              .first;
-    }
-    return value_pos->second.get();
-  }
-
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadLocalValues data structure while holding the lock, but
-    // defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      for (ThreadIdToThreadLocals::iterator it =
-          thread_to_thread_locals->begin();
-          it != thread_to_thread_locals->end();
-          ++it) {
-        ThreadLocalValues& thread_local_values = it->second;
-        ThreadLocalValues::iterator value_pos =
-            thread_local_values.find(thread_local_instance);
-        if (value_pos != thread_local_values.end()) {
-          value_holders.push_back(value_pos->second);
-          thread_local_values.erase(value_pos);
-          // This 'if' can only be successful at most once, so theoretically we
-          // could break out of the loop here, but we don't bother doing so.
-        }
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
-  static void OnThreadExit(DWORD thread_id) {
-    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
-    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadIdToThreadLocals data structure while holding the
-    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      ThreadIdToThreadLocals::iterator thread_local_pos =
-          thread_to_thread_locals->find(thread_id);
-      if (thread_local_pos != thread_to_thread_locals->end()) {
-        ThreadLocalValues& thread_local_values = thread_local_pos->second;
-        for (ThreadLocalValues::iterator value_pos =
-            thread_local_values.begin();
-            value_pos != thread_local_values.end();
-            ++value_pos) {
-          value_holders.push_back(value_pos->second);
-        }
-        thread_to_thread_locals->erase(thread_local_pos);
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
- private:
-  // In a particular thread, maps a ThreadLocal object to its value.
-  typedef std::map<const ThreadLocalBase*,
-                   linked_ptr<ThreadLocalValueHolderBase> > ThreadLocalValues;
-  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
-  // thread's ID.
-  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
-
-  // Holds the thread id and thread handle that we pass from
-  // StartWatcherThreadFor to WatcherThreadFunc.
-  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
-
-  static void StartWatcherThreadFor(DWORD thread_id) {
-    // The returned handle will be kept in thread_map and closed by
-    // watcher_thread in WatcherThreadFunc.
-    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
-                                 FALSE,
-                                 thread_id);
-    GTEST_CHECK_(thread != NULL);
-    // We need to to pass a valid thread ID pointer into CreateThread for it
-    // to work correctly under Win98.
-    DWORD watcher_thread_id;
-    HANDLE watcher_thread = ::CreateThread(
-        NULL,   // Default security.
-        0,      // Default stack size
-        &ThreadLocalRegistryImpl::WatcherThreadFunc,
-        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
-        CREATE_SUSPENDED,
-        &watcher_thread_id);
-    GTEST_CHECK_(watcher_thread != NULL);
-    // Give the watcher thread the same priority as ours to avoid being
-    // blocked by it.
-    ::SetThreadPriority(watcher_thread,
-                        ::GetThreadPriority(::GetCurrentThread()));
-    ::ResumeThread(watcher_thread);
-    ::CloseHandle(watcher_thread);
-  }
-
-  // Monitors exit from a given thread and notifies those
-  // ThreadIdToThreadLocals about thread termination.
-  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
-    const ThreadIdAndHandle* tah =
-        reinterpret_cast<const ThreadIdAndHandle*>(param);
-    GTEST_CHECK_(
-        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
-    OnThreadExit(tah->first);
-    ::CloseHandle(tah->second);
-    delete tah;
-    return 0;
-  }
-
-  // Returns map of thread local instances.
-  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
-    mutex_.AssertHeld();
-    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals;
-    return map;
-  }
-
-  // Protects access to GetThreadLocalsMapLocked() and its return value.
-  static Mutex mutex_;
-  // Protects access to GetThreadMapLocked() and its return value.
-  static Mutex thread_map_mutex_;
-};
-
-Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
-Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
-
-ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
-      thread_local_instance);
-}
-
-void ThreadLocalRegistry::OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
-}
-
-#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-#if GTEST_USES_POSIX_RE
-
-// Implements RE.  Currently only needed for death tests.
-
-RE::~RE() {
-  if (is_valid_) {
-    // regfree'ing an invalid regex might crash because the content
-    // of the regex is undefined. Since the regex's are essentially
-    // the same, one cannot be valid (or invalid) without the other
-    // being so too.
-    regfree(&partial_regex_);
-    regfree(&full_regex_);
-  }
-  free(const_cast<char*>(pattern_));
-}
-
-// Returns true iff regular expression re matches the entire str.
-bool RE::FullMatch(const char* str, const RE& re) {
-  if (!re.is_valid_) return false;
-
-  regmatch_t match;
-  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
-}
-
-// Returns true iff regular expression re matches a substring of str
-// (including str itself).
-bool RE::PartialMatch(const char* str, const RE& re) {
-  if (!re.is_valid_) return false;
-
-  regmatch_t match;
-  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
-}
-
-// Initializes an RE from its string representation.
-void RE::Init(const char* regex) {
-  pattern_ = posix::StrDup(regex);
-
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match.
-  const size_t full_regex_len = strlen(regex) + 10;
-  char* const full_pattern = new char[full_regex_len];
-
-  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
-  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
-  // We want to call regcomp(&partial_regex_, ...) even if the
-  // previous expression returns false.  Otherwise partial_regex_ may
-  // not be properly initialized can may cause trouble when it's
-  // freed.
-  //
-  // Some implementation of POSIX regex (e.g. on at least some
-  // versions of Cygwin) doesn't accept the empty string as a valid
-  // regex.  We change it to an equivalent form "()" to be safe.
-  if (is_valid_) {
-    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
-    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
-  }
-  EXPECT_TRUE(is_valid_)
-      << "Regular expression \"" << regex
-      << "\" is not a valid POSIX Extended regular expression.";
-
-  delete[] full_pattern;
-}
-
-#elif GTEST_USES_SIMPLE_RE
-
-// Returns true iff ch appears anywhere in str (excluding the
-// terminating '\0' character).
-bool IsInSet(char ch, const char* str) {
-  return ch != '\0' && strchr(str, ch) != NULL;
-}
-
-// Returns true iff ch belongs to the given classification.  Unlike
-// similar functions in <ctype.h>, these aren't affected by the
-// current locale.
-bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
-bool IsAsciiPunct(char ch) {
-  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
-}
-bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
-bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
-bool IsAsciiWordChar(char ch) {
-  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
-      ('0' <= ch && ch <= '9') || ch == '_';
-}
-
-// Returns true iff "\\c" is a supported escape sequence.
-bool IsValidEscape(char c) {
-  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
-}
-
-// Returns true iff the given atom (specified by escaped and pattern)
-// matches ch.  The result is undefined if the atom is invalid.
-bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
-  if (escaped) {  // "\\p" where p is pattern_char.
-    switch (pattern_char) {
-      case 'd': return IsAsciiDigit(ch);
-      case 'D': return !IsAsciiDigit(ch);
-      case 'f': return ch == '\f';
-      case 'n': return ch == '\n';
-      case 'r': return ch == '\r';
-      case 's': return IsAsciiWhiteSpace(ch);
-      case 'S': return !IsAsciiWhiteSpace(ch);
-      case 't': return ch == '\t';
-      case 'v': return ch == '\v';
-      case 'w': return IsAsciiWordChar(ch);
-      case 'W': return !IsAsciiWordChar(ch);
-    }
-    return IsAsciiPunct(pattern_char) && pattern_char == ch;
-  }
-
-  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
-}
-
-// Helper function used by ValidateRegex() to format error messages.
-std::string FormatRegexSyntaxError(const char* regex, int index) {
-  return (Message() << "Syntax error at index " << index
-          << " in simple regular expression \"" << regex << "\": ").GetString();
-}
-
-// Generates non-fatal failures and returns false if regex is invalid;
-// otherwise returns true.
-bool ValidateRegex(const char* regex) {
-  if (regex == NULL) {
-    // TODO(wan@google.com): fix the source file location in the
-    // assertion failures to match where the regex is used in user
-    // code.
-    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
-    return false;
-  }
-
-  bool is_valid = true;
-
-  // True iff ?, *, or + can follow the previous atom.
-  bool prev_repeatable = false;
-  for (int i = 0; regex[i]; i++) {
-    if (regex[i] == '\\') {  // An escape sequence
-      i++;
-      if (regex[i] == '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "'\\' cannot appear at the end.";
-        return false;
-      }
-
-      if (!IsValidEscape(regex[i])) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "invalid escape sequence \"\\" << regex[i] << "\".";
-        is_valid = false;
-      }
-      prev_repeatable = true;
-    } else {  // Not an escape sequence.
-      const char ch = regex[i];
-
-      if (ch == '^' && i > 0) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'^' can only appear at the beginning.";
-        is_valid = false;
-      } else if (ch == '$' && regex[i + 1] != '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'$' can only appear at the end.";
-        is_valid = false;
-      } else if (IsInSet(ch, "()[]{}|")) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' is unsupported.";
-        is_valid = false;
-      } else if (IsRepeat(ch) && !prev_repeatable) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' can only follow a repeatable token.";
-        is_valid = false;
-      }
-
-      prev_repeatable = !IsInSet(ch, "^$?*+");
-    }
-  }
-
-  return is_valid;
-}
-
-// Matches a repeated regex atom followed by a valid simple regular
-// expression.  The regex atom is defined as c if escaped is false,
-// or \c otherwise.  repeat is the repetition meta character (?, *,
-// or +).  The behavior is undefined if str contains too many
-// characters to be indexable by size_t, in which case the test will
-// probably time out anyway.  We are fine with this limitation as
-// std::string has it too.
-bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char c, char repeat, const char* regex,
-    const char* str) {
-  const size_t min_count = (repeat == '+') ? 1 : 0;
-  const size_t max_count = (repeat == '?') ? 1 :
-      static_cast<size_t>(-1) - 1;
-  // We cannot call numeric_limits::max() as it conflicts with the
-  // max() macro on Windows.
-
-  for (size_t i = 0; i <= max_count; ++i) {
-    // We know that the atom matches each of the first i characters in str.
-    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
-      // We have enough matches at the head, and the tail matches too.
-      // Since we only care about *whether* the pattern matches str
-      // (as opposed to *how* it matches), there is no need to find a
-      // greedy match.
-      return true;
-    }
-    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
-      return false;
-  }
-  return false;
-}
-
-// Returns true iff regex matches a prefix of str.  regex must be a
-// valid simple regular expression and not start with "^", or the
-// result is undefined.
-bool MatchRegexAtHead(const char* regex, const char* str) {
-  if (*regex == '\0')  // An empty regex matches a prefix of anything.
-    return true;
-
-  // "$" only matches the end of a string.  Note that regex being
-  // valid guarantees that there's nothing after "$" in it.
-  if (*regex == '$')
-    return *str == '\0';
-
-  // Is the first thing in regex an escape sequence?
-  const bool escaped = *regex == '\\';
-  if (escaped)
-    ++regex;
-  if (IsRepeat(regex[1])) {
-    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
-    // here's an indirect recursion.  It terminates as the regex gets
-    // shorter in each recursion.
-    return MatchRepetitionAndRegexAtHead(
-        escaped, regex[0], regex[1], regex + 2, str);
-  } else {
-    // regex isn't empty, isn't "$", and doesn't start with a
-    // repetition.  We match the first atom of regex with the first
-    // character of str and recurse.
-    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
-        MatchRegexAtHead(regex + 1, str + 1);
-  }
-}
-
-// Returns true iff regex matches any substring of str.  regex must be
-// a valid simple regular expression, or the result is undefined.
-//
-// The algorithm is recursive, but the recursion depth doesn't exceed
-// the regex length, so we won't need to worry about running out of
-// stack space normally.  In rare cases the time complexity can be
-// exponential with respect to the regex length + the string length,
-// but usually it's must faster (often close to linear).
-bool MatchRegexAnywhere(const char* regex, const char* str) {
-  if (regex == NULL || str == NULL)
-    return false;
-
-  if (*regex == '^')
-    return MatchRegexAtHead(regex + 1, str);
-
-  // A successful match can be anywhere in str.
-  do {
-    if (MatchRegexAtHead(regex, str))
-      return true;
-  } while (*str++ != '\0');
-  return false;
-}
-
-// Implements the RE class.
-
-RE::~RE() {
-  free(const_cast<char*>(pattern_));
-  free(const_cast<char*>(full_pattern_));
-}
-
-// Returns true iff regular expression re matches the entire str.
-bool RE::FullMatch(const char* str, const RE& re) {
-  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
-}
-
-// Returns true iff regular expression re matches a substring of str
-// (including str itself).
-bool RE::PartialMatch(const char* str, const RE& re) {
-  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
-}
-
-// Initializes an RE from its string representation.
-void RE::Init(const char* regex) {
-  pattern_ = full_pattern_ = NULL;
-  if (regex != NULL) {
-    pattern_ = posix::StrDup(regex);
-  }
-
-  is_valid_ = ValidateRegex(regex);
-  if (!is_valid_) {
-    // No need to calculate the full pattern when the regex is invalid.
-    return;
-  }
-
-  const size_t len = strlen(regex);
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match: we need space to prepend a '^', append a '$', and
-  // terminate the string with '\0'.
-  char* buffer = static_cast<char*>(malloc(len + 3));
-  full_pattern_ = buffer;
-
-  if (*regex != '^')
-    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
-
-  // We don't use snprintf or strncpy, as they trigger a warning when
-  // compiled with VC++ 8.0.
-  memcpy(buffer, regex, len);
-  buffer += len;
-
-  if (len == 0 || regex[len - 1] != '$')
-    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
-
-  *buffer = '\0';
-}
-
-#endif  // GTEST_USES_POSIX_RE
-
-const char kUnknownFile[] = "unknown file";
-
-// Formats a source file path and a line number as they would appear
-// in an error message from the compiler used to compile this code.
-GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
-  const std::string file_name(file == NULL ? kUnknownFile : file);
-
-  if (line < 0) {
-    return file_name + ":";
-  }
-#ifdef _MSC_VER
-  return file_name + "(" + StreamableToString(line) + "):";
-#else
-  return file_name + ":" + StreamableToString(line) + ":";
-#endif  // _MSC_VER
-}
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-// Note that FormatCompilerIndependentFileLocation() does NOT append colon
-// to the file location it produces, unlike FormatFileLocation().
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
-    const char* file, int line) {
-  const std::string file_name(file == NULL ? kUnknownFile : file);
-
-  if (line < 0)
-    return file_name;
-  else
-    return file_name + ":" + StreamableToString(line);
-}
-
-GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
-    : severity_(severity) {
-  const char* const marker =
-      severity == GTEST_INFO ?    "[  INFO ]" :
-      severity == GTEST_WARNING ? "[WARNING]" :
-      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
-  GetStream() << ::std::endl << marker << " "
-              << FormatFileLocation(file, line).c_str() << ": ";
-}
-
-// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-GTestLog::~GTestLog() {
-  GetStream() << ::std::endl;
-  if (severity_ == GTEST_FATAL) {
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-// Disable Microsoft deprecation warnings for POSIX functions called from
-// this class (creat, dup, dup2, and close)
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Object that captures an output stream (stdout/stderr).
-class CapturedStream {
- public:
-  // The ctor redirects the stream to a temporary file.
-  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
-# if GTEST_OS_WINDOWS
-    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-
-    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
-    const UINT success = ::GetTempFileNameA(temp_dir_path,
-                                            "gtest_redir",
-                                            0,  // Generate unique file name.
-                                            temp_file_path);
-    GTEST_CHECK_(success != 0)
-        << "Unable to create a temporary file in " << temp_dir_path;
-    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
-    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
-                                    << temp_file_path;
-    filename_ = temp_file_path;
-# else
-    // There's no guarantee that a test has write access to the current
-    // directory, so we create the temporary file in the /tmp directory
-    // instead. We use /tmp on most systems, and /sdcard on Android.
-    // That's because Android doesn't have /tmp.
-#  if GTEST_OS_LINUX_ANDROID
-    // Note: Android applications are expected to call the framework's
-    // Context.getExternalStorageDirectory() method through JNI to get
-    // the location of the world-writable SD Card directory. However,
-    // this requires a Context handle, which cannot be retrieved
-    // globally from native code. Doing so also precludes running the
-    // code as part of a regular standalone executable, which doesn't
-    // run in a Dalvik process (e.g. when running it through 'adb shell').
-    //
-    // The location /sdcard is directly accessible from native code
-    // and is the only location (unofficially) supported by the Android
-    // team. It's generally a symlink to the real SD Card mount point
-    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
-    // other OEM-customized locations. Never rely on these, and always
-    // use /sdcard.
-    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
-#  else
-    char name_template[] = "/tmp/captured_stream.XXXXXX";
-#  endif  // GTEST_OS_LINUX_ANDROID
-    const int captured_fd = mkstemp(name_template);
-    filename_ = name_template;
-# endif  // GTEST_OS_WINDOWS
-    fflush(NULL);
-    dup2(captured_fd, fd_);
-    close(captured_fd);
-  }
-
-  ~CapturedStream() {
-    remove(filename_.c_str());
-  }
-
-  std::string GetCapturedString() {
-    if (uncaptured_fd_ != -1) {
-      // Restores the original stream.
-      fflush(NULL);
-      dup2(uncaptured_fd_, fd_);
-      close(uncaptured_fd_);
-      uncaptured_fd_ = -1;
-    }
-
-    FILE* const file = posix::FOpen(filename_.c_str(), "r");
-    const std::string content = ReadEntireFile(file);
-    posix::FClose(file);
-    return content;
-  }
-
- private:
-  const int fd_;  // A stream to capture.
-  int uncaptured_fd_;
-  // Name of the temporary file holding the stderr output.
-  ::std::string filename_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
-};
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-static CapturedStream* g_captured_stderr = NULL;
-static CapturedStream* g_captured_stdout = NULL;
-
-// Starts capturing an output stream (stdout/stderr).
-void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
-  if (*stream != NULL) {
-    GTEST_LOG_(FATAL) << "Only one " << stream_name
-                      << " capturer can exist at a time.";
-  }
-  *stream = new CapturedStream(fd);
-}
-
-// Stops capturing the output stream and returns the captured string.
-std::string GetCapturedStream(CapturedStream** captured_stream) {
-  const std::string content = (*captured_stream)->GetCapturedString();
-
-  delete *captured_stream;
-  *captured_stream = NULL;
-
-  return content;
-}
-
-// Starts capturing stdout.
-void CaptureStdout() {
-  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
-}
-
-// Starts capturing stderr.
-void CaptureStderr() {
-  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
-}
-
-// Stops capturing stdout and returns the captured string.
-std::string GetCapturedStdout() {
-  return GetCapturedStream(&g_captured_stdout);
-}
-
-// Stops capturing stderr and returns the captured string.
-std::string GetCapturedStderr() {
-  return GetCapturedStream(&g_captured_stderr);
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-std::string TempDir() {
-#if GTEST_OS_WINDOWS_MOBILE
-  return "\\temp\\";
-#elif GTEST_OS_WINDOWS
-  const char* temp_dir = posix::GetEnv("TEMP");
-  if (temp_dir == NULL || temp_dir[0] == '\0')
-    return "\\temp\\";
-  else if (temp_dir[strlen(temp_dir) - 1] == '\\')
-    return temp_dir;
-  else
-    return std::string(temp_dir) + "\\";
-#elif GTEST_OS_LINUX_ANDROID
-  return "/sdcard/";
-#else
-  return "/tmp/";
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-size_t GetFileSize(FILE* file) {
-  fseek(file, 0, SEEK_END);
-  return static_cast<size_t>(ftell(file));
-}
-
-std::string ReadEntireFile(FILE* file) {
-  const size_t file_size = GetFileSize(file);
-  char* const buffer = new char[file_size];
-
-  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
-  size_t bytes_read = 0;       // # of bytes read so far
-
-  fseek(file, 0, SEEK_SET);
-
-  // Keeps reading the file until we cannot read further or the
-  // pre-determined file size is reached.
-  do {
-    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
-    bytes_read += bytes_last_read;
-  } while (bytes_last_read > 0 && bytes_read < file_size);
-
-  const std::string content(buffer, bytes_read);
-  delete[] buffer;
-
-  return content;
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
-                                        NULL;  // Owned.
-
-void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
-  if (g_injected_test_argvs != argvs)
-    delete g_injected_test_argvs;
-  g_injected_test_argvs = argvs;
-}
-
-const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
-  if (g_injected_test_argvs != NULL) {
-    return *g_injected_test_argvs;
-  }
-  return GetArgvs();
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-#if GTEST_OS_WINDOWS_MOBILE
-namespace posix {
-void Abort() {
-  DebugBreak();
-  TerminateProcess(GetCurrentProcess(), 1);
-}
-}  // namespace posix
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Returns the name of the environment variable corresponding to the
-// given flag.  For example, FlagToEnvVar("foo") will return
-// "GTEST_FOO" in the open-source version.
-static std::string FlagToEnvVar(const char* flag) {
-  const std::string full_flag =
-      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
-
-  Message env_var;
-  for (size_t i = 0; i != full_flag.length(); i++) {
-    env_var << ToUpper(full_flag.c_str()[i]);
-  }
-
-  return env_var.GetString();
-}
-
-// Parses 'str' for a 32-bit signed integer.  If successful, writes
-// the result to *value and returns true; otherwise leaves *value
-// unchanged and returns false.
-bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
-  // Parses the environment variable as a decimal integer.
-  char* end = NULL;
-  const long long_value = strtol(str, &end, 10);  // NOLINT
-
-  // Has strtol() consumed all characters in the string?
-  if (*end != '\0') {
-    // No - an invalid character was encountered.
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value \"" << str << "\".\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  // Is the parsed value in the range of an Int32?
-  const Int32 result = static_cast<Int32>(long_value);
-  if (long_value == LONG_MAX || long_value == LONG_MIN ||
-      // The parsed value overflows as a long.  (strtol() returns
-      // LONG_MAX or LONG_MIN when the input overflows.)
-      result != long_value
-      // The parsed value overflows as an Int32.
-      ) {
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value " << str << ", which overflows.\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  *value = result;
-  return true;
-}
-
-// Reads and returns the Boolean environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-//
-// The value is considered true iff it's not "0".
-bool BoolFromGTestEnv(const char* flag, bool default_value) {
-#if defined(GTEST_GET_BOOL_FROM_ENV_)
-  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
-#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  return string_value == NULL ?
-      default_value : strcmp(string_value, "0") != 0;
-}
-
-// Reads and returns a 32-bit integer stored in the environment
-// variable corresponding to the given flag; if it isn't set or
-// doesn't represent a valid 32-bit integer, returns default_value.
-Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
-#if defined(GTEST_GET_INT32_FROM_ENV_)
-  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
-#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  if (string_value == NULL) {
-    // The environment variable is not set.
-    return default_value;
-  }
-
-  Int32 result = default_value;
-  if (!ParseInt32(Message() << "Environment variable " << env_var,
-                  string_value, &result)) {
-    printf("The default value %s is used.\n",
-           (Message() << default_value).GetString().c_str());
-    fflush(stdout);
-    return default_value;
-  }
-
-  return result;
-}
-
-// Reads and returns the string environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-const char* StringFromGTestEnv(const char* flag, const char* default_value) {
-#if defined(GTEST_GET_STRING_FROM_ENV_)
-  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
-#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const value = posix::GetEnv(env_var.c_str());
-  return value == NULL ? default_value : value;
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Test - The Google C++ Testing Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// It uses the << operator when possible, and prints the bytes in the
-// object otherwise.  A user can override its behavior for a class
-// type Foo by defining either operator<<(::std::ostream&, const Foo&)
-// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
-// defines Foo.
-
-#include <ctype.h>
-#include <stdio.h>
-#include <cwchar>
-#include <ostream>  // NOLINT
-#include <string>
-
-namespace testing {
-
-namespace {
-
-using ::std::ostream;
-
-// Prints a segment of bytes in the given object.
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
-                                size_t count, ostream* os) {
-  char text[5] = "";
-  for (size_t i = 0; i != count; i++) {
-    const size_t j = start + i;
-    if (i != 0) {
-      // Organizes the bytes into groups of 2 for easy parsing by
-      // human.
-      if ((j % 2) == 0)
-        *os << ' ';
-      else
-        *os << '-';
-    }
-    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
-    *os << text;
-  }
-}
-
-// Prints the bytes in the given value to the given ostream.
-void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
-                              ostream* os) {
-  // Tells the user how big the object is.
-  *os << count << "-byte object <";
-
-  const size_t kThreshold = 132;
-  const size_t kChunkSize = 64;
-  // If the object size is bigger than kThreshold, we'll have to omit
-  // some details by printing only the first and the last kChunkSize
-  // bytes.
-  // TODO(wan): let the user control the threshold using a flag.
-  if (count < kThreshold) {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
-  } else {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
-    *os << " ... ";
-    // Rounds up to 2-byte boundary.
-    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
-    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
-  }
-  *os << ">";
-}
-
-}  // namespace
-
-namespace internal2 {
-
-// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
-// given object.  The delegation simplifies the implementation, which
-// uses the << operator and thus is easier done outside of the
-// ::testing::internal namespace, which contains a << operator that
-// sometimes conflicts with the one in STL.
-void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
-                          ostream* os) {
-  PrintBytesInObjectToImpl(obj_bytes, count, os);
-}
-
-}  // namespace internal2
-
-namespace internal {
-
-// Depending on the value of a char (or wchar_t), we print it in one
-// of three formats:
-//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
-//   - as a hexidecimal escape sequence (e.g. '\x7F'), or
-//   - as a special escape sequence (e.g. '\r', '\n').
-enum CharFormat {
-  kAsIs,
-  kHexEscape,
-  kSpecialEscape
-};
-
-// Returns true if c is a printable ASCII character.  We test the
-// value of c directly instead of calling isprint(), which is buggy on
-// Windows Mobile.
-inline bool IsPrintableAscii(wchar_t c) {
-  return 0x20 <= c && c <= 0x7E;
-}
-
-// Prints a wide or narrow char c as a character literal without the
-// quotes, escaping it when necessary; returns how c was formatted.
-// The template argument UnsignedChar is the unsigned version of Char,
-// which is the type of c.
-template <typename UnsignedChar, typename Char>
-static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
-  switch (static_cast<wchar_t>(c)) {
-    case L'\0':
-      *os << "\\0";
-      break;
-    case L'\'':
-      *os << "\\'";
-      break;
-    case L'\\':
-      *os << "\\\\";
-      break;
-    case L'\a':
-      *os << "\\a";
-      break;
-    case L'\b':
-      *os << "\\b";
-      break;
-    case L'\f':
-      *os << "\\f";
-      break;
-    case L'\n':
-      *os << "\\n";
-      break;
-    case L'\r':
-      *os << "\\r";
-      break;
-    case L'\t':
-      *os << "\\t";
-      break;
-    case L'\v':
-      *os << "\\v";
-      break;
-    default:
-      if (IsPrintableAscii(c)) {
-        *os << static_cast<char>(c);
-        return kAsIs;
-      } else {
-        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
-        return kHexEscape;
-      }
-  }
-  return kSpecialEscape;
-}
-
-// Prints a wchar_t c as if it's part of a string literal, escaping it when
-// necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
-  switch (c) {
-    case L'\'':
-      *os << "'";
-      return kAsIs;
-    case L'"':
-      *os << "\\\"";
-      return kSpecialEscape;
-    default:
-      return PrintAsCharLiteralTo<wchar_t>(c, os);
-  }
-}
-
-// Prints a char c as if it's part of a string literal, escaping it when
-// necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
-  return PrintAsStringLiteralTo(
-      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
-}
-
-// Prints a wide or narrow character c and its code.  '\0' is printed
-// as "'\\0'", other unprintable characters are also properly escaped
-// using the standard C++ escape sequence.  The template argument
-// UnsignedChar is the unsigned version of Char, which is the type of c.
-template <typename UnsignedChar, typename Char>
-void PrintCharAndCodeTo(Char c, ostream* os) {
-  // First, print c as a literal in the most readable form we can find.
-  *os << ((sizeof(c) > 1) ? "L'" : "'");
-  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
-  *os << "'";
-
-  // To aid user debugging, we also print c's code in decimal, unless
-  // it's 0 (in which case c was printed as '\\0', making the code
-  // obvious).
-  if (c == 0)
-    return;
-  *os << " (" << static_cast<int>(c);
-
-  // For more convenience, we print c's code again in hexidecimal,
-  // unless c was already printed in the form '\x##' or the code is in
-  // [1, 9].
-  if (format == kHexEscape || (1 <= c && c <= 9)) {
-    // Do nothing.
-  } else {
-    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
-  }
-  *os << ")";
-}
-
-void PrintTo(unsigned char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(c, os);
-}
-void PrintTo(signed char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(c, os);
-}
-
-// Prints a wchar_t as a symbol if it is printable or as its internal
-// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
-void PrintTo(wchar_t wc, ostream* os) {
-  PrintCharAndCodeTo<wchar_t>(wc, os);
-}
-
-// Prints the given array of characters to the ostream.  CharType must be either
-// char or wchar_t.
-// The array starts at begin, the length is len, it may include '\0' characters
-// and may not be NUL-terminated.
-template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static void PrintCharsAsStringTo(
-    const CharType* begin, size_t len, ostream* os) {
-  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
-  *os << kQuoteBegin;
-  bool is_previous_hex = false;
-  for (size_t index = 0; index < len; ++index) {
-    const CharType cur = begin[index];
-    if (is_previous_hex && IsXDigit(cur)) {
-      // Previous character is of '\x..' form and this character can be
-      // interpreted as another hexadecimal digit in its number. Break string to
-      // disambiguate.
-      *os << "\" " << kQuoteBegin;
-    }
-    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
-  }
-  *os << "\"";
-}
-
-// Prints a (const) char/wchar_t array of 'len' elements, starting at address
-// 'begin'.  CharType must be either char or wchar_t.
-template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static void UniversalPrintCharArray(
-    const CharType* begin, size_t len, ostream* os) {
-  // The code
-  //   const char kFoo[] = "foo";
-  // generates an array of 4, not 3, elements, with the last one being '\0'.
-  //
-  // Therefore when printing a char array, we don't print the last element if
-  // it's '\0', such that the output matches the string literal as it's
-  // written in the source code.
-  if (len > 0 && begin[len - 1] == '\0') {
-    PrintCharsAsStringTo(begin, len - 1, os);
-    return;
-  }
-
-  // If, however, the last element in the array is not '\0', e.g.
-  //    const char kFoo[] = { 'f', 'o', 'o' };
-  // we must print the entire array.  We also print a message to indicate
-  // that the array is not NUL-terminated.
-  PrintCharsAsStringTo(begin, len, os);
-  *os << " (no terminating NUL)";
-}
-
-// Prints a (const) char array of 'len' elements, starting at address 'begin'.
-void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
-// Prints a (const) wchar_t array of 'len' elements, starting at address
-// 'begin'.
-void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
-// Prints the given C string to the ostream.
-void PrintTo(const char* s, ostream* os) {
-  if (s == NULL) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, strlen(s), os);
-  }
-}
-
-// MSVC compiler can be configured to define whar_t as a typedef
-// of unsigned short. Defining an overload for const wchar_t* in that case
-// would cause pointers to unsigned shorts be printed as wide strings,
-// possibly accessing more memory than intended and causing invalid
-// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
-// wchar_t is implemented as a native type.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-// Prints the given wide C string to the ostream.
-void PrintTo(const wchar_t* s, ostream* os) {
-  if (s == NULL) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, std::wcslen(s), os);
-  }
-}
-#endif  // wchar_t is native
-
-// Prints a ::string object.
-#if GTEST_HAS_GLOBAL_STRING
-void PrintStringTo(const ::string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-void PrintStringTo(const ::std::string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-
-// Prints a ::wstring object.
-#if GTEST_HAS_GLOBAL_WSTRING
-void PrintWideStringTo(const ::wstring& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-#if GTEST_HAS_STD_WSTRING
-void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-}  // namespace internal
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-// The Google C++ Testing Framework (Google Test)
-
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-
-using internal::GetUnitTestImpl;
-
-// Gets the summary of the failure message by omitting the stack trace
-// in it.
-std::string TestPartResult::ExtractSummary(const char* message) {
-  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
-  return stack_trace == NULL ? message :
-      std::string(message, stack_trace);
-}
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
-  return os
-      << result.file_name() << ":" << result.line_number() << ": "
-      << (result.type() == TestPartResult::kSuccess ? "Success" :
-          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
-          "Non-fatal failure") << ":\n"
-      << result.message() << std::endl;
-}
-
-// Appends a TestPartResult to the array.
-void TestPartResultArray::Append(const TestPartResult& result) {
-  array_.push_back(result);
-}
-
-// Returns the TestPartResult at the given index (0-based).
-const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
-  if (index < 0 || index >= size()) {
-    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
-    internal::posix::Abort();
-  }
-
-  return array_[index];
-}
-
-// Returns the number of TestPartResult objects in the array.
-int TestPartResultArray::size() const {
-  return static_cast<int>(array_.size());
-}
-
-namespace internal {
-
-HasNewFatalFailureHelper::HasNewFatalFailureHelper()
-    : has_new_fatal_failure_(false),
-      original_reporter_(GetUnitTestImpl()->
-                         GetTestPartResultReporterForCurrentThread()) {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
-}
-
-HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
-      original_reporter_);
-}
-
-void HasNewFatalFailureHelper::ReportTestPartResult(
-    const TestPartResult& result) {
-  if (result.fatally_failed())
-    has_new_fatal_failure_ = true;
-  original_reporter_->ReportTestPartResult(result);
-}
-
-}  // namespace internal
-
-}  // namespace testing
-// Copyright 2008 Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-namespace testing {
-namespace internal {
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// Skips to the first non-space char in str. Returns an empty string if str
-// contains only whitespace characters.
-static const char* SkipSpaces(const char* str) {
-  while (IsSpace(*str))
-    str++;
-  return str;
-}
-
-static std::vector<std::string> SplitIntoTestNames(const char* src) {
-  std::vector<std::string> name_vec;
-  src = SkipSpaces(src);
-  for (; src != NULL; src = SkipComma(src)) {
-    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
-  }
-  return name_vec;
-}
-
-// Verifies that registered_tests match the test names in
-// registered_tests_; returns registered_tests if successful, or
-// aborts the program otherwise.
-const char* TypedTestCasePState::VerifyRegisteredTestNames(
-    const char* file, int line, const char* registered_tests) {
-  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
-  registered_ = true;
-
-  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
-
-  Message errors;
-
-  std::set<std::string> tests;
-  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
-       name_it != name_vec.end(); ++name_it) {
-    const std::string& name = *name_it;
-    if (tests.count(name) != 0) {
-      errors << "Test " << name << " is listed more than once.\n";
-      continue;
-    }
-
-    bool found = false;
-    for (RegisteredTestIter it = registered_tests_.begin();
-         it != registered_tests_.end();
-         ++it) {
-      if (name == it->first) {
-        found = true;
-        break;
-      }
-    }
-
-    if (found) {
-      tests.insert(name);
-    } else {
-      errors << "No test named " << name
-             << " can be found in this test case.\n";
-    }
-  }
-
-  for (RegisteredTestIter it = registered_tests_.begin();
-       it != registered_tests_.end();
-       ++it) {
-    if (tests.count(it->first) == 0) {
-      errors << "You forgot to list test " << it->first << ".\n";
-    }
-  }
-
-  const std::string& errors_str = errors.GetString();
-  if (errors_str != "") {
-    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
-            errors_str.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-
-  return registered_tests;
-}
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Google C++ Mocking Framework (Google Mock)
-//
-// This file #includes all Google Mock implementation .cc files.  The
-// purpose is to allow a user to build Google Mock by compiling this
-// file alone.
-
-// This line ensures that gmock.h can be compiled on its own, even
-// when it's fused.
-#include "gmock/gmock.h"
-
-// The following lines pull in the real gmock *.cc files.
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements cardinalities.
-
-
-#include <limits.h>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-
-namespace testing {
-
-namespace {
-
-// Implements the Between(m, n) cardinality.
-class BetweenCardinalityImpl : public CardinalityInterface {
- public:
-  BetweenCardinalityImpl(int min, int max)
-      : min_(min >= 0 ? min : 0),
-        max_(max >= min_ ? max : min_) {
-    std::stringstream ss;
-    if (min < 0) {
-      ss << "The invocation lower bound must be >= 0, "
-         << "but is actually " << min << ".";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    } else if (max < 0) {
-      ss << "The invocation upper bound must be >= 0, "
-         << "but is actually " << max << ".";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    } else if (min > max) {
-      ss << "The invocation upper bound (" << max
-         << ") must be >= the invocation lower bound (" << min
-         << ").";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    }
-  }
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  virtual int ConservativeLowerBound() const { return min_; }
-  virtual int ConservativeUpperBound() const { return max_; }
-
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return min_ <= call_count && call_count <= max_;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return call_count >= max_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const;
-
- private:
-  const int min_;
-  const int max_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
-};
-
-// Formats "n times" in a human-friendly way.
-inline internal::string FormatTimes(int n) {
-  if (n == 1) {
-    return "once";
-  } else if (n == 2) {
-    return "twice";
-  } else {
-    std::stringstream ss;
-    ss << n << " times";
-    return ss.str();
-  }
-}
-
-// Describes the Between(m, n) cardinality in human-friendly text.
-void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
-  if (min_ == 0) {
-    if (max_ == 0) {
-      *os << "never called";
-    } else if (max_ == INT_MAX) {
-      *os << "called any number of times";
-    } else {
-      *os << "called at most " << FormatTimes(max_);
-    }
-  } else if (min_ == max_) {
-    *os << "called " << FormatTimes(min_);
-  } else if (max_ == INT_MAX) {
-    *os << "called at least " << FormatTimes(min_);
-  } else {
-    // 0 < min_ < max_ < INT_MAX
-    *os << "called between " << min_ << " and " << max_ << " times";
-  }
-}
-
-}  // Unnamed namespace
-
-// Describes the given call count to an ostream.
-void Cardinality::DescribeActualCallCountTo(int actual_call_count,
-                                            ::std::ostream* os) {
-  if (actual_call_count > 0) {
-    *os << "called " << FormatTimes(actual_call_count);
-  } else {
-    *os << "never called";
-  }
-}
-
-// Creates a cardinality that allows at least n calls.
-GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
-
-// Creates a cardinality that allows at most n calls.
-GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
-
-// Creates a cardinality that allows any number of calls.
-GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
-
-// Creates a cardinality that allows between min and max calls.
-GTEST_API_ Cardinality Between(int min, int max) {
-  return Cardinality(new BetweenCardinalityImpl(min, max));
-}
-
-// Creates a cardinality that allows exactly n calls.
-GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
-
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file defines some utilities useful for implementing Google
-// Mock.  They are subject to change without notice, so please DO NOT
-// USE THEM IN USER CODE.
-
-
-#include <ctype.h>
-#include <ostream>  // NOLINT
-#include <string>
-
-namespace testing {
-namespace internal {
-
-// Converts an identifier name to a space-separated list of lower-case
-// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
-// treated as one word.  For example, both "FooBar123" and
-// "foo_bar_123" are converted to "foo bar 123".
-GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name) {
-  string result;
-  char prev_char = '\0';
-  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
-    // We don't care about the current locale as the input is
-    // guaranteed to be a valid C++ identifier name.
-    const bool starts_new_word = IsUpper(*p) ||
-        (!IsAlpha(prev_char) && IsLower(*p)) ||
-        (!IsDigit(prev_char) && IsDigit(*p));
-
-    if (IsAlNum(*p)) {
-      if (starts_new_word && result != "")
-        result += ' ';
-      result += ToLower(*p);
-    }
-  }
-  return result;
-}
-
-// This class reports Google Mock failures as Google Test failures.  A
-// user can define another class in a similar fashion if he intends to
-// use Google Mock with a testing framework other than Google Test.
-class GoogleTestFailureReporter : public FailureReporterInterface {
- public:
-  virtual void ReportFailure(FailureType type, const char* file, int line,
-                             const string& message) {
-    AssertHelper(type == kFatal ?
-                 TestPartResult::kFatalFailure :
-                 TestPartResult::kNonFatalFailure,
-                 file,
-                 line,
-                 message.c_str()) = Message();
-    if (type == kFatal) {
-      posix::Abort();
-    }
-  }
-};
-
-// Returns the global failure reporter.  Will create a
-// GoogleTestFailureReporter and return it the first time called.
-GTEST_API_ FailureReporterInterface* GetFailureReporter() {
-  // Points to the global failure reporter used by Google Mock.  gcc
-  // guarantees that the following use of failure_reporter is
-  // thread-safe.  We may need to add additional synchronization to
-  // protect failure_reporter if we port Google Mock to other
-  // compilers.
-  static FailureReporterInterface* const failure_reporter =
-      new GoogleTestFailureReporter();
-  return failure_reporter;
-}
-
-// Protects global resources (stdout in particular) used by Log().
-static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
-
-// Returns true iff a log with the given severity is visible according
-// to the --gmock_verbose flag.
-GTEST_API_ bool LogIsVisible(LogSeverity severity) {
-  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
-    // Always show the log if --gmock_verbose=info.
-    return true;
-  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
-    // Always hide it if --gmock_verbose=error.
-    return false;
-  } else {
-    // If --gmock_verbose is neither "info" nor "error", we treat it
-    // as "warning" (its default value).
-    return severity == kWarning;
-  }
-}
-
-// Prints the given message to stdout iff 'severity' >= the level
-// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
-// 0, also prints the stack trace excluding the top
-// stack_frames_to_skip frames.  In opt mode, any positive
-// stack_frames_to_skip is treated as 0, since we don't know which
-// function calls will be inlined by the compiler and need to be
-// conservative.
-GTEST_API_ void Log(LogSeverity severity,
-                    const string& message,
-                    int stack_frames_to_skip) {
-  if (!LogIsVisible(severity))
-    return;
-
-  // Ensures that logs from different threads don't interleave.
-  MutexLock l(&g_log_mutex);
-
-  // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
-  // macro.
-
-  if (severity == kWarning) {
-    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
-    std::cout << "\nGMOCK WARNING:";
-  }
-  // Pre-pends a new-line to message if it doesn't start with one.
-  if (message.empty() || message[0] != '\n') {
-    std::cout << "\n";
-  }
-  std::cout << message;
-  if (stack_frames_to_skip >= 0) {
-#ifdef NDEBUG
-    // In opt mode, we have to be conservative and skip no stack frame.
-    const int actual_to_skip = 0;
-#else
-    // In dbg mode, we can do what the caller tell us to do (plus one
-    // for skipping this function's stack frame).
-    const int actual_to_skip = stack_frames_to_skip + 1;
-#endif  // NDEBUG
-
-    // Appends a new-line to message if it doesn't end with one.
-    if (!message.empty() && *message.rbegin() != '\n') {
-      std::cout << "\n";
-    }
-    std::cout << "Stack trace:\n"
-         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
-             ::testing::UnitTest::GetInstance(), actual_to_skip);
-  }
-  std::cout << ::std::flush;
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements Matcher<const string&>, Matcher<string>, and
-// utilities for defining matchers.
-
-
-#include <string.h>
-#include <sstream>
-#include <string>
-
-namespace testing {
-
-// Constructs a matcher that matches a const string& whose value is
-// equal to s.
-Matcher<const internal::string&>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const string& whose value is
-// equal to s.
-Matcher<const internal::string&>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a string whose value is equal to s.
-Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a string whose value is equal to s.
-Matcher<internal::string>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-#if GTEST_HAS_STRING_PIECE_
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(StringPiece s) {
-  *this = Eq(s.ToString());
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(StringPiece s) {
-  *this = Eq(s.ToString());
-}
-#endif  // GTEST_HAS_STRING_PIECE_
-
-namespace internal {
-
-// Joins a vector of strings as if they are fields of a tuple; returns
-// the joined string.
-GTEST_API_ string JoinAsTuple(const Strings& fields) {
-  switch (fields.size()) {
-    case 0:
-      return "";
-    case 1:
-      return fields[0];
-    default:
-      string result = "(" + fields[0];
-      for (size_t i = 1; i < fields.size(); i++) {
-        result += ", ";
-        result += fields[i];
-      }
-      result += ")";
-      return result;
-  }
-}
-
-// Returns the description for a matcher defined using the MATCHER*()
-// macro where the user-supplied description string is "", if
-// 'negation' is false; otherwise returns the description of the
-// negation of the matcher.  'param_values' contains a list of strings
-// that are the print-out of the matcher's parameters.
-GTEST_API_ string FormatMatcherDescription(bool negation,
-                                           const char* matcher_name,
-                                           const Strings& param_values) {
-  string result = ConvertIdentifierNameToWords(matcher_name);
-  if (param_values.size() >= 1)
-    result += " " + JoinAsTuple(param_values);
-  return negation ? "not (" + result + ")" : result;
-}
-
-// FindMaxBipartiteMatching and its helper class.
-//
-// Uses the well-known Ford-Fulkerson max flow method to find a maximum
-// bipartite matching. Flow is considered to be from left to right.
-// There is an implicit source node that is connected to all of the left
-// nodes, and an implicit sink node that is connected to all of the
-// right nodes. All edges have unit capacity.
-//
-// Neither the flow graph nor the residual flow graph are represented
-// explicitly. Instead, they are implied by the information in 'graph' and
-// a vector<int> called 'left_' whose elements are initialized to the
-// value kUnused. This represents the initial state of the algorithm,
-// where the flow graph is empty, and the residual flow graph has the
-// following edges:
-//   - An edge from source to each left_ node
-//   - An edge from each right_ node to sink
-//   - An edge from each left_ node to each right_ node, if the
-//     corresponding edge exists in 'graph'.
-//
-// When the TryAugment() method adds a flow, it sets left_[l] = r for some
-// nodes l and r. This induces the following changes:
-//   - The edges (source, l), (l, r), and (r, sink) are added to the
-//     flow graph.
-//   - The same three edges are removed from the residual flow graph.
-//   - The reverse edges (l, source), (r, l), and (sink, r) are added
-//     to the residual flow graph, which is a directional graph
-//     representing unused flow capacity.
-//
-// When the method augments a flow (moving left_[l] from some r1 to some
-// other r2), this can be thought of as "undoing" the above steps with
-// respect to r1 and "redoing" them with respect to r2.
-//
-// It bears repeating that the flow graph and residual flow graph are
-// never represented explicitly, but can be derived by looking at the
-// information in 'graph' and in left_.
-//
-// As an optimization, there is a second vector<int> called right_ which
-// does not provide any new information. Instead, it enables more
-// efficient queries about edges entering or leaving the right-side nodes
-// of the flow or residual flow graphs. The following invariants are
-// maintained:
-//
-// left[l] == kUnused or right[left[l]] == l
-// right[r] == kUnused or left[right[r]] == r
-//
-// . [ source ]                                        .
-// .   |||                                             .
-// .   |||                                             .
-// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
-// .   ||                   |                    |     .
-// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
-// .   |                                        ||     .
-// .   \----> left[2]=2  ------> right[2]=2  --\||     .
-// .                                           |||     .
-// .         elements           matchers       vvv     .
-// .                                         [ sink ]  .
-//
-// See Also:
-//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
-//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
-//   [2] "Ford-Fulkerson algorithm", Wikipedia,
-//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
-class MaxBipartiteMatchState {
- public:
-  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
-      : graph_(&graph),
-        left_(graph_->LhsSize(), kUnused),
-        right_(graph_->RhsSize(), kUnused) {
-  }
-
-  // Returns the edges of a maximal match, each in the form {left, right}.
-  ElementMatcherPairs Compute() {
-    // 'seen' is used for path finding { 0: unseen, 1: seen }.
-    ::std::vector<char> seen;
-    // Searches the residual flow graph for a path from each left node to
-    // the sink in the residual flow graph, and if one is found, add flow
-    // to the graph. It's okay to search through the left nodes once. The
-    // edge from the implicit source node to each previously-visited left
-    // node will have flow if that left node has any path to the sink
-    // whatsoever. Subsequent augmentations can only add flow to the
-    // network, and cannot take away that previous flow unit from the source.
-    // Since the source-to-left edge can only carry one flow unit (or,
-    // each element can be matched to only one matcher), there is no need
-    // to visit the left nodes more than once looking for augmented paths.
-    // The flow is known to be possible or impossible by looking at the
-    // node once.
-    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
-      // Reset the path-marking vector and try to find a path from
-      // source to sink starting at the left_[ilhs] node.
-      GTEST_CHECK_(left_[ilhs] == kUnused)
-          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
-      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
-      seen.assign(graph_->RhsSize(), 0);
-      TryAugment(ilhs, &seen);
-    }
-    ElementMatcherPairs result;
-    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
-      size_t irhs = left_[ilhs];
-      if (irhs == kUnused) continue;
-      result.push_back(ElementMatcherPair(ilhs, irhs));
-    }
-    return result;
-  }
-
- private:
-  static const size_t kUnused = static_cast<size_t>(-1);
-
-  // Perform a depth-first search from left node ilhs to the sink.  If a
-  // path is found, flow is added to the network by linking the left and
-  // right vector elements corresponding each segment of the path.
-  // Returns true if a path to sink was found, which means that a unit of
-  // flow was added to the network. The 'seen' vector elements correspond
-  // to right nodes and are marked to eliminate cycles from the search.
-  //
-  // Left nodes will only be explored at most once because they
-  // are accessible from at most one right node in the residual flow
-  // graph.
-  //
-  // Note that left_[ilhs] is the only element of left_ that TryAugment will
-  // potentially transition from kUnused to another value. Any other
-  // left_ element holding kUnused before TryAugment will be holding it
-  // when TryAugment returns.
-  //
-  bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
-    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
-      if ((*seen)[irhs])
-        continue;
-      if (!graph_->HasEdge(ilhs, irhs))
-        continue;
-      // There's an available edge from ilhs to irhs.
-      (*seen)[irhs] = 1;
-      // Next a search is performed to determine whether
-      // this edge is a dead end or leads to the sink.
-      //
-      // right_[irhs] == kUnused means that there is residual flow from
-      // right node irhs to the sink, so we can use that to finish this
-      // flow path and return success.
-      //
-      // Otherwise there is residual flow to some ilhs. We push flow
-      // along that path and call ourselves recursively to see if this
-      // ultimately leads to sink.
-      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
-        // Add flow from left_[ilhs] to right_[irhs].
-        left_[ilhs] = irhs;
-        right_[irhs] = ilhs;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  const MatchMatrix* graph_;  // not owned
-  // Each element of the left_ vector represents a left hand side node
-  // (i.e. an element) and each element of right_ is a right hand side
-  // node (i.e. a matcher). The values in the left_ vector indicate
-  // outflow from that node to a node on the the right_ side. The values
-  // in the right_ indicate inflow, and specify which left_ node is
-  // feeding that right_ node, if any. For example, left_[3] == 1 means
-  // there's a flow from element #3 to matcher #1. Such a flow would also
-  // be redundantly represented in the right_ vector as right_[1] == 3.
-  // Elements of left_ and right_ are either kUnused or mutually
-  // referent. Mutually referent means that left_[right_[i]] = i and
-  // right_[left_[i]] = i.
-  ::std::vector<size_t> left_;
-  ::std::vector<size_t> right_;
-
-  GTEST_DISALLOW_ASSIGN_(MaxBipartiteMatchState);
-};
-
-const size_t MaxBipartiteMatchState::kUnused;
-
-GTEST_API_ ElementMatcherPairs
-FindMaxBipartiteMatching(const MatchMatrix& g) {
-  return MaxBipartiteMatchState(g).Compute();
-}
-
-static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
-                                     ::std::ostream* stream) {
-  typedef ElementMatcherPairs::const_iterator Iter;
-  ::std::ostream& os = *stream;
-  os << "{";
-  const char *sep = "";
-  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
-    os << sep << "\n  ("
-       << "element #" << it->first << ", "
-       << "matcher #" << it->second << ")";
-    sep = ",";
-  }
-  os << "\n}";
-}
-
-// Tries to find a pairing, and explains the result.
-GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
-                            MatchResultListener* listener) {
-  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
-
-  size_t max_flow = matches.size();
-  bool result = (max_flow == matrix.RhsSize());
-
-  if (!result) {
-    if (listener->IsInterested()) {
-      *listener << "where no permutation of the elements can "
-                   "satisfy all matchers, and the closest match is "
-                << max_flow << " of " << matrix.RhsSize()
-                << " matchers with the pairings:\n";
-      LogElementMatcherPairVec(matches, listener->stream());
-    }
-    return false;
-  }
-
-  if (matches.size() > 1) {
-    if (listener->IsInterested()) {
-      const char *sep = "where:\n";
-      for (size_t mi = 0; mi < matches.size(); ++mi) {
-        *listener << sep << " - element #" << matches[mi].first
-                  << " is matched by matcher #" << matches[mi].second;
-        sep = ",\n";
-      }
-    }
-  }
-  return true;
-}
-
-bool MatchMatrix::NextGraph() {
-  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
-    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
-      char& b = matched_[SpaceIndex(ilhs, irhs)];
-      if (!b) {
-        b = 1;
-        return true;
-      }
-      b = 0;
-    }
-  }
-  return false;
-}
-
-void MatchMatrix::Randomize() {
-  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
-    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
-      char& b = matched_[SpaceIndex(ilhs, irhs)];
-      b = static_cast<char>(rand() & 1);  // NOLINT
-    }
-  }
-}
-
-string MatchMatrix::DebugString() const {
-  ::std::stringstream ss;
-  const char *sep = "";
-  for (size_t i = 0; i < LhsSize(); ++i) {
-    ss << sep;
-    for (size_t j = 0; j < RhsSize(); ++j) {
-      ss << HasEdge(i, j);
-    }
-    sep = ";";
-  }
-  return ss.str();
-}
-
-void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
-    ::std::ostream* os) const {
-  if (matcher_describers_.empty()) {
-    *os << "is empty";
-    return;
-  }
-  if (matcher_describers_.size() == 1) {
-    *os << "has " << Elements(1) << " and that element ";
-    matcher_describers_[0]->DescribeTo(os);
-    return;
-  }
-  *os << "has " << Elements(matcher_describers_.size())
-      << " and there exists some permutation of elements such that:\n";
-  const char* sep = "";
-  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep << " - element #" << i << " ";
-    matcher_describers_[i]->DescribeTo(os);
-    sep = ", and\n";
-  }
-}
-
-void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
-    ::std::ostream* os) const {
-  if (matcher_describers_.empty()) {
-    *os << "isn't empty";
-    return;
-  }
-  if (matcher_describers_.size() == 1) {
-    *os << "doesn't have " << Elements(1)
-        << ", or has " << Elements(1) << " that ";
-    matcher_describers_[0]->DescribeNegationTo(os);
-    return;
-  }
-  *os << "doesn't have " << Elements(matcher_describers_.size())
-      << ", or there exists no permutation of elements such that:\n";
-  const char* sep = "";
-  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep << " - element #" << i << " ";
-    matcher_describers_[i]->DescribeTo(os);
-    sep = ", and\n";
-  }
-}
-
-// Checks that all matchers match at least one element, and that all
-// elements match at least one matcher. This enables faster matching
-// and better error reporting.
-// Returns false, writing an explanation to 'listener', if and only
-// if the success criteria are not met.
-bool UnorderedElementsAreMatcherImplBase::
-VerifyAllElementsAndMatchersAreMatched(
-    const ::std::vector<string>& element_printouts,
-    const MatchMatrix& matrix,
-    MatchResultListener* listener) const {
-  bool result = true;
-  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
-  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
-
-  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
-    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
-      char matched = matrix.HasEdge(ilhs, irhs);
-      element_matched[ilhs] |= matched;
-      matcher_matched[irhs] |= matched;
-    }
-  }
-
-  {
-    const char* sep =
-        "where the following matchers don't match any elements:\n";
-    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
-      if (matcher_matched[mi])
-        continue;
-      result = false;
-      if (listener->IsInterested()) {
-        *listener << sep << "matcher #" << mi << ": ";
-        matcher_describers_[mi]->DescribeTo(listener->stream());
-        sep = ",\n";
-      }
-    }
-  }
-
-  {
-    const char* sep =
-        "where the following elements don't match any matchers:\n";
-    const char* outer_sep = "";
-    if (!result) {
-      outer_sep = "\nand ";
-    }
-    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
-      if (element_matched[ei])
-        continue;
-      result = false;
-      if (listener->IsInterested()) {
-        *listener << outer_sep << sep << "element #" << ei << ": "
-                  << element_printouts[ei];
-        sep = ",\n";
-        outer_sep = "";
-      }
-    }
-  }
-  return result;
-}
-
-}  // namespace internal
-}  // namespace testing
-// Copyright 2007, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements the spec builder syntax (ON_CALL and
-// EXPECT_CALL).
-
-
-#include <stdlib.h>
-#include <iostream>  // NOLINT
-#include <map>
-#include <set>
-#include <string>
-
-#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
-# include <unistd.h>  // NOLINT
-#endif
-
-namespace testing {
-namespace internal {
-
-// Protects the mock object registry (in class Mock), all function
-// mockers, and all expectations.
-GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
-
-// Logs a message including file and line number information.
-GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
-                                const char* file, int line,
-                                const string& message) {
-  ::std::ostringstream s;
-  s << file << ":" << line << ": " << message << ::std::endl;
-  Log(severity, s.str(), 0);
-}
-
-// Constructs an ExpectationBase object.
-ExpectationBase::ExpectationBase(const char* a_file,
-                                 int a_line,
-                                 const string& a_source_text)
-    : file_(a_file),
-      line_(a_line),
-      source_text_(a_source_text),
-      cardinality_specified_(false),
-      cardinality_(Exactly(1)),
-      call_count_(0),
-      retired_(false),
-      extra_matcher_specified_(false),
-      repeated_action_specified_(false),
-      retires_on_saturation_(false),
-      last_clause_(kNone),
-      action_count_checked_(false) {}
-
-// Destructs an ExpectationBase object.
-ExpectationBase::~ExpectationBase() {}
-
-// Explicitly specifies the cardinality of this expectation.  Used by
-// the subclasses to implement the .Times() clause.
-void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
-  cardinality_specified_ = true;
-  cardinality_ = a_cardinality;
-}
-
-// Retires all pre-requisites of this expectation.
-void ExpectationBase::RetireAllPreRequisites()
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  if (is_retired()) {
-    // We can take this short-cut as we never retire an expectation
-    // until we have retired all its pre-requisites.
-    return;
-  }
-
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    ExpectationBase* const prerequisite = it->expectation_base().get();
-    if (!prerequisite->is_retired()) {
-      prerequisite->RetireAllPreRequisites();
-      prerequisite->Retire();
-    }
-  }
-}
-
-// Returns true iff all pre-requisites of this expectation have been
-// satisfied.
-bool ExpectationBase::AllPrerequisitesAreSatisfied() const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    if (!(it->expectation_base()->IsSatisfied()) ||
-        !(it->expectation_base()->AllPrerequisitesAreSatisfied()))
-      return false;
-  }
-  return true;
-}
-
-// Adds unsatisfied pre-requisites of this expectation to 'result'.
-void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    if (it->expectation_base()->IsSatisfied()) {
-      // If *it is satisfied and has a call count of 0, some of its
-      // pre-requisites may not be satisfied yet.
-      if (it->expectation_base()->call_count_ == 0) {
-        it->expectation_base()->FindUnsatisfiedPrerequisites(result);
-      }
-    } else {
-      // Now that we know *it is unsatisfied, we are not so interested
-      // in whether its pre-requisites are satisfied.  Therefore we
-      // don't recursively call FindUnsatisfiedPrerequisites() here.
-      *result += *it;
-    }
-  }
-}
-
-// Describes how many times a function call matching this
-// expectation has occurred.
-void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-
-  // Describes how many times the function is expected to be called.
-  *os << "         Expected: to be ";
-  cardinality().DescribeTo(os);
-  *os << "\n           Actual: ";
-  Cardinality::DescribeActualCallCountTo(call_count(), os);
-
-  // Describes the state of the expectation (e.g. is it satisfied?
-  // is it active?).
-  *os << " - " << (IsOverSaturated() ? "over-saturated" :
-                   IsSaturated() ? "saturated" :
-                   IsSatisfied() ? "satisfied" : "unsatisfied")
-      << " and "
-      << (is_retired() ? "retired" : "active");
-}
-
-// Checks the action count (i.e. the number of WillOnce() and
-// WillRepeatedly() clauses) against the cardinality if this hasn't
-// been done before.  Prints a warning if there are too many or too
-// few actions.
-void ExpectationBase::CheckActionCountIfNotDone() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  bool should_check = false;
-  {
-    MutexLock l(&mutex_);
-    if (!action_count_checked_) {
-      action_count_checked_ = true;
-      should_check = true;
-    }
-  }
-
-  if (should_check) {
-    if (!cardinality_specified_) {
-      // The cardinality was inferred - no need to check the action
-      // count against it.
-      return;
-    }
-
-    // The cardinality was explicitly specified.
-    const int action_count = static_cast<int>(untyped_actions_.size());
-    const int upper_bound = cardinality().ConservativeUpperBound();
-    const int lower_bound = cardinality().ConservativeLowerBound();
-    bool too_many;  // True if there are too many actions, or false
-    // if there are too few.
-    if (action_count > upper_bound ||
-        (action_count == upper_bound && repeated_action_specified_)) {
-      too_many = true;
-    } else if (0 < action_count && action_count < lower_bound &&
-               !repeated_action_specified_) {
-      too_many = false;
-    } else {
-      return;
-    }
-
-    ::std::stringstream ss;
-    DescribeLocationTo(&ss);
-    ss << "Too " << (too_many ? "many" : "few")
-       << " actions specified in " << source_text() << "...\n"
-       << "Expected to be ";
-    cardinality().DescribeTo(&ss);
-    ss << ", but has " << (too_many ? "" : "only ")
-       << action_count << " WillOnce()"
-       << (action_count == 1 ? "" : "s");
-    if (repeated_action_specified_) {
-      ss << " and a WillRepeatedly()";
-    }
-    ss << ".";
-    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
-  }
-}
-
-// Implements the .Times() clause.
-void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
-  if (last_clause_ == kTimes) {
-    ExpectSpecProperty(false,
-                       ".Times() cannot appear "
-                       "more than once in an EXPECT_CALL().");
-  } else {
-    ExpectSpecProperty(last_clause_ < kTimes,
-                       ".Times() cannot appear after "
-                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
-                       "or .RetiresOnSaturation().");
-  }
-  last_clause_ = kTimes;
-
-  SpecifyCardinality(a_cardinality);
-}
-
-// Points to the implicit sequence introduced by a living InSequence
-// object (if any) in the current thread or NULL.
-GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
-
-// Reports an uninteresting call (whose description is in msg) in the
-// manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const string& msg) {
-  // Include a stack trace only if --gmock_verbose=info is specified.
-  const int stack_frames_to_skip =
-      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
-  switch (reaction) {
-    case kAllow:
-      Log(kInfo, msg, stack_frames_to_skip);
-      break;
-    case kWarn:
-      Log(kWarning,
-          msg +
-          "\nNOTE: You can safely ignore the above warning unless this "
-          "call should not happen.  Do not suppress it by blindly adding "
-          "an EXPECT_CALL() if you don't mean to enforce the call.  "
-          "See http://code.google.com/p/googlemock/wiki/CookBook#"
-          "Knowing_When_to_Expect for details.\n",
-          stack_frames_to_skip);
-      break;
-    default:  // FAIL
-      Expect(false, NULL, -1, msg);
-  }
-}
-
-UntypedFunctionMockerBase::UntypedFunctionMockerBase()
-    : mock_obj_(NULL), name_("") {}
-
-UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
-
-// Sets the mock object this mock method belongs to, and registers
-// this information in the global mock registry.  Will be called
-// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
-// method.
-void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  {
-    MutexLock l(&g_gmock_mutex);
-    mock_obj_ = mock_obj;
-  }
-  Mock::Register(mock_obj, this);
-}
-
-// Sets the mock object this mock method belongs to, and sets the name
-// of the mock function.  Will be called upon each invocation of this
-// mock function.
-void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
-                                                const char* name)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  // We protect name_ under g_gmock_mutex in case this mock function
-  // is called from two threads concurrently.
-  MutexLock l(&g_gmock_mutex);
-  mock_obj_ = mock_obj;
-  name_ = name;
-}
-
-// Returns the name of the function being mocked.  Must be called
-// after RegisterOwner() or SetOwnerAndName() has been called.
-const void* UntypedFunctionMockerBase::MockObject() const
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  const void* mock_obj;
-  {
-    // We protect mock_obj_ under g_gmock_mutex in case this mock
-    // function is called from two threads concurrently.
-    MutexLock l(&g_gmock_mutex);
-    Assert(mock_obj_ != NULL, __FILE__, __LINE__,
-           "MockObject() must not be called before RegisterOwner() or "
-           "SetOwnerAndName() has been called.");
-    mock_obj = mock_obj_;
-  }
-  return mock_obj;
-}
-
-// Returns the name of this mock method.  Must be called after
-// SetOwnerAndName() has been called.
-const char* UntypedFunctionMockerBase::Name() const
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  const char* name;
-  {
-    // We protect name_ under g_gmock_mutex in case this mock
-    // function is called from two threads concurrently.
-    MutexLock l(&g_gmock_mutex);
-    Assert(name_ != NULL, __FILE__, __LINE__,
-           "Name() must not be called before SetOwnerAndName() has "
-           "been called.");
-    name = name_;
-  }
-  return name;
-}
-
-// Calculates the result of invoking this mock function with the given
-// arguments, prints it, and returns it.  The caller is responsible
-// for deleting the result.
-UntypedActionResultHolderBase*
-UntypedFunctionMockerBase::UntypedInvokeWith(const void* const untyped_args)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  if (untyped_expectations_.size() == 0) {
-    // No expectation is set on this mock method - we have an
-    // uninteresting call.
-
-    // We must get Google Mock's reaction on uninteresting calls
-    // made on this mock object BEFORE performing the action,
-    // because the action may DELETE the mock object and make the
-    // following expression meaningless.
-    const CallReaction reaction =
-        Mock::GetReactionOnUninterestingCalls(MockObject());
-
-    // True iff we need to print this call's arguments and return
-    // value.  This definition must be kept in sync with
-    // the behavior of ReportUninterestingCall().
-    const bool need_to_report_uninteresting_call =
-        // If the user allows this uninteresting call, we print it
-        // only when he wants informational messages.
-        reaction == kAllow ? LogIsVisible(kInfo) :
-        // If the user wants this to be a warning, we print it only
-        // when he wants to see warnings.
-        reaction == kWarn ? LogIsVisible(kWarning) :
-        // Otherwise, the user wants this to be an error, and we
-        // should always print detailed information in the error.
-        true;
-
-    if (!need_to_report_uninteresting_call) {
-      // Perform the action without printing the call information.
-      return this->UntypedPerformDefaultAction(untyped_args, "");
-    }
-
-    // Warns about the uninteresting call.
-    ::std::stringstream ss;
-    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
-
-    // Calculates the function result.
-    UntypedActionResultHolderBase* const result =
-        this->UntypedPerformDefaultAction(untyped_args, ss.str());
-
-    // Prints the function result.
-    if (result != NULL)
-      result->PrintAsActionResult(&ss);
-
-    ReportUninterestingCall(reaction, ss.str());
-    return result;
-  }
-
-  bool is_excessive = false;
-  ::std::stringstream ss;
-  ::std::stringstream why;
-  ::std::stringstream loc;
-  const void* untyped_action = NULL;
-
-  // The UntypedFindMatchingExpectation() function acquires and
-  // releases g_gmock_mutex.
-  const ExpectationBase* const untyped_expectation =
-      this->UntypedFindMatchingExpectation(
-          untyped_args, &untyped_action, &is_excessive,
-          &ss, &why);
-  const bool found = untyped_expectation != NULL;
-
-  // True iff we need to print the call's arguments and return value.
-  // This definition must be kept in sync with the uses of Expect()
-  // and Log() in this function.
-  const bool need_to_report_call =
-      !found || is_excessive || LogIsVisible(kInfo);
-  if (!need_to_report_call) {
-    // Perform the action without printing the call information.
-    return
-        untyped_action == NULL ?
-        this->UntypedPerformDefaultAction(untyped_args, "") :
-        this->UntypedPerformAction(untyped_action, untyped_args);
-  }
-
-  ss << "    Function call: " << Name();
-  this->UntypedPrintArgs(untyped_args, &ss);
-
-  // In case the action deletes a piece of the expectation, we
-  // generate the message beforehand.
-  if (found && !is_excessive) {
-    untyped_expectation->DescribeLocationTo(&loc);
-  }
-
-  UntypedActionResultHolderBase* const result =
-      untyped_action == NULL ?
-      this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
-      this->UntypedPerformAction(untyped_action, untyped_args);
-  if (result != NULL)
-    result->PrintAsActionResult(&ss);
-  ss << "\n" << why.str();
-
-  if (!found) {
-    // No expectation matches this call - reports a failure.
-    Expect(false, NULL, -1, ss.str());
-  } else if (is_excessive) {
-    // We had an upper-bound violation and the failure message is in ss.
-    Expect(false, untyped_expectation->file(),
-           untyped_expectation->line(), ss.str());
-  } else {
-    // We had an expected call and the matching expectation is
-    // described in ss.
-    Log(kInfo, loc.str() + ss.str(), 2);
-  }
-
-  return result;
-}
-
-// Returns an Expectation object that references and co-owns exp,
-// which must be an expectation on this mock function.
-Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
-       it != untyped_expectations_.end(); ++it) {
-    if (it->get() == exp) {
-      return Expectation(*it);
-    }
-  }
-
-  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
-  return Expectation();
-  // The above statement is just to make the code compile, and will
-  // never be executed.
-}
-
-// Verifies that all expectations on this mock function have been
-// satisfied.  Reports one or more Google Test non-fatal failures
-// and returns false if not.
-bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  bool expectations_met = true;
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
-       it != untyped_expectations_.end(); ++it) {
-    ExpectationBase* const untyped_expectation = it->get();
-    if (untyped_expectation->IsOverSaturated()) {
-      // There was an upper-bound violation.  Since the error was
-      // already reported when it occurred, there is no need to do
-      // anything here.
-      expectations_met = false;
-    } else if (!untyped_expectation->IsSatisfied()) {
-      expectations_met = false;
-      ::std::stringstream ss;
-      ss  << "Actual function call count doesn't match "
-          << untyped_expectation->source_text() << "...\n";
-      // No need to show the source file location of the expectation
-      // in the description, as the Expect() call that follows already
-      // takes care of it.
-      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
-      untyped_expectation->DescribeCallCountTo(&ss);
-      Expect(false, untyped_expectation->file(),
-             untyped_expectation->line(), ss.str());
-    }
-  }
-
-  // Deleting our expectations may trigger other mock objects to be deleted, for
-  // example if an action contains a reference counted smart pointer to that
-  // mock object, and that is the last reference. So if we delete our
-  // expectations within the context of the global mutex we may deadlock when
-  // this method is called again. Instead, make a copy of the set of
-  // expectations to delete, clear our set within the mutex, and then clear the
-  // copied set outside of it.
-  UntypedExpectations expectations_to_delete;
-  untyped_expectations_.swap(expectations_to_delete);
-
-  g_gmock_mutex.Unlock();
-  expectations_to_delete.clear();
-  g_gmock_mutex.Lock();
-
-  return expectations_met;
-}
-
-}  // namespace internal
-
-// Class Mock.
-
-namespace {
-
-typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
-
-// The current state of a mock object.  Such information is needed for
-// detecting leaked mock objects and explicitly verifying a mock's
-// expectations.
-struct MockObjectState {
-  MockObjectState()
-      : first_used_file(NULL), first_used_line(-1), leakable(false) {}
-
-  // Where in the source file an ON_CALL or EXPECT_CALL is first
-  // invoked on this mock object.
-  const char* first_used_file;
-  int first_used_line;
-  ::std::string first_used_test_case;
-  ::std::string first_used_test;
-  bool leakable;  // true iff it's OK to leak the object.
-  FunctionMockers function_mockers;  // All registered methods of the object.
-};
-
-// A global registry holding the state of all mock objects that are
-// alive.  A mock object is added to this registry the first time
-// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
-// is removed from the registry in the mock object's destructor.
-class MockObjectRegistry {
- public:
-  // Maps a mock object (identified by its address) to its state.
-  typedef std::map<const void*, MockObjectState> StateMap;
-
-  // This destructor will be called when a program exits, after all
-  // tests in it have been run.  By then, there should be no mock
-  // object alive.  Therefore we report any living object as test
-  // failure, unless the user explicitly asked us to ignore it.
-  ~MockObjectRegistry() {
-    // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is
-    // a macro.
-
-    if (!GMOCK_FLAG(catch_leaked_mocks))
-      return;
-
-    int leaked_count = 0;
-    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
-         ++it) {
-      if (it->second.leakable)  // The user said it's fine to leak this object.
-        continue;
-
-      // TODO(wan@google.com): Print the type of the leaked object.
-      // This can help the user identify the leaked object.
-      std::cout << "\n";
-      const MockObjectState& state = it->second;
-      std::cout << internal::FormatFileLocation(state.first_used_file,
-                                                state.first_used_line);
-      std::cout << " ERROR: this mock object";
-      if (state.first_used_test != "") {
-        std::cout << " (used in test " << state.first_used_test_case << "."
-             << state.first_used_test << ")";
-      }
-      std::cout << " should be deleted but never is. Its address is @"
-           << it->first << ".";
-      leaked_count++;
-    }
-    if (leaked_count > 0) {
-      std::cout << "\nERROR: " << leaked_count
-           << " leaked mock " << (leaked_count == 1 ? "object" : "objects")
-           << " found at program exit.\n";
-      std::cout.flush();
-      ::std::cerr.flush();
-      // RUN_ALL_TESTS() has already returned when this destructor is
-      // called.  Therefore we cannot use the normal Google Test
-      // failure reporting mechanism.
-      _exit(1);  // We cannot call exit() as it is not reentrant and
-                 // may already have been called.
-    }
-  }
-
-  StateMap& states() { return states_; }
-
- private:
-  StateMap states_;
-};
-
-// Protected by g_gmock_mutex.
-MockObjectRegistry g_mock_object_registry;
-
-// Maps a mock object to the reaction Google Mock should have when an
-// uninteresting method is called.  Protected by g_gmock_mutex.
-std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
-
-// Sets the reaction Google Mock should have when an uninteresting
-// method of the given mock object is called.
-void SetReactionOnUninterestingCalls(const void* mock_obj,
-                                     internal::CallReaction reaction)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction[mock_obj] = reaction;
-}
-
-}  // namespace
-
-// Tells Google Mock to allow uninteresting calls on the given mock
-// object.
-void Mock::AllowUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
-}
-
-// Tells Google Mock to warn the user about uninteresting calls on the
-// given mock object.
-void Mock::WarnUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
-}
-
-// Tells Google Mock to fail uninteresting calls on the given mock
-// object.
-void Mock::FailUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
-}
-
-// Tells Google Mock the given mock object is being destroyed and its
-// entry in the call-reaction table should be removed.
-void Mock::UnregisterCallReaction(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction.erase(mock_obj);
-}
-
-// Returns the reaction Google Mock will have on uninteresting calls
-// made on the given mock object.
-internal::CallReaction Mock::GetReactionOnUninterestingCalls(
-    const void* mock_obj)
-        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
-      internal::kDefault : g_uninteresting_call_reaction[mock_obj];
-}
-
-// Tells Google Mock to ignore mock_obj when checking for leaked mock
-// objects.
-void Mock::AllowLeak(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_mock_object_registry.states()[mock_obj].leakable = true;
-}
-
-// Verifies and clears all expectations on the given mock object.  If
-// the expectations aren't satisfied, generates one or more Google
-// Test non-fatal failures and returns false.
-bool Mock::VerifyAndClearExpectations(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  return VerifyAndClearExpectationsLocked(mock_obj);
-}
-
-// Verifies all expectations on the given mock object and clears its
-// default actions and expectations.  Returns true iff the
-// verification was successful.
-bool Mock::VerifyAndClear(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  ClearDefaultActionsLocked(mock_obj);
-  return VerifyAndClearExpectationsLocked(mock_obj);
-}
-
-// Verifies and clears all expectations on the given mock object.  If
-// the expectations aren't satisfied, generates one or more Google
-// Test non-fatal failures and returns false.
-bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-  if (g_mock_object_registry.states().count(mock_obj) == 0) {
-    // No EXPECT_CALL() was set on the given mock object.
-    return true;
-  }
-
-  // Verifies and clears the expectations on each mock method in the
-  // given mock object.
-  bool expectations_met = true;
-  FunctionMockers& mockers =
-      g_mock_object_registry.states()[mock_obj].function_mockers;
-  for (FunctionMockers::const_iterator it = mockers.begin();
-       it != mockers.end(); ++it) {
-    if (!(*it)->VerifyAndClearExpectationsLocked()) {
-      expectations_met = false;
-    }
-  }
-
-  // We don't clear the content of mockers, as they may still be
-  // needed by ClearDefaultActionsLocked().
-  return expectations_met;
-}
-
-// Registers a mock object and a mock method it owns.
-void Mock::Register(const void* mock_obj,
-                    internal::UntypedFunctionMockerBase* mocker)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
-}
-
-// Tells Google Mock where in the source code mock_obj is used in an
-// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
-// information helps the user identify which object it is.
-void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
-                                           const char* file, int line)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
-  if (state.first_used_file == NULL) {
-    state.first_used_file = file;
-    state.first_used_line = line;
-    const TestInfo* const test_info =
-        UnitTest::GetInstance()->current_test_info();
-    if (test_info != NULL) {
-      // TODO(wan@google.com): record the test case name when the
-      // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
-      // TearDownTestCase().
-      state.first_used_test_case = test_info->test_case_name();
-      state.first_used_test = test_info->name();
-    }
-  }
-}
-
-// Unregisters a mock method; removes the owning mock object from the
-// registry when the last mock method associated with it has been
-// unregistered.  This is called only in the destructor of
-// FunctionMockerBase.
-void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-  for (MockObjectRegistry::StateMap::iterator it =
-           g_mock_object_registry.states().begin();
-       it != g_mock_object_registry.states().end(); ++it) {
-    FunctionMockers& mockers = it->second.function_mockers;
-    if (mockers.erase(mocker) > 0) {
-      // mocker was in mockers and has been just removed.
-      if (mockers.empty()) {
-        g_mock_object_registry.states().erase(it);
-      }
-      return;
-    }
-  }
-}
-
-// Clears all ON_CALL()s set on the given mock object.
-void Mock::ClearDefaultActionsLocked(void* mock_obj)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-
-  if (g_mock_object_registry.states().count(mock_obj) == 0) {
-    // No ON_CALL() was set on the given mock object.
-    return;
-  }
-
-  // Clears the default actions for each mock method in the given mock
-  // object.
-  FunctionMockers& mockers =
-      g_mock_object_registry.states()[mock_obj].function_mockers;
-  for (FunctionMockers::const_iterator it = mockers.begin();
-       it != mockers.end(); ++it) {
-    (*it)->ClearDefaultActionsLocked();
-  }
-
-  // We don't clear the content of mockers, as they may still be
-  // needed by VerifyAndClearExpectationsLocked().
-}
-
-Expectation::Expectation() {}
-
-Expectation::Expectation(
-    const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
-    : expectation_base_(an_expectation_base) {}
-
-Expectation::~Expectation() {}
-
-// Adds an expectation to a sequence.
-void Sequence::AddExpectation(const Expectation& expectation) const {
-  if (*last_expectation_ != expectation) {
-    if (last_expectation_->expectation_base() != NULL) {
-      expectation.expectation_base()->immediate_prerequisites_
-          += *last_expectation_;
-    }
-    *last_expectation_ = expectation;
-  }
-}
-
-// Creates the implicit sequence if there isn't one.
-InSequence::InSequence() {
-  if (internal::g_gmock_implicit_sequence.get() == NULL) {
-    internal::g_gmock_implicit_sequence.set(new Sequence);
-    sequence_created_ = true;
-  } else {
-    sequence_created_ = false;
-  }
-}
-
-// Deletes the implicit sequence if it was created by the constructor
-// of this object.
-InSequence::~InSequence() {
-  if (sequence_created_) {
-    delete internal::g_gmock_implicit_sequence.get();
-    internal::g_gmock_implicit_sequence.set(NULL);
-  }
-}
-
-}  // namespace testing
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-namespace testing {
-
-// TODO(wan@google.com): support using environment variables to
-// control the flag values, like what Google Test does.
-
-GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
-                   "true iff Google Mock should report leaked mock objects "
-                   "as failures.");
-
-GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
-                     "Controls how verbose Google Mock's output is."
-                     "  Valid values:\n"
-                     "  info    - prints all messages.\n"
-                     "  warning - prints warnings and errors.\n"
-                     "  error   - prints errors only.");
-
-namespace internal {
-
-// Parses a string as a command line flag.  The string should have the
-// format "--gmock_flag=value".  When def_optional is true, the
-// "=value" part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-static const char* ParseGoogleMockFlagValue(const char* str,
-                                            const char* flag,
-                                            bool def_optional) {
-  // str and flag must not be NULL.
-  if (str == NULL || flag == NULL) return NULL;
-
-  // The flag must start with "--gmock_".
-  const std::string flag_str = std::string("--gmock_") + flag;
-  const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
-
-  // Skips the flag name.
-  const char* flag_end = str + flag_len;
-
-  // When def_optional is true, it's OK to not have a "=value" part.
-  if (def_optional && (flag_end[0] == '\0')) {
-    return flag_end;
-  }
-
-  // If def_optional is true and there are more characters after the
-  // flag name, or if def_optional is false, there must be a '=' after
-  // the flag name.
-  if (flag_end[0] != '=') return NULL;
-
-  // Returns the string after "=".
-  return flag_end + 1;
-}
-
-// Parses a string for a Google Mock bool flag, in the form of
-// "--gmock_flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
-                                    bool* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Converts the string value to a bool.
-  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
-  return true;
-}
-
-// Parses a string for a Google Mock string flag, in the form of
-// "--gmock_flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-template <typename String>
-static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
-                                      String* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Sets *value to the value of the flag.
-  *value = value_str;
-  return true;
-}
-
-// The internal implementation of InitGoogleMock().
-//
-// The type parameter CharType can be instantiated to either char or
-// wchar_t.
-template <typename CharType>
-void InitGoogleMockImpl(int* argc, CharType** argv) {
-  // Makes sure Google Test is initialized.  InitGoogleTest() is
-  // idempotent, so it's fine if the user has already called it.
-  InitGoogleTest(argc, argv);
-  if (*argc <= 0) return;
-
-  for (int i = 1; i != *argc; i++) {
-    const std::string arg_string = StreamableToString(argv[i]);
-    const char* const arg = arg_string.c_str();
-
-    // Do we see a Google Mock flag?
-    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
-                                &GMOCK_FLAG(catch_leaked_mocks)) ||
-        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
-      // Yes.  Shift the remainder of the argv list left by one.  Note
-      // that argv has (*argc + 1) elements, the last one always being
-      // NULL.  The following loop moves the trailing NULL element as
-      // well.
-      for (int j = i; j != *argc; j++) {
-        argv[j] = argv[j + 1];
-      }
-
-      // Decrements the argument count.
-      (*argc)--;
-
-      // We also need to decrement the iterator as we just removed
-      // an element.
-      i--;
-    }
-  }
-}
-
-}  // namespace internal
-
-// Initializes Google Mock.  This must be called before running the
-// tests.  In particular, it parses a command line for the flags that
-// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
-// removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Mock flag variables are
-// updated.
-//
-// Since Google Test is needed for Google Mock to work, this function
-// also initializes Google Test and parses its flags, if that hasn't
-// been done.
-GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
-  internal::InitGoogleMockImpl(argc, argv);
-}
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
-  internal::InitGoogleMockImpl(argc, argv);
-}
-
-}  // namespace testing
diff --git a/opensfm/src/third_party/gtest/gmock_main.cc b/opensfm/src/third_party/gtest/gmock_main.cc
deleted file mode 100644
index 9b2f64d41..000000000
--- a/opensfm/src/third_party/gtest/gmock_main.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2008, Google Inc.
-// 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.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include <iostream>
-#include "gflags/gflags.h"
-#include "glog/logging.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-// NOTE(keir): This flag is normally part of gtest within Google but isn't in
-// the open source Google Test, since it is build-system dependent. However for
-// Ceres this is needed for our tests. Add the new flag here.
-DEFINE_string(test_srcdir, "", "The location of the source code.");
-
-// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
-// causes a link error when _tmain is defined in a static library and UNICODE
-// is enabled. For this reason instead of _tmain, main function is used on
-// Windows. See the following link to track the current status of this bug:
-// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464  // NOLINT
-#if GTEST_OS_WINDOWS_MOBILE
-# include <tchar.h>  // NOLINT
-
-int _tmain(int argc, TCHAR** argv) {
-#else
-int main(int argc, char** argv) {
-#endif  // GTEST_OS_WINDOWS_MOBILE
-  google::InitGoogleLogging(argv[0]);
-  // Since Google Mock depends on Google Test, InitGoogleMock() is
-  // also responsible for initializing Google Test.  Therefore there's
-  // no need for calling testing::InitGoogleTest() separately.
-  testing::InitGoogleMock(&argc, argv);
-  // On Windows, gtest passes additional non-gflags command line flags to
-  // death-tests, specifically --gtest_filter & --gtest_internal_run_death_test
-  // in order that these unknown (to gflags) flags do not invoke an error in
-  // gflags, InitGoogleTest() (called by InitGoogleMock()) must be called
-  // before ParseCommandLineFlags() to handle & remove them before gflags
-  // parses the remaining flags.
-  CERES_GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  return RUN_ALL_TESTS();
-}

From 177d14643eb416925178b1053b017b05f4ae46bd Mon Sep 17 00:00:00 2001
From: generatedunixname89002005279527
 <generatedunixname89002005279527@meta.com>
Date: Wed, 16 Oct 2024 01:42:03 -0700
Subject: [PATCH 091/235] fbcode/mapillary/opensfm/opensfm/src

Reviewed By: bal-a

Differential Revision: D63971477

fbshipit-source-id: f646c9390378310e540b18945ed406bc966f4649
---
 opensfm/src/debug_c_extension.cc | 28 ----------------------------
 opensfm/src/testing_main.cc      | 11 -----------
 2 files changed, 39 deletions(-)
 delete mode 100644 opensfm/src/debug_c_extension.cc
 delete mode 100644 opensfm/src/testing_main.cc

diff --git a/opensfm/src/debug_c_extension.cc b/opensfm/src/debug_c_extension.cc
deleted file mode 100644
index f20318119..000000000
--- a/opensfm/src/debug_c_extension.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Tool to debug c extensions with a c debugger.
-//
-// How to use it:
-//
-//   1. Write a module in python that calls the extension you want to debug.
-//      Make sure the extension code is called at import time.
-//
-//   2. Build opensfm/cmake_build in Debug mode.
-//
-//   3. Tell the debugger to run
-//
-//        ./debug_c_extension module
-//
-//      where module is the name of the module that you wrote.
-
-#include <pybind11/embed.h>
-#include <iostream>
-namespace py = pybind11;
-
-int main(int argc, char *argv[]) {
-  py::scoped_interpreter guard{};
-
-  if (argc != 2) {
-    std::cout << "Usage: " << argv[0] << " module" << std::endl;
-  } else {
-    py::module sys = py::module::import(argv[1]);
-  }
-}
diff --git a/opensfm/src/testing_main.cc b/opensfm/src/testing_main.cc
deleted file mode 100644
index c5bfdd004..000000000
--- a/opensfm/src/testing_main.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-  google::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
-
-  return RUN_ALL_TESTS();
-}

From 444e362ed906597776e01ec67e72a3b455852f79 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005279527
 <generatedunixname89002005279527@meta.com>
Date: Wed, 16 Oct 2024 01:42:37 -0700
Subject: [PATCH 092/235] 
 fbcode/mapillary/opensfm/opensfm/src/third_party/vlfeat/vl

Reviewed By: bal-a

Differential Revision: D63971206

fbshipit-source-id: bc3487af5506ee36768712541eb3f546234a22b1
---
 opensfm/src/third_party/vlfeat/vl/aib.c       |  643 ----
 opensfm/src/third_party/vlfeat/vl/aib.h       |  134 -
 opensfm/src/third_party/vlfeat/vl/array.c     |  206 -
 opensfm/src/third_party/vlfeat/vl/array.h     |  105 -
 opensfm/src/third_party/vlfeat/vl/covdet.c    | 3400 -----------------
 opensfm/src/third_party/vlfeat/vl/covdet.h    |  263 --
 opensfm/src/third_party/vlfeat/vl/dsift.c     |  775 ----
 opensfm/src/third_party/vlfeat/vl/dsift.h     |  354 --
 opensfm/src/third_party/vlfeat/vl/fisher.c    |  586 ---
 opensfm/src/third_party/vlfeat/vl/fisher.h    |   57 -
 opensfm/src/third_party/vlfeat/vl/float.h     |  116 -
 opensfm/src/third_party/vlfeat/vl/generic.c   | 1679 --------
 opensfm/src/third_party/vlfeat/vl/generic.h   |  213 --
 .../src/third_party/vlfeat/vl/getopt_long.c   |  326 --
 .../src/third_party/vlfeat/vl/getopt_long.h   |   43 -
 opensfm/src/third_party/vlfeat/vl/gmm.c       | 1709 ---------
 opensfm/src/third_party/vlfeat/vl/gmm.h       |  149 -
 opensfm/src/third_party/vlfeat/vl/heap-def.h  |  464 ---
 opensfm/src/third_party/vlfeat/vl/hikmeans.c  |  371 --
 opensfm/src/third_party/vlfeat/vl/hikmeans.h  |   80 -
 opensfm/src/third_party/vlfeat/vl/hog.c       | 1072 ------
 opensfm/src/third_party/vlfeat/vl/hog.h       |   89 -
 opensfm/src/third_party/vlfeat/vl/homkermap.c |  580 ---
 opensfm/src/third_party/vlfeat/vl/homkermap.h |   86 -
 opensfm/src/third_party/vlfeat/vl/host.c      |  586 ---
 opensfm/src/third_party/vlfeat/vl/host.h      |  662 ----
 opensfm/src/third_party/vlfeat/vl/ikmeans.c   |  297 --
 opensfm/src/third_party/vlfeat/vl/ikmeans.h   |   87 -
 opensfm/src/third_party/vlfeat/vl/imopv.c     | 1074 ------
 opensfm/src/third_party/vlfeat/vl/imopv.h     |  164 -
 .../src/third_party/vlfeat/vl/imopv_sse2.c    |  289 --
 .../src/third_party/vlfeat/vl/imopv_sse2.h    |   54 -
 opensfm/src/third_party/vlfeat/vl/kdtree.c    | 1082 ------
 opensfm/src/third_party/vlfeat/vl/kdtree.h    |  185 -
 opensfm/src/third_party/vlfeat/vl/kmeans.c    | 2101 ----------
 opensfm/src/third_party/vlfeat/vl/kmeans.h    |  435 ---
 opensfm/src/third_party/vlfeat/vl/lbp.c       |  347 --
 opensfm/src/third_party/vlfeat/vl/lbp.h       |   44 -
 opensfm/src/third_party/vlfeat/vl/liop.c      |  641 ----
 opensfm/src/third_party/vlfeat/vl/liop.h      |   78 -
 opensfm/src/third_party/vlfeat/vl/mathop.c    | 1032 -----
 opensfm/src/third_party/vlfeat/vl/mathop.h    |  719 ----
 .../src/third_party/vlfeat/vl/mathop_avx.c    |  275 --
 .../src/third_party/vlfeat/vl/mathop_avx.h    |   61 -
 .../src/third_party/vlfeat/vl/mathop_sse2.c   |  564 ---
 .../src/third_party/vlfeat/vl/mathop_sse2.h   |   85 -
 opensfm/src/third_party/vlfeat/vl/mser.c      | 1001 -----
 opensfm/src/third_party/vlfeat/vl/mser.h      |  424 --
 opensfm/src/third_party/vlfeat/vl/pgm.c       |  542 ---
 opensfm/src/third_party/vlfeat/vl/pgm.h       |   73 -
 opensfm/src/third_party/vlfeat/vl/qsort-def.h |  200 -
 .../src/third_party/vlfeat/vl/quickshift.c    |  465 ---
 .../src/third_party/vlfeat/vl/quickshift.h    |  211 -
 opensfm/src/third_party/vlfeat/vl/random.c    |  266 --
 opensfm/src/third_party/vlfeat/vl/random.h    |  162 -
 opensfm/src/third_party/vlfeat/vl/rodrigues.c |  329 --
 opensfm/src/third_party/vlfeat/vl/rodrigues.h |   33 -
 .../src/third_party/vlfeat/vl/scalespace.c    |  821 ----
 .../src/third_party/vlfeat/vl/scalespace.h    |   99 -
 .../src/third_party/vlfeat/vl/shuffle-def.h   |  101 -
 opensfm/src/third_party/vlfeat/vl/sift.c      | 2197 -----------
 opensfm/src/third_party/vlfeat/vl/sift.h      |  418 --
 opensfm/src/third_party/vlfeat/vl/slic.c      |  411 --
 opensfm/src/third_party/vlfeat/vl/slic.h      |   30 -
 opensfm/src/third_party/vlfeat/vl/stringop.c  |  462 ---
 opensfm/src/third_party/vlfeat/vl/stringop.h  |   58 -
 opensfm/src/third_party/vlfeat/vl/svm.c       | 2172 -----------
 opensfm/src/third_party/vlfeat/vl/svm.h       |  195 -
 .../src/third_party/vlfeat/vl/svmdataset.c    |  407 --
 .../src/third_party/vlfeat/vl/svmdataset.h    |   82 -
 opensfm/src/third_party/vlfeat/vl/vlad.c      |  323 --
 opensfm/src/third_party/vlfeat/vl/vlad.h      |   53 -
 72 files changed, 35897 deletions(-)
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/aib.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/aib.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/array.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/array.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/covdet.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/covdet.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/dsift.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/dsift.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/fisher.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/fisher.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/float.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/generic.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/generic.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/getopt_long.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/getopt_long.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/gmm.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/gmm.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/heap-def.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/hikmeans.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/hikmeans.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/hog.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/hog.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/homkermap.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/homkermap.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/host.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/host.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/ikmeans.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/ikmeans.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/imopv.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/imopv.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/kdtree.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/kdtree.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/kmeans.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/kmeans.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/lbp.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/lbp.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/liop.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/liop.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_avx.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_avx.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mser.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/mser.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/pgm.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/pgm.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/qsort-def.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/quickshift.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/quickshift.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/random.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/random.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/rodrigues.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/rodrigues.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/scalespace.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/scalespace.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/shuffle-def.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/sift.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/sift.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/slic.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/slic.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/stringop.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/stringop.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/svm.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/svm.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/svmdataset.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/svmdataset.h
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/vlad.c
 delete mode 100644 opensfm/src/third_party/vlfeat/vl/vlad.h

diff --git a/opensfm/src/third_party/vlfeat/vl/aib.c b/opensfm/src/third_party/vlfeat/vl/aib.c
deleted file mode 100644
index 1c07b7084..000000000
--- a/opensfm/src/third_party/vlfeat/vl/aib.c
+++ /dev/null
@@ -1,643 +0,0 @@
-/** @file aib.c
- ** @brief AIB - Definition
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page aib Agglomerative Information Bottleneck (AIB)
-@author Brian Fulkerson
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref aib.h implemens the Agglomerative Information Bottleneck (AIB)
-algorithm as first described in @cite{slonim99agglomerative}.
-
-AIB takes a discrete valued feature @f$x@f$ and a label @f$c@f$ and
-gradually compresses @f$x@f$ by iteratively merging values which
-minimize the loss in mutual information @f$I(x,c)@f$.
-
-While the algorithm is equivalent to the one described in
-@cite{slonim99agglomerative}, it has some speedups that enable
-handling much larger datasets. Let <em>N</em> be the number of feature
-values and <em>C</em> the number of labels. The algorithm of
-@cite{slonim99agglomerative} is @f$O(N^2)@f$ in space and @f$O(C
-N^3)@f$ in time. This algorithm is @f$O(N)@f$ space and @f$O(C N^2)@f$
-time in common cases (@f$O(C N^3)@f$ in the worst case).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section aib-overview Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Given a discrete feature @f$x \in \mathcal{X} = \{x_1,\dots,x_N\}@f$
-and a category label @f$c = 1,\dots,C@f$ with joint probability
-@f$p(x,c)@f$, AIB computes a compressed feature @f$[x]_{ij}@f$ by
-merging two values @f$x_i@f$ and @f$x_j@f$.  Among all the pairs
-@f$ij@f$, AIB chooses the one that yields the smallest loss in the
-mutual information
-
-@f[
-   D_{ij} = I(x,c) - I([x]_{ij},c) =
-   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   +
-   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   -
-   \sum_c (p(x_i)+p(x_j)) \log \frac {p(x_i,c)+p(x_i,c)}{(p(x_i)+p(x_j))p(c)}
-@f]
-
-AIB iterates this procedure until the desired level of
-compression is achieved.
-
-@section aib-algorithm Algorithm details
-
-Computing @f$D_{ij}@f$ requires @f$O(C)@f$ operations. For example, in
-standard AIB we need to calculate
-
-@f[
-   D_{ij} = I(x,c) - I([x]_{ij},c) =
-   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   +
-   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   -
-   \sum_c (p(x_i)+p(x_j)) \log \frac {p(x_i,c)+p(x_i,c)}{(p(x_i)+p(x_j))p(c)}
-@f]
-
-Thus in a basic implementation of AIB, finding the optimal pair
-@f$ij@f$ of feature values requires @f$O(CN^2)@f$ operations in
-total. In order to join all the @f$N@f$ values, we repeat this
-procedure @f$O(N)@f$ times, yielding @f$O(N^3 C)@f$ time and
-@f$O(1)@f$ space complexity (this does not account for the space need
-to store the input).
-
-The complexity can be improved by reusing computations. For instance,
-we can store the matrix @f$D = [ D_{ij} ]@f$ (which requires
-@f$O(N^2)@f$ space). Then, after joining @f$ij@f$, all of the matrix
-<em>D</em> except the rows and columns (the matrix is symmetric) of
-indexes <em>i</em> and <em>j</em> is unchanged. These two rows and
-columns are deleted and a new row and column, whose computation
-requires @f$O(NC)@f$ operations, are added for the merged value
-@f$x_{ij}@f$.  Finding the minimal element of the matrix still
-requires @f$O(N^2)@f$ operations, so the complexity of this algorithm
-is @f$O(N^2C + N^3)@f$ time and @f$O(N^2)@f$ space.
-
-We can obtain a much better expected complexity as follows. First,
-instead of storing the whole matrix <em>D</em>, we store the smallest
-element (index and value) of each row as @f$(q_i, D_i)@f$ (notice that
-this is also the best element of each column since <em>D</em> is
-symmetric). This requires @f$O(N)@f$ space and finding the minimal
-element of the matrix requires @f$O(N)@f$ operations.  After joining
-@f$ij@f$, we have to efficiently update this representation. This is
-done as follows:
-
-- The entries @f$(q_i,D_i)@f$ and @f$(q_j,D_j)@f$ are deleted.
-- A new entry @f$(q_{ij},D_{ij})@f$ for the joint value @f$x_{ij}@f$
-  is added. This requires @f$O(CN)@f$ operations.
-- We test which other entries @f$(q_{k},D_{k})@f$ need to
-  be updated. Recall that @f$(q_{k},D_{k})@f$ means that, before the
-  merge, the value
-  closest to @f$x_k@f$ was @f$x_{q_k}@f$ at a distance @f$D_k@f$. Then
-  - If @f$q_k \not = i@f$, @f$q_k \not = j@f$ and @f$D_{k,ij} \geq D_k@f$, then
-    @f$q_k@f$ is still the closest element and we do not do anything.
-  - If @f$q_k \not = i@f$, @f$q_k \not = j@f$ and @f$D_{k,ij} <
-    D_k@f$, then the closest element is @f$ij@f$ and we update the
-    entry in constant time.
-  - If @f$q_k = i@f$ or @f$q_k = j@f$, then we need to re-compute
-    the closest element in @f$O(CN)@f$ operations.
-
-This algorithm requires only @f$O(N)@f$ space and @f$O(\gamma(N) C
-N^2)@f$ time, where @f$\gamma(N)@f$ is the expected number of times we
-fall in the last case. In common cases one has @f$\gamma(N) \approx
-\mathrm{const.}@f$, so the time saving is significant.
-
-**/
-
-#include "aib.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <float.h>
-#include <math.h>
-
-/* The maximum value which beta may take */
-#define BETA_MAX DBL_MAX
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Normalizes an array of probabilities to sum to 1
- **
- ** @param P        The array of probabilities
- ** @param nelem    The number of elements in the array
- **
- ** @return Modifies P to contain values which sum to 1
- **/
-
-void vl_aib_normalize_P (double * P, vl_uint nelem)
-{
-    vl_uint i;
-    double sum = 0;
-    for(i=0; i<nelem; i++)
-        sum += P[i];
-    for(i=0; i<nelem; i++)
-        P[i] /= sum;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Allocates and creates a list of nodes
- **
- ** @param nentries   The size of the list which will be created
- **
- ** @return an array containing elements 0...nentries
- **/
-
-vl_uint *vl_aib_new_nodelist (vl_uint nentries)
-{
-    vl_uint * nodelist = vl_malloc(sizeof(vl_uint)*nentries);
-    vl_uint n;
-    for(n=0; n<nentries; n++)
-        nodelist[n] = n;
-
-    return nodelist;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Allocates and creates the marginal distribution Px
- **
- ** @param Pcx   A two-dimensional array of probabilities
- ** @param nvalues The number of rows in Pcx
- ** @param nlabels The number of columns in Pcx
- **
- ** @return an array of size @a nvalues which contains the marginal
- **         distribution over the rows.
- **/
-
-double * vl_aib_new_Px(double * Pcx, vl_uint nvalues, vl_uint nlabels)
-{
-    double * Px = vl_malloc(sizeof(double)*nvalues);
-    vl_uint r,c;
-    for(r=0; r<nvalues; r++)
-    {
-        double sum = 0;
-        for(c=0; c<nlabels; c++)
-            sum += Pcx[r*nlabels+c];
-        Px[r] = sum;
-    }
-    return Px;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Allocates and creates the marginal distribution Pc
- **
- ** @param Pcx      A two-dimensional array of probabilities
- ** @param nvalues    The number of rows in Pcx
- ** @param nlabels    The number of columns in Pcx
- **
- ** @return an array of size @a nlabels which contains the marginal distribution
- **         over the columns
- **/
-
-double * vl_aib_new_Pc(double * Pcx, vl_uint nvalues, vl_uint nlabels)
-{
-    double * Pc = vl_malloc(sizeof(double)*nlabels);
-    vl_uint r, c;
-    for(c=0; c<nlabels; c++)
-    {
-        double sum = 0;
-        for(r=0; r<nvalues; r++)
-            sum += Pcx[r*nlabels+c];
-        Pc[c] = sum;
-    }
-    return Pc;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Find the two nodes which have minimum beta.
- **
- ** @param aib      A pointer to the internal data structure
- ** @param besti    The index of one member of the pair which has mininum beta
- ** @param bestj    The index of the other member of the pair which
- **                 minimizes beta
- ** @param minbeta  The minimum beta value corresponding to (@a i, @a j)
- **
- ** Searches @a aib->beta to find the minimum value and fills @a minbeta and
- ** @a besti and @a bestj with this information.
- **/
-
-void vl_aib_min_beta
-(VlAIB * aib, vl_uint * besti, vl_uint * bestj, double * minbeta)
-{
-    vl_uint i;
-    *minbeta = aib->beta[0];
-    *besti   = 0;
-    *bestj   = aib->bidx[0];
-
-    for(i=0; i<aib->nentries; i++)
-    {
-        if(aib->beta[i] < *minbeta)
-        {
-            *minbeta = aib->beta[i];
-            *besti = i;
-            *bestj = aib->bidx[i];
-        }
-    }
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Merges two nodes i,j in the internal datastructure
- **
- ** @param aib  A pointer to the internal data structure
- ** @param i    The index of one member of the pair to merge
- ** @param j    The index of the other member of the pair to merge
- ** @param new  The index of the new node which corresponds to the union of
- **             (@a i, @a j).
- **
- ** Nodes are merged by replacing the entry @a i with the union of @c
- ** ij, moving the node stored in last position (called @c lastnode)
- ** back to jth position and the entry at the end.
- **
- ** After the nodes have been merged, it updates which nodes should be
- ** considered on the next iteration based on which beta values could
- ** potentially change. The merged node will always be part of this
- ** list.
- **/
-
-void
-vl_aib_merge_nodes (VlAIB * aib, vl_uint i, vl_uint j, vl_uint new)
-{
-  vl_uint last_entry = aib->nentries - 1 ;
-  vl_uint c, n ;
-
-  /* clear the list of nodes to update */
-  aib->nwhich = 0;
-
-  /* make sure that i is smaller than j */
-  if(i > j) { vl_uint tmp = j; j = i; i = tmp; }
-
-  /* -----------------------------------------------------------------
-   *                    Merge entries i and j, storing the result in i
-   * -------------------------------------------------------------- */
-
-  aib-> Px   [i] += aib->Px[j] ;
-  aib-> beta [i]  = BETA_MAX ;
-  aib-> nodes[i]  = new ;
-
-  for (c = 0; c < aib->nlabels; c++)
-    aib-> Pcx [i*aib->nlabels + c] += aib-> Pcx [j*aib->nlabels + c] ;
-
-  /* -----------------------------------------------------------------
-   *                                              Move last entry to j
-   * -------------------------------------------------------------- */
-
-  aib-> Px    [j]  = aib-> Px    [last_entry];
-  aib-> beta  [j]  = aib-> beta  [last_entry];
-  aib-> bidx  [j]  = aib-> bidx  [last_entry];
-  aib-> nodes [j]  = aib-> nodes [last_entry];
-
-  for (c = 0 ;  c < aib->nlabels ; c++)
-    aib-> Pcx[j*aib->nlabels + c] = aib-> Pcx [last_entry*aib->nlabels + c] ;
-
-  /* delete last entry */
-  aib-> nentries -- ;
-
-  /* -----------------------------------------------------------------
-   *                                        Scan for entries to update
-   * -------------------------------------------------------------- */
-
-  /*
-   * After mergin entries i and j, we need to update all other entries
-   * that had one of these two as closest match. We also need to
-   * update the renewend entry i. This is added by the loop below
-   * since bidx [i] = j exactly because i was merged.
-   *
-   * Additionaly, since we moved the last entry back to the entry j,
-   * we need to adjust the valeus of bidx to reflect this.
-   */
-
-  for (n = 0 ; n < aib->nentries; n++) {
-    if(aib->bidx[n] == i || aib->bidx[n] == j) {
-        aib->bidx  [n] = 0;
-        aib->beta  [n] = BETA_MAX;
-        aib->which [aib->nwhich++] = n ;
-      }
-    else if(aib->bidx[n] == last_entry) {
-      aib->bidx[n] = j ;
-    }
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Updates @c aib->beta and @c aib->bidx according to @c aib->which
- **
- ** @param aib AIB data structure.
- **
- ** The function calculates @c beta[i] and @c bidx[i] for the nodes @c
- ** i listed in @c aib->which.  @c beta[i] is the minimal variation of mutual
- ** information (or other score) caused by merging entry @c i with another entry
- ** and @c bidx[i] is the index of this best matching entry.
- **
- ** Notice that for each entry @c i that we need to update, a full
- ** scan of all the other entries must be performed.
- **/
-
-void
-vl_aib_update_beta (VlAIB * aib)
-{
-
-#define PLOGP(x) ((x)*log((x)))
-
-  vl_uint i;
-  double * Px  = aib->Px;
-  double * Pcx = aib->Pcx;
-  double * tmp = vl_malloc(sizeof(double)*aib->nentries);
-  vl_uint a, b, c ;
-
-  /*
-   * T1 = I(x,c) - I([x]_ij) = A + B - C
-   *
-   * A  = \sum_c p(xa,c)           \log ( p(xa,c)          /  p(xa)       )
-   * B  = \sum_c p(xb,c)           \log ( p(xb,c)          /  p(xb)       )
-   * C  = \sum_c (p(xa,c)+p(xb,c)) \log ((p(xa,c)+p(xb,c)) / (p(xa)+p(xb)))
-   *
-   * C  = C1 + C2
-   * C1 = \sum_c (p(xa,c)+p(xb,c)) \log (p(xa,c)+p(xb,c))
-   * C2 = - (p(xa)+p(xb) \log (p(xa)+p(xb))
-   */
-
-  /* precalculate A and B */
-  for (a = 0; a < aib->nentries; a++) {
-    tmp[a] = 0;
-    for (c = 0; c < aib->nlabels; c++) {
-        double Pac = Pcx [a*aib->nlabels + c] ;
-        if(Pac != 0) tmp[a] += Pac * log (Pac / Px[a]) ;
-    }
-  }
-
-  /* for each entry listed in which */
-  for (i = 0 ; i < aib->nwhich; i++) {
-    a = aib->which[i];
-
-    /* for each other entry */
-    for(b = 0 ; b < aib->nentries ; b++) {
-      double T1 = 0 ;
-
-      if (a == b || Px [a] == 0 || Px [b] == 0) continue ;
-
-
-      T1 = PLOGP ((Px[a] + Px[b])) ;                  /* - C2 */
-      T1 += tmp[a] + tmp[b] ;                         /* + A + B */
-
-      for (c = 0 ; c < aib->nlabels; ++ c) {
-        double Pac = Pcx [a*aib->nlabels + c] ;
-        double Pbc = Pcx [b*aib->nlabels + c] ;
-        if (Pac == 0 && Pbc == 0) continue;
-        T1 += - PLOGP ((Pac + Pbc)) ;                 /* - C1 */
-      }
-
-      /*
-       * Now we have beta(a,b). We check wether this is the best beta
-       * for entries a and b.
-       */
-      {
-        double beta = T1 ;
-
-        if (beta < aib->beta[a])
-          {
-            aib->beta[a] = beta;
-            aib->bidx[a] = b;
-          }
-        if (beta < aib->beta[b])
-          {
-            aib->beta[b] = beta;
-            aib->bidx[b] = a;
-          }
-      }
-    }
-  }
-  vl_free(tmp);
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Calculates the current information and entropy
- **
- ** @param aib      A pointer to the internal data structure
- ** @param I        The current mutual information (out).
- ** @param H        The current entropy (out).
- **
- ** Calculates the current mutual information and entropy of Pcx and sets
- ** @a I and @a H to these new values.
- **/
-void vl_aib_calculate_information(VlAIB * aib, double * I, double * H)
-{
-    vl_uint r, c;
-    *H = 0;
-    *I = 0;
-
-    /*
-     * H(x)   = - sum_x p(x)    \ log p(x)
-     * I(x,c) =   sum_xc p(x,c) \ log (p(x,c) / p(x)p(c))
-     */
-
-    /* for each entry */
-    for(r = 0 ; r< aib->nentries ; r++) {
-
-      if (aib->Px[r] == 0) continue ;
-      *H += -log(aib->Px[r]) * aib->Px[r] ;
-
-      for(c=0; c<aib->nlabels; c++) {
-        if (aib->Pcx[r*aib->nlabels+c] == 0) continue;
-        *I += aib->Pcx[r*aib->nlabels+c] *
-          log (aib->Pcx[r*aib->nlabels+c] / (aib->Px[r]*aib->Pc[c])) ;
-      }
-    }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Allocates and initializes the internal data structure
- **
- ** @param Pcx      A pointer to a 2D array of probabilities
- ** @param nvalues    The number of rows in the array
- ** @param nlabels    The number of columns in the array
- **
- ** Creates a new @a VlAIB struct containing pointers to all the data that
- ** will be used during the AIB process.
- **
- ** Allocates memory for the following:
- ** - Px (nvalues*sizeof(double))
- ** - Pc (nlabels*sizeof(double))
- ** - nodelist (nvalues*sizeof(vl_uint))
- ** - which (nvalues*sizeof(vl_uint))
- ** - beta (nvalues*sizeof(double))
- ** - bidx (nvalues*sizeof(vl_uint))
- ** - parents ((2*nvalues-1)*sizeof(vl_uint))
- ** - costs (nvalues*sizeof(double))
- **
- ** Since it simply copies to pointer to Pcx, the total additional memory
- ** requirement is:
- **
- ** (3*nvalues+nlabels)*sizeof(double) + 4*nvalues*sizeof(vl_uint)
- **
- ** @returns An allocated and initialized @a VlAIB pointer
- **/
-VlAIB * vl_aib_new(double * Pcx, vl_uint nvalues, vl_uint nlabels)
-{
-    VlAIB * aib = vl_malloc(sizeof(VlAIB));
-    vl_uint i ;
-
-    aib->verbosity = 0 ;
-    aib->Pcx   = Pcx ;
-    aib->nvalues = nvalues ;
-    aib->nlabels = nlabels ;
-
-    vl_aib_normalize_P (aib->Pcx, aib->nvalues * aib->nlabels) ;
-
-    aib->Px = vl_aib_new_Px (aib->Pcx, aib->nvalues, aib->nlabels) ;
-    aib->Pc = vl_aib_new_Pc (aib->Pcx, aib->nvalues, aib->nlabels) ;
-
-    aib->nentries = aib->nvalues ;
-    aib->nodes    = vl_aib_new_nodelist(aib->nentries) ;
-    aib->beta     = vl_malloc(sizeof(double) * aib->nentries) ;
-    aib->bidx     = vl_malloc(sizeof(vl_uint)   * aib->nentries) ;
-
-    for(i = 0 ; i < aib->nentries ; i++)
-      aib->beta [i] = BETA_MAX ;
-
-    /* Initially we must consider all nodes */
-    aib->nwhich = aib->nvalues;
-    aib->which  = vl_aib_new_nodelist (aib->nwhich) ;
-
-    aib->parents = vl_malloc(sizeof(vl_uint)*(aib->nvalues*2-1));
-    /* Initially, all parents point to a nonexistent node */
-    for (i = 0 ; i < 2 * aib->nvalues - 1 ; i++)
-      aib->parents [i] = 2 * aib->nvalues ;
-
-    /* Allocate cost output vector */
-    aib->costs = vl_malloc (sizeof(double) * (aib->nvalues - 1 + 1)) ;
-
-
-    return aib ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Deletes AIB data structure
- ** @param aib data structure to delete.
- **/
-
-void
-vl_aib_delete (VlAIB * aib)
-{
-  if (aib) {
-    if (aib-> nodes)   vl_free (aib-> nodes);
-    if (aib-> beta)    vl_free (aib-> beta);
-    if (aib-> bidx)    vl_free (aib-> bidx);
-    if (aib-> which)   vl_free (aib-> which);
-    if (aib-> Px)      vl_free (aib-> Px);
-    if (aib-> Pc)      vl_free (aib-> Pc);
-    if (aib-> parents) vl_free (aib-> parents);
-    if (aib-> costs)   vl_free (aib-> costs);
-
-    vl_free (aib) ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Runs AIB on Pcx
- **
- ** @param aib     AIB object to process
- **
- ** The function runs Agglomerative Information Bottleneck (AIB) on
- ** the joint probability table @a aib->Pcx which has labels along the
- ** columns and feature values along the rows. AIB iteratively merges
- ** the two values of the feature @c x that causes the smallest
- ** decrease in mutual information between the random variables @c x
- ** and @c c.
- **
- ** Merge operations are arranged in a binary tree. The nodes of the
- ** tree correspond to the original feature values and any other value
- ** obtained as a result of a merge operation. The nodes are indexed
- ** in breadth-first order, starting from the leaves. The first index
- ** is zero. In this way, the leaves correspond directly to the
- ** original feature values.  In total there are @c 2*nvalues-1 nodes.
- **
- ** The results may be accessed through vl_aib_get_parents which
- ** returns an array with one element per tree node. Each
- ** element is the index the parent node. The root parent is equal to
- ** zero. The array has @c 2*nvalues-1 elements.
- **
- ** Feature values with null probability are ignored by the algorithm
- ** and their nodes have parents indexing a non-existent tree node (a
- ** value bigger than @c 2*nvalues-1).
- **
- ** Then the function will also compute the information level after each
- ** merge. vl_get_costs will return a vector with the information level
- ** after each merge. @a
- ** cost has @c nvalues entries: The first is the value of the cost
- ** functional before any merge, and the others are the cost after the
- ** @c nvalues-1 merges.
- **
- **/
-
-VL_EXPORT
-void vl_aib_process(VlAIB *aib)
-{
-    vl_uint i, besti, bestj, newnode, nodei, nodej;
-    double I, H;
-    double minbeta;
-
-    /* Calculate initial value of cost function */
-    vl_aib_calculate_information (aib, &I, &H) ;
-    aib->costs[0] = I;
-
-    /* Initially which = all */
-
-    /* For each merge */
-    for(i = 0 ; i < aib->nvalues - 1 ; i++) {
-
-      /* update entries in aib-> which */
-      vl_aib_update_beta(aib);
-
-      /* find best pair of nodes to merge */
-      vl_aib_min_beta (aib, &besti, &bestj, &minbeta);
-
-      if(minbeta == BETA_MAX)
-        /* only null-probability entries remain */
-        break;
-
-      /* Add the parent pointers for the new node */
-      newnode = aib->nvalues + i ;
-      nodei = aib->nodes[besti];
-      nodej = aib->nodes[bestj];
-
-      aib->parents [nodei] = newnode ;
-      aib->parents [nodej] = newnode ;
-      aib->parents [newnode] = 0 ;
-
-      /* Merge the nodes which produced the minimum beta */
-      vl_aib_merge_nodes (aib, besti, bestj, newnode) ;
-      vl_aib_calculate_information (aib, &I, &H) ;
-
-      aib->costs[i+1] = I;
-
-      if (aib->verbosity > 0) {
-        VL_PRINTF ("aib: (%5d,%5d)=%5d dE: %10.3g I: %6.4g H: %6.4g updt: %5d\n",
-                   nodei,
-                   nodej,
-                   newnode,
-                   minbeta,
-                   I,
-                   H,
-                   aib->nwhich) ;
-      }
-    }
-
-    /* fill ignored entries with NaNs */
-    for(; i < aib->nvalues - 1 ; i++)
-        aib->costs[i+1] = VL_NAN_D ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/aib.h b/opensfm/src/third_party/vlfeat/vl/aib.h
deleted file mode 100644
index ab7d4be21..000000000
--- a/opensfm/src/third_party/vlfeat/vl/aib.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/** @file aib.h
- ** @brief AIB (@ref aib)
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_AIB_H
-#define VL_AIB_H
-
-#include "generic.h"
-#include "mathop.h"
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief AIB algorithm data
- **
- ** The implementation is quite straightforward, but the way feature
- ** values are handled in order to support efficient joins,
- ** deletions and re-arrangement needs to be explained. This is
- ** achieved by adding a layer of indirection:
- ** - Call each feature value (either original or obtained by a join
- **   operation) a <em>node</em>. Nodes are identified by numbers.
- ** - Call each element of the various arrays (such as VlAIB::Px)
- **    an <em>entry</em>.
- ** - Entries are dynamically associated to nodes as specified by
- **   VlAIB::nodes. For example, @c Px[i] refers to the node @c
- **   nodes[i].
- **/
-
-typedef struct _VlAIB
-{
-  vl_uint   *nodes ;    /**< Entires to nodes */
-  vl_uint    nentries ; /**< Total number of entries (= # active nodes) */
-  double    *beta ;     /**< Minimum distance to an entry  */
-  vl_uint   *bidx ;     /**< Closest entry */
-
-
-  vl_uint   *which ;    /**< List of entries to update */
-  vl_uint    nwhich ;   /**< Number of entries to update */
-
-  double    *Pcx;       /**< Joint probability table */
-  double    *Px;        /**< Marginal. */
-  double    *Pc;        /**< Marginal. */
-  vl_uint    nvalues;   /**< Number of feature values */
-  vl_uint    nlabels;   /**< Number of labels */
-
-  vl_uint   *parents;   /**< Array of parents */
-  double    *costs;     /**< Cost of each merge */
-
-  vl_uint verbosity ; /** Verbosity level */
-} VlAIB;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT
-VlAIB * vl_aib_new(double * Pcx, vl_uint nvalues, vl_uint nlabels);
-
-VL_EXPORT
-void vl_aib_delete (VlAIB * aib);
-/** @} */
-
-/** @name Process data
- ** @{
- **/
-VL_EXPORT
-void vl_aib_process(VlAIB * aib);
-/** @} */
-
-/** @name Retrieve results
- ** @{
- **/
-VL_INLINE vl_uint * vl_aib_get_parents(VlAIB const * aib);
-VL_INLINE double  * vl_aib_get_costs(VlAIB const * aib);
-/** @} */
-
-
-/* -------------------------------------------------------------------
- *                                     Inline functions implementation
- * ---------------------------------------------------------------- */
-
-/** ------------------------------------------------------------------
- ** @brief Get resulting list of parents
- ** @param aib AIB filter.
- ** @return An array of parents
- **/
-VL_INLINE
-vl_uint * vl_aib_get_parents(VlAIB const * aib)
-{
-  return aib->parents;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get a list of merge costs
- ** @param aib AIB filter.
- ** @return An array of costs
- **/
-VL_INLINE
-double * vl_aib_get_costs(VlAIB const * aib)
-{
-  return aib->costs;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Set the verbosity
- ** @param self AIB object.
- ** @param verbosity a non-negative integer.
- **/
-VL_INLINE void
-vl_aib_set_verbosity (VlAIB * self, int verbosity)
-{
-  self->verbosity = verbosity ;
-}
-
-/** @brief Get the verbosity
- ** @param self AIB object.
- ** @return the verbosity level.
- **/
-VL_INLINE int
-vl_aib_get_verbosity (VlAIB const * self)
-{
-  return self->verbosity ;
-}
-
-/* VL_AIB_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/array.c b/opensfm/src/third_party/vlfeat/vl/array.c
deleted file mode 100644
index a81b438ec..000000000
--- a/opensfm/src/third_party/vlfeat/vl/array.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/** @file array.h
- ** @brief Array
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#include "array.h"
-#include <string.h>
-
-/** @brief Get number of elements in array
- ** @param self array.
- ** @return number of elements.
- **/
-
-VL_EXPORT vl_size
-vl_array_get_num_elements (VlArray const * self)
-{
-  vl_size numElements = 1 ;
-  vl_uindex k ;
-  if (self->numDimensions == 0) {
-    return 0 ;
-  }
-  for (k = 0 ; k < self->numDimensions ; ++k) {
-    numElements *= self->dimensions[k] ;
-  }
-  return numElements ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                  init &  dealloc */
-/* ---------------------------------------------------------------- */
-
-/** @brief New numeric array
- ** @param self array to initialize.
- ** @param type data type.
- ** @param numDimensions number of dimensions.
- ** @param dimensions dimensions.
- **
- ** The function initializes the specified array and allocates
- ** the necessary memory for storage.
- **/
-
-VL_EXPORT VlArray *
-vl_array_init (VlArray* self, vl_type type,
-               vl_size numDimensions, vl_size const * dimensions)
-{
-  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
-  self->type = type ;
-  self->numDimensions = numDimensions ;
-  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
-  self->data = vl_malloc(vl_get_type_size(type) * vl_array_get_num_elements (self)) ;
-  self->isEnvelope = VL_FALSE ;
-  self->isSparse = VL_FALSE ;
-  return self ;
-}
-
-/** @brief New numeric array envelope
- ** @param self array to initialize.
- ** @param data data to envelople.
- ** @param type data type.
- ** @param numDimensions number of dimensions.
- ** @param dimensions dimensions.
- **
- ** The function initializes the specified array wrapping the
- ** specified buffer.
- **/
-
-VL_EXPORT VlArray *
-vl_array_init_envelope (VlArray * self, void * data, vl_type type,
-                        vl_size numDimensions, vl_size const * dimensions)
-{
-  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
-  self->type = type ;
-  self->numDimensions = numDimensions ;
-  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
-  self->data = data ;
-  self->isEnvelope = VL_TRUE ;
-  self->isSparse = VL_FALSE ;
-  return self ;
-}
-
-/** @brief New numeric array with matrix shape
- ** @param self array to initialize.
- ** @param type type.
- ** @param numRows number of rows.
- ** @param numColumns number of columns.
- **/
-
-VL_EXPORT VlArray *
-vl_array_init_matrix (VlArray * self, vl_type type, vl_size numRows, vl_size numColumns)
-{
-  vl_size dimensions [2] = {numRows, numColumns} ;
-  return vl_array_init (self, type, 2, dimensions) ;
-}
-
-/** @brief New numeric array envelpe with matrix shape
- ** @param self array to initialize.
- ** @param data data to envelope.
- ** @param type type.
- ** @param numRows number of rows.
- ** @param numColumns number of columns.
- **/
-
-VL_EXPORT VlArray *
-vl_array_init_matrix_envelope (VlArray * self, void * data,
-                                vl_type type, vl_size numRows, vl_size numColumns)
-{
-  vl_size dimensions [2] = {numRows, numColumns} ;
-  return vl_array_init_envelope (self, data, type, 2, dimensions) ;
-}
-
-/** @brief Delete array
- ** @param self array.
- **/
-
-VL_EXPORT void
-vl_array_dealloc (VlArray * self)
-{
-  if (! self->isEnvelope) {
-    if (self->data) {
-      vl_free(self->data) ;
-      self->data = NULL ;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                    new &  delete */
-/* ---------------------------------------------------------------- */
-
-
-/** @brief New numeric array
- ** @param type data type.
- ** @param numDimensions number of dimensions.
- ** @param dimensions dimensions.
- **
- ** The function creates a new VLArray instance and allocates
- ** the necessary memory for storage.
- **/
-
-VL_EXPORT VlArray *
-vl_array_new (vl_type type, vl_size numDimensions, vl_size const * dimensions)
-{
-  VlArray * self = vl_malloc(sizeof(VlArray)) ;
-  return vl_array_init(self, type, numDimensions, dimensions) ;
-}
-
-/** @brief New numeric array with matrix shape
- ** @param type type.
- ** @param numRows number of rows.
- ** @param numColumns number of columns.
- **/
-
-VL_EXPORT VlArray *
-vl_array_new_matrix (vl_type type, vl_size numRows, vl_size numColumns)
-{
-  vl_size dimensions [2] = {numRows, numColumns} ;
-  return vl_array_new (type, 2, dimensions) ;
-}
-
-/** @brief New numeric array envelope
- ** @param data data to envelople.
- ** @param type data type.
- ** @param numDimensions number of dimensions.
- ** @param dimensions dimensions.
- **/
-
-VL_EXPORT VlArray *
-vl_array_new_envelope (void * data, vl_type type,
-                       vl_size numDimensions, vl_size const * dimensions)
-{
-  VlArray * self = vl_malloc(sizeof(VlArray)) ;
-  return vl_array_init_envelope(self, data, type, numDimensions, dimensions) ;
-}
-
-/** @brief New numeric array envelpe with matrix shape
- ** @param data data to envelope.
- ** @param type type.
- ** @param numRows number of rows.
- ** @param numColumns number of columns.
- **/
-
-VL_EXPORT VlArray *
-vl_array_new_matrix_envelope (void * data, vl_type type, vl_size numRows, vl_size numColumns)
-{
-  vl_size dimensions [2] = {numRows, numColumns} ;
-  return vl_array_new_envelope (data, type, 2, dimensions) ;
-}
-
-/** @brief Delete array
- ** @param self array.
- **/
-
-VL_EXPORT void
-vl_array_delete (VlArray * self)
-{
-  vl_array_dealloc(self) ;
-  vl_free(self) ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/array.h b/opensfm/src/third_party/vlfeat/vl/array.h
deleted file mode 100644
index d29dc483b..000000000
--- a/opensfm/src/third_party/vlfeat/vl/array.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/** @file array.h
- ** @brief Array - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_ARRAY_H
-#define VL_ARRAY_H
-
-#include "generic.h"
-
-/** @brief Maximum number of array dimensions */
-#define VL_ARRAY_MAX_NUM_DIMENSIONS 16
-
-/** @brief Numeric array */
-typedef struct _VlArray
-{
-  vl_type type ;
-  vl_bool isEnvelope ;
-  vl_bool isSparse ;
-  vl_size numDimensions ;
-  vl_size dimensions [VL_ARRAY_MAX_NUM_DIMENSIONS] ;
-  void * data ;
-  void * rowPointers ;
-  void * columnPointers ;
-} VlArray ;
-
-
-/** @name Get data and parameters
- ** @{ */
-
-/** @brief Get number of dimensions
- ** @param self array.
- ** @return number of dimensions.
- **/
-
-VL_INLINE vl_size
-vl_array_get_num_dimensions (VlArray const * self)
-{
-  return self->numDimensions ;
-}
-
-/** @brief Get dimensions
- ** @param self array.
- ** @return dimensions.
- **/
-
-VL_INLINE vl_size const *
-vl_array_get_dimensions (VlArray const * self)
-{
-  return self->dimensions ;
-}
-
-/** @brief Get data
- ** @param self array.
- ** @return data.
- **/
-
-VL_INLINE void *
-vl_array_get_data (VlArray const * self)
-{
-  return self->data;
-}
-
-/** @brief Get type
- ** @param self array.
- ** @return type.
- **/
-
-VL_INLINE vl_type
-vl_array_get_data_type (VlArray const * self)
-{
-  return self->type ;
-}
-
-VL_EXPORT vl_size vl_array_get_num_elements (VlArray const * self) ;
-
-/** @{ */
-
-/** @name Constructing and destroying
- ** @{ */
-
-VL_EXPORT VlArray * vl_array_init (VlArray * self, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
-VL_EXPORT VlArray * vl_array_init_envelope (VlArray *self, void * data, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
-VL_EXPORT VlArray * vl_array_init_matrix (VlArray * self, vl_type type, vl_size numRows, vl_size numColumns) ;
-VL_EXPORT VlArray * vl_array_init_matrix_envelope (VlArray * self, void * data, vl_type type, vl_size numRows, vl_size numColumns) ;
-
-VL_EXPORT VlArray * vl_array_new (vl_type type, vl_size numDimension, vl_size const * dimensions) ;
-VL_EXPORT VlArray * vl_array_new_envelope (void * data, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
-VL_EXPORT VlArray * vl_array_new_matrix (vl_type type, vl_size numRows, vl_size numColumns) ;
-VL_EXPORT VlArray * vl_array_new_matrix_envelope (void * data, vl_type type, vl_size numRows, vl_size numColumns) ;
-
-VL_EXPORT void vl_array_dealloc (VlArray * self) ;
-VL_EXPORT void vl_array_delete (VlArray * self) ;
-/** @} */
-
-/* VL_ARRAY_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/covdet.c b/opensfm/src/third_party/vlfeat/vl/covdet.c
deleted file mode 100644
index 0b0592f0d..000000000
--- a/opensfm/src/third_party/vlfeat/vl/covdet.c
+++ /dev/null
@@ -1,3400 +0,0 @@
-/** @file covdet.c
- ** @brief Covariant feature detectors - Definition
- ** @author Karel Lenc
- ** @author Andrea Vedaldi
- ** @author Michal Perdoch
- **/
-
-/*
-Copyright (C) 2013-14 Andrea Vedaldi.
-Copyright (C) 2012 Karel Lenc, Andrea Vedaldi and Michal Perdoch.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page covdet Covariant feature detectors
-@author Karel Lenc
-@author Andrea Vedaldi
-@author Michal Perdoch
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref covdet.h implements a number of covariant feature detectors, based
-on three cornerness measures (determinant of the Hessian, trace of the Hessian
-(aka Difference of Gaussians, and Harris). It supprots affine adaptation,
-orientation estimation, as well as Laplacian scale detection.
-
-- @subpage covdet-fundamentals
-- @subpage covdet-principles
-- @subpage covdet-differential
-- @subpage covdet-corner-types
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The ::VlCovDet object implements a number of covariant feature
-detectors: Difference of Gaussian, Harris, determinant of Hessian.
-Variant of the basic detectors support scale selection by maximizing
-the Laplacian measure as well as affine normalization.
-
-@code
-// create a detector object
-VlCovDet * covdet = vl_covdet_new(method) ;
-
-// set various parameters (optional)
-vl_covdet_set_first_octave(covdet, -1) ; // start by doubling the image resolution
-vl_covdet_set_octave_resolution(covdet, octaveResolution) ;
-vl_covdet_set_peak_threshold(covdet, peakThreshold) ;
-vl_covdet_set_edge_threshold(covdet, edgeThreshold) ;
-
-// process the image and run the detector
-vl_covdet_put_image(covdet, image, numRows, numCols) ;
-vl_covdet_detect(covdet) ;
-
-// drop features on the margin (optional)
-vl_covdet_drop_features_outside (covdet, boundaryMargin) ;
-
-// compute the affine shape of the features (optional)
-vl_covdet_extract_affine_shape(covdet) ;
-
-// compute the orientation of the features (optional)
-vl_covdet_extract_orientations(covdet) ;
-
-// get feature frames back
-vl_size numFeatures = vl_covdet_get_num_features(covdet) ;
-VlCovDetFeature const * feature = vl_covdet_get_features(covdet) ;
-
-// get normalized feature appearance patches (optional)
-vl_size w = 2*patchResolution + 1 ;
-for (i = 0 ; i < numFeatures ; ++i) {
-  float * patch = malloc(w*w*sizeof(*desc)) ;
-  vl_covdet_extract_patch_for_frame(covdet,
-                                    patch,
-                                    patchResolution,
-                                    patchRelativeExtent,
-                                    patchRelativeSmoothing,
-                                    feature[i].frame) ;
-  // do something with patch
-}
-@endcode
-
-This example code:
-
-- Calls ::vl_covdet_new constructs a new detector object. @ref
-  covdet.h supports a variety of different detectors (see
-  ::VlCovDetMethod).
-- Optionally calls various functions to set the detector parameters if
-  needed (e.g. ::vl_covdet_set_peak_threshold).
-- Calls ::vl_covdet_put_image to start processing a new image. It
-  causes the detector to compute the scale space representation of the
-  image, but does not compute the features yet.
-- Calls ::vl_covdet_detect runs the detector. At this point features are
-  ready to be extracted. However, one or all of the following steps
-  may be executed in order to process the features further.
-- Optionally calls ::vl_covdet_drop_features_outside to drop features
-  outside the image boundary.
-- Optionally calls ::vl_covdet_extract_affine_shape to compute the
-  affine shape of features using affine adaptation.
-- Optionally calls ::vl_covdet_extract_orientations to compute the
-  dominant orientation of features looking for the dominant gradient
-  orientation in patches.
-- Optionally calls ::vl_covdet_extract_patch_for_frame to extract a
-  normalized feature patch, for example to compute an invariant
-  feature descriptor.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@page covdet-fundamentals Covariant detectors fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-This page describes the fundamental concepts required to understand a
-covariant feature detector, the geometry of covariant features, and
-the process of feature normalization.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section covdet-covariance Covariant detection
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The purpose of a *covariant detector* is to extract from an image a
-set of local features in a manner which is consistent with spatial
-transformations of the image itself. For instance, a covariant
-detector that extracts interest points $\bx_1,\dots,\bx_n$ from image
-$\ell$ extracts the translated points $\bx_1+T,\dots,\bx_n+T$ from the
-translated image $\ell'(\bx) = \ell(\bx-T)$.
-
-More in general, consider a image $\ell$ and a transformed version
-$\ell' = \ell \circ w^{-1}$ of it, as in the following figure:
-
-@image html covdet.png "Covariant detection of local features."
-
-The transformation or <em>warp</em> $w : \real^2 \mapsto \real^2$ is a
-deformation of the image domain which may capture a change of camera
-viewpoint or similar imaging factor. Examples of warps typically
-considered are translations, scaling, rotations, and general affine
-transformations; however, in $w$ could be another type of continuous
-and invertible transformation.
-
-Given an image $\ell$, a **detector** selects features $R_1,\dots,R_n$
-(one such features is shown in the example as a green circle). The
-detector is said to be **covariant** with the warps $w$ if it extracts
-the transformed features $w[R_1],\dots, w[R_n]$ from the transformed
-image $w[\ell]$. Intuitively, this means that the &ldquo;same
-features&rdquo; are extracted in both cases up to the transformation
-$w$. This property is described more formally in @ref
-covdet-principles.
-
-Covariance is a key property of local feature detectors as it allows
-extracting corresponding features from two or more images, making it
-possible to match them in a meaningful way.
-
-The @ref covdet.h module in VLFeat implements an array of feature
-detection algorithm that have are covariant to different classes of
-transformations.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section covdet-frame Feature geometry and feature frames
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-As we have seen, local features are subject to image transformations,
-and they apply a fundamental role in matching and normalizing
-images. To operates effectively with local features is therefore
-necessary to understand their geometry.
-
-The geometry of a local feature is captured by a <b>feature frame</b>
-$R$. In VLFeat, depending on the specific detector, the frame can be
-either a point, a disc, an ellipse, an oriented disc, or an oriented
-ellipse.
-
-A frame captures both the extent of the local features, useful to know
-which portions of two images are put in correspondence, as well their
-shape.  The latter can be used to associate to diagnose the
-transformation that affects a feature and remove it through the
-process of **normalization**.
-
-More precisely, in covariant detection feature frames are constructed
-to be compatible with a certain class of transformations. For example,
-circles are compatible with similarity transformations as they are
-closed under them. Likewise, ellipses are compatible with affine
-transformations.
-
-Beyond this closure property, the key idea here is that all feature
-occurrences can be seen as transformed versions of a base or
-<b>canonical</b> feature. For example, all discs $R$ can be obtained
-by applying a similarity transformation to the unit disc $\bar R$
-centered at the origin. $\bar R$ is an example of canonical frame
-as any other disc can be written as $R = w[\bar R]$ for a suitable
-similarity $w$.
-
-@image html frame-canonical.png "The idea of canonical frame and normalization"
-
-The equation $R = w[\bar R_0]$ matching the canonical and detected
-feature frames establishes a constraint on the warp $w$, very similar
-to the way two reference frames in geometry establish a transformation
-between spaces. The transformation $w$ can be thought as a the
-**pose** of the detected feature, a generalization of its location.
-
-In the case of discs and similarity transformations, the equation $R =
-w[\bar R_0]$ fixes $w$ up to a residual rotation. This can be
-addressed by considering oriented discs instead. An **oriented disc**
-is a disc with a radius highlighted to represent the feature
-orientation.
-
-While discs are appropriate for similarity transformations, they are
-not closed under general affine transformations. In this case, one
-should consider the more general class of (oriented) ellipses. The
-following image illustrates the five types of feature frames used in
-VLFeat:
-
-@image html frame-types.png "Types of local feature frames: points, discs, oriented discs, ellipses, oriented ellipses."
-
-Note that these frames are described respectively by 2, 3, 4, 5 and 6
-parameters. The most general type are the oriented ellipses, which can
-be used to represent all the other frame types as well.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section covdet-frame-transformation Transforming feature frames
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-Consider a warp $w$ mapping image $\ell$ into image $\ell'$ as in the
-figure below. A feature $R$ in the first image co-variantly transform
-into a feature $R'=w[R]$ in the second image:
-
-@image html covdet-normalization.png "Normalization removes the effect of an image deformation."
-
-The poses $u,u'$ of $R=u[R_0]$ and $R' = u'[R_0]$ are then related by
-the simple expression:
-
-\[
-  u' = w \circ u.
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section covdet-frame-normalization Normalizing feature frames
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-In the example above, the poses $u$ and $u'$ relate the two
-occurrences $R$ and $R'$ of the feature to its canonical version
-$R_0$. If the pose $u$ of the feature in image $\ell$ is known, the
-canonical feature appearance can be computed by un-warping it:
-
-\[
- \ell_0 = u^{-1}[\ell] = \ell \circ u.
-\]
-
-This process is known as **normalization** and is the key in the
-computation of invariant feature descriptors as well as in the
-construction of most co-variant detectors.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@page covdet-principles Principles of covariant detection
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The goals of a co-variant detector were discussed in @ref
-covdet-fundamentals. This page introduces a few general principles
-that are at the basis of most covariant detection algorithms. Consider
-an input image $\ell$ and a two dimensional continuous and invertible
-warp $w$. The *warped image* $w[\ell]$ is defined to be
-
-\[
- w[\ell] = \ell \circ w^{-1},
-\]
-
-or, equivalently,
-
-\[
- w[\ell](x,y) =  \ell(w^{-1}(x,y)), \qquad \forall (x,y)\in\real^2.
-\]
-
-Note that, while $w$ pushes pixels forward, from the original to the
-transformed image domain, defining the transformed image $\ell'$
-requires inverting the warp and composing $\ell$ with $w^{-1}$.
-
-The goal a covariant detector is to extract the same local features
-irregardless of image transformations. The detector is said to be
-<b>covariant</b> or <b>equivariant</b> with a class of warps
-$w\in\mathcal{W}$ if, when the feature $R$ is detected in image
-$\ell$, then the transformed feature $w[R]$ is detected in the
-transformed image $w[\ell]$.
-
-The net effect is that a covariant feature detector appears to
-&ldquo;track&rdquo; image transformations; however, it is important to
-note that a detector *is not a tracker* because it processes images
-individually rather than jointly as part of a sequence.
-
-An intuitive way to construct a covariant feature detector is to
-extract features in correspondence of images structures that are
-easily identifiable even after a transformation. Example of specific
-structures include dots, corners, and blobs. These will be generically
-indicated as **corners** in the followup.
-
-A covariant detector faces two challenges. First, corners have, in
-practice, an infinite variety of individual appearances and the
-detector must be able to capture them to be of general applicability.
-Second, the way corners are identified and detected must remain stable
-under transformations of the image. These two problems are addressed
-in @ref covdet-cornerness-localmax and @ref
-covdet-cornerness-normalization respectively.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-cornerness Detection using a cornerness measure
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-One way to decide whether an image region $R$ contains a corner is to
-compare the local appearance to a model or template of the corner; the
-result of this comparisons produces a *cornerness score* at that
-location. This page describe general theoretical properties of the
-cornerness and the detection process. Concrete examples of cornerness
-are given in @ref covdet-corner-types.
-
-A **cornerness measure** associate a score to all possible feature
-locations in an image $\ell$. As described in @ref covdet-frame, the
-location or, more in general, pose $u$ of a feature $R$ is the warp
-$w$ that maps the canonical feature frame $R_0$ to $R$:
-
-\[
-    R = u[R_0].
-\]
-
-The goal of a cornerness measure is to associate a score $F(u;\ell)$
-to all possible feature poses $u$ and use this score to extract a
-finite number of co-variant features from any image.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-cornerness-localmax Local maxima of a cornerness measure
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Given the cornerness of each candidate feature, the detector must
-extract a finite number of them. However, the cornerness of features
-with nearly identical pose must be similar (otherwise the cornerness
-measure would be unstable). As such, simply thresholding $F(w;\ell)$
-would detect an infinite number of nearly identical features rather
-than a finite number.
-
-The solution is to detect features in correspondence of the local
-maxima of the score measure:
-
-\[
- \{w_1,\dots,w_n\} = \operatorname{localmax}_{w\in\mathcal{W}} F(w;\ell).
-\]
-
-This also means that features are never detected in isolation, but by
-comparing neighborhoods of them.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-cornerness-normalization Covariant detection by normalization
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The next difficulty is to guarantee that detection is co-variant with
-image transformations. Hence, if $u$ is the pose of a feature
-extracted from image $\ell$, then the transformed pose $u' = w[u]$
-must be detected in the transformed image $\ell' = w[\ell]$.
-
-Since features are extracted in correspondence of the local maxima of
-the cornerness score, a sufficient condition is that corresponding
-features attain the same score in the two images:
-
-\[
-\forall u\in\mathcal{W}: \quad F(u;\ell) = F(w[u];w[\ell]),
-\qquad\text{or}\qquad
-F(u;\ell) = F(w \circ u ;\ell \circ w^{-1}).
-\]
-
-One simple way to satisfy this equation is to compute a cornerness
-score *after normalizing the image* by the inverse of the candidate
-feature pose warp $u$, as follows:
-
-\[
-  F(u;\ell) = F(1;u^{-1}[\ell]) = F(1;\ell \circ u) = \mathcal{F}(\ell \circ u),
-\]
-
-where $1 = u^{-1} \circ u$ is the identity transformation and
-$\mathcal{F}$ is an arbitrary functional. Intuitively, co-variant
-detection is obtained by looking if the appearance of the feature
-resembles a corner only *after normalization*. Formally:
-
-@f{align*}
-F(w[u];w[\ell])
-&=
-F(w \circ u ;\ell \circ w^{-1})
-\\
-&=
-F(1; \ell \circ w^{-1} \circ w \circ u)
-\\
-&=
-\mathcal{F}(\ell\circ u)
-\\
-&=
-F(u;\ell).
-@f}
-
-Concrete examples of the functional $\mathcal{F}$ are given in @ref
-covdet-corner-types.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-locality Locality of the detected features
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In the definition above, the cornenress functional $\mathcal{F}$ is an
-arbitrary functional of the entire normalized image $u^{-1}[\ell]$.
-In practice, one is always interested in detecting **local features**
-(at the very least because the image extent is finite).
-
-This is easily obtained by considering a cornerness $\mathcal{F}$
-which only looks in a small region of the normalized image, usually
-corresponding to the extent of the canonical feature $R_0$ (e.g. a
-unit disc centered at the origin).
-
-In this case the extent of the local feature in the original image is
-simply given by $R = u[R_0]$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-partial Partial and iterated normalization
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Practical detectors implement variants of the ideas above. Very often,
-for instance, detection is an iterative process, in which successive
-parameters of the pose of a feature are determined. For instance, it
-is typical to first detect the location and scale of a feature using a
-rotation-invariant cornerness score $\mathcal{F}$. Once these two
-parameters are known, the rotation can be determined using a different
-score, sensitive to the orientation of the local image structures.
-
-Certain detectors (such as Harris-Laplace and Hessian-Laplace) use
-even more sophisticated schemes, in which different scores are used to
-jointly (rather than in succession) different parameters of the pose
-of a feature, such as its translation and scale. While a formal
-treatment of these cases is possible as well, we point to the original
-papers.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page covdet-differential Differential and integral image operations
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Dealing with covariant interest point detector requires working a good
-deal with derivatives, convolutions, and transformations of images.
-The notation and fundamental properties of interest here are discussed
-next.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-derivatives Derivative operations: gradients
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-For the derivatives, we borrow the notation of
-@cite{kinghorn96integrals}. Let $f: \mathbb{R}^m \rightarrow
-\mathbb{R}^n, \bx \mapsto f(\bx)$ be a vector function. The derivative
-of the function with respect to $\bx$ is given by its *Jacobian
-matrix* denoted by the symbol:
-
-\[
-\frac{\partial f}{\partial \bx^\top}
-=
-\begin{bmatrix}
-  \frac{\partial f_1}{x_1} & \frac{\partial f_1}{x_2} & \dots \\
-  \frac{\partial f_2}{x_1} & \frac{\partial f_2}{x_2} & \dots \\
-  \vdots & \vdots & \ddots \\
-\end{bmatrix}.
-\]
-
-When the function $ f $ is scalar ($n=1$), the Jacobian is the same as
-the gradient of the function (or, in fact, its transpose). More
-precisely, the <b>gradient</b> $\nabla f $ of $ f $ denotes the column
-vector of partial derivatives:
-
-\[
-\nabla f
- = \frac{\partial f}{\partial \bx}
- =
- \begin{bmatrix}
-  \frac{\partial f}{\partial x_1} \\
-  \frac{\partial f}{\partial x_2} \\
-  \vdots
-\end{bmatrix}.
-\]
-
-The second derivative $H_f $ of a scalar function $ f $, or
-<b>Hessian</b>, is denoted as
-
-\[
-H_f
-= \frac{\partial f}{\partial \bx \partial \bx^\top}
-= \frac{\partial \nabla f}{\partial \bx^\top}
-=
-\begin{bmatrix}
-  \frac{\partial f}{\partial x_1 \partial x_1} & \frac{\partial f}{\partial x_1 \partial x_2} & \dots \\
-  \frac{\partial f}{\partial x_2 \partial x_1} & \frac{\partial f}{\partial x_2 \partial x_2} & \dots \\
-  \vdots & \vdots & \ddots \\
-\end{bmatrix}.
-\]
-
-The determinant of the Hessian is also known as <b>Laplacian</b> and denoted as
-
-\[
- \Delta f = \operatorname{det} H_f =
-\frac{\partial f}{\partial x_1^2} +
-\frac{\partial f}{\partial x_2^2} +
-\dots
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-derivative-transformations Derivative and image warps
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In the following, we will often been interested in domain warpings $u:
-\mathbb{R}^m \rightarrow \mathbb{R}^n, \bx \mapsto u(\bx)$ of a
-function $f(\bar\bx) $ and its effect on the derivatives of the
-function. The key transformation is the chain rule:
-
-\[
-\frac{\partial f \circ u}{\partial \bx^\top}
-=
-\left(\frac{\partial f}{\partial \bar\bx^\top} \circ u\right)
-\frac{\partial u}{\partial \bx^\top}
-\]
-
-In particular, for an affine transformation $u = (A,T) : \bx \mapsto
-A\bx + T$, one obtains the transformation rules:
-
-\[
-\begin{align*}
-\frac{\partial f \circ (A,T)}{\partial \bx^\top}
-&=
-\left(\frac{\partial f}{\partial \bar\bx^\top} \circ (A,T)\right)A,
-\\
-\nabla (f \circ (A,T))
-&= A^\top (\nabla f) \circ (A,T),
-\\
-H_{f \circ(A,T)}
-&= A^\top (H_f \circ (A,T)) A,
-\\
-\Delta (f \circ(A,T))
-&= \det(A)^2\, (\Delta f) \circ (A,T).
-\end{align*}
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-smoothing Integral operations: smoothing
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In practice, given an image $\ell$ expressed in digital format, good
-derivative approximations can be computed only if the bandwidth of the
-image is limited and, in particular, compatible with the sampling
-density. Since it is unreasonable to expect real images to be
-band-limited, the bandwidth is artificially constrained by suitably
-smoothing the image prior to computing its derivatives. This is also
-interpreted as a form of regularization or as a way of focusing on the
-image content at a particular scale.
-
-Formally, we will focus on Gaussian smoothing kernels. For the 2D case
-$\bx\in\real^2$, the Gaussian kernel of covariance $\Sigma$ is given
-by
-
-\[
-g_{\Sigma}(\bx) = \frac{1}{2\pi \sqrt{\det\Sigma}}
-  \exp\left(
-  - \frac{1}{2} \bx^\top \Sigma^{-1} \bx
-  \right).
-\]
-
-The symbol $g_{\sigma^2}$ will be used to denote a Gaussian kernel
-with isotropic standard deviation $\sigma$, i.e. $\Sigma = \sigma^2
-I$. Given an image $\ell$, the symbol $\ell_\Sigma$ will be used to
-denote the image smoothed by the Gaussian kernel of parameter
-$\Sigma$:
-
-\[
-\ell_\Sigma(\bx) = (g_\Sigma * \ell)(\bx)
-=
-\int_{\real^m}
-g_\Sigma(\bx - \by) \ell(\by)\,d\by.
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-smoothing-transformations Smoothing and image warps
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-One advantage of Gaussian kernels is that they are (up to
-renormalization) closed under a linear warp:
-
-\[
- |A|\, g_\Sigma \circ A = g_{A^{-1} \Sigma A^{-\top}}
-\]
-
-This also means that smoothing a warped image is the same as warping
-the result of smoothing the original image by a suitably adjusted
-Gaussian kernel:
-
-\[
-g_{\Sigma} * (\ell \circ (A,T))
-=
-(g_{A\Sigma A^\top} * \ell) \circ (A,T).
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page covdet-corner-types Cornerness measures
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The goal of a cornerness measure (@ref covdet-cornerness) is to
-associate to an image patch a score proportional to how strongly the
-patch contain a certain strucuture, for example a corner or a
-blob. This page reviews the most important cornerness measures as
-implemented in VLFeat:
-
-- @ref covdet-harris
-- @ref covdet-laplacian
-- @ref covdet-hessian
-
-This page makes use of notation introduced in @ref
-covdet-differential.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-harris Harris corners
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This section introduces the fist of the cornerness measure
-$\mathcal{F}[\ell]$. Recall (@ref covdet-cornerness) that the goal of
-this functional is to respond strongly to images $\ell$ of corner-like
-structure.
-
-Rather than explicitly encoding the appearance of corners, the idea of
-the Harris measure is to label as corner *any* image patch whose
-appearance is sufficiently distinctive to allow accurate
-localization. In particular, consider an image patch $\ell(\bx),
-\bx\in\Omega$, where $\Omega$ is a smooth circular window of radius
-approximately $\sigma_i$; at necessary condition for the patch to
-allow accurate localization is that even a small translation
-$\ell(\bx+\delta)$ causes the appearance to vary significantly (if not
-the origin and location $\delta$ would not be distinguishable from the
-image alone). This variation is measured by the sum of squared
-differences
-
-\[
-E(\delta) = \int g_{\sigma_i^2}(\bx)
-(\ell_{\sigma_d^2}(\bx+\delta) -
- \ell_{\sigma_d^2}(\bx))^2 \,d\bx
-\]
-
-Note that images are compared at scale $\sigma_d$, known as
- *differentiation scale* for reasons that will be clear in a moment,
-and that the squared differences are summed over a window softly
-defined by $\sigma_i$, also known as *integration scale*. This
-function can be approximated as $E(\delta)\approx \delta^\top
-M[\ell;\sigma_i^2,\sigma_d^2] \delta$ where
-
-\[
-  M[\ell;\sigma_i^2,\sigma_d^2]
-= \int  g_{\sigma_i^2}(\bx)
- (\nabla \ell_{\sigma_d^2}(\bx))
- (\nabla \ell_{\sigma_d^2}(\bx))^\top \, d\bx.
-\]
-
-is the so called **structure tensor**.
-
-A corner is identified when the sum of squared differences $E(\delta)$
-is large for displacements $\delta$ in all directions. This condition
-is obtained when both the eignenvalues $\lambda_1,\lambda_2$ of the
-structure tensor $M$ are large. The **Harris cornerness measure**
-captures this fact:
-
-\[
- \operatorname{Harris}[\ell;\sigma_i^2,\sigma_d^2] =
- \det M - \kappa \operatorname{trace}^2 M =
- \lambda_1\lambda_2 - \kappa (\lambda_1+\lambda_2)^2
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-harris-warped Harris in the warped domain
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The cornerness measure of a feature a location $u$ (recall that
-locations $u$ are in general defined as image warps) should be
-computed after normalizing the image (by applying to it the warp
-$u^{-1}$). This section shows that, for affine warps, the Harris
-cornerness measure can be computed directly in the Gaussian affine
-scale space of the image. In particular, for similarities, it can be
-computed in the standard Gaussian scale space.
-
-To this end, let $u=(A,T)$ be an affine warp identifying a feature
-location in image $\ell(\bx)$. Let $\bar\ell(\bar\bx) =
-\ell(A\bar\bx+T)$ be the normalized image and rewrite the structure
-tensor of the normalized image as follows:
-
-\[
- M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d]
-=
- M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
-=
-\left[
-g_{\bar\Sigma_i} *
-(\nabla\bar\ell_{\bar\Sigma_d})
-(\nabla\bar\ell_{\bar\Sigma_d})^\top
-\right](\mathbf{0})
-\]
-
-This notation emphasizes that the structure tensor is obtained by
-taking derivatives and convolutions of the image. Using the fact that
-$\nabla g_{\bar\Sigma_d} * \bar\ell = A^\top (\nabla g_{A\bar\Sigma
-A^\top} * \ell) \circ (A,T)$ and that $g_{\bar\Sigma} * \bar \ell =
-(g_{A\bar\Sigma A^\top} * \ell) \circ (A,T)$, we get the equivalent
-expression:
-
-\[
- M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
- =
-A^\top
-\left[
-g_{A\bar\Sigma_i A^\top} *
-(\nabla\ell_{A\bar\Sigma_dA^\top})(\nabla\ell_{A\bar\Sigma_d A^\top})^\top
-\right](A\mathbf{0}+T)
-A.
-\]
-
-In other words, the structure tensor of the normalized image can be
-computed as:
-
-\[
-M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
-=
-A^\top M[\ell; \Sigma_i, \Sigma_d](T) A,
-\quad
-\Sigma_{i} = A\bar\Sigma_{i}A^\top,
-\quad
-\Sigma_{d} = A\bar\Sigma_{d}A^\top.
-\]
-
-This equation allows to compute the structure tensor for feature at
-all locations directly in the original image. In particular, features
-at all translations $T$ can be evaluated efficiently by computing
-convolutions and derivatives of the image
-$\ell_{A\bar\Sigma_dA^\top}$.
-
-A case of particular instance is when $\bar\Sigma_i= \bar\sigma_i^2 I$
-and $\bar\Sigma_d = \bar\sigma_d^2$ are both isotropic covariance
-matrices and the affine transformation is a similarity $A=sR$.  Using
-the fact that $\det\left( s^2 R^\top M R \right)= s^4 \det M$ and
-$\operatorname{tr}\left(s^2 R^\top M R\right) = s^2 \operatorname{tr}
-M$, one obtains the relation
-
-\[
- \operatorname{Harris}[\bar \ell;\bar\sigma_i^2,\bar\sigma_d^2] =
- s^4 \operatorname{Harris}[\ell;s^2\bar\sigma_i^2,s^2\bar\sigma_d^2](T).
-\]
-
-This equation indicates that, for similarity transformations, not only
-the structure tensor, but directly the Harris cornerness measure can
-be computed on the original image and then be transferred back to the
-normalized domain. Note, however, that this requires rescaling the
-measure by the factor $s^4$.
-
-Another important consequence of this relation is that the Harris
-measure is invariant to pure image rotations. It cannot, therefore, be
-used to associate an orientation to the detected features.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-hessian Hessian blobs
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The *(determinant of the) Hessian* cornerness measure is given
-determinant of the Hessian of the image:
-
-\[
- \operatorname{DetHess}[\ell;\sigma_d^2]
- =
- \det H_{g_{\sigma_d^2} * \ell}(\mathbf{0})
-\]
-
-This number is large and positive if the image is locally curved
-(peaked), roughly corresponding to blob-like structures in the image.
-In particular, a large score requires the product of the eigenvalues
-of the Hessian to be large, which requires both of them to have the
-same sign and are large in absolute value.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection covdet-hessian-warped Hessian in the warped domain
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Similarly to the Harris measure, it is possible to work with the
-Hessian measure on the original unnormalized image. As before, let
-$\bar\ell(\bar\bx) = \ell(A\bar\bx+T)$ be the normalized image and
-rewrite the Hessian of the normalized image as follows:
-
-\[
-H_{g_{\bar\Sigma_d} * \bar\ell}(\mathbf{0}) = A^\top \left(H_{g_{\Sigma_d} * \ell}(T)\right) A.
-\]
-
-Then
-
-\[
- \operatorname{DetHess}[\bar\ell;\bar\Sigma_d]
- =
- (\det A)^2 \operatorname{DetHess}[\ell;A\bar\Sigma_d A^\top](T).
-\]
-
-In particular, for isotropic covariance matrices and similarity
-transformations $A=sR$:
-
-\[
- \operatorname{DetHess}[\bar\ell;\bar\sigma_d^2]
- =
- s^4 \operatorname{DetHess}[\ell;s^2\bar\sigma_d^2](T)
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section covdet-laplacian Laplacian and Difference of Gaussians blobs
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The **Laplacian of Gaussian (LoG)** or **trace of the Hessian**
-cornerness measure is given by the trace of the Hessian of the image:
-
-\[
- \operatorname{Lap}[\ell;\sigma_d^2]
- =
- \operatorname{tr} H_{g_{\sigma_d}^2 * \ell}
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection covdet-laplacian-warped Laplacian in the warped domain
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-Similarly to the Hessian measure, the Laplacian cornenress can often
-be efficiently computed for features at all locations in the original
-unnormalized image domain. In particular, if the derivative covariance
-matrix $\Sigma_d$ is isotropic and one considers as warpings
-similarity transformations $A=sR$, where $R$ is a rotatin and $s$ a
-rescaling, one has
-
-\[
- \operatorname{Lap}[\bar\ell;\bar\sigma_d^2]
- =
- s^2 \operatorname{Lap}[\ell;s^2\bar\sigma_d^2](T)
-\]
-
-Note that, comparing to the Harris and determinant of Hessian
-measures, the scaling for the Laplacian is $s^2$ rather than $s^4$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection covdet-laplacian-matched Laplacian as a matched filter
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The Laplacian is given by the trace of the Hessian
-operator. Differently from the determinant of the Hessian, this is a
-linear operation. This means that computing the Laplacian cornerness
-measure can be seen as applying a linear filtering operator to the
-image. This filter can then be interpreted as a *template* of a corner
-being matched to the image. Hence, the Laplacian cornerness measure
-can be interpreted as matching this corner template at all possible
-image locations.
-
-To see this formally, compute the Laplacian score in the input image domain:
-
-\[
- \operatorname{Lap}[\bar\ell;\bar\sigma_d^2]
- =
- s^2 \operatorname{Lap}[\ell;s^2\bar\sigma_d^2](T)
- =
- s^2 (\Delta g_{s^2\bar\sigma_d^2} * \ell)(T)
-\]
-
-The Laplacian fitler is obtained by moving the Laplacian operator from
-the image to the Gaussian smoothing kernel:
-
-\[
- s^2 (\Delta g_{s^2\bar\sigma_d^2} * \ell)
-=
- (s^2 \Delta g_{s^2\bar\sigma_d^2}) * \ell
-\]
-
-Note that the filter is rescaled by the $s^2$; sometimes, this factor
-is incorporated in the Laplacian operator, yielding the so-called
-normalized Laplacian.
-
-The Laplacian of Gaussian is also called *top-hat function* and has
-the expression:
-
-\[
-\Delta g_{\sigma^2}(x,y)
-=
-\frac{x^2+y^2 - 2 \sigma^2}{\sigma^4} g_{\sigma^2}(x,y).
-\]
-
-This filter, which acts as corner template, resembles a blob (a dark
-disk surrounded by a bright ring).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection covdet-laplacian-dog Difference of Gaussians
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The **Difference of Gaussian** (DoG) cornerness measure can be
-interpreted as an approximation of the Laplacian that is easy to
-obtain once a scalespace of the input image has been computed.
-
-As noted above, the Laplacian cornerness of the normalized feature can
-be computed directly from the input image by convolving the image by
-the normalized Laplacian of Gaussian filter $s^2 \Delta
-g_{s^2\bar\sigma_d^2}$.
-
-Like the other derivative operators, this filter is simpe to
-discriteize. However, it is often approximated by computing the the
-*Difference of Gaussians* (DoG) approximation instead. This
-approximation is obtained from the easily-proved identity:
-
-\[
-  \frac{\partial}{\partial \sigma} g_{\sigma^2} =
-  \sigma \Delta g_{\sigma^2}.
-\]
-
-This indicates that computing the normalized Laplacian of a Gaussian
-filter is, in the limit, the same as taking the difference between
-Gaussian filters of slightly increasing standard deviation $\sigma$
-and $\kappa\sigma$, where $\kappa \approx 1$:
-
-\[
-\sigma^2 \Delta g_{\sigma^2}
-\approx
-\sigma \frac{g_{(\kappa\sigma)^2} - g_{\sigma^2}}{\kappa\sigma - \sigma}
-=
-\frac{1}{\kappa - 1}
-(g_{(\kappa\sigma)^2} - g_{\sigma^2}).
-\]
-
-One nice propery of this expression is that the factor $\sigma$
-cancels out in the right-hand side. Usually, scales $\sigma$ and
-$\kappa\sigma$ are pre-computed in the image scale-space and
-successive scales are sampled with uniform geometric spacing, meaning
-that the factor $\kappa$ is the same for all scales. Then, up to a
-overall scaling factor, the LoG cornerness measure can be obtained by
-taking the difference of successive scale space images
-$\ell_{(\kappa\sigma)^2}$ and $\ell_{\sigma^2}$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page covdet-affine-adaptation Affine adaptation
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page covdet-dominant-orientation Dominant orientation
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-**/
-
-#include "covdet.h"
-#include <string.h>
-
-/** @brief Reallocate buffer
- ** @param buffer
- ** @param bufferSize
- ** @param targetSize
- ** @return error code
- **/
-
-static int
-_vl_resize_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
-  void * newBuffer ;
-  if (*buffer == NULL) {
-    *buffer = vl_malloc(targetSize) ;
-    if (*buffer) {
-      *bufferSize = targetSize ;
-      return VL_ERR_OK ;
-    } else {
-      *bufferSize = 0 ;
-      return VL_ERR_ALLOC ;
-    }
-  }
-  newBuffer = vl_realloc(*buffer, targetSize) ;
-  if (newBuffer) {
-    *buffer = newBuffer ;
-    *bufferSize = targetSize ;
-    return VL_ERR_OK ;
-  } else {
-    return VL_ERR_ALLOC ;
-  }
-}
-
-/** @brief Enlarge buffer
- ** @param buffer
- ** @param bufferSize
- ** @param targetSize
- ** @return error code
- **/
-
-static int
-_vl_enlarge_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
-  if (*bufferSize >= targetSize) return VL_ERR_OK ;
-  return _vl_resize_buffer(buffer,bufferSize,targetSize) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                            Finding local extrema */
-/* ---------------------------------------------------------------- */
-
-/* Todo: make this generally available in the library */
-
-typedef struct _VlCovDetExtremum2
-{
-  vl_index xi ;
-  vl_index yi ;
-  float x ;
-  float y ;
-  float peakScore ;
-  float edgeScore ;
-} VlCovDetExtremum2 ;
-
-typedef struct _VlCovDetExtremum3
-{
-  vl_index xi ;
-  vl_index yi ;
-  vl_index zi ;
-  float x ;
-  float y ;
-  float z ;
-  float peakScore ;
-  float edgeScore ;
-} VlCovDetExtremum3 ;
-
-VL_EXPORT vl_size
-vl_find_local_extrema_3 (vl_index ** extrema, vl_size * bufferSize,
-                         float const * map,
-                         vl_size width, vl_size height, vl_size depth,
-                         double threshold) ;
-
-VL_EXPORT vl_size
-vl_find_local_extrema_2 (vl_index ** extrema, vl_size * bufferSize,
-                         float const * map,
-                         vl_size width, vl_size height,
-                         double threshold) ;
-
-VL_EXPORT vl_bool
-vl_refine_local_extreum_3 (VlCovDetExtremum3 * refined,
-                           float const * map,
-                           vl_size width, vl_size height, vl_size depth,
-                           vl_index x, vl_index y, vl_index z) ;
-
-VL_EXPORT vl_bool
-vl_refine_local_extreum_2 (VlCovDetExtremum2 * refined,
-                           float const * map,
-                           vl_size width, vl_size height,
-                           vl_index x, vl_index y) ;
-
-/** @internal
- ** @brief Find the extrema of a 3D function
- ** @param extrema buffer containing the extrema found (in/out).
- ** @param bufferSize size of the @a extrema buffer in bytes (in/out).
- ** @param map a 3D array representing the map.
- ** @param width of the map.
- ** @param height of the map.
- ** @param depth of the map.
- ** @param threshold minumum extremum value.
- ** @return number of extrema found.
- ** @see @ref ::vl_refine_local_extreum_2.
- **/
-
-vl_size
-vl_find_local_extrema_3 (vl_index ** extrema, vl_size * bufferSize,
-                         float const * map,
-                         vl_size width, vl_size height, vl_size depth,
-                         double threshold)
-{
-  vl_index x, y, z ;
-  vl_size const xo = 1 ;
-  vl_size const yo = width ;
-  vl_size const zo = width * height ;
-  float const *pt = map + xo + yo + zo ;
-
-  vl_size numExtrema = 0 ;
-  vl_size requiredSize = 0 ;
-
-#define CHECK_NEIGHBORS_3(v,CMP,SGN)     (\
-v CMP ## = SGN threshold &&               \
-v CMP *(pt + xo) &&                       \
-v CMP *(pt - xo) &&                       \
-v CMP *(pt + zo) &&                       \
-v CMP *(pt - zo) &&                       \
-v CMP *(pt + yo) &&                       \
-v CMP *(pt - yo) &&                       \
-\
-v CMP *(pt + yo + xo) &&                  \
-v CMP *(pt + yo - xo) &&                  \
-v CMP *(pt - yo + xo) &&                  \
-v CMP *(pt - yo - xo) &&                  \
-\
-v CMP *(pt + xo      + zo) &&             \
-v CMP *(pt - xo      + zo) &&             \
-v CMP *(pt + yo      + zo) &&             \
-v CMP *(pt - yo      + zo) &&             \
-v CMP *(pt + yo + xo + zo) &&             \
-v CMP *(pt + yo - xo + zo) &&             \
-v CMP *(pt - yo + xo + zo) &&             \
-v CMP *(pt - yo - xo + zo) &&             \
-\
-v CMP *(pt + xo      - zo) &&             \
-v CMP *(pt - xo      - zo) &&             \
-v CMP *(pt + yo      - zo) &&             \
-v CMP *(pt - yo      - zo) &&             \
-v CMP *(pt + yo + xo - zo) &&             \
-v CMP *(pt + yo - xo - zo) &&             \
-v CMP *(pt - yo + xo - zo) &&             \
-v CMP *(pt - yo - xo - zo) )
-
-  for (z = 1 ; z < (signed)depth - 1 ; ++z) {
-    for (y = 1 ; y < (signed)height - 1 ; ++y) {
-      for (x = 1 ; x < (signed)width - 1 ; ++x) {
-        float value = *pt ;
-        if (CHECK_NEIGHBORS_3(value,>,+) || CHECK_NEIGHBORS_3(value,<,-)) {
-          numExtrema ++ ;
-          requiredSize += sizeof(vl_index) * 3 ;
-          if (*bufferSize < requiredSize) {
-            int err = _vl_resize_buffer((void**)extrema, bufferSize,
-                                        requiredSize + 2000 * 3 * sizeof(vl_index)) ;
-            if (err != VL_ERR_OK) abort() ;
-          }
-          (*extrema) [3 * (numExtrema - 1) + 0] = x ;
-          (*extrema) [3 * (numExtrema - 1) + 1] = y ;
-          (*extrema) [3 * (numExtrema - 1) + 2] = z ;
-        }
-        pt += xo ;
-      }
-      pt += 2*xo ;
-    }
-    pt += 2*yo ;
-  }
-  return numExtrema ;
-}
-
-/** @internal
- ** @brief Find extrema in a 2D function
- ** @param extrema buffer containing the found extrema (in/out).
- ** @param bufferSize size of the @a extrema buffer in bytes (in/out).
- ** @param map a 3D array representing the map.
- ** @param width of the map.
- ** @param height of the map.
- ** @param threshold minumum extremum value.
- ** @return number of extrema found.
- **
- ** An extremum contains 2 ::vl_index values; they are arranged
- ** sequentially.
- **
- ** The function can reuse an already allocated buffer if
- ** @a extrema and @a bufferSize are initialized on input.
- ** It may have to @a realloc the memory if the buffer is too small.
- **/
-
-vl_size
-vl_find_local_extrema_2 (vl_index ** extrema, vl_size * bufferSize,
-                         float const* map,
-                         vl_size width, vl_size height,
-                         double threshold)
-{
-  vl_index x, y ;
-  vl_size const xo = 1 ;
-  vl_size const yo = width ;
-  float const *pt = map + xo + yo ;
-
-  vl_size numExtrema = 0 ;
-  vl_size requiredSize = 0 ;
-#define CHECK_NEIGHBORS_2(v,CMP,SGN)     (\
-v CMP ## = SGN threshold &&               \
-v CMP *(pt + xo) &&                       \
-v CMP *(pt - xo) &&                       \
-v CMP *(pt + yo) &&                       \
-v CMP *(pt - yo) &&                       \
-\
-v CMP *(pt + yo + xo) &&                  \
-v CMP *(pt + yo - xo) &&                  \
-v CMP *(pt - yo + xo) &&                  \
-v CMP *(pt - yo - xo) )
-
-  for (y = 1 ; y < (signed)height - 1 ; ++y) {
-    for (x = 1 ; x < (signed)width - 1 ; ++x) {
-      float value = *pt ;
-      if (CHECK_NEIGHBORS_2(value,>,+) || CHECK_NEIGHBORS_2(value,<,-)) {
-        numExtrema ++ ;
-        requiredSize += sizeof(vl_index) * 2 ;
-        if (*bufferSize < requiredSize) {
-          int err = _vl_resize_buffer((void**)extrema, bufferSize,
-                                      requiredSize + 2000 * 2 * sizeof(vl_index)) ;
-          if (err != VL_ERR_OK) abort() ;
-        }
-        (*extrema) [2 * (numExtrema - 1) + 0] = x ;
-        (*extrema) [2 * (numExtrema - 1) + 1] = y ;
-      }
-      pt += xo ;
-    }
-    pt += 2*xo ;
-  }
-  return numExtrema ;
-}
-
-/** @internal
- ** @brief Refine the location of a local extremum of a 3D map
- ** @param refined refined extremum (out).
- ** @param map a 3D array representing the map.
- ** @param width of the map.
- ** @param height of the map.
- ** @param depth of the map.
- ** @param x initial x position.
- ** @param y initial y position.
- ** @param z initial z position.
- ** @return a flat indicating whether the extrema refinement was stable.
- **/
-
-VL_EXPORT vl_bool
-vl_refine_local_extreum_3 (VlCovDetExtremum3 * refined,
-                           float const * map,
-                           vl_size width, vl_size height, vl_size depth,
-                           vl_index x, vl_index y, vl_index z)
-{
-  vl_size const xo = 1 ;
-  vl_size const yo = width ;
-  vl_size const zo = width * height ;
-
-  double Dx=0,Dy=0,Dz=0,Dxx=0,Dyy=0,Dzz=0,Dxy=0,Dxz=0,Dyz=0 ;
-  double A [3*3], b [3] ;
-
-#define at(dx,dy,dz) (*(pt + (dx)*xo + (dy)*yo + (dz)*zo))
-#define Aat(i,j) (A[(i)+(j)*3])
-
-  float const * pt ;
-  vl_index dx = 0 ;
-  vl_index dy = 0 ;
-  /*vl_index dz = 0 ;*/
-  vl_index iter ;
-  int err ;
-
-  assert (map) ;
-  assert (1 <= x && x <= (signed)width - 2) ;
-  assert (1 <= y && y <= (signed)height - 2) ;
-  assert (1 <= z && z <= (signed)depth - 2) ;
-
-  for (iter = 0 ; iter < 5 ; ++iter) {
-    x += dx ;
-    y += dy ;
-    pt = map + x*xo + y*yo + z*zo ;
-
-    /* compute the gradient */
-    Dx = 0.5 * (at(+1,0,0) - at(-1,0,0)) ;
-    Dy = 0.5 * (at(0,+1,0) - at(0,-1,0));
-    Dz = 0.5 * (at(0,0,+1) - at(0,0,-1)) ;
-
-    /* compute the Hessian */
-    Dxx = (at(+1,0,0) + at(-1,0,0) - 2.0 * at(0,0,0)) ;
-    Dyy = (at(0,+1,0) + at(0,-1,0) - 2.0 * at(0,0,0)) ;
-    Dzz = (at(0,0,+1) + at(0,0,-1) - 2.0 * at(0,0,0)) ;
-
-    Dxy = 0.25 * (at(+1,+1,0) + at(-1,-1,0) - at(-1,+1,0) - at(+1,-1,0)) ;
-    Dxz = 0.25 * (at(+1,0,+1) + at(-1,0,-1) - at(-1,0,+1) - at(+1,0,-1)) ;
-    Dyz = 0.25 * (at(0,+1,+1) + at(0,-1,-1) - at(0,-1,+1) - at(0,+1,-1)) ;
-
-    /* solve linear system */
-    Aat(0,0) = Dxx ;
-    Aat(1,1) = Dyy ;
-    Aat(2,2) = Dzz ;
-    Aat(0,1) = Aat(1,0) = Dxy ;
-    Aat(0,2) = Aat(2,0) = Dxz ;
-    Aat(1,2) = Aat(2,1) = Dyz ;
-
-    b[0] = - Dx ;
-    b[1] = - Dy ;
-    b[2] = - Dz ;
-
-    err = vl_solve_linear_system_3(b, A, b) ;
-
-    if (err != VL_ERR_OK) {
-      b[0] = 0 ;
-      b[1] = 0 ;
-      b[2] = 0 ;
-      break ;
-    }
-
-    /* Keep going if there is sufficient translation */
-
-    dx = (b[0] > 0.6 && x < (signed)width - 2 ?  1 : 0)
-    + (b[0] < -0.6 && x > 1 ? -1 : 0) ;
-
-    dy = (b[1] > 0.6 && y < (signed)height - 2 ?  1 : 0)
-    + (b[1] < -0.6 && y > 1 ? -1 : 0) ;
-
-    if (dx == 0 && dy == 0) break ;
-  }
-
-  /* check threshold and other conditions */
-  {
-    double peakScore = at(0,0,0)
-    + 0.5 * (Dx * b[0] + Dy * b[1] + Dz * b[2]) ;
-    double alpha = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
-    double edgeScore ;
-
-    if (alpha < 0) {
-      /* not an extremum */
-      edgeScore = VL_INFINITY_D ;
-    } else {
-      edgeScore = (0.5*alpha - 1) + sqrt(VL_MAX(0.25*alpha - 1,0)*alpha) ;
-    }
-
-    refined->xi = x ;
-    refined->yi = y ;
-    refined->zi = z ;
-    refined->x = x + b[0] ;
-    refined->y = y + b[1] ;
-    refined->z = z + b[2] ;
-    refined->peakScore = peakScore ;
-    refined->edgeScore = edgeScore ;
-
-    return
-    err == VL_ERR_OK &&
-    vl_abs_d(b[0]) < 1.5 &&
-    vl_abs_d(b[1]) < 1.5 &&
-    vl_abs_d(b[2]) < 1.5 &&
-    0 <= refined->x && refined->x <= (signed)width - 1 &&
-    0 <= refined->y && refined->y <= (signed)height - 1 &&
-    0 <= refined->z && refined->z <= (signed)depth - 1 ;
-  }
-#undef Aat
-#undef at
-}
-
-/** @internal
- ** @brief Refine the location of a local extremum of a 2D map
- ** @param refined refined extremum (out).
- ** @param map a 2D array representing the map.
- ** @param width of the map.
- ** @param height of the map.
- ** @param x initial x position.
- ** @param y initial y position.
- ** @return a flat indicating whether the extrema refinement was stable.
- **/
-
-VL_EXPORT vl_bool
-vl_refine_local_extreum_2 (VlCovDetExtremum2 * refined,
-                           float const * map,
-                           vl_size width, vl_size height,
-                           vl_index x, vl_index y)
-{
-  vl_size const xo = 1 ;
-  vl_size const yo = width ;
-
-  double Dx=0,Dy=0,Dxx=0,Dyy=0,Dxy=0;
-  double A [2*2], b [2] ;
-
-#define at(dx,dy) (*(pt + (dx)*xo + (dy)*yo ))
-#define Aat(i,j) (A[(i)+(j)*2])
-
-  float const * pt ;
-  vl_index dx = 0 ;
-  vl_index dy = 0 ;
-  vl_index iter ;
-  int err ;
-
-  assert (map) ;
-  assert (1 <= x && x <= (signed)width - 2) ;
-  assert (1 <= y && y <= (signed)height - 2) ;
-
-  for (iter = 0 ; iter < 5 ; ++iter) {
-    x += dx ;
-    y += dy ;
-    pt = map + x*xo + y*yo  ;
-
-    /* compute the gradient */
-    Dx = 0.5 * (at(+1,0) - at(-1,0)) ;
-    Dy = 0.5 * (at(0,+1) - at(0,-1));
-
-    /* compute the Hessian */
-    Dxx = (at(+1,0) + at(-1,0) - 2.0 * at(0,0)) ;
-    Dyy = (at(0,+1) + at(0,-1) - 2.0 * at(0,0)) ;
-    Dxy = 0.25 * (at(+1,+1) + at(-1,-1) - at(-1,+1) - at(+1,-1)) ;
-
-    /* solve linear system */
-    Aat(0,0) = Dxx ;
-    Aat(1,1) = Dyy ;
-    Aat(0,1) = Aat(1,0) = Dxy ;
-
-    b[0] = - Dx ;
-    b[1] = - Dy ;
-
-    err = vl_solve_linear_system_2(b, A, b) ;
-
-    if (err != VL_ERR_OK) {
-      b[0] = 0 ;
-      b[1] = 0 ;
-      break ;
-    }
-
-    /* Keep going if there is sufficient translation */
-
-    dx = (b[0] > 0.6 && x < (signed)width - 2 ?  1 : 0)
-    + (b[0] < -0.6 && x > 1 ? -1 : 0) ;
-
-    dy = (b[1] > 0.6 && y < (signed)height - 2 ?  1 : 0)
-    + (b[1] < -0.6 && y > 1 ? -1 : 0) ;
-
-    if (dx == 0 && dy == 0) break ;
-  }
-
-  /* check threshold and other conditions */
-  {
-    double peakScore = at(0,0) + 0.5 * (Dx * b[0] + Dy * b[1]) ;
-    double alpha = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
-    double edgeScore ;
-
-    if (alpha < 0) {
-      /* not an extremum */
-      edgeScore = VL_INFINITY_D ;
-    } else {
-      edgeScore = (0.5*alpha - 1) + sqrt(VL_MAX(0.25*alpha - 1,0)*alpha) ;
-    }
-
-    refined->xi = x ;
-    refined->yi = y ;
-    refined->x = x + b[0] ;
-    refined->y = y + b[1] ;
-    refined->peakScore = peakScore ;
-    refined->edgeScore = edgeScore ;
-
-    return
-    err == VL_ERR_OK &&
-    vl_abs_d(b[0]) < 1.5 &&
-    vl_abs_d(b[1]) < 1.5 &&
-    0 <= refined->x && refined->x <= (signed)width - 1 &&
-    0 <= refined->y && refined->y <= (signed)height - 1 ;
-  }
-#undef Aat
-#undef at
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                Covarant detector */
-/* ---------------------------------------------------------------- */
-
-#define VL_COVDET_MAX_NUM_ORIENTATIONS 4
-#define VL_COVDET_MAX_NUM_LAPLACIAN_SCALES 4
-#define VL_COVDET_AA_PATCH_RESOLUTION 20
-#define VL_COVDET_AA_MAX_NUM_ITERATIONS 15
-#define VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS 36
-#define VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA 3
-#define VL_COVDET_AA_RELATIVE_DERIVATIVE_SIGMA 1
-#define VL_COVDET_AA_MAX_ANISOTROPY 5
-#define VL_COVDET_AA_CONVERGENCE_THRESHOLD 1.001
-#define VL_COVDET_AA_ACCURATE_SMOOTHING VL_FALSE
-#define VL_COVDET_AA_PATCH_EXTENT (3*VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA)
-#define VL_COVDET_OR_ADDITIONAL_PEAKS_RELATIVE_SIZE 0.8
-#define VL_COVDET_LAP_NUM_LEVELS 10
-#define VL_COVDET_LAP_PATCH_RESOLUTION 16
-#define VL_COVDET_LAP_DEF_PEAK_THRESHOLD 0.01
-#define VL_COVDET_DOG_DEF_PEAK_THRESHOLD VL_COVDET_LAP_DEF_PEAK_THRESHOLD
-#define VL_COVDET_DOG_DEF_EDGE_THRESHOLD 10.0
-#define VL_COVDET_HARRIS_DEF_PEAK_THRESHOLD 0.000002
-#define VL_COVDET_HARRIS_DEF_EDGE_THRESHOLD 10.0
-#define VL_COVDET_HESSIAN_DEF_PEAK_THRESHOLD 0.003
-#define VL_COVDET_HESSIAN_DEF_EDGE_THRESHOLD 10.0
-
-/** @brief Covariant feature detector */
-struct _VlCovDet
-{
-  VlScaleSpace *gss ;        /**< Gaussian scale space. */
-  VlScaleSpace *css ;        /**< Cornerness scale space. */
-  VlCovDetMethod method ;    /**< feature extraction method. */
-  double peakThreshold ;     /**< peak threshold. */
-  double edgeThreshold ;     /**< edge threshold. */
-  double lapPeakThreshold;   /**< peak threshold for Laplacian scale selection. */
-  vl_size octaveResolution ; /**< resolution of each octave. */
-  vl_index firstOctave ;     /**< index of the first octave. */
-
-  double nonExtremaSuppression ;
-  vl_size numNonExtremaSuppressed ;
-
-  VlCovDetFeature *features ;
-  vl_size numFeatures ;
-  vl_size numFeatureBufferSize ;
-
-  float * patch ;
-  vl_size patchBufferSize ;
-
-  vl_bool transposed ;
-  VlCovDetFeatureOrientation orientations [VL_COVDET_MAX_NUM_ORIENTATIONS] ;
-  VlCovDetFeatureLaplacianScale scales [VL_COVDET_MAX_NUM_LAPLACIAN_SCALES] ;
-
-  vl_bool aaAccurateSmoothing ;
-  float aaPatch [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
-  float aaPatchX [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
-  float aaPatchY [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
-  float aaMask [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
-
-  float lapPatch [(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)] ;
-  float laplacians [(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*VL_COVDET_LAP_NUM_LEVELS] ;
-  vl_size numFeaturesWithNumScales [VL_COVDET_MAX_NUM_LAPLACIAN_SCALES + 1] ;
-}  ;
-
-VlEnumerator vlCovdetMethods [VL_COVDET_METHOD_NUM] = {
-  {"DoG" ,              (vl_index)VL_COVDET_METHOD_DOG               },
-  {"Hessian",           (vl_index)VL_COVDET_METHOD_HESSIAN           },
-  {"HessianLaplace",    (vl_index)VL_COVDET_METHOD_HESSIAN_LAPLACE   },
-  {"HarrisLaplace",     (vl_index)VL_COVDET_METHOD_HARRIS_LAPLACE    },
-  {"MultiscaleHessian", (vl_index)VL_COVDET_METHOD_MULTISCALE_HESSIAN},
-  {"MultiscaleHarris",  (vl_index)VL_COVDET_METHOD_MULTISCALE_HARRIS },
-  {0,                   0                                            }
-} ;
-
-/** @brief Create a new object instance
- ** @param method method for covariant feature detection.
- ** @return new covariant detector.
- **/
-
-VlCovDet *
-vl_covdet_new (VlCovDetMethod method)
-{
-  VlCovDet * self = vl_calloc(sizeof(VlCovDet),1) ;
-  self->method = method ;
-  self->octaveResolution = 3 ;
-  self->firstOctave = -1 ;
-  switch (self->method) {
-    case VL_COVDET_METHOD_DOG :
-      self->peakThreshold = VL_COVDET_DOG_DEF_PEAK_THRESHOLD ;
-      self->edgeThreshold = VL_COVDET_DOG_DEF_EDGE_THRESHOLD ;
-      self->lapPeakThreshold = 0  ; /* not used */
-      break ;
-    case VL_COVDET_METHOD_HARRIS_LAPLACE:
-    case VL_COVDET_METHOD_MULTISCALE_HARRIS:
-      self->peakThreshold = VL_COVDET_HARRIS_DEF_PEAK_THRESHOLD ;
-      self->edgeThreshold = VL_COVDET_HARRIS_DEF_EDGE_THRESHOLD ;
-      self->lapPeakThreshold = VL_COVDET_LAP_DEF_PEAK_THRESHOLD ;
-      break ;
-    case VL_COVDET_METHOD_HESSIAN :
-    case VL_COVDET_METHOD_HESSIAN_LAPLACE:
-    case VL_COVDET_METHOD_MULTISCALE_HESSIAN:
-      self->peakThreshold = VL_COVDET_HESSIAN_DEF_PEAK_THRESHOLD ;
-      self->edgeThreshold = VL_COVDET_HESSIAN_DEF_EDGE_THRESHOLD ;
-      self->lapPeakThreshold = VL_COVDET_LAP_DEF_PEAK_THRESHOLD ;
-      break;
-    default:
-      assert(0) ;
-  }
-
-  self->nonExtremaSuppression = 0.5 ;
-  self->features = NULL ;
-  self->numFeatures = 0 ;
-  self->numFeatureBufferSize = 0 ;
-  self->patch = NULL ;
-  self->patchBufferSize = 0 ;
-  self->transposed = VL_FALSE ;
-  self->aaAccurateSmoothing = VL_COVDET_AA_ACCURATE_SMOOTHING ;
-
-  {
-    vl_index const w = VL_COVDET_AA_PATCH_RESOLUTION ;
-    vl_index i,j ;
-    double step = (2.0 * VL_COVDET_AA_PATCH_EXTENT) / (2*w+1) ;
-    double sigma = VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA ;
-    for (j = -w ; j <= w ; ++j) {
-      for (i = -w ; i <= w ; ++i) {
-        double dx = i*step/sigma ;
-        double dy = j*step/sigma ;
-        self->aaMask[(i+w) + (2*w+1)*(j+w)] = exp(-0.5*(dx*dx+dy*dy)) ;
-      }
-    }
-  }
-
-  {
-    /*
-     Covers one octave of Laplacian filters, from sigma=1 to sigma=2.
-     The spatial sampling step is 0.5.
-     */
-    vl_index s ;
-    for (s = 0 ; s < VL_COVDET_LAP_NUM_LEVELS ; ++s) {
-      double sigmaLap = pow(2.0, -0.5 +
-                            (double)s / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
-      double const sigmaImage = 1.0 / sqrt(2.0) ;
-      double const step = 0.5 * sigmaImage ;
-      double const sigmaDelta = sqrt(sigmaLap*sigmaLap - sigmaImage*sigmaImage) ;
-      vl_size const w = VL_COVDET_LAP_PATCH_RESOLUTION ;
-      vl_size const num = 2 * w + 1  ;
-      float * pt = self->laplacians + s * (num * num) ;
-
-      memset(pt, 0, num * num * sizeof(float)) ;
-
-#define at(x,y) pt[(x+w)+(y+w)*(2*w+1)]
-      at(0,0) = - 4.0 ;
-      at(-1,0) = 1.0 ;
-      at(+1,0) = 1.0 ;
-      at(0,1) = 1.0 ;
-      at(0,-1) = 1.0 ;
-#undef at
-
-      vl_imsmooth_f(pt, num,
-                    pt, num, num, num,
-                    sigmaDelta / step, sigmaDelta / step) ;
-
-#if 0
-      {
-        char name [200] ;
-        snprintf(name, 200, "/tmp/%f-lap.pgm", sigmaDelta) ;
-        vl_pgm_write_f(name, pt, num, num) ;
-      }
-#endif
-
-    }
-  }
-  return self ;
-}
-
-/** @brief Reset object
- ** @param self object.
- **
- ** This function removes any buffered features and frees other
- ** internal buffers.
- **/
-
-void
-vl_covdet_reset (VlCovDet * self)
-{
-  if (self->features) {
-    vl_free(self->features) ;
-    self->features = NULL ;
-  }
-  if (self->css) {
-    vl_scalespace_delete(self->css) ;
-    self->css = NULL ;
-  }
-  if (self->gss) {
-    vl_scalespace_delete(self->gss) ;
-    self->gss = NULL ;
-  }
-}
-
-/** @brief Delete object instance
- ** @param self object.
- **/
-
-void
-vl_covdet_delete (VlCovDet * self)
-{
-  vl_covdet_reset(self) ;
-  if (self->patch) vl_free (self->patch) ;
-  vl_free(self) ;
-}
-
-/** @brief Append a feature to the internal buffer.
- ** @param self object.
- ** @param feature a pointer to the feature to append.
- ** @return status.
- **
- ** The feature is copied. The function may fail with @c status
- ** equal to ::VL_ERR_ALLOC if there is insufficient memory.
- **/
-
-int
-vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature)
-{
-  vl_size requiredSize ;
-  assert(self) ;
-  assert(feature) ;
-  self->numFeatures ++ ;
-  requiredSize = self->numFeatures * sizeof(VlCovDetFeature) ;
-  if (requiredSize > self->numFeatureBufferSize) {
-    int err = _vl_resize_buffer((void**)&self->features, &self->numFeatureBufferSize,
-                                (self->numFeatures + 1000) * sizeof(VlCovDetFeature)) ;
-    if (err) {
-      self->numFeatures -- ;
-      return err ;
-    }
-  }
-  self->features[self->numFeatures - 1] = *feature ;
-  return VL_ERR_OK ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Process a new image */
-/* ---------------------------------------------------------------- */
-
-/** @brief Detect features in an image
- ** @param self object.
- ** @param image image to process.
- ** @param width image width.
- ** @param height image height.
- ** @return status.
- **
- ** @a width and @a height must be at least one pixel. The function
- ** fails by returing ::VL_ERR_ALLOC if the memory is insufficient.
- **/
-
-int
-vl_covdet_put_image (VlCovDet * self,
-                     float const * image,
-                     vl_size width, vl_size height)
-{
-  vl_size const minOctaveSize = 16 ;
-  vl_index lastOctave ;
-  vl_index octaveFirstSubdivision ;
-  vl_index octaveLastSubdivision ;
-  VlScaleSpaceGeometry geom = vl_scalespace_get_default_geometry(width,height) ;
-
-  assert (self) ;
-  assert (image) ;
-  assert (width >= 1) ;
-  assert (height >= 1) ;
-
-  /* (minOctaveSize - 1) 2^lastOctave <= min(width,height) - 1 */
-  lastOctave = vl_floor_d(vl_log2_d(VL_MIN((double)width-1,(double)height-1) / (minOctaveSize - 1))) ;
-
-  if (self->method == VL_COVDET_METHOD_DOG) {
-    octaveFirstSubdivision = -1 ;
-    octaveLastSubdivision = self->octaveResolution + 1 ;
-  } else if (self->method == VL_COVDET_METHOD_HESSIAN) {
-    octaveFirstSubdivision = -1 ;
-    octaveLastSubdivision = self->octaveResolution ;
-  } else {
-    octaveFirstSubdivision = 0 ;
-    octaveLastSubdivision = self->octaveResolution - 1 ;
-  }
-
-  geom.width = width ;
-  geom.height = height ;
-  geom.firstOctave = self->firstOctave ;
-  geom.lastOctave = lastOctave ;
-  geom.octaveResolution = self->octaveResolution ;
-  geom.octaveFirstSubdivision = octaveFirstSubdivision ;
-  geom.octaveLastSubdivision = octaveLastSubdivision ;
-
-  if (self->gss == NULL ||
-      ! vl_scalespacegeometry_is_equal (geom,
-                                        vl_scalespace_get_geometry(self->gss)))
-  {
-    if (self->gss) vl_scalespace_delete(self->gss) ;
-    self->gss = vl_scalespace_new_with_geometry(geom) ;
-    if (self->gss == NULL) return VL_ERR_ALLOC ;
-  }
-  vl_scalespace_put_image(self->gss, image) ;
-  return VL_ERR_OK ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Cornerness measures */
-/* ---------------------------------------------------------------- */
-
-/** @brief Scaled derminant of the Hessian filter
- ** @param hessian output image.
- ** @param image input image.
- ** @param width image width.
- ** @param height image height.
- ** @param step image sampling step (pixel size).
- ** @param sigma Gaussian smoothing of the input image.
- **/
-
-static void
-_vl_det_hessian_response (float * hessian,
-                          float const * image,
-                          vl_size width, vl_size height,
-                          double step, double sigma)
-{
-  float factor = (float) pow(sigma/step, 4.0) ;
-  vl_index const xo = 1 ; /* x-stride */
-  vl_index const yo = width;  /* y-stride */
-  vl_size r, c;
-
-  float p11, p12, p13, p21, p22, p23, p31, p32, p33;
-
-  /* setup input pointer to be centered at 0,1 */
-  float const *in = image + yo ;
-
-  /* setup output pointer to be centered at 1,1 */
-  float *out = hessian + xo + yo;
-
-  /* move 3x3 window and convolve */
-  for (r = 1; r < height - 1; ++r)
-  {
-    /* fill in shift registers at the beginning of the row */
-    p11 = in[-yo]; p12 = in[xo - yo];
-    p21 = in[  0]; p22 = in[xo     ];
-    p31 = in[+yo]; p32 = in[xo + yo];
-    /* setup input pointer to (2,1) of the 3x3 square */
-    in += 2;
-    for (c = 1; c < width - 1; ++c)
-    {
-      float Lxx, Lyy, Lxy;
-      /* fetch remaining values (last column) */
-      p13 = in[-yo]; p23 = *in; p33 = in[+yo];
-
-      /* Compute 3x3 Hessian values from pixel differences. */
-      Lxx = (-p21 + 2*p22 - p23);
-      Lyy = (-p12 + 2*p22 - p32);
-      Lxy = ((p11 - p31 - p13 + p33)/4.0f);
-
-      /* normalize and write out */
-      *out = (Lxx * Lyy - Lxy * Lxy) * factor ;
-
-      /* move window */
-      p11=p12; p12=p13;
-      p21=p22; p22=p23;
-      p31=p32; p32=p33;
-
-      /* move input/output pointers */
-      in++; out++;
-    }
-    out += 2;
-  }
-
-  /* Copy the computed values to borders */
-  in = hessian + yo + xo ;
-  out = hessian + xo ;
-
-  /* Top row without corners */
-  memcpy(out, in, (width - 2)*sizeof(float));
-  out--;
-  in -= yo;
-
-  /* Left border columns without last row */
-  for (r = 0; r < height - 1; r++){
-    *out = *in;
-    *(out + yo - 1) = *(in + yo - 3);
-    in += yo;
-    out += yo;
-  }
-
-  /* Bottom corners */
-  in -= yo;
-  *out = *in;
-  *(out + yo - 1) = *(in + yo - 3);
-
-  /* Bottom row without corners */
-  out++;
-  memcpy(out, in, (width - 2)*sizeof(float));
-}
-
-/** @brief Scale-normalised Harris response
- ** @param harris output image.
- ** @param image input image.
- ** @param width image width.
- ** @param height image height.
- ** @param step image sampling step (pixel size).
- ** @param sigma Gaussian smoothing of the input image.
- ** @param sigmaI integration scale.
- ** @param alpha factor in the definition of the Harris score.
- **/
-
-static void
-_vl_harris_response (float * harris,
-                     float const * image,
-                     vl_size width, vl_size height,
-                     double step, double sigma,
-                     double sigmaI, double alpha)
-{
-  float factor = (float) pow(sigma/step, 4.0) ;
-  vl_index k ;
-
-  float * LxLx ;
-  float * LyLy ;
-  float * LxLy ;
-
-  LxLx = vl_malloc(sizeof(float) * width * height) ;
-  LyLy = vl_malloc(sizeof(float) * width * height) ;
-  LxLy = vl_malloc(sizeof(float) * width * height) ;
-
-  vl_imgradient_f (LxLx, LyLy, 1, width, image, width, height, width) ;
-
-  for (k = 0 ; k < (signed)(width * height) ; ++k) {
-    float dx = LxLx[k] ;
-    float dy = LyLy[k] ;
-    LxLx[k] = dx*dx ;
-    LyLy[k] = dy*dy ;
-    LxLy[k] = dx*dy ;
-  }
-
-  vl_imsmooth_f(LxLx, width, LxLx, width, height, width,
-                sigmaI / step, sigmaI / step) ;
-
-  vl_imsmooth_f(LyLy, width, LyLy, width, height, width,
-                sigmaI / step, sigmaI / step) ;
-
-  vl_imsmooth_f(LxLy, width, LxLy, width, height, width,
-                sigmaI / step, sigmaI / step) ;
-
-  for (k = 0 ; k < (signed)(width * height) ; ++k) {
-    float a = LxLx[k] ;
-    float b = LyLy[k] ;
-    float c = LxLy[k] ;
-
-    float determinant = a * b - c * c ;
-    float trace = a + b ;
-
-    harris[k] = factor * (determinant - alpha * (trace * trace)) ;
-  }
-
-  vl_free(LxLy) ;
-  vl_free(LyLy) ;
-  vl_free(LxLx) ;
-}
-
-/** @brief Difference of Gaussian
- ** @param dog output image.
- ** @param level1 input image at the smaller Gaussian scale.
- ** @param level2 input image at the larger Gaussian scale.
- ** @param width image width.
- ** @param height image height.
- **/
-
-static void
-_vl_dog_response (float * dog,
-                  float const * level1,
-                  float const * level2,
-                  vl_size width, vl_size height)
-{
-  vl_index k ;
-  for (k = 0 ; k < (signed)(width*height) ; ++k) {
-    dog[k] = level2[k] - level1[k] ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                  Detect features */
-/* ---------------------------------------------------------------- */
-
-/** @brief Detect scale-space features
- ** @param self object.
- **
- ** This function runs the configured feature detector on the image
- ** that was passed by using ::vl_covdet_put_image.
- **/
-
-void
-vl_covdet_detect (VlCovDet * self, vl_size max_num_features)
-{
-  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
-  VlScaleSpaceGeometry cgeom ;
-  float * levelxx = NULL ;
-  float * levelyy = NULL ;
-  float * levelxy = NULL ;
-  vl_index o, s ;
-
-  assert (self) ;
-  assert (self->gss) ;
-
-  /* clear previous detections if any */
-  self->numFeatures = 0 ;
-
-  /* prepare buffers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-  cgeom = geom ;
-  if (self->method == VL_COVDET_METHOD_DOG) {
-    cgeom.octaveLastSubdivision -= 1 ;
-  }
-  if (!self->css ||
-      !vl_scalespacegeometry_is_equal(cgeom,
-                                      vl_scalespace_get_geometry(self->css)))
-  {
-    if (self->css) vl_scalespace_delete(self->css) ;
-    self->css = vl_scalespace_new_with_geometry(cgeom) ;
-  }
-  if (self->method == VL_COVDET_METHOD_HARRIS_LAPLACE ||
-      self->method == VL_COVDET_METHOD_MULTISCALE_HARRIS) {
-    VlScaleSpaceOctaveGeometry oct = vl_scalespace_get_octave_geometry(self->gss, geom.firstOctave) ;
-    levelxx = vl_malloc(oct.width * oct.height * sizeof(float)) ;
-    levelyy = vl_malloc(oct.width * oct.height * sizeof(float)) ;
-    levelxy = vl_malloc(oct.width * oct.height * sizeof(float)) ;
-  }
-
-  /* compute cornerness ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-  for (o = cgeom.firstOctave ; o <= cgeom.lastOctave ; ++o) {
-    VlScaleSpaceOctaveGeometry oct = vl_scalespace_get_octave_geometry(self->css, o) ;
-
-    for (s = cgeom.octaveFirstSubdivision ; s <= cgeom.octaveLastSubdivision ; ++s) {
-      float * level = vl_scalespace_get_level(self->gss, o, s) ;
-      float * clevel = vl_scalespace_get_level(self->css, o, s) ;
-      double sigma = vl_scalespace_get_level_sigma(self->css, o, s) ;
-      switch (self->method) {
-        case VL_COVDET_METHOD_DOG:
-          _vl_dog_response(clevel,
-                           vl_scalespace_get_level(self->gss, o, s + 1),
-                           level,
-                           oct.width, oct.height) ;
-          break ;
-
-        case VL_COVDET_METHOD_HARRIS_LAPLACE:
-        case VL_COVDET_METHOD_MULTISCALE_HARRIS:
-          _vl_harris_response(clevel,
-                              level, oct.width, oct.height, oct.step,
-                              sigma, 1.4 * sigma, 0.05) ;
-          break ;
-
-        case VL_COVDET_METHOD_HESSIAN:
-        case VL_COVDET_METHOD_HESSIAN_LAPLACE:
-        case VL_COVDET_METHOD_MULTISCALE_HESSIAN:
-          _vl_det_hessian_response(clevel, level, oct.width, oct.height, oct.step, sigma) ;
-          break ;
-
-        default:
-          assert(0) ;
-      }
-    }
-  }
-
-  /* find and refine local maxima ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-  {
-    vl_index * extrema = NULL ;
-    vl_size extremaBufferSize = 0 ;
-    vl_size numExtrema ;
-    vl_size index ;
-    for (o = cgeom.lastOctave; o >= cgeom.firstOctave; --o) {
-      VlScaleSpaceOctaveGeometry octgeom = vl_scalespace_get_octave_geometry(self->css, o) ;
-      double step = octgeom.step ;
-      vl_size width = octgeom.width ;
-      vl_size height = octgeom.height ;
-      vl_size depth = cgeom.octaveLastSubdivision - cgeom.octaveFirstSubdivision + 1 ;
-
-      switch (self->method) {
-        case VL_COVDET_METHOD_DOG:
-        case VL_COVDET_METHOD_HESSIAN:
-        {
-          /* scale-space extrema */
-          float const * octave =
-          vl_scalespace_get_level(self->css, o, cgeom.octaveFirstSubdivision) ;
-          numExtrema = vl_find_local_extrema_3(&extrema, &extremaBufferSize,
-                                               octave, width, height, depth,
-                                               0.8 * self->peakThreshold);
-          for (index = 0 ; index < numExtrema ; ++index) {
-            VlCovDetExtremum3 refined ;
-            VlCovDetFeature feature ;
-            vl_bool ok ;
-            memset(&feature, 0, sizeof(feature)) ;
-            ok = vl_refine_local_extreum_3(&refined,
-                                           octave, width, height, depth,
-                                           extrema[3*index+0],
-                                           extrema[3*index+1],
-                                           extrema[3*index+2]) ;
-            ok &= fabs(refined.peakScore) > self->peakThreshold ;
-            ok &= refined.edgeScore < self->edgeThreshold ;
-            if (ok) {
-              double sigma = cgeom.baseScale *
-              pow(2.0, o + (refined.z + cgeom.octaveFirstSubdivision)
-                  / cgeom.octaveResolution) ;
-              feature.frame.x = refined.x * step ;
-              feature.frame.y = refined.y * step ;
-              feature.frame.a11 = sigma ;
-              feature.frame.a12 = 0.0 ;
-              feature.frame.a21 = 0.0 ;
-              feature.frame.a22 = sigma ;
-              feature.o = o ;
-              feature.s = round(refined.z) ;
-              feature.peakScore = refined.peakScore ;
-              feature.edgeScore = refined.edgeScore ;
-              vl_covdet_append_feature(self, &feature) ;
-            }
-          }
-          break ;
-        }
-
-        default:
-        {
-          for (s = cgeom.octaveFirstSubdivision ; s < cgeom.octaveLastSubdivision ; ++s) {
-            /* space extrema */
-            float const * level = vl_scalespace_get_level(self->css,o,s) ;
-            numExtrema = vl_find_local_extrema_2(&extrema, &extremaBufferSize,
-                                                 level,
-                                                 width, height,
-                                                 0.8 * self->peakThreshold);
-            for (index = 0 ; index < numExtrema ; ++index) {
-              VlCovDetExtremum2 refined ;
-              VlCovDetFeature feature ;
-              vl_bool ok ;
-              memset(&feature, 0, sizeof(feature)) ;
-              ok = vl_refine_local_extreum_2(&refined,
-                                             level, width, height,
-                                             extrema[2*index+0],
-                                             extrema[2*index+1]);
-              ok &= fabs(refined.peakScore) > self->peakThreshold ;
-              ok &= refined.edgeScore < self->edgeThreshold ;
-              if (ok) {
-                double sigma = cgeom.baseScale *
-                pow(2.0, o + (double)s / cgeom.octaveResolution) ;
-                feature.frame.x = refined.x * step ;
-                feature.frame.y = refined.y * step ;
-                feature.frame.a11 = sigma ;
-                feature.frame.a12 = 0.0 ;
-                feature.frame.a21 = 0.0 ;
-                feature.frame.a22 = sigma ;
-                feature.o = o ;
-                feature.s = s ;
-                feature.peakScore = refined.peakScore ;
-                feature.edgeScore = refined.edgeScore ;
-                vl_covdet_append_feature(self, &feature) ;
-              }
-            }
-          }
-          break ;
-        }
-      }
-      if (self->numFeatures >= max_num_features) {
-        break;
-      }
-    } /* next octave */
-
-    if (extrema) { vl_free(extrema) ; extrema = 0 ; }
-  }
-
-  /* Laplacian scale selection for certain methods */
-  switch (self->method) {
-    case VL_COVDET_METHOD_HARRIS_LAPLACE :
-    case VL_COVDET_METHOD_HESSIAN_LAPLACE :
-      vl_covdet_extract_laplacian_scales (self) ;
-      break ;
-    default:
-      break ;
-  }
-
-  if (self->nonExtremaSuppression) {
-    vl_index i, j ;
-    double tol = self->nonExtremaSuppression ;
-    self->numNonExtremaSuppressed = 0 ;
-    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
-      double x = self->features[i].frame.x ;
-      double y = self->features[i].frame.y ;
-      double sigma = self->features[i].frame.a11 ;
-      double score = self->features[i].peakScore ;
-      if (score == 0) continue ;
-
-      for (j = 0 ; j < (signed)self->numFeatures ; ++j) {
-        double dx_ = self->features[j].frame.x - x ;
-        double dy_ = self->features[j].frame.y - y ;
-        double sigma_ = self->features[j].frame.a11 ;
-        double score_ = self->features[j].peakScore ;
-        if (score_ == 0) continue ;
-        if (sigma < (1+tol) * sigma_ &&
-            sigma_ < (1+tol) * sigma &&
-            vl_abs_d(dx_) < tol * sigma &&
-            vl_abs_d(dy_) < tol * sigma &&
-            vl_abs_d(score) > vl_abs_d(score_)) {
-          self->features[j].peakScore = 0 ;
-          self->numNonExtremaSuppressed ++ ;
-        }
-      }
-    }
-    j = 0 ;
-    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
-      VlCovDetFeature feature = self->features[i] ;
-      if (self->features[i].peakScore != 0) {
-        self->features[j++] = feature ;
-      }
-    }
-    self->numFeatures = j ;
-  }
-
-  if (levelxx) vl_free(levelxx) ;
-  if (levelyy) vl_free(levelyy) ;
-  if (levelxy) vl_free(levelxy) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                  Extract patches */
-/* ---------------------------------------------------------------- */
-
-/** @internal
- ** @brief Helper for extracting patches
- ** @param self object.
- ** @param[out] sigma1 actual patch smoothing along the first axis.
- ** @param[out] sigma2 actual patch smoothing along the second axis.
- ** @param patch buffer.
- ** @param resolution patch resolution.
- ** @param extent patch extent.
- ** @param sigma desired smoothing in the patch frame.
- ** @param A_ linear transfomration from patch to image.
- ** @param T_ translation from patch to image.
- ** @param d1 first singular value @a A.
- ** @param d2 second singular value of @a A.
- **/
-
-vl_bool
-vl_covdet_extract_patch_helper (VlCovDet * self,
-                                double * sigma1,
-                                double * sigma2,
-                                float * patch,
-                                vl_size resolution,
-                                double extent,
-                                double sigma,
-                                double A_ [4],
-                                double T_ [2],
-                                double d1, double d2)
-{
-  vl_index o, s ;
-  double factor ;
-  double sigma_ ;
-  float const * level ;
-  vl_size width, height ;
-  double step ;
-
-  double A [4] = {A_[0], A_[1], A_[2], A_[3]} ;
-  double T [2] = {T_[0], T_[1]} ;
-
-  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
-  VlScaleSpaceOctaveGeometry oct ;
-
-  /* Starting from a pre-smoothed image at scale sigma_
-     because of the mapping A the resulting smoothing in
-     the warped patch is S, where
-
-        sigma_^2 I = A S A',
-
-        S = sigma_^2 inv(A) inv(A)' = sigma_^2 V D^-2 V',
-
-        A = U D V'.
-
-     Thus we rotate A by V to obtain an axis-aligned smoothing:
-
-        A = U*D,
-
-        S = sigma_^2 D^-2.
-
-     Then we search the scale-space for the best sigma_ such
-     that the target smoothing is approximated from below:
-
-        max sigma_(o,s) :    simga_(o,s) factor <= sigma,
-        factor = max{abs(D11), abs(D22)}.
-   */
-
-
-  /*
-   Determine the best level (o,s) such that sigma_(o,s) factor <= sigma.
-   This can be obtained by scanning octaves from smallest to largest
-   and stopping when no level in the octave satisfies the relation.
-
-   Given the range of octave availables, do the best you can.
-   */
-
-  factor = 1.0 / VL_MIN(d1, d2) ;
-
-  for (o = geom.firstOctave + 1 ; o <= geom.lastOctave ; ++o) {
-    s = vl_floor_d(vl_log2_d(sigma / (factor * geom.baseScale)) - o) ;
-    s = VL_MAX(s, geom.octaveFirstSubdivision) ;
-    s = VL_MIN(s, geom.octaveLastSubdivision) ;
-    sigma_ = geom.baseScale * pow(2.0, o + (double)s / geom.octaveResolution) ;
-    /*VL_PRINTF(".. %d D=%g %g; sigma_=%g factor*sigma_=%g\n", o, d1, d2, sigma_, factor* sigma_) ;*/
-    if (factor * sigma_ > sigma) {
-      o -- ;
-      break ;
-    }
-  }
-  o = VL_MIN(o, geom.lastOctave) ;
-  s = vl_floor_d(vl_log2_d(sigma / (factor * geom.baseScale)) - o) ;
-  s = VL_MAX(s, geom.octaveFirstSubdivision) ;
-  s = VL_MIN(s, geom.octaveLastSubdivision) ;
-  sigma_ = geom.baseScale * pow(2.0, o + (double)s / geom.octaveResolution) ;
-  if (sigma1) *sigma1 = sigma_ / d1 ;
-  if (sigma2) *sigma2 = sigma_ / d2 ;
-
-  /*VL_PRINTF("%d %d %g %g %g %g\n", o, s, factor, sigma_, factor * sigma_, sigma) ;*/
-
-  /*
-   Now the scale space level to be used for this warping has been
-   determined.
-
-   If the patch is partially or completely out of the image boundary,
-   create a padded copy of the required region first.
-   */
-
-  level = vl_scalespace_get_level(self->gss, o, s) ;
-  oct = vl_scalespace_get_octave_geometry(self->gss, o) ;
-  width = oct.width ;
-  height = oct.height ;
-  step = oct.step ;
-
-  A[0] /= step ;
-  A[1] /= step ;
-  A[2] /= step ;
-  A[3] /= step ;
-  T[0] /= step ;
-  T[1] /= step ;
-
-  {
-    /*
-     Warp the patch domain [x0hat,y0hat,x1hat,y1hat] to the image domain/
-     Obtain a box [x0,y0,x1,y1] enclosing that wrapped box, and then
-     an integer vertexes version [x0i, y0i, x1i, y1i], making room
-     for one pixel at the boundary to simplify bilinear interpolation
-     later on.
-     */
-    vl_index x0i, y0i, x1i, y1i ;
-    double x0 = +VL_INFINITY_D ;
-    double x1 = -VL_INFINITY_D ;
-    double y0 = +VL_INFINITY_D ;
-    double y1 = -VL_INFINITY_D ;
-    double boxx [4] = {extent, extent, -extent, -extent} ;
-    double boxy [4] = {-extent, extent, extent, -extent} ;
-    int i ;
-    for (i = 0 ; i < 4 ; ++i) {
-      double x = A[0] * boxx[i] + A[2] * boxy[i] + T[0] ;
-      double y = A[1] * boxx[i] + A[3] * boxy[i] + T[1] ;
-      x0 = VL_MIN(x0, x) ;
-      x1 = VL_MAX(x1, x) ;
-      y0 = VL_MIN(y0, y) ;
-      y1 = VL_MAX(y1, y) ;
-    }
-
-    /* Leave one pixel border for bilinear interpolation. */
-    x0i = floor(x0) - 1 ;
-    y0i = floor(y0) - 1 ;
-    x1i = ceil(x1) + 1 ;
-    y1i = ceil(y1) + 1 ;
-
-    /*
-     If the box [x0i,y0i,x1i,y1i] is not fully contained in the
-     image domain, then create a copy of this region by padding
-     the image. The image is extended by continuity.
-     */
-
-    if (x0i < 0 || x1i > (signed)width-1 ||
-        y0i < 0 || y1i > (signed)height-1) {
-      vl_index xi, yi ;
-
-      /* compute the amount of l,r,t,b padding needed to complete the patch */
-      vl_index padx0 = VL_MAX(0, - x0i) ;
-      vl_index pady0 = VL_MAX(0, - y0i) ;
-      vl_index padx1 = VL_MAX(0, x1i - ((signed)width - 1)) ;
-      vl_index pady1 = VL_MAX(0, y1i - ((signed)height - 1)) ;
-
-      /* make enough room for the patch */
-      vl_index patchWidth = x1i - x0i + 1 ;
-      vl_index patchHeight = y1i - y0i + 1 ;
-      vl_size patchBufferSize = patchWidth * patchHeight * sizeof(float) ;
-      if (patchBufferSize > self->patchBufferSize) {
-        int err = _vl_resize_buffer((void**)&self->patch, &self->patchBufferSize, patchBufferSize) ;
-        if (err) return vl_set_last_error(VL_ERR_ALLOC, NULL) ;
-      }
-
-      if (pady0 < patchHeight - pady1) {
-        /* start by filling the central horizontal band */
-        for (yi = y0i + pady0 ; yi < y0i + patchHeight - pady1 ; ++ yi) {
-          float *dst = self->patch + (yi - y0i) * patchWidth ;
-          float const *src = level + yi * width + VL_MIN(VL_MAX(0, x0i),(signed)width-1) ;
-          for (xi = x0i ; xi < x0i + padx0 ; ++xi) *dst++ = *src ;
-          for ( ; xi < x0i + patchWidth - padx1 - 2 ; ++xi) *dst++ = *src++ ;
-          for ( ; xi < x0i + patchWidth ; ++xi) *dst++ = *src ;
-        }
-        /* now extend the central band up and down */
-        for (yi = 0 ; yi < pady0 ; ++yi) {
-          memcpy(self->patch + yi * patchWidth,
-                 self->patch + pady0 * patchWidth,
-                 patchWidth * sizeof(float)) ;
-        }
-        for (yi = patchHeight - pady1 ; yi < patchHeight ; ++yi) {
-          memcpy(self->patch + yi * patchWidth,
-                 self->patch + (patchHeight - pady1 - 1) * patchWidth,
-                 patchWidth * sizeof(float)) ;
-        }
-      } else {
-        /* should be handled better! */
-        memset(self->patch, 0, self->patchBufferSize) ;
-      }
-#if 0
-      {
-        char name [200] ;
-        snprintf(name, 200, "/tmp/%20.0f-ext.pgm", 1e10*vl_get_cpu_time()) ;
-        vl_pgm_write_f(name, patch, patchWidth, patchWidth) ;
-      }
-#endif
-
-      level = self->patch ;
-      width = patchWidth ;
-      height = patchHeight ;
-      T[0] -= x0i ;
-      T[1] -= y0i ;
-    }
-  }
-
-  /*
-   Resample by using bilinear interpolation.
-   */
-  {
-    float * pt = patch ;
-    double yhat = -extent ;
-    vl_index xxi ;
-    vl_index yyi ;
-    double stephat = extent / resolution ;
-
-    for (yyi = 0 ; yyi < 2 * (signed)resolution + 1 ; ++yyi) {
-      double xhat = -extent ;
-      double rx = A[2] * yhat + T[0] ;
-      double ry = A[3] * yhat + T[1] ;
-      for (xxi = 0 ; xxi < 2 * (signed)resolution + 1 ; ++xxi) {
-        double x = A[0] * xhat + rx ;
-        double y = A[1] * xhat + ry ;
-        vl_index xi = vl_floor_d(x) ;
-        vl_index yi = vl_floor_d(y) ;
-        double i00 = level[yi * width + xi] ;
-        double i10 = level[yi * width + xi + 1] ;
-        double i01 = level[(yi + 1) * width + xi] ;
-        double i11 = level[(yi + 1) * width + xi + 1] ;
-        double wx = x - xi ;
-        double wy = y - yi ;
-
-        assert(xi >= 0 && xi <= (signed)width - 1) ;
-        assert(yi >= 0 && yi <= (signed)height - 1) ;
-
-        *pt++ =
-        (1.0 - wy) * ((1.0 - wx) * i00 + wx * i10) +
-        wy * ((1.0 - wx) * i01 + wx * i11) ;
-
-        xhat += stephat ;
-      }
-      yhat += stephat ;
-    }
-  }
-#if 0
-    {
-      char name [200] ;
-      snprintf(name, 200, "/tmp/%20.0f.pgm", 1e10*vl_get_cpu_time()) ;
-      vl_pgm_write_f(name, patch, 2*resolution+1, 2*resolution+1) ;
-    }
-#endif
-  return VL_ERR_OK ;
-}
-
-/** @brief Helper for extracting patches
- ** @param self object.
- ** @param patch buffer.
- ** @param resolution patch resolution.
- ** @param extent patch extent.
- ** @param sigma desired smoothing in the patch frame.
- ** @param frame feature frame.
- **
- ** The function considers a patch of extent <code>[-extent,extent]</code>
- ** on each side, with a side counting <code>2*resolution+1</code> pixels.
- ** In attempts to extract from the scale space a patch
- ** based on the affine warping specified by @a frame in such a way
- ** that the resulting smoothing of the image is @a sigma (in the
- ** patch frame).
- **
- ** The transformation is specified by the matrices @c A and @c T
- ** embedded in the feature @a frame. Note that this transformation maps
- ** pixels from the patch frame to the image frame.
- **/
-
-vl_bool
-vl_covdet_extract_patch_for_frame (VlCovDet * self,
-                                   float * patch,
-                                   vl_size resolution,
-                                   double extent,
-                                   double sigma,
-                                   VlFrameOrientedEllipse frame)
-{
-  double A[2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
-  double T[2] = {frame.x, frame.y} ;
-  double D[4], U[4], V[4] ;
-
-  vl_svd2(D, U, V, A) ;
-
-  return vl_covdet_extract_patch_helper
-  (self, NULL, NULL, patch, resolution, extent, sigma, A, T, D[0], D[3]) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                     Affine shape */
-/* ---------------------------------------------------------------- */
-
-/** @brief Extract the affine shape for a feature frame
- ** @param self object.
- ** @param adapted the shape-adapted frame.
- ** @param frame the input frame.
- ** @return ::VL_ERR_OK if affine adaptation is successful.
- **
- ** This function may fail if adaptation is unsuccessful or if
- ** memory is insufficient.
- **/
-
-int
-vl_covdet_extract_affine_shape_for_frame (VlCovDet * self,
-                                          VlFrameOrientedEllipse * adapted,
-                                          VlFrameOrientedEllipse frame)
-{
-  vl_index iter = 0 ;
-
-  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
-  double T [2] = {frame.x, frame.y} ;
-  double U [2*2] ;
-  double V [2*2] ;
-  double D [2*2] ;
-  double M [2*2] ;
-  double P [2*2] ;
-  double P_ [2*2] ;
-  double Q [2*2] ;
-  double sigma1, sigma2 ;
-  double sigmaD = VL_COVDET_AA_RELATIVE_DERIVATIVE_SIGMA ;
-  double factor ;
-  double anisotropy ;
-  double referenceScale ;
-  vl_size const resolution = VL_COVDET_AA_PATCH_RESOLUTION ;
-  vl_size const side = 2*VL_COVDET_AA_PATCH_RESOLUTION + 1 ;
-  double const extent = VL_COVDET_AA_PATCH_EXTENT ;
-
-
-  *adapted = frame ;
-
-  while (1) {
-    double lxx = 0, lxy = 0, lyy = 0 ;
-    vl_index k ;
-    int err ;
-
-    /* A = U D V' */
-    vl_svd2(D, U, V, A) ;
-    anisotropy = VL_MAX(D[0]/D[3], D[3]/D[0]) ;
-
-    /* VL_PRINTF("anisot: %g\n", anisotropy); */
-
-    if (anisotropy > VL_COVDET_AA_MAX_ANISOTROPY) {
-      /* diverged, give up with current solution */
-      break ;
-    }
-
-    /* make sure that the smallest singluar value stays fixed
-       after the first iteration */
-    if (iter == 0) {
-      referenceScale = VL_MIN(D[0], D[3]) ;
-      factor = 1.0 ;
-    } else {
-      factor = referenceScale / VL_MIN(D[0],D[3]) ;
-    }
-
-    D[0] *= factor ;
-    D[3] *= factor ;
-
-    A[0] = U[0] * D[0] ;
-    A[1] = U[1] * D[0] ;
-    A[2] = U[2] * D[3] ;
-    A[3] = U[3] * D[3] ;
-
-    adapted->a11 = A[0] ;
-    adapted->a21 = A[1] ;
-    adapted->a12 = A[2] ;
-    adapted->a22 = A[3] ;
-
-    if (++iter >= VL_COVDET_AA_MAX_NUM_ITERATIONS) break ;
-
-    err = vl_covdet_extract_patch_helper(self,
-                                         &sigma1, &sigma2,
-                                         self->aaPatch,
-                                         resolution,
-                                         extent,
-                                         sigmaD,
-                                         A, T, D[0], D[3]) ;
-    if (err) return err ;
-
-    if (self->aaAccurateSmoothing ) {
-      double deltaSigma1 = sqrt(VL_MAX(sigmaD*sigmaD - sigma1*sigma1,0)) ;
-      double deltaSigma2 = sqrt(VL_MAX(sigmaD*sigmaD - sigma2*sigma2,0)) ;
-      double stephat = extent / resolution ;
-      vl_imsmooth_f(self->aaPatch, side,
-                    self->aaPatch, side, side, side,
-                    deltaSigma1 / stephat, deltaSigma2 / stephat) ;
-    }
-
-    /* compute second moment matrix */
-    vl_imgradient_f (self->aaPatchX, self->aaPatchY, 1, side,
-                     self->aaPatch, side, side, side) ;
-
-    for (k = 0 ; k < (signed)(side*side) ; ++k) {
-      double lx = self->aaPatchX[k] ;
-      double ly = self->aaPatchY[k] ;
-      lxx += lx * lx * self->aaMask[k] ;
-      lyy += ly * ly * self->aaMask[k] ;
-      lxy += lx * ly * self->aaMask[k] ;
-    }
-    M[0] = lxx ;
-    M[1] = lxy ;
-    M[2] = lxy ;
-    M[3] = lyy ;
-
-    if (lxx == 0 || lyy == 0) {
-      *adapted = frame ;
-      break ;
-    }
-
-    /* decompose M = P * Q * P' */
-    vl_svd2 (Q, P, P_, M) ;
-
-    /*
-     Setting A <- A * dA results in M to change approximatively as
-
-     M --> dA'  M dA = dA' P Q P dA
-
-     To make this proportional to the identity, we set
-
-     dA ~= P Q^1/2
-
-     we also make it so the smallest singular value of A is unchanged.
-     */
-
-    if (Q[3]/Q[0] < VL_COVDET_AA_CONVERGENCE_THRESHOLD &&
-        Q[0]/Q[3] < VL_COVDET_AA_CONVERGENCE_THRESHOLD) {
-      break ;
-    }
-
-    {
-      double Ap [4] ;
-      double q0 = sqrt(Q[0]) ;
-      double q1 = sqrt(Q[3]) ;
-      Ap[0] = (A[0] * P[0] + A[2] * P[1]) / q0 ;
-      Ap[1] = (A[1] * P[0] + A[3] * P[1]) / q0 ;
-      Ap[2] = (A[0] * P[2] + A[2] * P[3]) / q1 ;
-      Ap[3] = (A[1] * P[2] + A[3] * P[3]) / q1 ;
-      memcpy(A,Ap,4*sizeof(double)) ;
-    }
-
-  } /* next iteration */
-
-  /*
-   Make upright.
-
-   Shape adaptation does not estimate rotation. This is fixed by default
-   so that a selected axis is not rotated at all (usually this is the
-   vertical axis for upright features). To do so, the frame is rotated
-   as follows.
-   */
-  {
-    double A [2*2] = {adapted->a11, adapted->a21, adapted->a12, adapted->a22} ;
-    double ref [2] ;
-    double ref_ [2] ;
-    double angle ;
-    double angle_ ;
-    double dangle ;
-    double r1, r2 ;
-
-    if (self->transposed) {
-      /* up is the x axis */
-      ref[0] = 1 ;
-      ref[1] = 0 ;
-    } else {
-      /* up is the y axis */
-      ref[0] = 0 ;
-      ref[1] = 1 ;
-    }
-
-    vl_solve_linear_system_2 (ref_, A, ref) ;
-    angle = atan2(ref[1], ref[0]) ;
-    angle_ = atan2(ref_[1], ref_[0]) ;
-    dangle = angle_ - angle ;
-    r1 = cos(dangle) ;
-    r2 = sin(dangle) ;
-    adapted->a11 = + A[0] * r1 + A[2] * r2 ;
-    adapted->a21 = + A[1] * r1 + A[3] * r2 ;
-    adapted->a12 = - A[0] * r2 + A[2] * r1 ;
-    adapted->a22 = - A[1] * r2 + A[3] * r1 ;
-  }
-
-  return VL_ERR_OK ;
-}
-
-/** @brief Extract the affine shape for the stored features
- ** @param self object.
- **
- ** This function may discard features for which no affine
- ** shape can reliably be detected.
- **/
-
-void
-vl_covdet_extract_affine_shape (VlCovDet * self)
-{
-  vl_index i, j = 0 ;
-  vl_size numFeatures = vl_covdet_get_num_features(self) ;
-  VlCovDetFeature * feature = vl_covdet_get_features(self);
-  for (i = 0 ; i < (signed)numFeatures ; ++i) {
-    int status ;
-    VlFrameOrientedEllipse adapted ;
-    status = vl_covdet_extract_affine_shape_for_frame(self, &adapted, feature[i].frame) ;
-    if (status == VL_ERR_OK) {
-      feature[j] = feature[i] ;
-      feature[j].frame = adapted ;
-      ++ j ;
-    }
-  }
-  self->numFeatures = j ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                      Orientation */
-/* ---------------------------------------------------------------- */
-
-static int
-_vl_covdet_compare_orientations_descending (void const * a_,
-                                            void const * b_)
-{
-  VlCovDetFeatureOrientation const * a = a_ ;
-  VlCovDetFeatureOrientation const * b = b_ ;
-  if (a->score > b->score) return -1 ;
-  if (a->score < b->score) return +1 ;
-  return 0 ;
-}
-
-/** @brief Extract the orientation(s) for a feature
- ** @param self object.
- ** @param numOrientations the number of detected orientations.
- ** @param frame pose of the feature.
- ** @return an array of detected orientations with their scores.
- **
- ** The returned array is a matrix of size @f$ 2 \times n @f$
- ** where <em>n</em> is the number of detected orientations.
- **
- ** The function returns @c NULL if memory is insufficient.
- **/
-
-VlCovDetFeatureOrientation *
-vl_covdet_extract_orientations_for_frame (VlCovDet * self,
-                                          vl_size * numOrientations,
-                                          VlFrameOrientedEllipse frame)
-{
-  int err ;
-  vl_index k, i ;
-  vl_index iter ;
-
-  double extent = VL_COVDET_AA_PATCH_EXTENT ;
-  vl_size resolution = VL_COVDET_AA_PATCH_RESOLUTION ;
-  vl_size side = 2 * resolution + 1  ;
-
-  vl_size const numBins = VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS ;
-  double hist [VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS] ;
-  double const binExtent = 2 * VL_PI / VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS ;
-  double const peakRelativeSize = VL_COVDET_OR_ADDITIONAL_PEAKS_RELATIVE_SIZE ;
-  double maxPeakValue ;
-
-  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
-  double T [2] = {frame.x, frame.y} ;
-  double U [2*2] ;
-  double V [2*2] ;
-  double D [2*2] ;
-  double sigma1, sigma2 ;
-  double sigmaD = 1.0 ;
-  double theta0 ;
-
-  assert(self);
-  assert(numOrientations) ;
-
-  /*
-   The goal is to estimate a rotation R(theta) such that the patch given
-   by the transformation A R(theta) has the strongest average
-   gradient pointing right (or down for transposed conventions).
-
-   To compensate for tha anisotropic smoothing due to warping,
-   A is decomposed as A = U D V' and the patch is warped by
-   U D only, meaning that the matrix R_(theta) will be estimated instead,
-   where:
-
-      A R(theta) = U D V' R(theta) = U D R_(theta)
-
-   such that R(theta) = V R(theta). That is an extra rotation of
-   theta0 = atan2(V(2,1),V(1,1)).
-   */
-
-  /* axis aligned anisotropic smoothing for easier compensation */
-  vl_svd2(D, U, V, A) ;
-
-  A[0] = U[0] * D[0] ;
-  A[1] = U[1] * D[0] ;
-  A[2] = U[2] * D[3] ;
-  A[3] = U[3] * D[3] ;
-
-  theta0 = atan2(V[1],V[0]) ;
-
-  err = vl_covdet_extract_patch_helper(self,
-                                       &sigma1, &sigma2,
-                                       self->aaPatch,
-                                       resolution,
-                                       extent,
-                                       sigmaD,
-                                       A, T, D[0], D[3]) ;
-
-  if (err) {
-    *numOrientations = 0 ;
-    return NULL ;
-  }
-
-  if (1) {
-    double deltaSigma1 = sqrt(VL_MAX(sigmaD*sigmaD - sigma1*sigma1,0)) ;
-    double deltaSigma2 = sqrt(VL_MAX(sigmaD*sigmaD - sigma2*sigma2,0)) ;
-    double stephat = extent / resolution ;
-    vl_imsmooth_f(self->aaPatch, side,
-                  self->aaPatch, side, side, side,
-                  deltaSigma1 / stephat, deltaSigma2 / stephat) ;
-  }
-
-  /* histogram of oriented gradients */
-  vl_imgradient_polar_f (self->aaPatchX, self->aaPatchY, 1, side,
-                         self->aaPatch, side, side, side) ;
-
-  memset (hist, 0, sizeof(double) * numBins) ;
-
-  for (k = 0 ; k < (signed)(side*side) ; ++k) {
-    double modulus = self->aaPatchX[k] ;
-    double angle = self->aaPatchY[k] ;
-    double weight = self->aaMask[k] ;
-
-    double x = angle / binExtent ;
-    vl_index bin = vl_floor_d(x) ;
-    double w2 = x - bin ;
-    double w1 = 1.0 - w2 ;
-
-    hist[(bin + numBins) % numBins] += w1 * (modulus * weight) ;
-    hist[(bin + numBins + 1) % numBins] += w2 * (modulus * weight) ;
-  }
-
-  /* smooth histogram */
-  for (iter = 0; iter < 6; iter ++) {
-    double prev = hist [numBins - 1] ;
-    double first = hist [0] ;
-    vl_index i ;
-    for (i = 0; i < (signed)numBins - 1; ++i) {
-      double curr = (prev + hist[i] + hist[(i + 1) % numBins]) / 3.0 ;
-      prev = hist[i] ;
-      hist[i] = curr ;
-    }
-    hist[i] = (prev + hist[i] + first) / 3.0 ;
-  }
-
-  /* find the histogram maximum */
-  maxPeakValue = 0 ;
-  for (i = 0 ; i < (signed)numBins ; ++i) {
-    maxPeakValue = VL_MAX (maxPeakValue, hist[i]) ;
-  }
-
-  /* find peaks within 80% from max */
-  *numOrientations = 0 ;
-  for(i = 0 ; i < (signed)numBins ; ++i) {
-    double h0 = hist [i] ;
-    double hm = hist [(i - 1 + numBins) % numBins] ;
-    double hp = hist [(i + 1 + numBins) % numBins] ;
-
-    /* is this a peak? */
-    if (h0 > peakRelativeSize * maxPeakValue && h0 > hm && h0 > hp) {
-      /* quadratic interpolation */
-      double di = - 0.5 * (hp - hm) / (hp + hm - 2 * h0) ;
-      double th = binExtent * (i + di) + theta0 ;
-      if (self->transposed) {
-        /* the axis to the right is y, measure orientations from this */
-        th = th - VL_PI/2 ;
-      }
-      self->orientations[*numOrientations].angle = th ;
-      self->orientations[*numOrientations].score = h0 ;
-      *numOrientations += 1 ;
-      //VL_PRINTF("%d %g\n", *numOrientations, th) ;
-
-      if (*numOrientations >= VL_COVDET_MAX_NUM_ORIENTATIONS) break ;
-    }
-  }
-
-  /* sort the orientations by decreasing scores */
-  qsort(self->orientations,
-        *numOrientations,
-        sizeof(VlCovDetFeatureOrientation),
-        _vl_covdet_compare_orientations_descending) ;
-
-  return self->orientations ;
-}
-
-/** @brief Extract the orientation(s) for the stored features.
- ** @param self object.
- **
- ** Note that, since more than one orientation can be detected
- ** for each feature, this function may create copies of them,
- ** one for each orientation.
- **/
-
-void
-vl_covdet_extract_orientations (VlCovDet * self)
-{
-  vl_index i, j  ;
-  vl_size numFeatures = vl_covdet_get_num_features(self) ;
-  for (i = 0 ; i < (signed)numFeatures ; ++i) {
-    vl_size numOrientations ;
-    VlCovDetFeature feature = self->features[i] ;
-    VlCovDetFeatureOrientation* orientations =
-    vl_covdet_extract_orientations_for_frame(self, &numOrientations, feature.frame) ;
-
-    for (j = 0 ; j < (signed)numOrientations ; ++j) {
-      double A [2*2] = {
-        feature.frame.a11,
-        feature.frame.a21,
-        feature.frame.a12,
-        feature.frame.a22} ;
-      double r1 = cos(orientations[j].angle) ;
-      double r2 = sin(orientations[j].angle) ;
-      VlCovDetFeature * oriented ;
-
-      if (j == 0) {
-        oriented = & self->features[i] ;
-      } else {
-        vl_covdet_append_feature(self, &feature) ;
-        oriented = & self->features[self->numFeatures -1] ;
-      }
-
-      oriented->orientationScore = orientations[j].score ;
-      oriented->frame.a11 = + A[0] * r1 + A[2] * r2 ;
-      oriented->frame.a21 = + A[1] * r1 + A[3] * r2 ;
-      oriented->frame.a12 = - A[0] * r2 + A[2] * r1 ;
-      oriented->frame.a22 = - A[1] * r2 + A[3] * r1 ;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 Laplacian scales */
-/* ---------------------------------------------------------------- */
-
-/** @brief Extract the Laplacian scale(s) for a feature frame.
- ** @param self object.
- ** @param numScales the number of detected scales.
- ** @param frame pose of the feature.
- ** @return an array of detected scales.
- **
- ** The function returns @c NULL if memory is insufficient.
- **/
-
-VlCovDetFeatureLaplacianScale *
-vl_covdet_extract_laplacian_scales_for_frame (VlCovDet * self,
-                                              vl_size * numScales,
-                                              VlFrameOrientedEllipse frame)
-{
-  /*
-   We try to explore one octave, with the nominal detection scale 1.0
-   (in the patch reference frame) in the middle. Thus the goal is to sample
-   the response of the tr-Laplacian operator at logarithmically
-   spaced scales in 1/sqrt(2), sqrt(2).
-
-   To this end, the patch is warped with a smoothing of at most
-   sigmaImage = 1 / sqrt(2) (beginning of the scale), sampled at
-   roughly twice the Nyquist frequency (so step = 1 / (2*sqrt(2))).
-   This maes it possible to approximate the Laplacian operator at
-   that scale by simple finite differences.
-
-   */
-  int err ;
-  double const sigmaImage = 1.0 / sqrt(2.0) ;
-  double const step = 0.5 * sigmaImage ;
-  double actualSigmaImage ;
-  vl_size const resolution = VL_COVDET_LAP_PATCH_RESOLUTION ;
-  vl_size const num = 2 * resolution + 1 ;
-  double extent = step * resolution ;
-  double scores [VL_COVDET_LAP_NUM_LEVELS] ;
-  double factor = 1.0 ;
-  float const * pt ;
-  vl_index k ;
-
-  double A[2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
-  double T[2] = {frame.x, frame.y} ;
-  double D[4], U[4], V[4] ;
-  double sigma1, sigma2 ;
-
-  assert(self) ;
-  assert(numScales) ;
-
-  *numScales = 0 ;
-
-  vl_svd2(D, U, V, A) ;
-
-  err = vl_covdet_extract_patch_helper
-  (self, &sigma1, &sigma2, self->lapPatch, resolution, extent, sigmaImage, A, T, D[0], D[3]) ;
-  if (err) return NULL ;
-
-  /* the actual smoothing after warping is never the target one */
-  if (sigma1 == sigma2) {
-    actualSigmaImage = sigma1 ;
-  } else {
-    /* here we could compensate */
-    actualSigmaImage = sqrt(sigma1*sigma2) ;
-  }
-
-  /* now multiply by the bank of Laplacians */
-  pt = self->laplacians ;
-  for (k = 0 ; k < VL_COVDET_LAP_NUM_LEVELS ; ++k) {
-    vl_index q ;
-    double score = 0 ;
-    double sigmaLap = pow(2.0, -0.5 + (double)k / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
-    /* note that the sqrt argument cannot be negative since by construction
-     sigmaLap >= sigmaImage */
-    sigmaLap = sqrt(sigmaLap*sigmaLap
-                    - sigmaImage*sigmaImage
-                    + actualSigmaImage*actualSigmaImage) ;
-
-    for (q = 0 ; q < (signed)(num * num) ; ++q) {
-      score += (*pt++) * self->lapPatch[q] ;
-    }
-    scores[k] = score * sigmaLap * sigmaLap ;
-  }
-
-  /* find and interpolate maxima */
-  for (k = 1 ; k < VL_COVDET_LAP_NUM_LEVELS - 1 ; ++k) {
-    double a = scores[k-1] ;
-    double b = scores[k] ;
-    double c = scores[k+1] ;
-    double t = self->lapPeakThreshold ;
-
-    if ((((b > a) && (b > c)) || ((b < a) && (b < c))) && (vl_abs_d(b) >= t)) {
-      double dk = - 0.5 * (c - a) / (c + a - 2 * b) ;
-      double s = k + dk ;
-      double sigmaLap = pow(2.0, -0.5 + s / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
-      double scale ;
-      sigmaLap = sqrt(sigmaLap*sigmaLap
-                      - sigmaImage*sigmaImage
-                      + actualSigmaImage*actualSigmaImage) ;
-      scale = sigmaLap / 1.0 ;
-      /*
-       VL_PRINTF("** k:%d, s:%f, sigmaLapFilter:%f, sigmaLap%f, scale:%f (%f %f %f)\n",
-       k,s,sigmaLapFilter,sigmaLap,scale,a,b,c) ;
-       */
-      if (*numScales < VL_COVDET_MAX_NUM_LAPLACIAN_SCALES) {
-        self->scales[*numScales].scale = scale * factor ;
-        self->scales[*numScales].score = b + 0.5 * (c - a) * dk ;
-        *numScales += 1 ;
-      }
-    }
-  }
-  return self->scales ;
-}
-
-/** @brief Extract the Laplacian scales for the stored features
- ** @param self object.
- **
- ** Note that, since more than one orientation can be detected
- ** for each feature, this function may create copies of them,
- ** one for each orientation.
- **/
-void
-vl_covdet_extract_laplacian_scales (VlCovDet * self)
-{
-  vl_index i, j  ;
-  vl_bool dropFeaturesWithoutScale = VL_TRUE ;
-  vl_size numFeatures = vl_covdet_get_num_features(self) ;
-  memset(self->numFeaturesWithNumScales, 0,
-         sizeof(self->numFeaturesWithNumScales)) ;
-
-  for (i = 0 ; i < (signed)numFeatures ; ++i) {
-    vl_size numScales ;
-    VlCovDetFeature feature = self->features[i] ;
-    VlCovDetFeatureLaplacianScale const * scales =
-    vl_covdet_extract_laplacian_scales_for_frame(self, &numScales, feature.frame) ;
-
-    self->numFeaturesWithNumScales[numScales] ++ ;
-
-    if (numScales == 0 && dropFeaturesWithoutScale) {
-      self->features[i].peakScore = 0 ;
-    }
-
-    for (j = 0 ; j < (signed)numScales ; ++j) {
-      VlCovDetFeature * scaled ;
-
-      if (j == 0) {
-        scaled = & self->features[i] ;
-      } else {
-        vl_covdet_append_feature(self, &feature) ;
-        scaled = & self->features[self->numFeatures -1] ;
-      }
-
-      scaled->laplacianScaleScore = scales[j].score ;
-      scaled->frame.a11 *= scales[j].scale ;
-      scaled->frame.a21 *= scales[j].scale ;
-      scaled->frame.a12 *= scales[j].scale ;
-      scaled->frame.a22 *= scales[j].scale ;
-    }
-  }
-  if (dropFeaturesWithoutScale) {
-    j = 0 ;
-    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
-      VlCovDetFeature feature = self->features[i] ;
-      if (feature.peakScore) {
-        self->features[j++] = feature ;
-      }
-    }
-    self->numFeatures = j ;
-  }
-
-}
-
-/* ---------------------------------------------------------------- */
-/*                       Checking that features are inside an image */
-/* ---------------------------------------------------------------- */
-
-vl_bool
-_vl_covdet_check_frame_inside (VlCovDet * self, VlFrameOrientedEllipse frame, double margin)
-{
-  double extent = margin ;
-  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
-  double T[2] = {frame.x, frame.y} ;
-  double x0 = +VL_INFINITY_D ;
-  double x1 = -VL_INFINITY_D ;
-  double y0 = +VL_INFINITY_D ;
-  double y1 = -VL_INFINITY_D ;
-  double boxx [4] = {extent, extent, -extent, -extent} ;
-  double boxy [4] = {-extent, extent, extent, -extent} ;
-  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
-  int i ;
-  for (i = 0 ; i < 4 ; ++i) {
-    double x = A[0] * boxx[i] + A[2] * boxy[i] + T[0] ;
-    double y = A[1] * boxx[i] + A[3] * boxy[i] + T[1] ;
-    x0 = VL_MIN(x0, x) ;
-    x1 = VL_MAX(x1, x) ;
-    y0 = VL_MIN(y0, y) ;
-    y1 = VL_MAX(y1, y) ;
-  }
-
-  return
-  0 <= x0 && x1 <= geom.width-1 &&
-  0 <= y0 && y1 <= geom.height-1 ;
-}
-
-/** @brief Drop features (partially) outside the image
- ** @param self object.
- ** @param margin geometric marging.
- **
- ** The feature extent is defined by @c maring. A bounding box
- ** in the normalised feature frame containin a circle of radius
- ** @a maring is created and mapped to the image by
- ** the feature frame transformation. Then the feature
- ** is dropped if the bounding box is not contained in the image.
- **
- ** For example, setting @c margin to zero drops a feature only
- ** if its center is not contained.
- **
- ** Typically a valua of @c margin equal to 1 or 2 is used.
- **/
-
-void
-vl_covdet_drop_features_outside (VlCovDet * self, double margin)
-{
-  vl_index i, j = 0 ;
-  vl_size numFeatures = vl_covdet_get_num_features(self) ;
-  for (i = 0 ; i < (signed)numFeatures ; ++i) {
-    vl_bool inside =
-    _vl_covdet_check_frame_inside (self, self->features[i].frame, margin) ;
-    if (inside) {
-      self->features[j] = self->features[i] ;
-      ++j ;
-    }
-  }
-  self->numFeatures = j ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Setters and getters */
-/* ---------------------------------------------------------------- */
-
-/* ---------------------------------------------------------------- */
-/** @brief Get wether images are passed in transposed
- ** @param self object.
- ** @return whether images are transposed.
- **/
-vl_bool
-vl_covdet_get_transposed (VlCovDet const  * self)
-{
-  return self->transposed ;
-}
-
-/** @brief Set the index of the first octave
- ** @param self object.
- ** @param t whether images are transposed.
- **/
-void
-vl_covdet_set_transposed (VlCovDet * self, vl_bool t)
-{
-  self->transposed = t ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the edge threshold
- ** @param self object.
- ** @return the edge threshold.
- **/
-double
-vl_covdet_get_edge_threshold (VlCovDet const * self)
-{
-  return self->edgeThreshold ;
-}
-
-/** @brief Set the edge threshold
- ** @param self object.
- ** @param edgeThreshold the edge threshold.
- **
- ** The edge threshold must be non-negative.
- **/
-void
-vl_covdet_set_edge_threshold (VlCovDet * self, double edgeThreshold)
-{
-  assert(edgeThreshold >= 0) ;
-  self->edgeThreshold = edgeThreshold ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the peak threshold
- ** @param self object.
- ** @return the peak threshold.
- **/
-double
-vl_covdet_get_peak_threshold (VlCovDet const * self)
-{
-  return self->peakThreshold ;
-}
-
-/** @brief Set the peak threshold
- ** @param self object.
- ** @param peakThreshold the peak threshold.
- **
- ** The peak threshold must be non-negative.
- **/
-void
-vl_covdet_set_peak_threshold (VlCovDet * self, double peakThreshold)
-{
-  assert(peakThreshold >= 0) ;
-  self->peakThreshold = peakThreshold ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the Laplacian peak threshold
- ** @param self object.
- ** @return the Laplacian peak threshold.
- **
- ** This parameter affects only the detecors using the Laplacian
- ** scale selectino method such as Harris-Laplace.
- **/
-double
-vl_covdet_get_laplacian_peak_threshold (VlCovDet const * self)
-{
-  return self->lapPeakThreshold ;
-}
-
-/** @brief Set the Laplacian peak threshold
- ** @param self object.
- ** @param peakThreshold the Laplacian peak threshold.
- **
- ** The peak threshold must be non-negative.
- **/
-void
-vl_covdet_set_laplacian_peak_threshold (VlCovDet * self, double peakThreshold)
-{
-  assert(peakThreshold >= 0) ;
-  self->lapPeakThreshold = peakThreshold ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the index of the first octave
- ** @param self object.
- ** @return index of the first octave.
- **/
-vl_index
-vl_covdet_get_first_octave (VlCovDet const * self)
-{
-  return self->firstOctave ;
-}
-
-/** @brief Set the index of the first octave
- ** @param self object.
- ** @param o index of the first octave.
- **
- ** Calling this function resets the detector.
- **/
-void
-vl_covdet_set_first_octave (VlCovDet * self, vl_index o)
-{
-  self->firstOctave = o ;
-  vl_covdet_reset(self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the octave resolution.
- ** @param self object.
- ** @return octave resolution.
- **/
-
-vl_size
-vl_covdet_get_octave_resolution (VlCovDet const * self)
-{
-  return self->octaveResolution ;
-}
-
-/** @brief Set the octave resolutuon.
- ** @param self object.
- ** @param r octave resoltuion.
- **
- ** Calling this function resets the detector.
- **/
-
-void
-vl_covdet_set_octave_resolution (VlCovDet * self, vl_size r)
-{
-  self->octaveResolution = r ;
-  vl_covdet_reset(self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get whether affine adaptation uses accurate smoothing.
- ** @param self object.
- ** @return @c true if accurate smoothing is used.
- **/
-
-vl_bool
-vl_covdet_get_aa_accurate_smoothing (VlCovDet const * self)
-{
-  return self->aaAccurateSmoothing ;
-}
-
-/** @brief Set whether affine adaptation uses accurate smoothing.
- ** @param self object.
- ** @param x whether accurate smoothing should be usd.
- **/
-
-void
-vl_covdet_set_aa_accurate_smoothing (VlCovDet * self, vl_bool x)
-{
-  self->aaAccurateSmoothing = x ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the non-extrema suppression threshold
- ** @param self object.
- ** @return threshold.
- **/
-
-double
-vl_covdet_get_non_extrema_suppression_threshold (VlCovDet const * self)
-{
-  return self->nonExtremaSuppression ;
-}
-
-/** @brief Set the non-extrema suppression threshod
- ** @param self object.
- ** @param x threshold.
- **/
-
-void
-vl_covdet_set_non_extrema_suppression_threshold (VlCovDet * self, double x)
-{
-  self->nonExtremaSuppression = x ;
-}
-
-/** @brief Get the number of non-extrema suppressed
- ** @param self object.
- ** @return number.
- **/
-
-vl_size
-vl_covdet_get_num_non_extrema_suppressed (VlCovDet const * self)
-{
-  return self->numNonExtremaSuppressed ;
-}
-
-
-/* ---------------------------------------------------------------- */
-/** @brief Get number of stored frames
- ** @return number of frames stored in the detector.
- **/
-vl_size
-vl_covdet_get_num_features (VlCovDet const * self)
-{
-  return self->numFeatures ;
-}
-
-/** @brief Get the stored frames
- ** @return frames stored in the detector.
- **/
-VlCovDetFeature *
-vl_covdet_get_features (VlCovDet * self)
-{
-  return self->features ;
-}
-
-/** @brief Get the Gaussian scale space
- ** @return Gaussian scale space.
- **
- ** A Gaussian scale space exists only after calling ::vl_covdet_put_image.
- ** Otherwise the function returns @c NULL.
- **/
-
-VlScaleSpace *
-vl_covdet_get_gss (VlCovDet const * self)
-{
-  return self->gss ;
-}
-
-/** @brief Get the cornerness measure scale space
- ** @return cornerness measure scale space.
- **
- ** A cornerness measure scale space exists only after calling
- ** ::vl_covdet_detect. Otherwise the function returns @c NULL.
- **/
-
-VlScaleSpace *
-vl_covdet_get_css (VlCovDet const * self)
-{
-  return self->css ;
-}
-
-/** @brief Get the number of features found with a certain number of scales
- ** @param self object.
- ** @param numScales length of the histogram (out).
- ** @return histogram.
- **
- ** Calling this function makes sense only after running a detector
- ** that uses the Laplacian as a secondary measure for scale
- ** detection
- **/
-
-vl_size const *
-vl_covdet_get_laplacian_scales_statistics (VlCovDet const * self,
-                                           vl_size * numScales)
-{
-  *numScales = VL_COVDET_MAX_NUM_LAPLACIAN_SCALES ;
-  return self->numFeaturesWithNumScales ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/covdet.h b/opensfm/src/third_party/vlfeat/vl/covdet.h
deleted file mode 100644
index c0fdabb72..000000000
--- a/opensfm/src/third_party/vlfeat/vl/covdet.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/** @file covdet.h
- ** @brief Covariant feature detectors (@ref covdet)
- ** @author Karel Lenc
- ** @author Andrea Vedaldi
- ** @author Michal Perdoch
- **/
-
-/*
-Copyright (C) 2013-14 Andrea Vedaldi.
-Copyright (C) 2012 Karel Lenc, Andrea Vedaldi and Michal Perdoch.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_COVDET_H
-#define VL_COVDET_H
-
-#include "generic.h"
-#include "stringop.h"
-#include "scalespace.h"
-
-#include <stdio.h>
-
-/* ---------------------------------------------------------------- */
-/*                                                   Feature Frames */
-/* ---------------------------------------------------------------- */
-
-/** @name Feature frames
- ** @{ */
-
-/** @brief Types of feature frames */
-typedef enum _VlFrameType {
-  VL_FRAMETYPE_DISC = 1,         /**< A disc. */
-  VL_FRAMETYPE_ORIENTED_DISC,    /**< An oriented disc. */
-  VL_FRAMETYPE_ELLIPSE,          /**< An ellipse. */
-  VL_FRAMETYPE_ORIENTED_ELLIPSE, /**< An oriented ellipse. */
-  VL_FRAMETYPE_NUM
-} VlFrameType ;
-
-/** @brief Names of the frame types */
-VL_EXPORT const char* vlFrameNames [VL_FRAMETYPE_NUM] ;
-
-/** @brief Mapping between string values and VlFrameType values */
-VL_EXPORT VlEnumerator vlFrameTypes [VL_FRAMETYPE_NUM] ;
-
-/** @brief Disc feature frame */
-typedef struct _VlFrameDisc
-{
-  float x ;     /**< center x-coordinate */
-  float y ;     /**< center y-coordinate */
-  float sigma ; /**< radius or scale */
-} VlFrameDisc ;
-
-/** @brief Oriented disc feature frame
- ** An upright frame has @c angle equal to zero.
- **/
-typedef struct _VlFrameOrientedDisc {
-  float x ;     /**< center x-coordinate */
-  float y ;     /**< center y-coordinate */
-  float sigma ; /**< radius or scale */
-  float angle ; /**< rotation angle (rad) */
-} VlFrameOrientedDisc ;
-
-/** @brief Ellipse feature frame */
-typedef struct _VlFrameEllipse {
-  float x ;     /**< center x-coordinate */
-  float y ;     /**< center y-coordinate */
-  float e11 ;   /**< */
-  float e12 ;
-  float e22 ;
-} VlFrameEllipse ;
-
-/** @brief Oriented ellipse feature frame
- ** The affine transformation transforms the ellipse shape into
- ** a circular region. */
-typedef struct _VlFrameOrientedEllipse {
-  float x ;     /**< center x-coordinate */
-  float y ;     /**< center y-coordinate */
-  float a11 ;   /**< */
-  float a12 ;
-  float a21 ;
-  float a22 ;
-} VlFrameOrientedEllipse;
-
-/** @brief Get the size of a frame structure
- ** @param frameType identifier of the type of frame.
- ** @return size of the corresponding frame structure in bytes.
- **/
-VL_INLINE vl_size
-vl_get_frame_size (VlFrameType frameType) {
-  switch (frameType) {
-    case VL_FRAMETYPE_DISC: return sizeof(VlFrameDisc);
-    case VL_FRAMETYPE_ORIENTED_DISC: return sizeof(VlFrameOrientedDisc);
-    case VL_FRAMETYPE_ELLIPSE: return sizeof(VlFrameEllipse);
-    case VL_FRAMETYPE_ORIENTED_ELLIPSE: return sizeof(VlFrameOrientedEllipse);
-    default:
-      assert(0);
-      break;
-  }
-  return 0;
-}
-
-/** @brief Get the size of a frame structure
- ** @param affineAdaptation whether the detector use affine adaptation.
- ** @param orientation whether the detector estimates the feature orientation.
- ** @return the type of extracted frame.
- **
- ** Depedning on whether the detector estimate the affine shape
- ** and orientation of a feature, different frame types
- ** are extracted. */
-
-VL_INLINE VlFrameType
-vl_get_frame_type (vl_bool affineAdaptation, vl_bool orientation)
-{
-  if (affineAdaptation) {
-    if (orientation) {
-      return VL_FRAMETYPE_ORIENTED_ELLIPSE;
-    } else {
-      return VL_FRAMETYPE_ELLIPSE;
-    }
-  } else {
-    if (orientation) {
-      return VL_FRAMETYPE_ORIENTED_DISC;
-    } else {
-      return VL_FRAMETYPE_DISC;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                       Covariant Feature Detector */
-/* ---------------------------------------------------------------- */
-
-/** @brief A detected feature shape and location */
-typedef struct _VlCovDetFeature
-{
-  VlFrameOrientedEllipse frame ; /**< feature frame. */
-  int o ; /**< Detected octave. */
-  int s ; /**< Octave subdivision. */
-  float peakScore ; /**< peak score. */
-  float edgeScore ; /**< edge score. */
-  float orientationScore ; /**< orientation score. */
-  float laplacianScaleScore ; /**< Laplacian scale score. */
-} VlCovDetFeature ;
-
-/** @brief A detected feature orientation */
-typedef struct _VlCovDetFeatureOrientation
-{
-  double angle ;
-  double score ;
-} VlCovDetFeatureOrientation ;
-
-/** @brief A detected feature Laplacian scale */
-typedef struct _VlCovDetFeatureLaplacianScale
-{
-  double scale ;
-  double score ;
-} VlCovDetFeatureLaplacianScale ;
-
-/** @brief Covariant feature detection method */
-typedef enum _VlCovDetMethod
-{
-  VL_COVDET_METHOD_DOG = 1,
-  VL_COVDET_METHOD_HESSIAN,
-  VL_COVDET_METHOD_HESSIAN_LAPLACE,
-  VL_COVDET_METHOD_HARRIS_LAPLACE,
-  VL_COVDET_METHOD_MULTISCALE_HESSIAN,
-  VL_COVDET_METHOD_MULTISCALE_HARRIS,
-  VL_COVDET_METHOD_NUM
-} VlCovDetMethod;
-
-/** @brief Mapping between strings and ::VlCovDetMethod values */
-VL_EXPORT VlEnumerator vlCovdetMethods [VL_COVDET_METHOD_NUM] ;
-
-#ifdef __DOXYGEN__
-/** @brief Covariant feature detector
- ** @see @ref covdet */
-struct _VlCovDet { }
-#endif
-
-/** @brief Covariant feature detector
- ** @see @ref covdet */
-typedef struct _VlCovDet VlCovDet ;
-
-/** @name Create and destroy
- ** @{ */
-VL_EXPORT VlCovDet * vl_covdet_new (VlCovDetMethod method) ;
-VL_EXPORT void vl_covdet_delete (VlCovDet * self) ;
-VL_EXPORT void vl_covdet_reset (VlCovDet * self) ;
-/** @} */
-
-/** @name Process data
- ** @{ */
-VL_EXPORT int vl_covdet_put_image (VlCovDet * self,
-                                    float const * image,
-                                    vl_size width, vl_size height) ;
-
-VL_EXPORT void vl_covdet_detect (VlCovDet * self, vl_size max_num_features) ;
-VL_EXPORT int vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature) ;
-VL_EXPORT void vl_covdet_extract_orientations (VlCovDet * self) ;
-VL_EXPORT void vl_covdet_extract_laplacian_scales (VlCovDet * self) ;
-VL_EXPORT void vl_covdet_extract_affine_shape (VlCovDet * self) ;
-
-VL_EXPORT VlCovDetFeatureOrientation *
-vl_covdet_extract_orientations_for_frame (VlCovDet * self,
-                                          vl_size *numOrientations,
-                                          VlFrameOrientedEllipse frame) ;
-
-VL_EXPORT VlCovDetFeatureLaplacianScale *
-vl_covdet_extract_laplacian_scales_for_frame (VlCovDet * self,
-                                              vl_size * numScales,
-                                              VlFrameOrientedEllipse frame) ;
-VL_EXPORT int
-vl_covdet_extract_affine_shape_for_frame (VlCovDet * self,
-                                          VlFrameOrientedEllipse * adapted,
-                                          VlFrameOrientedEllipse frame) ;
-
-VL_EXPORT vl_bool
-vl_covdet_extract_patch_for_frame (VlCovDet * self, float * patch,
-                                   vl_size resolution,
-                                   double extent,
-                                   double sigma,
-                                   VlFrameOrientedEllipse frame) ;
-
-VL_EXPORT void
-vl_covdet_drop_features_outside (VlCovDet * self, double margin) ;
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{ */
-VL_EXPORT vl_size vl_covdet_get_num_features (VlCovDet const * self) ;
-VL_EXPORT VlCovDetFeature * vl_covdet_get_features (VlCovDet * self) ;
-VL_EXPORT vl_index vl_covdet_get_first_octave (VlCovDet const * self) ;
-VL_EXPORT vl_size vl_covdet_get_octave_resolution (VlCovDet const * self) ;
-VL_EXPORT double vl_covdet_get_peak_threshold (VlCovDet const * self) ;
-VL_EXPORT double vl_covdet_get_edge_threshold (VlCovDet const * self) ;
-VL_EXPORT double vl_covdeg_get_laplacian_peak_threshold (VlCovDet const * self) ;
-VL_EXPORT vl_bool vl_covdet_get_transposed (VlCovDet const * self) ;
-VL_EXPORT VlScaleSpace *  vl_covdet_get_gss (VlCovDet const * self) ;
-VL_EXPORT VlScaleSpace *  vl_covdet_get_css (VlCovDet const * self) ;
-VL_EXPORT vl_bool vl_covdet_get_aa_accurate_smoothing (VlCovDet const * self) ;
-VL_EXPORT vl_size const * vl_covdet_get_laplacian_scales_statistics (VlCovDet const * self, vl_size * numScales) ;
-VL_EXPORT double vl_covdet_get_non_extrema_suppression_threshold (VlCovDet const * self) ;
-VL_EXPORT vl_size vl_covdet_get_num_non_extrema_suppressed (VlCovDet const * self) ;
-
-/** @} */
-
-/** @name Set parameters
- ** @{ */
-VL_EXPORT void vl_covdet_set_first_octave (VlCovDet * self, vl_index o) ;
-VL_EXPORT void vl_covdet_set_octave_resolution (VlCovDet * self, vl_size r) ;
-VL_EXPORT void vl_covdet_set_peak_threshold (VlCovDet * self, double peakThreshold) ;
-VL_EXPORT void vl_covdet_set_edge_threshold (VlCovDet * self, double edgeThreshold) ;
-VL_EXPORT void vl_covdet_set_laplacian_peak_threshold (VlCovDet * self, double peakThreshold) ;
-VL_EXPORT void vl_covdet_set_transposed (VlCovDet * self, vl_bool t) ;
-VL_EXPORT void vl_covdet_set_aa_accurate_smoothing (VlCovDet * self, vl_bool x) ;
-VL_EXPORT void vl_covdet_set_non_extrema_suppression_threshold (VlCovDet * self, double x) ;
-/** @} */
-
-/* VL_COVDET_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/dsift.c b/opensfm/src/third_party/vlfeat/vl/dsift.c
deleted file mode 100644
index b76c6184d..000000000
--- a/opensfm/src/third_party/vlfeat/vl/dsift.c
+++ /dev/null
@@ -1,775 +0,0 @@
-/** @file dsift.c
- ** @brief Dense SIFT - Definition
- ** @author Andrea Vedaldi
- ** @author Brian Fulkerson
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#include "dsift.h"
-#include "pgm.h"
-#include "mathop.h"
-#include "imopv.h"
-#include <math.h>
-#include <string.h>
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page dsift Dense Scale Invariant Feature Transform (DSIFT)
-@author Andrea Vedaldi
-@author Brian Fulkerson
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref dsift.h implements a dense version of @ref sift.h "SIFT". This is
-an object that can quickly compute descriptors for densely sampled
-keypoints with identical size and orientation. It can be reused for
-multiple images of the same size.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section dsift-intro Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@sa @ref sift "The SIFT module", @ref dsift-tech "Technical details"
-
-This module implements a fast algorithm for the calculation of a large
-number of SIFT descriptors of densely sampled features of the same
-scale and orientation. See the @ref sift "SIFT module" for an
-overview of SIFT.
-
-The feature frames (keypoints) are indirectly specified by the
-sampling steps (::vl_dsift_set_steps) and the sampling bounds
-(::vl_dsift_set_bounds).  The descriptor geometry (number and size of
-the spatial bins and number of orientation bins) can be customized
-(::vl_dsift_set_geometry, ::VlDsiftDescriptorGeometry).
-
-@image html dsift-geom.png "Dense SIFT descriptor geometry"
-
-By default, SIFT uses a Gaussian windowing function that discounts
-contributions of gradients further away from the descriptor
-centers. This function can be changed to a flat window by invoking
-::vl_dsift_set_flat_window. In this case, gradients are accumulated
-using only bilinear interpolation, but instad of being reweighted by a
-Gassuain window, they are all weighted equally. However, after
-gradients have been accumulated into a spatial bin, the whole bin is
-reweighted by the average of the Gaussian window over the spatial
-support of that bin. This &ldquo;approximation&rdquo; substantially
-improves speed with little or no loss of performance in applications.
-
-Keypoints are sampled in such a way that the centers of the spatial
-bins are at integer coordinates within the image boundaries. For
-instance, the top-left bin of the top-left descriptor is centered on
-the pixel (0,0). The bin immediately to the right at
-(<code>binSizeX</code>,0), where <code>binSizeX</code> is a paramtere
-in the ::VlDsiftDescriptorGeometry structure. ::vl_dsift_set_bounds
-can be used to further restrict sampling to the keypoints in an image.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
- @section dsift-usage Usage
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-DSIFT is implemented by a ::VlDsiftFilter object that can be used
-to process a sequence of images of a given geometry.
-To use the <b>DSIFT filter</b>:
-
-- Initialize a new DSIFT filter object by ::vl_dsift_new (or the simplified
-::vl_dsift_new_basic). Customize the descriptor parameters by
-::vl_dsift_set_steps, ::vl_dsift_set_geometry, etc.
-- Process an image by ::vl_dsift_process.
-- Retrieve the number of keypoints (::vl_dsift_get_keypoint_num), the
-  keypoints (::vl_dsift_get_keypoints), and their descriptors
-  (::vl_dsift_get_descriptors).
-- Optionally repeat for more images.
-- Delete the DSIFT filter by ::vl_dsift_delete.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section dsift-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This section extends the @ref sift-tech-descriptor "SIFT descriptor section"
-and specialzies it to the case of dense keypoints.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection dsift-tech-descriptor-dense Dense descriptors
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-When computing descriptors for many keypoints differing only by their
-position (and with null rotation), further simplifications are
-possible. In this case, in fact,
-
-@f{eqnarray*}
-     \mathbf{x} &=& m \sigma \hat{\mathbf{x}} + T,\\
- h(t,i,j)
- &=&
- m \sigma \int
- g_{\sigma_\mathrm{win}}(\mathbf{x} - T)\,
- w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,
- w\left(\frac{x - T_x}{m\sigma} - \hat{x}_i\right)\,
- w\left(\frac{y - T_y}{m\sigma} - \hat{y}_j\right)\,
- |J(\mathbf{x})|\,
- d\mathbf{x}.
-@f}
-
-Since many different values of @e T are sampled, this is conveniently
-expressed as a separable convolution. First, we translate by @f$
-\mathbf{x}_{ij} = m\sigma(\hat x_i,\ \hat y_i)^\top @f$ and we use the
-symmetry of the various binning and windowing functions to write
-
-@f{eqnarray*}
- h(t,i,j)
- &=&
- m \sigma \int
- g_{\sigma_\mathrm{win}}(T' - \mathbf{x} - \mathbf{x}_{ij})\,
- w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,
- w\left(\frac{T'_x - x}{m\sigma}\right)\,
- w\left(\frac{T'_y - y}{m\sigma}\right)\,
- |J(\mathbf{x})|\,
- d\mathbf{x},
-\\
-T' &=& T + m\sigma
-\left[\begin{array}{cc} x_i \\ y_j \end{array}\right].
-@f}
-
-Then we define kernels
-
-@f{eqnarray*}
- k_i(x) &=&
- \frac{1}{\sqrt{2\pi} \sigma_{\mathrm{win}}}
- \exp\left(
- -\frac{1}{2}
- \frac{(x-x_i)^2}{\sigma_{\mathrm{win}}^2}
- \right)
- w\left(\frac{x}{m\sigma}\right),
- \\
- k_j(y) &=&
- \frac{1}{\sqrt{2\pi} \sigma_{\mathrm{win}}}
- \exp\left(
- -\frac{1}{2}
- \frac{(y-y_j)^2}{\sigma_{\mathrm{win}}^2}
- \right)
- w\left(\frac{y}{m\sigma}\right),
-@f}
-
-and obtain
-
-@f{eqnarray*}
- h(t,i,j) &=& (k_ik_j * \bar J_t)\left( T + m\sigma
-\left[\begin{array}{cc} x_i \\ y_j \end{array}\right] \right),
-\\
-\bar J_t(\mathbf{x}) &=&  w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,|J(\mathbf{x})|.
-@f}
-
-Furthermore, if we use a flat rather than Gaussian windowing function,
-the kernels do not depend on the bin, and we have
-
-@f{eqnarray*}
- k(z) &=&
- \frac{1}{\sigma_{\mathrm{win}}}
- w\left(\frac{z}{m\sigma}\right),
-\\
- h(t,i,j) &=& (k(x)k(y) * \bar J_t)\left( T + m\sigma
-\left[\begin{array}{cc} x_i \\ y_j \end{array}\right] \right),
-@f}
-
-(here @f$ \sigma_\mathrm{win} @f$ is the side of the flat window).
-
-@note In this case the binning functions @f$ k(z) @f$ are triangular
-and the convolution can be computed in time independent on the filter
-(i.e. descriptor bin) support size by integral signals.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection dsift-tech-sampling Sampling
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-To avoid resampling and dealing with special boundary conditions, we
-impose some mild restrictions on the geometry of the descriptors that
-can be computed. In particular, we impose that the bin centers @f$ T +
-m\sigma (x_i,\ y_j) @f$ are always at integer coordinates within the
-image boundaries. This eliminates the need for costly interpolation.
-This condition amounts to (expressed in terms of the @e x coordinate,
-and equally applicable to @e y)
-
-@f[
- \{0,\dots, W-1\} \ni T_x + m\sigma x_i =
- T_x + m\sigma i - \frac{N_x-1}{2}
- = \bar T_x + m\sigma i,
- \qquad i = 0,\dots,N_x-1.
-@f]
-
-Notice that for this condition to be satisfied, the @em descriptor
-center @f$ T_x @f$ needs to be either fractional or integer depending
-on @f$ N_x @f$ being even or odd. To eliminate this complication,
-it is simpler to use as a reference not the descriptor center @e T,
-but the coordinates of the upper-left bin @f$ \bar T @f$. Thus we
-sample the latter on a regular (integer) grid
-
-@f[
- \left[\begin{array}{cc}
-   0 \\
-   0
- \end{array}\right]
- \leq
- \bar T =
- \left[\begin{array}{cc}
-   \bar T_x^{\min} + p \Delta_x \\
-   \bar T_y^{\min} + q \Delta_y \\
- \end{array}\right]
- \leq
- \left[\begin{array}{cc}
-   W - 1 - m\sigma N_x \\
-   H - 1 - m\sigma N_y
- \end{array}\right],
- \quad
- \bar T =
- \left[\begin{array}{cc}
-   T_x - \frac{N_x - 1}{2} \\
-   T_y - \frac{N_y - 1}{2} \\
-  \end{array}\right]
-@f]
-
-and we impose that the bin size @f$ m \sigma @f$ is integer as well.
-
-**/
-
-/** ------------------------------------------------------------------
- ** @internal @brief Initialize new convolution kernel
- ** @param binSize
- ** @param numBins
- ** @param binIndex negative to use flat window.
- ** @param windowSize
- ** @return a pointer to new filter.
- **/
-
-float *
-_vl_dsift_new_kernel (int binSize, int numBins, int binIndex, double windowSize)
-{
-  int filtLen = 2 * binSize - 1 ;
-  float * ker = vl_malloc (sizeof(float) * filtLen) ;
-  float * kerIter = ker ;
-  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
-  /*
-  float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;
-  float sigma = 0.5F * ((numBins) * binSize) ;
-  */
-  float sigma = (float) binSize * (float) windowSize ;
-  int x ;
-
-  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
-    float z = (x - delta) / sigma ;
-    *kerIter++ = (1.0F - fabsf(x) / binSize) *
-      ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
-  }
-  return ker ;
-}
-
-static float
-_vl_dsift_get_bin_window_mean
-(int binSize, int numBins, int binIndex, double windowSize)
-{
-  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
-  /*float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;*/
-  float sigma = (float) binSize * (float) windowSize ;
-  int x ;
-
-  float acc = 0.0 ;
-  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
-    float z = (x - delta) / sigma ;
-    acc += ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
-  }
-  return acc /= (2 * binSize - 1) ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Normalize histogram
- ** @param begin first element of the histogram.
- ** @param end last plus one element of the histogram.
- **
- ** The function divides the specified histogram by its l2 norm.
- **/
-
-VL_INLINE float
-_vl_dsift_normalize_histogram (float * begin, float * end)
-{
-  float * iter ;
-  float  norm = 0.0F ;
-
-  for (iter = begin ; iter < end ; ++ iter) {
-    norm += (*iter) * (*iter) ;
-  }
-  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;
-
-  for (iter = begin; iter < end ; ++ iter) {
-    *iter /= norm ;
-  }
-  return norm ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Free internal buffers
- ** @param self DSIFT filter.
- **/
-
-static void
-_vl_dsift_free_buffers (VlDsiftFilter* self)
-{
-  if (self->frames) {
-    vl_free(self->frames) ;
-    self->frames = NULL ;
-  }
-  if (self->descrs) {
-    vl_free(self->descrs) ;
-    self->descrs = NULL ;
-  }
-  if (self->grads) {
-    int t ;
-    for (t = 0 ; t < self->numGradAlloc ; ++t)
-      if (self->grads[t]) vl_free(self->grads[t]) ;
-    vl_free(self->grads) ;
-    self->grads = NULL ;
-  }
-  self->numFrameAlloc = 0 ;
-  self->numBinAlloc = 0 ;
-  self->numGradAlloc = 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Updates internal buffers to current geometry
- **/
-
-VL_EXPORT void
-_vl_dsift_update_buffers (VlDsiftFilter * self)
-{
-  int x1 = self->boundMinX ;
-  int x2 = self->boundMaxX ;
-  int y1 = self->boundMinY ;
-  int y2 = self->boundMaxY ;
-
-  int rangeX = x2 - x1 - (self->geom.numBinX - 1) * self->geom.binSizeX ;
-  int rangeY = y2 - y1 - (self->geom.numBinY - 1) * self->geom.binSizeY ;
-
-  int numFramesX = (rangeX >= 0) ? rangeX / self->stepX + 1 : 0 ;
-  int numFramesY = (rangeY >= 0) ? rangeY / self->stepY + 1 : 0 ;
-
-  self->numFrames = numFramesX * numFramesY ;
-  self->descrSize = self->geom.numBinT *
-                    self->geom.numBinX *
-                    self->geom.numBinY ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Allocate internal buffers
- ** @param self DSIFT filter.
- **
- ** The function (re)allocates the internal buffers in accordance with
- ** the current image and descriptor geometry.
- **/
-
-static void
-_vl_dsift_alloc_buffers (VlDsiftFilter* self)
-{
-  _vl_dsift_update_buffers (self) ;
-  {
-    int numFrameAlloc = vl_dsift_get_keypoint_num (self) ;
-    int numBinAlloc   = vl_dsift_get_descriptor_size (self) ;
-    int numGradAlloc  = self->geom.numBinT ;
-
-    /* see if we need to update the buffers */
-    if (numBinAlloc != self->numBinAlloc ||
-        numGradAlloc != self->numGradAlloc ||
-        numFrameAlloc != self->numFrameAlloc) {
-
-      int t ;
-
-      _vl_dsift_free_buffers(self) ;
-
-      self->frames = vl_malloc(sizeof(VlDsiftKeypoint) * numFrameAlloc) ;
-      self->descrs = vl_malloc(sizeof(float) * numBinAlloc * numFrameAlloc) ;
-      self->grads  = vl_malloc(sizeof(float*) * numGradAlloc) ;
-      for (t = 0 ; t < numGradAlloc ; ++t) {
-        self->grads[t] =
-          vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
-      }
-      self->numBinAlloc = numBinAlloc ;
-      self->numGradAlloc = numGradAlloc ;
-      self->numFrameAlloc = numFrameAlloc ;
-    }
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new DSIFT filter
- **
- ** @param imWidth width of the image.
- ** @param imHeight height of the image
- **
- ** @return new filter.
- **/
-
-VL_EXPORT VlDsiftFilter *
-vl_dsift_new (int imWidth, int imHeight)
-{
-  VlDsiftFilter * self = vl_malloc (sizeof(VlDsiftFilter)) ;
-  self->imWidth  = imWidth ;
-  self->imHeight = imHeight ;
-
-  self->stepX = 5 ;
-  self->stepY = 5 ;
-
-  self->boundMinX = 0 ;
-  self->boundMinY = 0 ;
-  self->boundMaxX = imWidth - 1 ;
-  self->boundMaxY = imHeight - 1 ;
-
-  self->geom.numBinX = 4 ;
-  self->geom.numBinY = 4 ;
-  self->geom.numBinT = 8 ;
-  self->geom.binSizeX = 5 ;
-  self->geom.binSizeY = 5 ;
-
-  self->useFlatWindow = VL_FALSE ;
-  self->windowSize = 2.0 ;
-
-  self->convTmp1 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
-  self->convTmp2 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
-
-  self->numBinAlloc = 0 ;
-  self->numFrameAlloc = 0 ;
-  self->numGradAlloc = 0 ;
-
-  self->descrSize = 0 ;
-  self->numFrames = 0 ;
-  self->grads = NULL ;
-  self->frames = NULL ;
-  self->descrs = NULL ;
-
-  _vl_dsift_update_buffers(self) ;
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new DSIFT filter (basic interface)
- ** @param imWidth width of the image.
- ** @param imHeight height of the image.
- ** @param step sampling step.
- ** @param binSize bin size.
- ** @return new filter.
- **
- ** The descriptor geometry matches the standard SIFT descriptor.
- **/
-
-VL_EXPORT VlDsiftFilter *
-vl_dsift_new_basic (int imWidth, int imHeight, int step, int binSize)
-{
-  VlDsiftFilter* self = vl_dsift_new(imWidth, imHeight) ;
-  VlDsiftDescriptorGeometry geom = *vl_dsift_get_geometry(self) ;
-  geom.binSizeX = binSize ;
-  geom.binSizeY = binSize ;
-  vl_dsift_set_geometry(self, &geom) ;
-  vl_dsift_set_steps(self, step, step) ;
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Delete DSIFT filter
- ** @param self DSIFT filter.
- **/
-
-VL_EXPORT void
-vl_dsift_delete (VlDsiftFilter * self)
-{
-  _vl_dsift_free_buffers (self) ;
-  if (self->convTmp2) vl_free (self->convTmp2) ;
-  if (self->convTmp1) vl_free (self->convTmp1) ;
-  vl_free (self) ;
-}
-
-
-/** ------------------------------------------------------------------
- ** @internal @brief Process with Gaussian window
- ** @param self DSIFT filter.
- **/
-
-VL_INLINE void
-_vl_dsift_with_gaussian_window (VlDsiftFilter * self)
-{
-  int binx, biny, bint ;
-  int framex, framey ;
-  float *xker, *yker ;
-
-  int Wx = self->geom.binSizeX - 1 ;
-  int Wy = self->geom.binSizeY - 1 ;
-
-  for (biny = 0 ; biny < self->geom.numBinY ; ++biny) {
-
-    yker = _vl_dsift_new_kernel (self->geom.binSizeY,
-                                 self->geom.numBinY,
-                                 biny,
-                                 self->windowSize) ;
-
-    for (binx = 0 ; binx < self->geom.numBinX ; ++binx) {
-
-      xker = _vl_dsift_new_kernel(self->geom.binSizeX,
-                                  self->geom.numBinX,
-                                  binx,
-                                  self->windowSize) ;
-
-      for (bint = 0 ; bint < self->geom.numBinT ; ++bint) {
-
-        vl_imconvcol_vf (self->convTmp1, self->imHeight,
-                         self->grads[bint], self->imWidth, self->imHeight,
-                         self->imWidth,
-                         yker, -Wy, +Wy, 1,
-                         VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
-
-        vl_imconvcol_vf (self->convTmp2, self->imWidth,
-                         self->convTmp1, self->imHeight, self->imWidth,
-                         self->imHeight,
-                         xker, -Wx, +Wx, 1,
-                         VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
-
-        {
-          float *dst = self->descrs
-            + bint
-            + binx * self->geom.numBinT
-            + biny * (self->geom.numBinX * self->geom.numBinT)  ;
-
-          float *src = self->convTmp2 ;
-
-          int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
-          int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
-          int descrSize = vl_dsift_get_descriptor_size (self) ;
-
-          for (framey  = self->boundMinY ;
-               framey <= self->boundMaxY - frameSizeY + 1 ;
-               framey += self->stepY) {
-            for (framex  = self->boundMinX ;
-                 framex <= self->boundMaxX - frameSizeX + 1 ;
-                 framex += self->stepX) {
-              *dst = src [(framex + binx * self->geom.binSizeX) * 1 +
-                          (framey + biny * self->geom.binSizeY) * self->imWidth]  ;
-              dst += descrSize ;
-            } /* framex */
-          } /* framey */
-        }
-
-      } /* for bint */
-      vl_free (xker) ;
-    } /* for binx */
-    vl_free (yker) ;
-  } /* for biny */
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Process with flat window.
- ** @param self DSIFT filter object.
- **/
-
-VL_INLINE void
-_vl_dsift_with_flat_window (VlDsiftFilter* self)
-{
-  int binx, biny, bint ;
-  int framex, framey ;
-
-  /* for each orientation bin */
-  for (bint = 0 ; bint < self->geom.numBinT ; ++bint) {
-
-    vl_imconvcoltri_f (self->convTmp1, self->imHeight,
-                       self->grads [bint], self->imWidth, self->imHeight,
-                       self->imWidth,
-                       self->geom.binSizeY, /* filt size */
-                       1, /* subsampling step */
-                       VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
-
-    vl_imconvcoltri_f (self->convTmp2, self->imWidth,
-                       self->convTmp1, self->imHeight, self->imWidth,
-                       self->imHeight,
-                       self->geom.binSizeX,
-                       1,
-                       VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
-
-    for (biny = 0 ; biny < self->geom.numBinY ; ++biny) {
-
-      /*
-      This fast version of DSIFT does not use a proper Gaussian
-      weighting scheme for the gradiens that are accumulated on the
-      spatial bins. Instead each spatial bins is accumulated based on
-      the triangular kernel only, equivalent to bilinear interpolation
-      plus a flat, rather than Gaussian, window. Eventually, however,
-      the magnitude of the spatial bins in the SIFT descriptor is
-      reweighted by the average of the Gaussian window on each bin.
-      */
-
-      float wy = _vl_dsift_get_bin_window_mean
-        (self->geom.binSizeY, self->geom.numBinY, biny,
-         self->windowSize) ;
-
-      /* The convolution functions vl_imconvcoltri_* convolve by a
-       * triangular kernel with unit integral. Instead for SIFT the
-       * triangular kernel should have unit height. This is
-       * compensated for by multiplying by the bin size:
-       */
-
-      wy *= self->geom.binSizeY ;
-
-      for (binx = 0 ; binx < self->geom.numBinX ; ++binx) {
-        float w ;
-        float wx = _vl_dsift_get_bin_window_mean (self->geom.binSizeX,
-                                                  self->geom.numBinX,
-                                                  binx,
-                                                  self->windowSize) ;
-
-        float *dst = self->descrs
-          + bint
-          + binx * self->geom.numBinT
-          + biny * (self->geom.numBinX * self->geom.numBinT)  ;
-
-        float *src = self->convTmp2 ;
-
-        int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
-        int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
-        int descrSize = vl_dsift_get_descriptor_size (self) ;
-
-        wx *= self->geom.binSizeX ;
-        w = wx * wy ;
-
-        for (framey  = self->boundMinY ;
-             framey <= self->boundMaxY - frameSizeY + 1 ;
-             framey += self->stepY) {
-          for (framex  = self->boundMinX ;
-               framex <= self->boundMaxX - frameSizeX + 1 ;
-               framex += self->stepX) {
-            *dst = w * src [(framex + binx * self->geom.binSizeX) * 1 +
-                            (framey + biny * self->geom.binSizeY) * self->imWidth]  ;
-            dst += descrSize ;
-          } /* framex */
-        } /* framey */
-      } /* binx */
-    } /* biny */
-  } /* bint */
-}
-
-/** ------------------------------------------------------------------
- ** @brief Compute keypoints and descriptors
- **
- ** @param self DSIFT filter.
- ** @param im   image data.
- **/
-
-void vl_dsift_process (VlDsiftFilter* self, float const* im)
-{
-  int t, x, y ;
-
-  /* update buffers */
-  _vl_dsift_alloc_buffers (self) ;
-
-  /* clear integral images */
-  for (t = 0 ; t < self->geom.numBinT ; ++t)
-    memset (self->grads[t], 0,
-            sizeof(float) * self->imWidth * self->imHeight) ;
-
-#undef at
-#define at(x,y) (im[(y)*self->imWidth+(x)])
-
-  /* Compute gradients, their norm, and their angle */
-
-  for (y = 0 ; y < self->imHeight ; ++ y) {
-    for (x = 0 ; x < self->imWidth ; ++ x) {
-      float gx, gy ;
-      float angle, mod, nt, rbint ;
-      int bint ;
-
-      /* y derivative */
-      if (y == 0) {
-        gy = at(x,y+1) - at(x,y) ;
-      } else if (y == self->imHeight - 1) {
-        gy = at(x,y) - at(x,y-1) ;
-      } else {
-        gy = 0.5F * (at(x,y+1) - at(x,y-1)) ;
-      }
-
-      /* x derivative */
-      if (x == 0) {
-        gx = at(x+1,y) - at(x,y) ;
-      } else if (x == self->imWidth - 1) {
-        gx = at(x,y) - at(x-1,y) ;
-      } else {
-        gx = 0.5F * (at(x+1,y) - at(x-1,y)) ;
-      }
-
-      /* angle and modulus */
-      angle = vl_fast_atan2_f (gy,gx) ;
-      mod = vl_fast_sqrt_f (gx*gx + gy*gy) ;
-
-      /* quantize angle */
-      nt = vl_mod_2pi_f (angle) * (self->geom.numBinT / (2*VL_PI)) ;
-      bint = (int) vl_floor_f (nt) ;
-      rbint = nt - bint ;
-
-      /* write it back */
-      self->grads [(bint    ) % self->geom.numBinT][x + y * self->imWidth] = (1 - rbint) * mod ;
-      self->grads [(bint + 1) % self->geom.numBinT][x + y * self->imWidth] = (    rbint) * mod ;
-    }
-  }
-
-  if (self->useFlatWindow) {
-    _vl_dsift_with_flat_window(self) ;
-  } else {
-    _vl_dsift_with_gaussian_window(self) ;
-  }
-
-  {
-    VlDsiftKeypoint* frameIter = self->frames ;
-    float * descrIter = self->descrs ;
-    int framex, framey, bint ;
-
-    int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
-    int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
-    int descrSize = vl_dsift_get_descriptor_size (self) ;
-
-    float deltaCenterX = 0.5F * self->geom.binSizeX * (self->geom.numBinX - 1) ;
-    float deltaCenterY = 0.5F * self->geom.binSizeY * (self->geom.numBinY - 1) ;
-
-    float normConstant = frameSizeX * frameSizeY ;
-
-    for (framey  = self->boundMinY ;
-         framey <= self->boundMaxY - frameSizeY + 1 ;
-         framey += self->stepY) {
-
-      for (framex  = self->boundMinX ;
-           framex <= self->boundMaxX - frameSizeX + 1 ;
-           framex += self->stepX) {
-
-        frameIter->x    = framex + deltaCenterX ;
-        frameIter->y    = framey + deltaCenterY ;
-
-        /* mass */
-        {
-          float mass = 0 ;
-          for (bint = 0 ; bint < descrSize ; ++ bint)
-            mass += descrIter[bint] ;
-          mass /= normConstant ;
-          frameIter->norm = mass ;
-        }
-
-        /* L2 normalize */
-        _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ;
-
-        /* clamp */
-        for(bint = 0 ; bint < descrSize ; ++ bint)
-          if (descrIter[bint] > 0.2F) descrIter[bint] = 0.2F ;
-
-        /* L2 normalize */
-        _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ;
-
-        frameIter ++ ;
-        descrIter += descrSize ;
-      } /* for framex */
-    } /* for framey */
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/dsift.h b/opensfm/src/third_party/vlfeat/vl/dsift.h
deleted file mode 100644
index 8bb301b7e..000000000
--- a/opensfm/src/third_party/vlfeat/vl/dsift.h
+++ /dev/null
@@ -1,354 +0,0 @@
-/** @file dsift.h
- ** @brief Dense SIFT (@ref dsift)
- ** @author Andrea Vedaldi
- ** @author Brian Fulkerson
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_DSIFT_H
-#define VL_DSIFT_H
-
-#include "generic.h"
-
-/** @brief Dense SIFT keypoint */
-typedef struct VlDsiftKeypoint_
-{
-  double x ; /**< x coordinate */
-  double y ; /**< y coordinate */
-  double s ; /**< scale */
-  double norm ; /**< SIFT descriptor norm */
-} VlDsiftKeypoint ;
-
-/** @brief Dense SIFT descriptor geometry */
-typedef struct VlDsiftDescriptorGeometry_
-{
-  int numBinT ;  /**< number of orientation bins */
-  int numBinX ;  /**< number of bins along X */
-  int numBinY ;  /**< number of bins along Y */
-  int binSizeX ; /**< size of bins along X */
-  int binSizeY ; /**< size of bins along Y */
-} VlDsiftDescriptorGeometry ;
-
-/** @brief Dense SIFT filter */
-typedef struct VlDsiftFilter_
-{
-  int imWidth ;            /**< @internal @brief image width */
-  int imHeight ;           /**< @internal @brief image height */
-
-  int stepX ;              /**< frame sampling step X */
-  int stepY ;              /**< frame sampling step Y */
-
-  int boundMinX ;          /**< frame bounding box min X */
-  int boundMinY ;          /**< frame bounding box min Y */
-  int boundMaxX ;          /**< frame bounding box max X */
-  int boundMaxY ;          /**< frame bounding box max Y */
-
-  /** descriptor parameters */
-  VlDsiftDescriptorGeometry geom ;
-
-  int useFlatWindow ;      /**< flag: whether to approximate the Gaussian window with a flat one */
-  double windowSize ;      /**< size of the Gaussian window */
-
-  int numFrames ;          /**< number of sampled frames */
-  int descrSize ;          /**< size of a descriptor */
-  VlDsiftKeypoint *frames ; /**< frame buffer */
-  float *descrs ;          /**< descriptor buffer */
-
-  int numBinAlloc ;        /**< buffer allocated: descriptor size */
-  int numFrameAlloc ;      /**< buffer allocated: number of frames  */
-  int numGradAlloc ;       /**< buffer allocated: number of orientations */
-
-  float **grads ;          /**< gradient buffer */
-  float *convTmp1 ;        /**< temporary buffer */
-  float *convTmp2 ;        /**< temporary buffer */
-}  VlDsiftFilter ;
-
-VL_EXPORT VlDsiftFilter *vl_dsift_new (int width, int height) ;
-VL_EXPORT VlDsiftFilter *vl_dsift_new_basic (int width, int height, int step, int binSize) ;
-VL_EXPORT void vl_dsift_delete (VlDsiftFilter *self) ;
-VL_EXPORT void vl_dsift_process (VlDsiftFilter *self, float const* im) ;
-VL_INLINE void vl_dsift_transpose_descriptor (float* dst,
-                                             float const* src,
-                                             int numBinT,
-                                             int numBinX,
-                                             int numBinY) ;
-
-/** @name Setting parameters
- ** @{
- **/
-VL_INLINE void vl_dsift_set_steps (VlDsiftFilter *self,
-                                  int stepX,
-                                  int stepY) ;
-VL_INLINE void vl_dsift_set_bounds (VlDsiftFilter *self,
-                                   int minX,
-                                   int minY,
-                                   int maxX,
-                                   int maxY) ;
-VL_INLINE void vl_dsift_set_geometry (VlDsiftFilter *self,
-                                      VlDsiftDescriptorGeometry const* geom) ;
-VL_INLINE void vl_dsift_set_flat_window (VlDsiftFilter *self, vl_bool useFlatWindow) ;
-VL_INLINE void vl_dsift_set_window_size (VlDsiftFilter *self, double windowSize) ;
-/** @} */
-
-/** @name Retrieving data and parameters
- ** @{
- **/
-VL_INLINE float const    *vl_dsift_get_descriptors     (VlDsiftFilter const *self) ;
-VL_INLINE int             vl_dsift_get_descriptor_size (VlDsiftFilter const *self) ;
-VL_INLINE int             vl_dsift_get_keypoint_num    (VlDsiftFilter const *self) ;
-VL_INLINE VlDsiftKeypoint const *vl_dsift_get_keypoints (VlDsiftFilter const *self) ;
-VL_INLINE void            vl_dsift_get_bounds          (VlDsiftFilter const *self,
-                                                       int* minX,
-                                                       int* minY,
-                                                       int* maxX,
-                                                       int* maxY) ;
-VL_INLINE void            vl_dsift_get_steps           (VlDsiftFilter const* self,
-                                                       int* stepX,
-                                                       int* stepY) ;
-VL_INLINE VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self) ;
-VL_INLINE vl_bool         vl_dsift_get_flat_window     (VlDsiftFilter const *self) ;
-VL_INLINE double          vl_dsift_get_window_size     (VlDsiftFilter const *self) ;
-/** @} */
-
-VL_EXPORT
-void _vl_dsift_update_buffers (VlDsiftFilter *self) ;
-
-/** ------------------------------------------------------------------
- ** @brief Get descriptor size.
- ** @param self DSIFT filter object.
- ** @return size of a descriptor.
- **/
-
-int
-vl_dsift_get_descriptor_size (VlDsiftFilter const *self)
-{
-  return self->descrSize ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get descriptors.
- ** @param self DSIFT filter object.
- ** @return descriptors.
- **/
-
-float const *
-vl_dsift_get_descriptors (VlDsiftFilter const *self)
-{
-  return self->descrs ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get keypoints
- ** @param self DSIFT filter object.
- **/
-
-VlDsiftKeypoint const *
-vl_dsift_get_keypoints (VlDsiftFilter const *self)
-{
-  return self->frames ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get number of keypoints
- ** @param self DSIFT filter object.
- **/
-
-int
-vl_dsift_get_keypoint_num (VlDsiftFilter const *self)
-{
-  return self->numFrames ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get SIFT descriptor geometry
- ** @param self DSIFT filter object.
- ** @return DSIFT descriptor geometry.
- **/
-
-VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self)
-{
-  return &self->geom ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get bounds
- ** @param self DSIFT filter object.
- ** @param minX bounding box minimum X coordinate.
- ** @param minY bounding box minimum Y coordinate.
- ** @param maxX bounding box maximum X coordinate.
- ** @param maxY bounding box maximum Y coordinate.
- **/
-
-void
-vl_dsift_get_bounds (VlDsiftFilter const* self,
-                    int *minX, int *minY, int *maxX, int *maxY)
-{
-  *minX = self->boundMinX ;
-  *minY = self->boundMinY ;
-  *maxX = self->boundMaxX ;
-  *maxY = self->boundMaxY ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get flat window flag
- ** @param self DSIFT filter object.
- ** @return @c TRUE if the DSIFT filter uses a flat window.
- **/
-
-int
-vl_dsift_get_flat_window (VlDsiftFilter const* self)
-{
-  return self->useFlatWindow ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get steps
- ** @param self DSIFT filter object.
- ** @param stepX sampling step along X.
- ** @param stepY sampling step along Y.
- **/
-
-void
-vl_dsift_get_steps (VlDsiftFilter const* self,
-                   int* stepX,
-                   int* stepY)
-{
-  *stepX = self->stepX ;
-  *stepY = self->stepY ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set steps
- ** @param self DSIFT filter object.
- ** @param stepX sampling step along X.
- ** @param stepY sampling step along Y.
- **/
-
-void
-vl_dsift_set_steps (VlDsiftFilter* self,
-                   int stepX,
-                   int stepY)
-{
-  self->stepX = stepX ;
-  self->stepY = stepY ;
-  _vl_dsift_update_buffers(self) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set bounds
- ** @param self DSIFT filter object.
- ** @param minX bounding box minimum X coordinate.
- ** @param minY bounding box minimum Y coordinate.
- ** @param maxX bounding box maximum X coordinate.
- ** @param maxY bounding box maximum Y coordinate.
- **/
-
-void
-vl_dsift_set_bounds (VlDsiftFilter* self,
-                    int minX, int minY, int maxX, int maxY)
-{
-  self->boundMinX = minX ;
-  self->boundMinY = minY ;
-  self->boundMaxX = maxX ;
-  self->boundMaxY = maxY ;
-  _vl_dsift_update_buffers(self) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set SIFT descriptor geometry
- ** @param self DSIFT filter object.
- ** @param geom descriptor geometry parameters.
- **/
-
-void
-vl_dsift_set_geometry (VlDsiftFilter *self,
-                       VlDsiftDescriptorGeometry const *geom)
-{
-  self->geom = *geom ;
-  _vl_dsift_update_buffers(self) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set flat window flag
- ** @param self DSIFT filter object.
- ** @param useFlatWindow @c true if the DSIFT filter should use a flat window.
- **/
-
-void
-vl_dsift_set_flat_window (VlDsiftFilter* self,
-                         vl_bool useFlatWindow)
-{
-  self->useFlatWindow = useFlatWindow ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Transpose descriptor
- **
- ** @param dst destination buffer.
- ** @param src source buffer.
- ** @param numBinT
- ** @param numBinX
- ** @param numBinY
- **
- ** The function writes to @a dst the transpose of the SIFT descriptor
- ** @a src. Let <code>I</code> be an image. The transpose operator
- ** satisfies the equation <code>transpose(dsift(I,x,y)) =
- ** dsift(transpose(I),y,x)</code>
- **/
-
-VL_INLINE void
-vl_dsift_transpose_descriptor (float* dst,
-                              float const* src,
-                              int numBinT,
-                              int numBinX,
-                              int numBinY)
-{
-  int t, x, y ;
-
-  for (y = 0 ; y < numBinY ; ++y) {
-    for (x = 0 ; x < numBinX ; ++x) {
-      int offset  = numBinT * (x + y * numBinX) ;
-      int offsetT = numBinT * (y + x * numBinY) ;
-
-      for (t = 0 ; t < numBinT ; ++t) {
-        int tT = numBinT / 4 - t ;
-        dst [offsetT + (tT + numBinT) % numBinT] = src [offset + t] ;
-      }
-    }
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set SIFT descriptor Gaussian window size
- ** @param self DSIFT filter object.
- ** @param windowSize window size.
- **/
-
-void
-vl_dsift_set_window_size(VlDsiftFilter * self, double windowSize)
-{
-  assert(windowSize >= 0.0) ;
-  self->windowSize = windowSize ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get SIFT descriptor Gaussian window size
- ** @param self DSIFT filter object.
- ** @return window size.
- **/
-
-VL_INLINE double
-vl_dsift_get_window_size(VlDsiftFilter const * self)
-{
-  return self->windowSize ;
-}
-
-/*  VL_DSIFT_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/fisher.c b/opensfm/src/third_party/vlfeat/vl/fisher.c
deleted file mode 100644
index 480e29fc6..000000000
--- a/opensfm/src/third_party/vlfeat/vl/fisher.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/** @file fisher.c
- ** @brief Fisher - Declaration
- ** @author David Novotny
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page fisher Fisher Vector encoding (FV)
-@author David Novotny
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref fisher.h implements the Fisher Vectors (FV) image representation
-@cite{perronnin06fisher} @cite{perronnin10improving}. A FV is a
-statistics capturing the distribution of a set of vectors, usually a
-set of local image descriptors.
-
-@ref fisher-starting demonstrates how to use the C API to compute the
-FV representation of an image. For further details refer to:
-
-- @subpage fisher-fundamentals - Fisher Vector definition.
-- @subpage fisher-derivation - Deriving the Fisher Vectors as a Fisher Kernel.
-- @subpage fisher-kernel - The Fisher Kernel in general.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section fisher-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The Fisher Vector encoding of a set of features is obtained by using
-the function ::vl_fisher_encode. Note that the function requires a
-@ref gmm "Gaussian Mixture Model" (GMM) of the encoded feature
-distribution. In the following code, the result of the coding process
-is stored in the @c enc array and the improved fisher vector
-normalization is used.
-
-@code
-float * means ;
-float * covariances ;
-float * priors ;
-float * posteriors ;
-float * enc;
-
-// create a GMM object and cluster input data to get means, covariances
-// and priors of the estimated mixture
-gmm = vl_gmm_new (VL_TYPE_FLOAT) ;
-vl_gmm_cluster (gmm, data, dimension, numData, numClusters);
-
-// allocate space for the encoding
-enc = vl_malloc(sizeof(float) * 2 * dimension * numClusters);
-
-// run fisher encoding
-vl_fisher_encode
-    (enc, VL_F_TYPE,
-     vl_gmm_get_means(gmm), dimension, numClusters,
-     vl_gmm_get_covariances(gmm),
-     vl_gmm_get_priors(gmm),
-     dataToEncode, numDataToEncode,
-     VL_FISHER_FLAG_IMPROVED
-     ) ;
-@endcode
-
-The performance of the standard Fisher Vector can be significantly
-improved @cite{perronnin10improving} by using appropriate @ref
-fisher-normalization normalizations. These are controlled by the @c
-flag parameter of ::vl_fisher_encode.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page fisher-fundamentals Fisher vector fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page describes the *Fisher Vector* (FV) of
-@cite{perronnin06fisher} @cite{perronnin10improving}. See @ref fisher
-for an overview of the C API and @ref fisher-kernel for its relation
-to the more general notion of Fisher kernel.
-
-The FV is an image representation obtained by pooling local image
-features. It is frequently used as a global image descriptor in visual
-classification.
-
-While the FV can be @ref fisher-kernel "derived" as a special,
-approximate, and improved case of the general Fisher Kernel framework,
-it is easy to describe directly. Let $I = (\bx_1,\dots,\bx_N)$ be a
-set of $D$ dimensional feature vectors (e.g. SIFT descriptors)
-extracted from an image. Let
-$\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$ be the parameters of a
-@ref gmm "Gaussian Mixture Model" fitting the distribution of
-descriptors. The GMM associates each vector $\bx_i$ to a mode $k$ in
-the mixture with a strength given by the posterior probability:
-
-\[
-  q_{ik} =
-  \frac
-  {\exp\left[-\frac{1}{2}(\bx_i - \mu_k)^T \Sigma_k^{-1} (\bx_i - \mu_k)\right]}
-  {\sum_{t=1}^K \exp\left[-\frac{1}{2}(\bx_i - \mu_t)^T \Sigma_k^{-1} (\bx_i - \mu_t)\right]}.
-\]
-
-For each mode $k$, consider the mean and covariance deviation vectors
-
-@f{align*}
-u_{jk} &=
-{1 \over {N \sqrt{\pi_k}}}
-\sum_{i=1}^{N}
-q_{ik} \frac{x_{ji} - \mu_{jk}}{\sigma_{jk}},
-\\
-v_{jk} &=
-{1 \over {N \sqrt{2 \pi_k}}}
-\sum_{i=1}^{N}
-q_{ik} \left[ \left(\frac{x_{ji} - \mu_{jk}}{\sigma_{jk}}\right)^2 - 1 \right].
-@f}
-
-where $j=1,2,\dots,D$ spans the vector dimensions. The FV of image $I$
-is the stacking of the vectors $\bu_k$ and then of the vectors
-$\bv_k$ for each of the $K$ modes in the Gaussian mixtures:
-
-\[
- \Phi(I) = \begin{bmatrix} \vdots \\ \bu_k \\ \vdots \\ \bv_k \\ \vdots \end{bmatrix}.
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section fisher-normalization Normalization and improved Fisher vectors
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The *improved* Fisher Vector @cite{perronnin10improving} (IFV) improves the
-classification performance of the representation by using to ideas:
-
-1. *Non-linear additive kernel.* The Hellinger's kernel (or
-   Bhattacharya coefficient) can be used instead of the linear one at
-   no cost by signed squared rooting. This is obtained by applying the
-   function $|z| \sign z$ to each dimension of the vector $\Phi(I)$.
-   Other @ref homkermap "additive kernels" can also be used at an
-   increased space or time cost.
-2. *Normalization.* Before using the representation in a linear model
-   (e.g. a @ref svm "support vector machine"), the vector $\Phi(I)$ is
-   further normalized by the $l^2$ norm (note that the standard Fisher
-   vector is normalized by the number of encoded feature vectors).
-
-After square-rooting and normalization, the IFV is often used in a
-linear classifier such as an @ref svm "SVM".
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section fisher-fast Faster computations
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In practice, several data to cluster assignments $q_{ik}$ are likely
-to be very small or even negligible. The *fast* version of the FV sets
-to zero all but the largest assignment for each input feature $\bx_i$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page fisher-derivation Fisher vector derivation
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The FV of @cite{perronnin06fisher} is a special case of the @ref
-fisher-kernel "Fisher kernel" construction. It is designed to encode
-local image features in a format that is suitable for learning and
-comparison with simple metrics such as the Euclidean. In this
-construction, an image is modeled as a collection of $D$-dimensional
-feature vectors $I=(\bx_1,\dots,\bx_n)$ generated by a GMM with $K$
-components $\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$. The covariance
-matrices are assumed to be diagonal, i.e. $\Sigma_k = \diag
-\bsigma_k^2$, $\bsigma_k \in \real^D_+$.
-
-The generative model of *one* feature vector $\bx$ is given by the GMM
-density function:
-
-\[
- p(\bx|\Theta) =
-\sum_{k=1}^K \pi_k p(\bx|\Theta_k),
-\quad
-p(\bx|\Theta_k)
-=
-\frac{1}{(2\pi)^\frac{D}{2} (\det \Sigma_k)^{\frac{1}{2}}}
-\exp
-\left[
--\frac{1}{2}
-(\bx - \mu_k)^\top \Sigma_k^{-1} (\bx - \mu_k)
-\right]
-\]
-
-where $\Theta_k = (\mu_k,\Sigma_k)$. The Fisher Vector requires
-computing the derivative of the log-likelihood function with respect
-to the various model parameters. Consider in particular the parameters
-$\Theta_k$ of a mode. Due to the exponent in the Gaussian density
-function, the derivative can be written as
-
-\[
-\nabla_{\Theta_k} p(\bx|\Theta_k) =
-p(\bx|\Theta_k)
-g(\bx|\Theta_k)
-\]
-
-for a simple vector function $g$. The derivative of the log-likelihood
-function is then
-
-\[
-\nabla_{\Theta_k} \log p(\bx|\Theta)
-=
-\frac{\pi_k p(\bx|\Theta_k)}{\sum_{t=1}^K \pi_k p(\bx|\Theta_k)}
-g(\bx|\Theta_k)
-=
-q_k(\bx) g(\bx|\Theta_k)
-\]
-
-where $q_k(\bx)$ is the soft-assignment of the point $\bx$ to the mode
-$k$. We make the approximation that $q_k(\bx)\approx 1$ if $\bx$ is
-sampled from mode $k$ and $\approx 0$ otherwise
-@cite{perronnin06fisher}. Hence one gets:
-
-\[
-E_{\bx \sim p(\bx|\Theta)}
-[
-\nabla_{\Theta_k} \log p(\bx|\Theta)
-\nabla_{\Theta_t} \log p(\bx|\Theta)^\top
-]
-\approx
-\begin{cases}
-\pi_k E_{\bx \sim p(\bx|\Theta_k)} [ g(\bx|\Theta_k) g(\bx|\Theta_k)^\top], & t = k, \\
-0, & t\not=k.
-\end{cases}
-\]
-
-Thus under this approximation there is no correlation between the
-parameters of the various Gaussian modes.
-
-The function $g$ can be further broken down as the stacking of the
-derivative w.r.t. the mean and the diagonal covariance.
-
-\[
-g(\bx|\Theta_k)
-=
-\begin{bmatrix}
-g(\bx|\mu_k) \\
-g(\bx|\bsigma_k)
-\end{bmatrix},
-\quad
-[g(\bx|\mu_k)]_j
-=
-\frac{x_j - \mu_{jk}}{\sigma_{jk}^2},
-\quad
-[g(\bx|\bsigma_k^2)]_j
-=
-\frac{1}{2\sigma_{jk}^2}
-\left(
-\left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2
--
-1
-\right)
-\]
-
-Thus the covariance of the model (Fisher information) is diagonal and
-the diagonal entries are given by
-
-\[
- H_{\mu_{jk}} = \pi_k E[g(\bx|\mu_{jk})g(\bx|\mu_{jk})]
- = \frac{\pi_k}{\sigma_{jk}^2},
- \quad
- H_{\sigma_{jk}^2} = \frac{\pi_k}{2 \sigma_{jk}^4}.
-\]
-
-where in the calculation it was used the fact that the fourth moment
-of the standard Gaussian distribution is 3. Multiplying the inverse
-square root of the matrix $H$ by the derivative of the log-likelihood
-function results in the Fisher vector encoding of one image feature
-$\bx$:
-
-\[
- \Phi_{\mu_{jk}}(\bx) = H_{\mu_{jk}}^{-\frac{1}{2}} q_k(\bx) g(\bx|\mu_{jk})
-= q_k(\bx) \frac{x_j - \mu_{jk}}{\sqrt{\pi_k}\sigma_{jk}},
-\qquad
- \Phi_{\sigma^2_{jk}}(\bx) =
-\frac{q_k(\bx)}{\sqrt{2 \pi_k}}
-\left(
-\left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2
--
-1
-\right)
-\]
-
-Assuming that features are sampled i.i.d. from the GMM results in the
-formulas given in @ref fisher-fundamentals (note the normalization
-factor). Note that:
-
-* The Fisher components relative to the prior probabilities $\pi_k$
-  have been ignored. This is because they have little effect on the
-  representation @cite{perronnin10improving}.
-
-* Technically, the derivation of the Fisher Vector for multiple image
-  features requires the number of features to be the same in both
-  images. Ultimately, however, the representation can be computed by
-  using any number of features.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page fisher-kernel Fisher kernel
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page discusses the Fisher Kernels (FK) of
-@cite{jaakkola98exploiting} and shows how the FV of
-@cite{perronnin06fisher} can be derived from it as a special case. The
-FK induces a similarity measures between data points $\bx$ and $\bx'$
-from a parametric generative model $p(\bx|\Theta)$ of the data. The
-parameter $\Theta$ of the model is selected to fit the a-priori
-distribution of the data, and is usually the Maximum Likelihood (MLE)
-estimate obtained from a set of training examples. Once the generative
-model is learned, each particular datum $\bx$ is represented by
-looking at how it affects the MLE parameter estimate. This effect is
-measured by computing the gradient of the log-likelihood term
-corresponding to $\bx$:
-
-\[
-  \hat\Phi(\bx) = \nabla_\Theta \log p(\bx|\Theta)
-\]
-
-The vectors $\hat\Phi(\bx)$ should be appropriately scaled before they
-can be meaningfully compared. This is obtained by *whitening* the data
-by multiplying the vectors by the inverse of the square root of their
-*covariance matrix*. The covariance matrix can be obtained from the
-generative model $p(\bx|\Theta)$ itself. Since $\Theta$ is the ML
-parameter and $\hat\Phi(\bx)$ is the gradient of the log-likelihood
-function, its expected value $E[\hat\Phi(\bx)]$ is zero. Thus, since
-the vectors are already centered, their covariance matrix is simply:
-
-\[
-H = E_{\bx \sim p(\bx|\Theta)} [\hat\Phi(\bx) \hat\Phi(\bx)^\top]
-\]
-
-Note that $H$ is also the *Fisher information matrix* of the
-model. The final FV encoding $\Phi(\bx)$ is given by the whitened
-gradient of the log-likelihood function, i.e.:
-
-\[
- \Phi(\bx) = H^{-\frac{1}{2}}  \nabla_\Theta \log p(\bx|\Theta).
-\]
-
-Taking the inner product of two such vectors yields the *Fisher
-kernel*:
-
-\[
- K(\bx,\bx')
-= \langle \Phi(\bx),\Phi(\bx') \rangle
-= \nabla_\Theta \log p(\bx|\Theta)^\top H^{-1} \nabla_\Theta \log p(\bx'|\Theta).
-\]
-
-**/
-
-#include "fisher.h"
-#include "gmm.h"
-#include "mathop.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef VL_FISHER_INSTANTIATING
-
-static vl_size
-VL_XCAT(_vl_fisher_encode_, SFX)
-(TYPE * enc,
- TYPE const * means, vl_size dimension, vl_size numClusters,
- TYPE const * covariances,
- TYPE const * priors,
- TYPE const * data, vl_size numData,
- int flags)
-{
-  vl_size dim;
-  vl_index i_cl, i_d;
-  vl_size numTerms = 0 ;
-  TYPE * posteriors ;
-  TYPE * sqrtInvSigma;
-
-  assert(numClusters >= 1) ;
-  assert(dimension >= 1) ;
-
-  posteriors = vl_malloc(sizeof(TYPE) * numClusters * numData);
-  sqrtInvSigma = vl_malloc(sizeof(TYPE) * dimension * numClusters);
-
-  memset(enc, 0, sizeof(TYPE) * 2 * dimension * numClusters) ;
-
-  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-    for(dim = 0; dim < dimension; dim++) {
-      sqrtInvSigma[i_cl*dimension + dim] = sqrt(1.0 / covariances[i_cl*dimension + dim]);
-    }
-  }
-
-  VL_XCAT(vl_get_gmm_data_posteriors_, SFX)(posteriors, numClusters, numData,
-                                            priors,
-                                            means, dimension,
-                                            covariances,
-                                            data) ;
-
-  /* sparsify posterior assignments with the FAST option */
-  if (flags & VL_FISHER_FLAG_FAST) {
-    for(i_d = 0; i_d < (signed)numData; i_d++) {
-      /* find largest posterior assignment for datum i_d */
-      vl_index best = 0 ;
-      TYPE bestValue = posteriors[i_d * numClusters] ;
-      for (i_cl = 1 ; i_cl < (signed)numClusters; ++ i_cl) {
-        TYPE p = posteriors[i_cl + i_d * numClusters] ;
-        if (p > bestValue) {
-          bestValue = p ;
-          best = i_cl ;
-        }
-      }
-      /* make all posterior assignments zero but the best one */
-      for (i_cl = 0 ; i_cl < (signed)numClusters; ++ i_cl) {
-        posteriors[i_cl + i_d * numClusters] =
-        (TYPE)(i_cl == best) ;
-      }
-    }
-  }
-
-#if defined(_OPENMP)
-#pragma omp parallel for default(shared) private(i_cl, i_d, dim) num_threads(vl_get_max_threads()) reduction(+:numTerms)
-#endif
-  for(i_cl = 0; i_cl < (signed)numClusters; ++ i_cl) {
-    TYPE uprefix;
-    TYPE vprefix;
-
-    TYPE * uk = enc + i_cl*dimension ;
-    TYPE * vk = enc + i_cl*dimension + numClusters * dimension ;
-
-    /*
-    If the GMM component is degenerate and has a null prior, then it
-    must have null posterior as well. Hence it is safe to skip it.  In
-    practice, we skip over it even if the prior is very small; if by
-    any chance a feature is assigned to such a mode, then its weight
-    would be very high due to the division by priors[i_cl] below.
-    */
-    if (priors[i_cl] < 1e-6) { continue ; }
-
-    for(i_d = 0; i_d < (signed)numData; i_d++) {
-      TYPE p = posteriors[i_cl + i_d * numClusters] ;
-      if (p < 1e-6) continue ;
-      numTerms += 1;
-      for(dim = 0; dim < dimension; dim++) {
-        TYPE diff = data[i_d*dimension + dim] - means[i_cl*dimension + dim] ;
-        diff *= sqrtInvSigma[i_cl*dimension + dim] ;
-        *(uk + dim) += p * diff ;
-        *(vk + dim) += p * (diff * diff - 1);
-      }
-    }
-
-    if (numData > 0) {
-      uprefix = 1/(numData*sqrt(priors[i_cl]));
-      vprefix = 1/(numData*sqrt(2*priors[i_cl]));
-      for(dim = 0; dim < dimension; dim++) {
-        *(uk + dim) = *(uk + dim) * uprefix;
-        *(vk + dim) = *(vk + dim) * vprefix;
-      }
-    }
-  }
-
-  vl_free(posteriors);
-  vl_free(sqrtInvSigma) ;
-
-  if (flags & VL_FISHER_FLAG_SQUARE_ROOT) {
-    for(dim = 0; dim < 2 * dimension * numClusters ; dim++) {
-      TYPE z = enc [dim] ;
-      if (z >= 0) {
-        enc[dim] = VL_XCAT(vl_sqrt_, SFX)(z) ;
-      } else {
-        enc[dim] = - VL_XCAT(vl_sqrt_, SFX)(- z) ;
-      }
-    }
-  }
-
-  if (flags & VL_FISHER_FLAG_NORMALIZED) {
-    TYPE n = 0 ;
-    for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) {
-      TYPE z = enc [dim] ;
-      n += z * z ;
-    }
-    n = VL_XCAT(vl_sqrt_, SFX)(n) ;
-    n = VL_MAX(n, 1e-12) ;
-    for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) {
-      enc[dim] /= n ;
-    }
-  }
-
-  return numTerms ;
-}
-
-#else
-/* not VL_FISHER_INSTANTIATING */
-
-#ifndef __DOXYGEN__
-#define FLT VL_TYPE_FLOAT
-#define TYPE float
-#define SFX f
-#define VL_FISHER_INSTANTIATING
-#include "fisher.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define TYPE double
-#define SFX d
-#define VL_FISHER_INSTANTIATING
-#include "fisher.c"
-#endif
-
-/* not VL_FISHER_INSTANTIATING */
-#endif
-
-/* ================================================================ */
-#ifndef VL_FISHER_INSTANTIATING
-
-/** @brief Fisher vector encoding of a set of vectors.
- ** @param dataType the type of the input data (::VL_TYPE_DOUBLE or ::VL_TYPE_FLOAT).
- ** @param enc Fisher vector (output).
- ** @param means Gaussian mixture means.
- ** @param dimension dimension of the data.
- ** @param numClusters number of Gaussians mixture components.
- ** @param covariances Gaussian mixture diagonal covariances.
- ** @param priors Gaussian mixture prior probabilities.
- ** @param data vectors to encode.
- ** @param numData number of vectors to encode.
- ** @param flags options.
- ** @return number of averaging operations.
- **
- ** @a means and @a covariances have @a dimension rows and @a
- ** numCluster columns.  @a priors is a vector of size @a
- ** numCluster. @a data has @a dimension rows and @a numData
- ** columns. @a enc is a vecotr of size equal to twice the product of
- ** @a dimension and @a numClusters. All these vectors and matrices
- ** have the same class, as specified by @a dataType, and must be
- ** stored in column-major format.
- **
- ** @a flag can be used to control several options:
- ** ::VL_FISHER_FLAG_SQUARE_ROOT, ::VL_FISHER_FLAG_NORMALIZED,
- ** ::VL_FISHER_FLAG_IMPROVED, and ::VL_FISHER_FLAG_FAST.
- **
- ** The function returns the number of averaging operations actually
- ** performed. The upper bound is the number of input features by the
- ** number of GMM modes; however, assignments are usually failry
- ** sparse, so this number is often much smaller. In particular, with
- ** the ::VL_FISHER_FLAG_FAST, is equal to the number of input
- ** features. This information can be used for diagnostic purposes.
- **
- ** @sa @ref fisher
- **/
-
-VL_EXPORT vl_size
-vl_fisher_encode
-(void * enc, vl_type dataType,
- void const * means, vl_size dimension, vl_size numClusters,
- void const * covariances,
- void const * priors,
- void const * data,  vl_size numData,
- int flags
-)
-{
-  switch(dataType) {
-    case VL_TYPE_FLOAT:
-      return _vl_fisher_encode_f
-      ((float *) enc,
-       (float const *) means, dimension, numClusters,
-       (float const *) covariances,
-       (float const *) priors,
-       (float const *) data, numData,
-       flags);
-    case VL_TYPE_DOUBLE:
-      return _vl_fisher_encode_d
-      ((double *) enc,
-       (double const *) means, dimension, numClusters,
-       (double const *) covariances,
-       (double const *) priors,
-       (double const *) data, numData,
-       flags);
-      break;
-    default:
-      abort();
-  }
-}
-/* not VL_FISHER_INSTANTIATING */
-#endif
-
-#undef SFX
-#undef TYPE
-#undef FLT
-#undef VL_FISHER_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/fisher.h b/opensfm/src/third_party/vlfeat/vl/fisher.h
deleted file mode 100644
index 907e66a48..000000000
--- a/opensfm/src/third_party/vlfeat/vl/fisher.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/** @file fisher.h
- ** @brief Fisher encoding (@ref fisher)
- ** @author David Novotny
- ** @author Andrea Vedaldi
- ** @see @ref fisher
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_FISHER_H
-#define VL_FISHER_H
-
-#include "generic.h"
-
-/** @name Fisher vector options
- ** @{ */
-#define VL_FISHER_FLAG_SQUARE_ROOT          (0x1 << 0)
-#define VL_FISHER_FLAG_NORMALIZED           (0x1 << 1)
-#define VL_FISHER_FLAG_IMPROVED             (VL_FISHER_FLAG_NORMALIZED|VL_FISHER_FLAG_SQUARE_ROOT)
-#define VL_FISHER_FLAG_FAST                 (0x1 << 2)
-
-/** @def VL_FISHER_FLAG_SQUARE_ROOT
- ** @brief Use signed squared-root (@ref fisher-normalization).
- **/
-
-/** @def VL_FISHER_FLAG_NORMALIZED
- ** @brief Gobally normalize the Fisher vector in L2 norm (@ref fisher-normalization).
- **/
-
-/** @def VL_FISHER_FLAG_IMPROVED
- ** @brief Improved Fisher vector.
- ** This is the same as @c VL_FISHER_FLAG_SQUARE_ROOT|VL_FISHER_FLAG_NORMALIZED.
- **/
-
-/** @def VL_FISHER_FLAG_FAST
- ** @brief Fast but more approximate calculations (@ref fisher-fast).
- ** Keep only the larges data to cluster assignment (posterior).
- **/
-
-/** @} */
-
-VL_EXPORT vl_size vl_fisher_encode
-(void * enc, vl_type dataType,
- void const * means, vl_size dimension, vl_size numClusters,
- void const * covariances,
- void const * priors,
- void const * data, vl_size numData,
- int flags) ;
-
-/* VL_FISHER_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/float.h b/opensfm/src/third_party/vlfeat/vl/float.h
deleted file mode 100644
index 267ca98f8..000000000
--- a/opensfm/src/third_party/vlfeat/vl/float.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/** @file float.h
- ** @brief Float - Template
- ** @author Andrea Vedaldi
- ** @author David Novotny
- **/
-
-/*
-Copyright (C) 2014 Andrea Vedaldi.
-Copyright (C) 2013 David Novotny.
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#include "generic.h"
-
-#undef  T
-#undef  SFX
-#undef  VSIZE
-#undef  VSFX
-#undef  VTYPE
-#undef  VSIZEavx
-#undef  VSFXavx
-#undef  VTYPEavx
-
-#if (FLT == VL_TYPE_FLOAT)
-#  define T float
-#  define SFX f
-#elif (FLT == VL_TYPE_DOUBLE)
-#  define T double
-#  define SFX d
-#elif (FLT == VL_TYPE_UINT32)
-#  define T vl_uint32
-#  define SFX ui32
-#elif (FLT == VL_TYPE_INT32)
-#  define T vl_int32
-#  define SFX i32
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                                              AVX */
-/* ---------------------------------------------------------------- */
-
-#ifdef __AVX__
-
-#if (FLT == VL_TYPE_FLOAT)
-#  define VSIZEavx  8
-#  define VSFXavx   s
-#  define VTYPEavx  __m256
-#elif (FLT == VL_TYPE_DOUBLE)
-#  define VSIZEavx  4
-#  define VSFXavx   d
-#  define VTYPEavx  __m256d
-#endif
-
-#define VALIGNEDavx(x) (! (((vl_uintptr)(x)) & 0x1F))
-
-#define VMULavx  VL_XCAT(_mm256_mul_p,     VSFX)
-#define VDIVavx  VL_XCAT(_mm256_div_p,     VSFX)
-#define VADDavx  VL_XCAT(_mm256_add_p,     VSFX)
-#define VHADDavx  VL_XCAT(_mm_hadd_p,     VSFX)
-#define VHADD2avx  VL_XCAT(_mm256_hadd_p,     VSFX)
-#define VSUBavx  VL_XCAT(_mm256_sub_p,     VSFX)
-#define VSTZavx  VL_XCAT(_mm256_setzero_p, VSFX)
-#define VLD1avx  VL_XCAT(_mm256_broadcast_s,   VSFX)
-#define VLDUavx  VL_XCAT(_mm256_loadu_p,   VSFX)
-#define VST1avx  VL_XCAT(_mm256_store_s,   VSFX)
-#define VST2avx  VL_XCAT(_mm256_store_p,   VSFX)
-#define VST2Uavx VL_XCAT(_mm256_storeu_p,  VSFX)
-#define VPERMavx VL_XCAT(_mm256_permute2f128_p,  VSFX)
-//#define VCSTavx VL_XCAT( _mm256_castps256_ps128,  VSFX)
-#define VCSTavx  VL_XCAT5(_mm256_castp,VSFX,256_p,VSFX,128)
-
-/* __AVX__ */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                                             SSE2 */
-/* ---------------------------------------------------------------- */
-
-#ifdef __SSE2__
-
-#if (FLT == VL_TYPE_FLOAT)
-#  define VSIZE  4
-#  define VSFX   s
-#  define VTYPE  __m128
-#elif (FLT == VL_TYPE_DOUBLE)
-#  define VSIZE  2
-#  define VSFX   d
-#  define VTYPE  __m128d
-#endif
-
-#define VALIGNED(x) (! (((vl_uintptr)(x)) & 0xF))
-
-#define VMAX  VL_XCAT(_mm_max_p,     VSFX)
-#define VMUL  VL_XCAT(_mm_mul_p,     VSFX)
-#define VDIV  VL_XCAT(_mm_div_p,     VSFX)
-#define VADD  VL_XCAT(_mm_add_p,     VSFX)
-#define VSUB  VL_XCAT(_mm_sub_p,     VSFX)
-#define VSTZ  VL_XCAT(_mm_setzero_p, VSFX)
-#define VLD1  VL_XCAT(_mm_load1_p,   VSFX)
-#define VLDU  VL_XCAT(_mm_loadu_p,   VSFX)
-#define VST1  VL_XCAT(_mm_store_s,   VSFX)
-#define VSET1 VL_XCAT(_mm_set_s,     VSFX)
-#define VSHU  VL_XCAT(_mm_shuffle_p, VSFX)
-#define VNEQ  VL_XCAT(_mm_cmpneq_p,  VSFX)
-#define VAND  VL_XCAT(_mm_and_p,     VSFX)
-#define VANDN VL_XCAT(_mm_andnot_p,  VSFX)
-#define VST2  VL_XCAT(_mm_store_p,   VSFX)
-#define VST2U VL_XCAT(_mm_storeu_p,  VSFX)
-
-/* __SSE2__ */
-#endif
-
diff --git a/opensfm/src/third_party/vlfeat/vl/generic.c b/opensfm/src/third_party/vlfeat/vl/generic.c
deleted file mode 100644
index d4982e43b..000000000
--- a/opensfm/src/third_party/vlfeat/vl/generic.c
+++ /dev/null
@@ -1,1679 +0,0 @@
-/** @file generic.c
- ** @brief Generic - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@mainpage Vision Lab Features Library (VLFeat)
-@version __VLFEAT_VERSION__
-@author The VLFeat Team
-@par Copyright &copy; 2012-14 The VLFeat Authors
-@par Copyright &copy; 2007-11 Andrea Vedaldi and Brian Fulkerson
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The VLFeat C library implements common computer
-vision algorithms, with a special focus on visual features, as used
-in state-of-the-art object recognition and image
-matching applications.
-
-VLFeat strives to be clutter-free, simple, portable, and well documented.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section main-contents Contents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-- **Visual feature detectors and descriptors**
-  - @subpage sift
-  - @subpage dsift
-  - @subpage mser
-  - @subpage covdet
-  - @subpage scalespace
-  - @subpage hog
-  - @subpage fisher
-  - @subpage vlad
-  - @subpage liop
-  - @subpage lbp
-
-- **Clustering and indexing**
-  - @subpage kmeans
-  - @subpage ikmeans.h  "Integer K-means (IKM)"
-  - @subpage hikmeans.h "Hierarchical Integer K-means (HIKM)"
-  - @subpage gmm
-  - @subpage aib
-  - @subpage kdtree
-
-- **Segmentation**
-  - @subpage slic
-  - @subpage quickshift
-
-- **Statistical methods**
-  - @subpage aib
-  - @subpage homkermap
-  - @subpage svm
-
-- **Utilities**
-  - @subpage random
-  - @subpage mathop
-  - @subpage stringop.h  "String operations"
-  - @subpage imopv.h     "Image operations"
-  - @subpage pgm.h       "PGM image format"
-  - @subpage heap-def.h  "Generic heap object (priority queue)"
-  - @subpage rodrigues.h "Rodrigues formula"
-  - @subpage mexutils.h  "MATLAB MEX helper functions"
-  - @subpage getopt_long.h "Drop-in @c getopt_long replacement"
-
-- **General information**
-  - @subpage conventions
-  - @subpage generic
-  - @subpage portability
-  - @ref resources
-  - @subpage objects
-  - @ref threads
-  - @subpage matlab
-  - @subpage metaprogram
-
-- @subpage dev
-- @subpage glossary
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page resources Memory and resource handling
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Some VLFeat functions return pointers to memory blocks or
-objects. Only ::vl_malloc, ::vl_calloc, ::vl_realloc and functions
-whose name contains either the keywords @c new or @c copy transfer the
-ownership of the memory block or object to the caller. The caller must
-dispose explicitly of all the resources it owns (by calling ::vl_free
-for a memory block, or the appropriate deletion function for an
-object).
-
-The memory allocation functions can be customized by
-::vl_set_alloc_func (which sets the implementations of ::vl_malloc,
-::vl_realloc, ::vl_calloc and ::vl_free). Remapping the memory
-allocation functions can be done only if there are no currently
-allocated VLFeat memory blocks or objects -- thus typically at the
-very beginning of a program. The memory allocation functions are a
-global property, shared by all threads.
-
-VLFeat uses three rules that simplify handling exceptions when used in
-combination which certain environment such as MATLAB.
-
-- The library allocates local memory only through the re-programmable
-  ::vl_malloc, ::vl_calloc, and ::vl_realloc functions.
-
-- The only resource referenced by VLFeat objects is memory (for
-  instance, it is illegal for an object to reference an open file).
-  Other resources such as files or threads may be allocated within a
-  VLFeat function call, but they are all released before the function
-  ends, or their ownership is directly transferred to the caller.
-
-- The global library state is an exception. It cannot reference any
-  local object created by the caller and uses the standard C memory
-  allocation functions.
-
-In this way, the VLFeat local state can be reset at any time simply by
-disposing of all the memory allocated by the library so far. The
-latter can be done easily by mapping the memory allocation functions
-to implementations that track the memory blocks allocated, and then
-disposing of all such blocks. Since the global state does not
-reference any local object nor uses the remapped memory functions, it
-is unaffected by such an operation; conversely, since no VLFeat object
-references anything but memory, this guarantees that all allocated
-resources are properly disposed (avoiding leaking resource). This is
-used extensively in the design of MATLAB MEX files (see @ref
-matlab).
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page conventions Conventions
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page summarizes some of the conventions used by the library.
-
-@section conventions-storage Matrix and image storage conventions
-
-If not otherwise specified, matrices in VLFeat are stored in memory in
-<em>column major</em> order. Given a matrix $[A_{ij}] \in \real^{m
-\times n}$, this amounts of enumerating the elements one column per
-time: $A_{11}, A_{21}, \dots, A_{m1}, A_{12}, \dots, A_{mn}$. This
-convention is compatible with Fortran, MATLAB, and popular numerical
-libraries.
-
-Matrices are often used in the library to pack a number data vectors
-$\bx_1,\dots,\bx_n \in \real^m$ of equal dimension together. These are
-normally stored as the columns of the matrix:
-
-\[
-X = \begin{bmatrix} \bx_1, \dots, \bx_n \end{bmatrix},
-\qquad
-X \in \real_{m\times n}
-\]
-
-In this manner, consecutive elements of each data vector $\bx_i$ is
-stored in consecutive memory locations, improving memory access
-locality in most algorithms.
-
-Images $I(x,y)$ are stored instead in <em>row-major</em> order,
-i.e. one row after the other. Note that an image can be naturally
-identified as a matrix $I_{yx}$, where the vertical coordinate $y$
-indexes the rows and the horizontal coordinate $x$ the columns. The
-image convention amounts to storing this matrix in row-major rather
-than column-major order, which is in conflict with the rule given
-above. The reason for this choice is that most image processing and
-graphical libraries assume this convention; it is, however,
-<em>not</em> the same as MATLAB's.
-
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page objects Objects
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Many VLFeat algorithms are available in the form of *objects*. The C
-language, used by VLFeat, does not support objects explicitly. Here an
-object is intended a C structure along with a number of functions (the
-object member functions or methods) operating on it. Ideally, the
-object data structure is kept opaque to the user, for example by
-defining it in the @c .c implementation files which are not accessible
-to the library user.
-
-Object names are capitalized and start with the <code>Vl</code> prefix
-(for example @c VlExampleObject). Object methods are lowercase and
-start with the <code>vl_<object_name>_</code> suffix
-(e.g. @c vl_example_object_new).
-
-<!-- ------------------------------------------------------------  -->
-@section objects-lifecycle Object lifecycle
-<!-- ------------------------------------------------------------  -->
-
-Conceptually, an object undergoes four phases during its lifecycle:
-allocation, initialization, finalization, and deallocation:
-
-- **Allocation.** The memory to hold the object structure is allocated.
-  This is usually done by calling a memory allocation function such as
-  ::vl_calloc to reserve an object of the required size @c
-  sizeof(VlExampleObject). Alternatively, the object can simply by
-  allocated on the stack by declaring a local variable of type
-  VlExampleObject.
-- **Initialization.** The object is initialized by assigning a value to
-  its data members and potentially allocating a number of resources,
-  including other objects or memory buffers. Initialization is
-  done by methods containing the @c init keyword, e.g.  @c
-  vl_example_object_init. Several such methods may be provided.
-- **Finalization.** Initialization is undone by finalization, whose main
-  purpose is to release any resource allocated and still owned by the
-  object. Finalization is done by the @c vl_example_object_finalize
-  method.
-- **Deallocation.** The memory holding the object structure is
-  disposed of, for example by calling ::vl_free or automatically when
-  the corresponding local variable is popped from the stack.
-
-In practice, most VlFeat object are supposed to be created on the
-heap. To this end, allocation/initialization and
-finalization/deallocation are combined into two operations:
-
-- **Creating a new object.** This allocates a new object on the heap
-  and initializes it, combining allocation and initialization in a
-  single operation. It is done by methods containing the @c new keyword,
-  e.g. @c vl_example_object_new.
-- **Deleting an object.** This disposes of an object created by a @c
-  new method, combining finalization and deallocation, for example
-  @c vl_example_object_delete.
-
-<!-- ------------------------------------------------------------  -->
-@section objects-getters-setters Getters and setters
-<!-- ------------------------------------------------------------  -->
-
-Most objects contain a number of methods to get (getters) and set
-(setters) properties. These should contain the @c get and @c set
-keywords in their name, for example
-
-@code
-double x = vl_example_object_get_property () ;
-vl_example_object_set_property(x) ;
-@endcode
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page matlab MATLAB integration
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The VLFeat C library is designed to integrate seamlessly with MATLAB.
-Binary compatibility is simplified by the use of the C language
-(rather than C++). In addition, the library design follows certain
-restrictions that make it compatible with the MATLAB MEX interface.
-
-The main issue in calling a library function from a MATLAB MEX
-function is that MATLAB can abort the execution of the MEX function
-at any point, either due to an error, or directly upon a user request
-(Ctrl-C) (empirically, however, a MEX function seems to be
-incorruptible only during the invocation of certain functions of the
-MEX API such as @c mexErrMsgTxt).
-
-When a MEX function is interrupted, resources (memory blocks or
-objects) whose ownership was transferred from VLFeat to the MEX
-function may be leaked. Notice that interrupting a MEX function would
-similarly leak any memory block allocated within the MEX function. To
-solve this issue, MATLAB provides his own memory manager (@c
-mxMalloc, @c mxRealloc, ...). When a MEX file is interrupted or ends,
-all memory blocks allocated by using one of such functions are
-released, preventing leakage.
-
-In order to integrate VLFeat with this model in the most seamless
-way, VLFeat memory allocation functions (::vl_malloc, ::vl_realloc,
-::vl_calloc) are mapped to the corresponding MEX memory allocation
-functions. Such functions automatically dispose of all the memory
-allocated by a MEX function when the function ends (even because of
-an exception). Because of the restrictions of the library design
-illustrated in @ref resources, this operation is safe and
-correctly dispose of VLFeat local state. As a consequence, it is
-possible to call @c mexErrMsgTxt at any point in the MEX function
-without worrying about leaking resources.
-
-This however comes at the price of some limitations. Beyond the
-restrictions illustrated in @ref resources, here we note that no
-VLFeat local resource (memory blocks or objects) can persist across
-MEX file invocations. This implies that any result produced by a
-VLFeat MEX function must be converted back to a MATLAB object such as
-a vector or a structure. In particular, there is no direct way of
-creating an object within a MEX file, returning it to MATLAB, and
-passing it again to another MEX file.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page metaprogram Preprocessor metaprogramming
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Part of VLFeat code uses a simple form of preprocessor metaprogramming.
-This technique is used, similarly to C++ templates, to instantiate
-multiple version of a given algorithm for different data types
-(e.g. @c float and @c double).
-
-In most cases preprocessor metaprogramming is invisible to the library
-user, as it is used only internally.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page glossary Glossary
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
- - <b>Column-major.</b> A <em>M x N </em> matrix <em>A</em> is
- stacked with column-major order as the sequence \f$(A_{11}, A_{21},
- \dots, A_{12}, \dots)\f$. More in general, when stacking a multi
- dimensional array this indicates that the first index is the one
- varying most quickly, with the other followed in the natural order.
- - <b>Opaque structure.</b> A structure is opaque if the user is not supposed
- to access its member directly, but through appropriate interface functions.
- Opaque structures are commonly used to define objects.
- - <b>Row-major.</b> A <em>M x N </em> matrix <em>A</em> is
- stacked with row-major order as the sequence \f$(A_{11}, A_{12},
- \dots, A_{21}, \dots)\f$. More in general, when stacking a multi
- dimensional array this indicates that the last index is the one
- varying most quickly, with the other followed in reverse order.
- - <b>Feature frame.</b> A <em>feature frame</em> is the geometrical
- description of a visual features. For instance, the frame of
- a @ref sift.h "SIFT feature" is oriented disk and the frame of
- @ref mser.h "MSER feature" is either a compact and connected set or
- a disk.
- - <b>Feature descriptor.</b> A <em>feature descriptor</em> is a quantity
- (usually a vector) which describes compactly the appearance of an
- image region (usually corresponding to a feature frame).
-**/
-
-/**
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page dev Developing the library
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page contains information useful to the developer of VLFeat.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section dev-copy Copyright
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A short copyright notice is added at the beginning of each file. For
-example:
-
-<pre>
-Copyright (C) 2013 Milan Sulc
-Copyright (C) 2012 Daniele Perrone.
-Copyright (C) 2011-13 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-</pre>
-
-The copyright of each file is assigned to the authors of the file.
-Every author making a substantial contribution to a file should
-note its copyright by adding a line to the copyright list with the year
-of the modification. Year ranges are acceptable. Lines are never
-deleted, only appended, or potentially modified to list
-more years.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section dev-style Coding style
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<ul>
-
-<li><b>Look at existing code before you start.</b> The general rule
-is: try to match the style of the existing code as much as
-possible.</li>
-
-<li><b>No white spaces at the end of lines.</b> White spaces introduce
-invisible changes in the code that are however picked up by control
-version systems such as Git.</li>
-
-<li><b>Descriptive variable names.</b> Most variable names start with
-a lower case letter and are capitalized, e.g., @c numElements. Only
-the following abbreviations are considered acceptable: @c num. The @c
-dimension of a vector is the number of elements it contains (for other
-objects that could be a @c size, a @c length, or a @c
-numElements). For multi-dimensional arrays, @c dimensions could
-indicate the array with each of the @c numDimensions dimensions.</li>
-
-<li><b>Short variable names.</b> For indexes in short for loops it is
-fine to use short index names such as @c i, @c j, and @c k. For example:
-<pre>
-for (i = 0 ; i < numEntries ; ++i) values[i] ++ ;
-</pre>
-is considered acceptable.</li>
-
-<li><b>Function arguments.</b> VLFeat functions that operate on an
-object (member functions) should be passed the object address as first
-argument; this argument should be called @c self. For example:
-<pre>
-   void vl_object_do_something(VlObject *self) ;
-</pre>
-Multi-dimensional arrays should be specified first by their address,
-and then by their dimensions. For example
-<pre>
-  void vl_use_array (float * array, vl_size numColumns, vl_size numRows) ; // good
-  void vl_use_array (vl_size numColumns, vl_size numRows, float * array) ; // bad
-</pre>
-Arguments that are used as outputs should be specified first (closer to
-the left-hand side of an expression). For example
-<pre>
- void vl_sum_numbers (float * output, float input1, float input2) ; // good
- void vl_sum_numbers (float input1, float input2, float * output) ; // bad
-</pre>
-These rules can be combined. For example
-<pre>
- void vl_object_sum_to_array (VlObject * self, float * outArray,
-        vl_size numColumns, vl_size numRows, float * inArray) ; // good
-</pre>
-Note that in this case no dimension for @c inArray is specified as it
-is assumed that @c numColumns and @c numRows are the dimensions of
-both arrays.
-</li>
-</ul>
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection dev-style-matlab MATLAB coding style
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<ul>
-<li><b>Help messages.</b> Each @c .m file should include a standard
-help comment block (accessible from MATLAB @c help() command).
-The first line of the block has a space, the name of the function,
-4 spaces, and a brief command description. The body of the help
-message is indented with 4 spaces. For example
-@code
-% VL_FUNCTION    An example function
-%    VL_FUNCTION() does nothing.
-@endcode
-The content HELP message itself should follow MATLAB default style.
-For example, rather than giving a list of formal input and output
-arguments as often done, one simply shows how to use the function, explaining
-along the way the different ways the function can be called and
-the format of the parameters.
-</li>
-</ul>
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section dev-doc Documenting the code
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The VLFeat C library code contains its own in documentation <a
-href='http://www.stack.nl/~dimitri/doxygen/'>Doxygen</a> format. The
-documentation consists in generic pages, such as the @ref index
-"index" and the page you are reading, and documentations for each
-library module, usually corresponding to a certain header file.
-
-- **Inline comments.** Inline Doxygen comments are discouraged except
-  in the documentation of data members of structures. They start with
-  a capital letter and end with a period. For example:
-  @code
-  struct VlExampleStructure {
-    int aMember ; /\*\*< A useful data member.
-  }
-  @endcode
-
-- **Brief comments.** Brief Doxygen comments starts by a capital
-  and end with a period. The documentation of all functions start
-  with a brief comment.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection devl-doc-modules Documenting the library modules
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A library module groups a number of data types and functions that
-implement a certain functionality of VLFeat. The documentation of a
-library module is generally organized as follows:
-
-1. A page introducing the module and including a getting started
-   section (3.g. @ref svm-starting) containing a short tutorial to
-   quickly familiarize the user with the module (e.g. @ref svm).
-2. One or more pages of detailed technical background discussing the
-   algorithms implemented. These sections are used not just as part of
-   the C API, but also as documentation for other APIs such as MATLAB
-   (e.g. @ref svm-fundamentals).
-3. One or more pages with the structure and function documentation
-   (e.g. @ref svm.h).
-
-More in detail, consider a module called <em>Example Module</em>. Then one would
-typically have:
-
-<ul>
-<li>A header or declaration file @c example-module.h. Such a file has an
-heading of the type:
-
-@verbinclude example-module-doc.h
-
-This comment block contains a file directive, causing the file to be
-included in the documentation, a brief directive, specifying a short
-description of what the file is, and a list of authors. A
-(non-Doxygen) comment block with a short the copyright notice follows.
-The brief directive should include a <code>@@ref</code> directive to point
-to the main documentation page describing the module, if there is one.
-</li>
-
-<li> An implementation or definition file @c example-module.c. This file
-has an heading of the type:
-
-@verbinclude example-module-doc.c
-
-This is similar to the declaration file, except for the content of the
-brief comment.
-</li>
-</ul>
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection devl-doc-functions Documenting functions
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection devl-doc-structures Documenting structures
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection devl-doc-structures Documenting objects
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-As seen in @ref objects, VLFeat treats certain structures with
-an object-like semantics. Usually, a module defines exactly one such
-objects. In this case, the object member functions should be grouped
-(by using Doxygen grouping functionality) as
-
-- **Construct and destroy** for the @c vl_object_new, @c
-    vl_object_delete and similar member functions.
-- **Set parameters** for setter functions.
-- **Retrieve parameters and data** for getter functions.
-- **Process data** for functions processing data.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection devl-doc-bib Bibliographic references
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Since version 0.9.14, the VLFeat C library documentation makes use of
-a proper bibliographic reference in BibTeX format (see the file @c
-docsrc/vlfeat.bib). Doxygen uses this file when it sees instances of
-the <code>@@cite{xyz}</code> command.  Here @c xyz is a BibTeX
-key. For example, @c vlfeat.bib file contains the entry:
-
-<pre>
-@@inproceedings{martin97the-det-curve,
-	Author = {A. Martin and G. Doddington and T. Kamm and M. Ordowski and M. Przybocki},
-	Booktitle = {Proc. Conf. on Speech Communication and Technology},
-	Title = {The {DET} curve in assessment of detection task performance},
-	Year = {1997}}
-</pre>
-
-For example, the Doxygen directive
-<code>@@cite{martin97the-det-curve}</code> generates the output
-@cite{martin97the-det-curve}, which is a link to the corresponding
-entry in the bibliography.
-
-**/
-
-/**
-
-@file generic.h
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page generic General support functionalities
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat contains several support functionalities addressing the C
-preprocessors, using multiple threads (including parallel computations),
-handling errors, allocating memory, etc. These are described in
-the following pages:
-
-- @subpage resources
-- @subpage threads
-- @subpage misc
-**/
-
-/**
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page misc Preprocssor, library state, etc.
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-preproc C preprocessor helpers
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat provides a few C preprocessor macros of general
-utility. These include stringification (::VL_STRINGIFY,
-::VL_XSTRINGIFY) and concatenation (::VL_CAT, ::VL_XCAT) of symbols.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-state VLFeat state and configuration parameters
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat has some global configuration parameters that can
-changed. Changing the configuration is thread unsave
-(@ref threads). Use ::vl_set_simd_enabled to toggle the use of
-a SIMD unit (Intel SSE code), ::vl_set_alloc_func to change
-the memory allocation functions, and ::vl_set_printf_func
-to change the logging function.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-error Error handling
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Some VLFeat functions signal errors in a way similar to the
-standard C library. In case of error, a VLFeat function
-may return an error code directly,
-or an invalid result (for instance a negative file descriptor or a null
-pointer). Then ::vl_get_last_error and ::vl_get_last_error_message can be used
-to retrieve further details about the error (these functions should be
-used right after an error has occurred, before any other VLFeat call).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-memory Memory allocation
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat uses the ::vl_malloc, ::vl_realloc, ::vl_calloc and ::vl_free
-functions to allocate memory. Normally these functions are mapped to
-the underlying standard C library implementations. However
-::vl_set_alloc_func can be used to map them to other
-implementations.  For instance, in MATALB MEX files these functions
-are mapped to the MATLAB equivalent which has a garbage collection
-mechanism to cope with interruptions during execution.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-logging Logging
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat uses the macros ::VL_PRINT and ::VL_PRINTF to print progress
-or debug informations. These functions are normally mapped to the @c
-printf function of the underlying standard C library. However
-::vl_set_printf_func can be used to map it to a different
-implementation. For instance, in MATLAB MEX files this function is
-mapped to @c mexPrintf. Setting the function to @c NULL disables
-logging.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section misc-time Measuring time
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat provides ::vl_tic and ::vl_toc as an easy way of measuring
-elapsed time.
-
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page threads Threading
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat supports for threaded computations can be used to take advantage
-of multi-core architectures. Threading support includes:
-
-- Supporting using VLFeat functions and objects from multiple threads
-  simultaneously. This is discussed in @ref threads-multiple.
-- Using multiple cores to accelerate computations. This is
-  discussed in @ref threads-parallel.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section threads-multiple Using VLFeat from multiple threads
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat can be used from multiple threads simultaneously if proper
-rules are followed.
-
-- <b>A VLFeat object instance is accessed only from one thread at any
-  given time.</b> Functions operating on objects (member functions)
-  are conditionally thread safe: the same function may be called
-  simultaneously from multiple threads provided that it operates on
-  different, independent objects. However, modifying the same object
-  from multiple threads (using the same or different member functions)
-  is possible only from one thread at any given time, and should
-  therefore be synchronized. Certain VLFeat objects may contain
-  features specific to simplify multi-threaded operations
-  (e.g. ::VlKDForest).
-- <b>Thread-safe global functions are used.</b> These include
-  thread-specific operations such as retrieving the last error by
-  ::vl_get_last_error and obtaining the thread-specific random number
-  generator instance by ::vl_get_rand. In these cases, the functions
-  operate on thread-specific data that VLFeat creates and
-  maintains. Note in particular that each thread has an independent
-  default random number generator (as returned by
-  ::vl_get_rand). VLFeat objects that involve using random numbers
-  will typically use the random number generator of the thread
-  currently accessing the object (although an object-specific
-  generator can be often be specified instead).
-- <b>Any other global function is considered non-thread safe and is
-  accessed exclusively by one thread at a time.</b> A small number of
-  operations are non-reentrant <em>and</em> affect all threads
-  simultaneously. These are restricted to changing certain global
-  configuration parameters, such as the memory allocation functions by
-  ::vl_set_alloc_func. These operations are <em>not</em> thread safe
-  and are preferably executed before multiple threads start to operate
-  with the library.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section threads-parallel Parallel computations
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat uses OpenMP to implement parallel computations. Generally, this
-means that multiple cores are uses appropriately and transparently,
-provided that other multi-threaded parts of the application use OpenMP
-and that VLFeat and the application link to the same OpenMP library.
-If finer control is required, read on.
-
-VLFeat functions avoids affecting OpenMP global state, including the
-desired number of computational threads, in order to minimize side
-effects to the linked application (e.g. MATLAB). Instead, VLFeat
-duplicates a few OpenMP control parameters when needed (this approach
-is similar to the method used by other libraries such as Intel MKL).
-
-The maximum number of threads available to the application can be
-obtained by ::vl_get_thread_limit (for OpenMP version 3.0 and
-greater). This limit is controlled by the OpenMP library (the function
-is a wrapper around @c omp_get_thread_limit), which in turn may
-determined that based on the number of computational cores or the
-value of the @c OMP_THREAD_LIMIT variable when the program is
-launched. This value is an upper bound on the number of computation
-threads that can be used at any time.
-
-The maximum number of computational thread that VLFeat should use is
-set by ::vl_set_num_threads() and retrieved by ::vl_get_max_threads().
-This number is a target value as well as an upper bound to the number
-of threads used by VLFeat. This value is stored in the VLFeat private
-state and is not necessarily equal to the corresponding OpenMP state
-variable retrieved by calling @c omp_get_max_threads(). @c
-vl_set_num_threads(1) disables the use of multiple threads and @c
-vl_set_num_threads(0) uses the value returned by the OpenMP call @c
-omp_get_max_threads(). The latter value is controlled, for example, by
-calling @c omp_set_num_threads() in the application. Note that:
-
-- @c vl_set_num_threads(0) determines the number of treads using @c
-  omp_get_max_threads() *when it is called*. Subsequent calls to @c
-  omp_set_num_threads() will therefore *not* affect the number of
-  threads used by VLFeat.
-- @c vl_set_num_threads(vl_get_thread_limit()) causes VLFeat use all
-  the available threads, regardless on the number of threads set
-  within the application by calls to @c omp_set_num_threads().
-- OpenMP may still dynamically decide to use a smaller number of
-  threads in any specific parallel computation.
-
-@sa http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_userguide_win/GUID-C2295BC8-DD22-466B-94C9-5FAA79D4F56D.htm
- http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_userguide_win/index.htm#GUID-DEEF0363-2B34-4BAB-87FA-A75DBE842040.htm
- http://software.intel.com/sites/products/documentation/hpc/mkl/lin/MKL_UG_managing_performance/Using_Additional_Threading_Control.htm
-
-**/
-
-#include "generic.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <math.h>
-
-#if defined(VL_OS_WIN)
-#include <Windows.h>
-#else
-#include <unistd.h>
-#endif
-
-#if ! defined(VL_DISABLE_THREADS) && defined(VL_THREADS_POSIX)
-#include <pthread.h>
-#endif
-
-#if defined(_OPENMP)
-#include <omp.h>
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                         Global and thread states */
-/* ---------------------------------------------------------------- */
-
-/* Thread state */
-typedef struct _VlThreadState
-{
-  /* errors */
-  int lastError ;
-  char lastErrorMessage [VL_ERR_MSG_LEN] ;
-
-  /* random number generator */
-  VlRand rand ;
-
-  /* time */
-#if defined(VL_OS_WIN)
-  LARGE_INTEGER ticFreq ;
-  LARGE_INTEGER ticMark ;
-#else
-  clock_t ticMark ;
-#endif
-} VlThreadState ;
-
-/* Gobal state */
-typedef struct _VlState
-{
-  /* The thread state uses either a mutex (POSIX)
-    or a critical section (Win) */
-#if defined(VL_DISABLE_THREADS)
-  VlThreadState * threadState ;
-#else
-#if defined(VL_THREADS_POSIX)
-  pthread_key_t threadKey ;
-  pthread_mutex_t mutex ;
-  pthread_t mutexOwner ;
-  pthread_cond_t mutexCondition ;
-  size_t mutexCount ;
-#elif defined(VL_THREADS_WIN)
-  DWORD tlsIndex ;
-  CRITICAL_SECTION mutex ;
-#endif
-#endif /* VL_DISABLE_THREADS */
-
-  /* Configurable functions */
-  int   (*printf_func)  (char const * format, ...) ;
-  void *(*malloc_func)  (size_t) ;
-  void *(*realloc_func) (void*,size_t) ;
-  void *(*calloc_func)  (size_t, size_t) ;
-  void  (*free_func)    (void*) ;
-
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  VlX86CpuInfo cpuInfo ;
-#endif
-  vl_size numCPUs ;
-  vl_bool simdEnabled ;
-  vl_size numThreads ;
-} VlState ;
-
-/* Global state instance */
-VlState _vl_state ;
-
-/* ----------------------------------------------------------------- */
-VL_INLINE VlState * vl_get_state () ;
-VL_INLINE VlThreadState * vl_get_thread_specific_state () ;
-static void vl_lock_state (void) ;
-static void vl_unlock_state (void) ;
-static VlThreadState * vl_thread_specific_state_new (void) ;
-static void vl_thread_specific_state_delete (VlThreadState * self) ;
-
-/** @brief Get VLFeat version string
- ** @return the library version string.
- **/
-
-char const *
-vl_get_version_string ()
-{
-  return VL_VERSION_STRING ;
-}
-
-/** @brief Get VLFeat configuration string.
- ** @return a new configuration string.
- **
- ** The function returns a new string containing a human readable
- ** description of the library configuration.
- **/
-
-char *
-vl_configuration_to_string_copy ()
-{
-  char * string = 0 ;
-  int length = 0 ;
-  char * staticString = vl_static_configuration_to_string_copy() ;
-  char * cpuString =
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  _vl_x86cpu_info_to_string_copy(&vl_get_state()->cpuInfo) ;
-#else
-  "Generic CPU" ;
-#endif
-#if defined(DEBUG)
-  int const debug = 1 ;
-#else
-  int const debug = 0 ;
-#endif
-
-  while (string == 0) {
-    if (length > 0) {
-      string = vl_malloc(sizeof(char) * length) ;
-      if (string == NULL) break ;
-    }
-    length = snprintf(string, length,
-                      "VLFeat version %s\n"
-                      "    Static config: %s\n"
-                      "    %" VL_FMT_SIZE " CPU(s): %s\n"
-#if defined(_OPENMP)
-                      "    OpenMP: max threads: %d (library: %" VL_FMT_SIZE ")\n"
-#endif
-                      "    Debug: %s\n",
-                      vl_get_version_string (),
-                      staticString,
-                      vl_get_num_cpus(), cpuString,
-#if defined(_OPENMP)
-                      omp_get_max_threads(), vl_get_max_threads(),
-#endif
-                      VL_YESNO(debug)) ;
-    length += 1 ;
-  }
-
-  if (staticString) vl_free(staticString) ;
-  if (cpuString) vl_free(cpuString) ;
-  return string ;
-}
-
-/** @internal @brief A printf that does not do anything */
-static int
-do_nothing_printf (char const* format VL_UNUSED, ...)
-{
-  return 0 ;
-}
-
-/** @internal
- ** @brief Lock VLFeat state
- **
- ** The function locks VLFeat global state mutex.
- **
- ** The mutex is recursive: locking multiple times from the same thread
- ** is a valid operations, but requires an equivalent number
- ** of calls to ::vl_unlock_state.
- **
- ** @sa ::vl_unlock_state
- **/
-
-static void
-vl_lock_state (void)
-{
-#if ! defined(VL_DISABLE_THREADS)
-#if   defined(VL_THREADS_POSIX)
-  VlState * state = vl_get_state () ;
-  pthread_t thisThread = pthread_self () ;
-  pthread_mutex_lock (&state->mutex) ;
-  if (state->mutexCount >= 1 &&
-      pthread_equal (state->mutexOwner, thisThread)) {
-    state->mutexCount ++ ;
-  } else {
-    while (state->mutexCount >= 1) {
-      pthread_cond_wait (&state->mutexCondition, &state->mutex) ;
-    }
-    state->mutexOwner = thisThread ;
-    state->mutexCount = 1 ;
-  }
-  pthread_mutex_unlock (&state->mutex) ;
-#elif defined(VL_THREADS_WIN)
-  EnterCriticalSection (&vl_get_state()->mutex) ;
-#endif
-#endif
-}
-
-/** @internal
- ** @brief Unlock VLFeat state
- **
- ** The function unlocks VLFeat global state mutex.
- **
- ** @sa ::vl_lock_state
- **/
-
-static void
-vl_unlock_state (void)
-{
-#if ! defined(VL_DISABLE_THREADS)
-#if   defined(VL_THREADS_POSIX)
-  VlState * state = vl_get_state () ;
-  pthread_mutex_lock (&state->mutex) ;
-  -- state->mutexCount ;
-  if (state->mutexCount == 0) {
-    pthread_cond_signal (&state->mutexCondition) ;
-  }
-  pthread_mutex_unlock (&state->mutex) ;
-#elif defined(VL_THREADS_WIN)
-  LeaveCriticalSection (&vl_get_state()->mutex) ;
-#endif
-#endif
-}
-
-/** @internal
- ** @brief Return VLFeat global state
- **
- ** The function returns a pointer to VLFeat global state.
- **
- ** @return pointer to the global state structure.
- **/
-
-VL_INLINE VlState *
-vl_get_state (void)
-{
-  return &_vl_state ;
-}
-
-/** @internal@brief Get VLFeat thread state
- ** @return pointer to the thread state structure.
- **
- ** The function returns a pointer to VLFeat thread state.
- **/
-
-VL_INLINE VlThreadState *
-vl_get_thread_specific_state (void)
-{
-#ifdef VL_DISABLE_THREADS
-  return vl_get_state()->threadState ;
-#else
-  VlState * state ;
-  VlThreadState * threadState ;
-
-  vl_lock_state() ;
-  state = vl_get_state() ;
-
-#if defined(VL_THREADS_POSIX)
-  threadState = (VlThreadState *) pthread_getspecific(state->threadKey) ;
-#elif defined(VL_THREADS_WIN)
-  threadState = (VlThreadState *) TlsGetValue(state->tlsIndex) ;
-#endif
-
-  if (! threadState) {
-    threadState = vl_thread_specific_state_new () ;
-  }
-
-#if defined(VL_THREADS_POSIX)
-  pthread_setspecific(state->threadKey, threadState) ;
-#elif defined(VL_THREADS_WIN)
-  TlsSetValue(state->tlsIndex, threadState) ;
-#endif
-
-  vl_unlock_state() ;
-  return threadState ;
-#endif
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the number of CPU cores of the host
- ** @return number of CPU cores.
- **/
-
-vl_size
-vl_get_num_cpus (void)
-{
-  return vl_get_state()->numCPUs ;
-}
-
-/** @fn ::vl_set_simd_enabled(vl_bool)
- ** @brief Toggle usage of SIMD instructions
- ** @param x @c true if SIMD instructions are used.
- **
- ** Notice that SIMD instructions are used only if the CPU model
- ** supports them. Note also that data alignment may restrict the use
- ** of such instructions.
- **
- ** @see ::vl_cpu_has_sse2(), ::vl_cpu_has_sse3(), etc.
- **/
-
-void
-vl_set_simd_enabled (vl_bool x)
-{
-  vl_get_state()->simdEnabled = x ;
-}
-
-/** @brief Are SIMD instructons enabled?
- ** @return @c true if SIMD instructions are enabled.
- **/
-
-vl_bool
-vl_get_simd_enabled (void)
-{
-  return vl_get_state()->simdEnabled ;
-}
-
-/** @brief Check for AVX instruction set
- ** @return @c true if AVX is present.
- **/
-
-vl_bool
-vl_cpu_has_avx (void)
-{
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  return vl_get_state()->cpuInfo.hasAVX ;
-#else
-  return VL_FALSE ;
-#endif
-}
-
-/** @brief Check for SSE3 instruction set
- ** @return @c true if SSE3 is present.
- **/
-
-vl_bool
-vl_cpu_has_sse3 (void)
-{
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  return vl_get_state()->cpuInfo.hasSSE3 ;
-#else
-  return VL_FALSE ;
-#endif
-}
-
-/** @brief Check for SSE2 instruction set
- ** @return @c true if SSE2 is present.
- **/
-
-vl_bool
-vl_cpu_has_sse2 (void)
-{
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  return vl_get_state()->cpuInfo.hasSSE2 ;
-#else
-  return VL_FALSE ;
-#endif
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Get the number of computational threads available to the application
- ** @return number of threads.
- **
- ** This function wraps the OpenMP function @c
- ** omp_get_thread_limit(). If VLFeat was compiled without OpenMP
- ** support, this function returns 1. If VLFeat was compiled with
- ** OpenMP prior to version 3.0 (2008/05), it returns 0.
- **
- ** @sa @ref threads-parallel
- **/
-
-vl_size
-vl_get_thread_limit (void)
-{
-#if defined(_OPENMP)
-#if _OPENMP >= 200805
-  /* OpenMP version >= 3.0 */
-  return omp_get_thread_limit() ;
-#else
-  return 0 ;
-#endif
-#else
-  return 1 ;
-#endif
-}
-
-/** @brief Get the maximum number of computational threads used by VLFeat.
- ** @return number of threads.
- **
- ** This function returns the maximum number of thread used by
- ** VLFeat. VLFeat will try to use this number of computational
- ** threads and never exceed it.
- **
- ** This is similar to the OpenMP function @c omp_get_max_threads();
- ** however, it reads a parameter private to VLFeat which is
- ** independent of the value used by the OpenMP library.
- **
- ** If VLFeat was compiled without OpenMP support, this function
- ** returns 1.
- **
- ** @sa vl_set_num_threads(), @ref threads-parallel
- **/
-
-vl_size
-vl_get_max_threads (void)
-{
-#if defined(_OPENMP)
-  return vl_get_state()->numThreads ;
-#else
-  return 1 ;
-#endif
-}
-
-/** @brief Set the maximum number of threads used by VLFeat.
- ** @param numThreads number of threads to use.
- **
- ** This function sets the maximum number of computational threads
- ** that will be used by VLFeat. VLFeat may in practice use fewer
- ** threads (for example because @a numThreads is larger than the
- ** number of computational cores in the host, or because the number
- ** of threads exceeds the limit available to the application).
- **
- ** If @c numThreads is set to 0, then VLFeat sets the number of
- ** threads to the OpenMP current maximum, obtained by calling @c
- ** omp_get_max_threads().
- **
- ** This function is similar to @c omp_set_num_threads() but changes a
- ** parameter internal to VLFeat rather than affecting OpenMP global
- ** state.
- **
- ** If VLFeat was compiled without, this function does nothing.
- **
- ** @sa vl_get_max_threads(), @ref threads-parallel
- **/
-
-#if defined(_OPENMP)
-void
-vl_set_num_threads (vl_size numThreads)
-{
-  if (numThreads == 0) {
-    numThreads = omp_get_max_threads() ;
-  }
-  vl_get_state()->numThreads = numThreads ;
-}
-#else
-void
-vl_set_num_threads (vl_size numThreads VL_UNUSED) { }
-#endif
-
-/* ---------------------------------------------------------------- */
-/** @brief Set last VLFeat error
- ** @param error error code.
- ** @param errorMessage error message format string.
- ** @param ... format string arguments.
- ** @return error code.
- **
- ** The function sets the code and optionally the error message
- ** of the last encountered error. @a errorMessage is the message
- ** format. It uses the @c printf convention and is followed by
- ** the format arguments. The maximum length of the error message is
- ** given by ::VL_ERR_MSG_LEN (longer messages are truncated).
- **
- ** Passing @c NULL as @a errorMessage
- ** sets the error message to the empty string.
- **/
-
-int
-vl_set_last_error (int error, char const * errorMessage, ...)
-{
-  VlThreadState * state = vl_get_thread_specific_state() ;
-  va_list args;
-  va_start(args, errorMessage) ;
-  if (errorMessage) {
-#ifdef VL_COMPILER_LCC
-    vsprintf(state->lastErrorMessage, errorMessage, args) ;
-#else
-    vsnprintf(state->lastErrorMessage,
-              sizeof(state->lastErrorMessage)/sizeof(char),
-              errorMessage, args) ;
-#endif
-  } else {
-    state->lastErrorMessage[0] = 0 ;
-  }
-  state->lastError = error ;
-  va_end(args) ;
-  return error ;
-}
-
-/** @brief Get the code of the last error
- ** @return error code.
- ** @sa ::vl_get_last_error_message.
- **/
-
-int
-vl_get_last_error (void) {
-  return vl_get_thread_specific_state()->lastError ;
-}
-
-/** @brief Get the last error message
- ** @return pointer to the error message.
- ** @sa ::vl_get_last_error.
- **/
-
-char const *
-vl_get_last_error_message (void)
-{
-  return vl_get_thread_specific_state()->lastErrorMessage ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Set memory allocation functions
- ** @param malloc_func  pointer to @c malloc.
- ** @param realloc_func pointer to @c realloc.
- ** @param calloc_func  pointer to @c calloc.
- ** @param free_func    pointer to @c free.
- **/
-
-void
-vl_set_alloc_func (void *(*malloc_func)  (size_t),
-                   void *(*realloc_func) (void*, size_t),
-                   void *(*calloc_func)  (size_t, size_t),
-                   void  (*free_func)    (void*))
-{
-  VlState * state ;
-  vl_lock_state () ;
-  state = vl_get_state() ;
-  state->malloc_func  = malloc_func ;
-  state->realloc_func = realloc_func ;
-  state->calloc_func  = calloc_func ;
-  state->free_func    = free_func ;
-  vl_unlock_state () ;
-}
-
-/** @brief Allocate a memory block
- ** @param n size in bytes of the new block.
- ** @return pointer to the allocated block.
- **
- ** This function allocates a memory block of the specified size.
- ** The synopsis is the same as the POSIX @c malloc function.
- **/
-
-void *
-vl_malloc (size_t n)
-{
-  return (vl_get_state()->malloc_func)(n) ;
-  //return (memalign)(32,n) ;
-}
-
-
-/** @brief Reallocate a memory block
- ** @param ptr pointer to a memory block previously allocated.
- ** @param n size in bytes of the new block.
- ** @return pointer to the new block.
- **
- ** This function reallocates a memory block to change its size.
- ** The synopsis is the same as the POSIX @c realloc function.
- **/
-
-void *
-vl_realloc (void* ptr, size_t n)
-{
-  return (vl_get_state()->realloc_func)(ptr, n) ;
-}
-
-/** @brief Free and clear a memory block
- ** @param n number of items to allocate.
- ** @param size size in bytes of an item.
- ** @return pointer to the new block.
- **
- ** This function allocates and clears a memory block.
- ** The synopsis is the same as the POSIX @c calloc function.
- **/
-
-void *
-vl_calloc (size_t n, size_t size)
-{
-  return (vl_get_state()->calloc_func)(n, size) ;
-}
-
-/** @brief Free a memory block
- ** @param ptr pointer to the memory block.
- **
- ** This function frees a memory block allocated by ::vl_malloc,
- ** ::vl_calloc, or ::vl_realloc. The synopsis is the same as the POSIX
- ** @c malloc function.
- **/
-
-void
-vl_free (void *ptr)
-{
-  (vl_get_state()->free_func)(ptr) ;
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Set the printf function
- ** @param printf_func pointer to a @c printf implementation.
- ** Set @c print_func to NULL to disable printf.
- **/
-
-void
-vl_set_printf_func (printf_func_t printf_func)
-{
-  vl_get_state()->printf_func = printf_func ? printf_func : do_nothing_printf ;
-}
-
-/** @brief Get the printf function
- ** @return printf_func pointer to the @c printf implementation.
- ** @sa ::vl_set_printf_func.
- **/
-
-printf_func_t
-vl_get_printf_func (void) {
-  return vl_get_state()->printf_func ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get processor time
- ** @return processor time in seconds.
- ** @sa ::vl_tic, ::vl_toc
- **/
-
-double
-vl_get_cpu_time ()
-{
-  #ifdef VL_OS_WIN
-  VlThreadState * threadState = vl_get_thread_specific_state() ;
-  LARGE_INTEGER mark ;
-  QueryPerformanceCounter (&mark) ;
-  return (double)mark.QuadPart / (double)threadState->ticFreq.QuadPart ;
-#else
-  return (double)clock() / (double)CLOCKS_PER_SEC ;
-#endif
-}
-
-/** @brief Reset processor time reference
- ** The function resets VLFeat TIC/TOC time reference. There is one
- ** such reference per thread.
- ** @sa ::vl_get_cpu_time, ::vl_toc.
- **/
-
-void
-vl_tic (void)
-{
-  VlThreadState * threadState = vl_get_thread_specific_state() ;
-#ifdef VL_OS_WIN
-  QueryPerformanceCounter (&threadState->ticMark) ;
-#else
-  threadState->ticMark = clock() ;
-#endif
-}
-
-/** @brief Get elapsed time since tic
- ** @return elapsed time in seconds.
- **
- ** The function
- ** returns the processor time elapsed since ::vl_tic was called last.
- **
- ** @remark In multi-threaded applications, there is an independent
- ** timer for each execution thread.
- **
- ** @remark On UNIX, this function uses the @c clock() system call.
- ** On Windows, it uses the @c QueryPerformanceCounter() system call,
- ** which is more accurate than @c clock() on this platform.
- **/
-
-double
-vl_toc (void)
-{
-  VlThreadState * threadState = vl_get_thread_specific_state() ;
-#ifdef VL_OS_WIN
-  LARGE_INTEGER tocMark ;
-  QueryPerformanceCounter(&tocMark) ;
-  return (double) (tocMark.QuadPart - threadState->ticMark.QuadPart) /
-    threadState->ticFreq.QuadPart ;
-#else
-  return (double) (clock() - threadState->ticMark) / CLOCKS_PER_SEC ;
-#endif
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the default random number generator.
- ** @return random number generator.
- **
- ** The function returns a pointer to the default
- ** random number generator.
- ** There is one such generator per thread.
- **/
-
-VL_EXPORT VlRand *
-vl_get_rand (void)
-{
-  return &vl_get_thread_specific_state()->rand ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                    Library construction and destruction routines */
-/*  --------------------------------------------------------------- */
-
-/** @internal@brief Construct a new thread state object
- ** @return new state structure.
- **/
-
-static VlThreadState *
-vl_thread_specific_state_new (void)
-{
-  VlThreadState * self ;
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: thread constructor begins.\n") ;
-#endif
-  self = malloc(sizeof(VlThreadState)) ;
-  self->lastError = 0 ;
-  self->lastErrorMessage[0] = 0 ;
-#if defined(VL_OS_WIN)
-  QueryPerformanceFrequency (&self->ticFreq) ;
-  self->ticMark.QuadPart = 0 ;
-#else
-  self->ticMark = 0 ;
-#endif
-  vl_rand_init (&self->rand) ;
-
-  return self ;
-}
-
-/** @internal@brief Delete a thread state structure
- ** @param self thread state object.
- **/
-
-static void
-vl_thread_specific_state_delete (VlThreadState * self)
-{
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: thread destructor begins.\n") ;
-#endif
-  free (self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                               Library constructor and destructor */
-/* ---------------------------------------------------------------- */
-
-/** @internal @brief Initialize VLFeat state */
-void
-vl_constructor (void)
-{
-  VlState * state ;
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: constructor begins.\n") ;
-#endif
-
-  state = vl_get_state() ;
-
-#if ! defined(VL_DISABLE_THREADS)
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: constructing thread specific state.\n") ;
-#endif
-#if defined(VL_THREADS_POSIX)
-  {
-    typedef void (*destructorType)(void * );
-    pthread_key_create (&state->threadKey,
-                        (destructorType)
-                          vl_thread_specific_state_delete) ;
-    pthread_mutex_init (&state->mutex, NULL) ;
-    pthread_cond_init (&state->mutexCondition, NULL) ;
-  }
-#elif defined(VL_THREADS_WIN)
-  InitializeCriticalSection (&state->mutex) ;
-  state->tlsIndex = TlsAlloc () ;
-#endif
-#else
-
-/* threading support disabled */
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: constructing the generic thread state instance (threading support disabled).\n") ;
-#endif
-  vl_get_state()->threadState = vl_thread_specific_state_new() ;
-#endif
-
-  state->malloc_func  = malloc ;
-  state->realloc_func = realloc ;
-  state->calloc_func  = calloc ;
-  state->free_func    = free ;
-  state->printf_func  = printf ;
-
-  /* on x86 platforms read the CPUID register */
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
-  _vl_x86cpu_info_init (&state->cpuInfo) ;
-#endif
-
-  /* get the number of CPUs */
-#if defined(VL_OS_WIN)
-  {
-    SYSTEM_INFO info;
-    GetSystemInfo (&info) ;
-    state->numCPUs = info.dwNumberOfProcessors ;
-  }
-#elif defined(_SC_NPROCESSORS_ONLN)
-  state->numCPUs = sysconf(_SC_NPROCESSORS_ONLN) ;
-#else
-  state->numCPUs = 1 ;
-#endif
-  state->simdEnabled = VL_TRUE ;
-
-  /* get the number of (OpenMP) threads used by the library */
-#if defined(_OPENMP)
-  state->numThreads = omp_get_max_threads() ;
-#else
-  state->numThreads = 1 ;
-#endif
-
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: constructor ends.\n") ;
-#endif
-}
-
-/** @internal @brief Destruct VLFeat */
-void
-vl_destructor ()
-{
-  VlState * state ;
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: destructor begins.\n") ;
-#endif
-
-  state = vl_get_state() ;
-
-#if ! defined(VL_DISABLE_THREADS)
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: destroying a thread specific state instance.\n") ;
-#endif
-#if   defined(VL_THREADS_POSIX)
-  {
-    /* Delete the thread state of this thread as the
-       destructor is not called by pthread_key_delete or after
-       the key is deleted. When the library
-       is unloaded, this thread should also be the last one
-       using the library, so this is fine.
-     */
-    VlThreadState * threadState =
-       pthread_getspecific(state->threadKey) ;
-    if (threadState) {
-      vl_thread_specific_state_delete (threadState) ;
-      pthread_setspecific(state->threadKey, NULL) ;
-    }
-  }
-  pthread_cond_destroy (&state->mutexCondition) ;
-  pthread_mutex_destroy (&state->mutex) ;
-  pthread_key_delete (state->threadKey) ;
-#elif defined(VL_THREADS_WIN)
- {
-    /* Delete the thread state of this thread as the
-       destructor is not called by pthread_key_delete or after
-       the key is deleted. When the library
-       is unloaded, this thread should also be the last one
-       using the library, so this is fine.
-     */
-    VlThreadState * threadState =
-       TlsGetValue(state->tlsIndex) ;
-    if (threadState) {
-      vl_thread_specific_state_delete (threadState) ;
-      TlsSetValue(state->tlsIndex, NULL) ;
-    }
-  }
-  TlsFree (state->tlsIndex) ;
-  DeleteCriticalSection (&state->mutex) ;
-#endif
-#else
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: destroying the generic thread state instance (threading support disabled).\n") ;
-#endif
-  vl_thread_specific_state_delete(vl_get_state()->threadState) ;
-#endif
-
-#if defined(DEBUG)
-  printf("VLFeat DEBUG: destructor ends.\n") ;
-#endif
-}
-
-/* ---------------------------------------------------------------- */
-/*                    Cross-platform call to constructor/destructor */
-/* ---------------------------------------------------------------- */
-
-#ifdef __cplusplus
-    #define INITIALIZER(f) \
-        static void f(void); \
-        struct f##_t_ { f##_t_(void) { f(); } }; static f##_t_ f##_; \
-        static void f(void)
-#elif defined(_MSC_VER)
-    #pragma section(".CRT$XCU",read)
-    #define INITIALIZER2_(f,p) \
-        static void f(void); \
-        __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
-        __pragma(comment(linker,"/include:" p #f "_")) \
-        static void f(void)
-    #ifdef _WIN64
-        #define INITIALIZER(f) INITIALIZER2_(f,"")
-    #else
-        #define INITIALIZER(f) INITIALIZER2_(f,"_")
-    #endif
-#else
-    #define INITIALIZER(f) \
-        static void f(void) __attribute__((constructor)); \
-        static void f(void)
-#endif
-
-INITIALIZER(vl_initialize)
-{
-    vl_constructor();
-    atexit(vl_destructor);
-}
-
diff --git a/opensfm/src/third_party/vlfeat/vl/generic.h b/opensfm/src/third_party/vlfeat/vl/generic.h
deleted file mode 100644
index 4a6296e8c..000000000
--- a/opensfm/src/third_party/vlfeat/vl/generic.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/** @file generic.h
- ** @brief Generic (@ref generic)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 Andrea Vedaldi.
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_GENERIC_H
-#define VL_GENERIC_H
-
-#include "host.h"
-#include "random.h"
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <time.h>
-#include <assert.h>
-
-/** @brief Library version string */
-#define VL_VERSION_STRING "0.9.20"
-
-/** @brief Maximum length (in characters) of an error message */
-#define VL_ERR_MSG_LEN 1024
-
-/** @name Type identifiers for atomic data types
- ** @{ */
-
-#define VL_TYPE_FLOAT   1     /**< @c float type */
-#define VL_TYPE_DOUBLE  2     /**< @c double type */
-#define VL_TYPE_INT8    3     /**< @c ::vl_int8 type */
-#define VL_TYPE_UINT8   4     /**< @c ::vl_uint8 type */
-#define VL_TYPE_INT16   5     /**< @c ::vl_int16 type */
-#define VL_TYPE_UINT16  6     /**< @c ::vl_uint16 type */
-#define VL_TYPE_INT32   7     /**< @c ::vl_int32 type */
-#define VL_TYPE_UINT32  8     /**< @c ::vl_uint32 type */
-#define VL_TYPE_INT64   9     /**< @c ::vl_int64 type */
-#define VL_TYPE_UINT64  10    /**< @c ::vl_uint64 type */
-
-typedef vl_uint32 vl_type ;
-
-/** @brief Get the name of a data type.
- ** @param type data type.
- ** @return data name of the data type.
- **
- ** @c type is one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE,
- ** ::VL_TYPE_INT8, ::VL_TYPE_INT16, ::VL_TYPE_INT32, ::VL_TYPE_INT64,
- ** ::VL_TYPE_UINT8, ::VL_TYPE_UINT16, ::VL_TYPE_UINT32, ::VL_TYPE_UINT64.
- **/
-
-void vl_constructor();
-void vl_destructor();
-
-VL_INLINE char const *
-vl_get_type_name (vl_type type)
-{
-  switch (type) {
-    case VL_TYPE_FLOAT   : return "float"  ;
-    case VL_TYPE_DOUBLE  : return "double" ;
-    case VL_TYPE_INT8    : return "int8"   ;
-    case VL_TYPE_INT16   : return "int16"  ;
-    case VL_TYPE_INT32   : return "int32"  ;
-    case VL_TYPE_INT64   : return "int64"  ;
-    case VL_TYPE_UINT8   : return "int8"   ;
-    case VL_TYPE_UINT16  : return "int16"  ;
-    case VL_TYPE_UINT32  : return "int32"  ;
-    case VL_TYPE_UINT64  : return "int64"  ;
-    default: return NULL ;
-  }
-}
-
-/** @brief Get data type size.
- ** @param type data type.
- ** @return size (in byte)
- **
- ** @c type is one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE,
- ** ::VL_TYPE_INT8, ::VL_TYPE_INT16, ::VL_TYPE_INT32, ::VL_TYPE_INT64,
- ** ::VL_TYPE_UINT8, ::VL_TYPE_UINT16, ::VL_TYPE_UINT32, ::VL_TYPE_UINT64.
- **/
-
-VL_INLINE vl_size
-vl_get_type_size (vl_type type)
-{
-  vl_size dataSize = 0 ;
-  switch (type) {
-    case VL_TYPE_DOUBLE : dataSize = sizeof(double) ; break ;
-    case VL_TYPE_FLOAT  : dataSize = sizeof(float) ; break ;
-    case VL_TYPE_INT64  : case VL_TYPE_UINT64 : dataSize = sizeof(vl_int64) ; break ;
-    case VL_TYPE_INT32  : case VL_TYPE_UINT32 : dataSize = sizeof(vl_int32) ; break ;
-    case VL_TYPE_INT16  : case VL_TYPE_UINT16 : dataSize = sizeof(vl_int16) ; break ;
-    case VL_TYPE_INT8   : case VL_TYPE_UINT8  : dataSize = sizeof(vl_int8)  ; break ;
-    default:
-      abort() ;
-  }
-  return dataSize ;
-}
-/** @} */
-
-VL_EXPORT char const * vl_get_version_string (void) ;
-VL_EXPORT char * vl_configuration_to_string_copy (void) ;
-VL_EXPORT void vl_set_simd_enabled (vl_bool x) ;
-VL_EXPORT vl_bool vl_get_simd_enabled (void) ;
-VL_EXPORT vl_bool vl_cpu_has_avx (void) ;
-VL_EXPORT vl_bool vl_cpu_has_sse3 (void) ;
-VL_EXPORT vl_bool vl_cpu_has_sse2 (void) ;
-VL_EXPORT vl_size vl_get_num_cpus (void) ;
-VL_EXPORT VlRand * vl_get_rand (void) ;
-
-/** @name Multi-thread computations
- ** @{ */
-VL_EXPORT vl_size vl_get_max_threads (void) ;
-VL_EXPORT void vl_set_num_threads (vl_size n) ;
-VL_EXPORT vl_size vl_get_thread_limit (void) ;
-/** @} (*/
-
-/** ------------------------------------------------------------------
- ** @name Error handling
- ** @{ */
-#define VL_ERR_OK       0  /**< No error */
-#define VL_ERR_OVERFLOW 1  /**< Buffer overflow error */
-#define VL_ERR_ALLOC    2  /**< Resource allocation error */
-#define VL_ERR_BAD_ARG  3  /**< Bad argument or illegal data error */
-#define VL_ERR_IO       4  /**< Input/output error */
-#define VL_ERR_EOF      5  /**< End-of-file or end-of-sequence error */
-#define VL_ERR_NO_MORE  5  /**< End-of-sequence @deprecated */
-
-VL_EXPORT int vl_get_last_error (void) ;
-VL_EXPORT char const *  vl_get_last_error_message (void) ;
-VL_EXPORT int vl_set_last_error (int error, char const * errorMessage, ...) ;
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Memory allocation
- ** @{ */
-VL_EXPORT void
-vl_set_alloc_func (void *(*malloc_func)  (size_t),
-                   void *(*realloc_func) (void*,size_t),
-                   void *(*calloc_func)  (size_t, size_t),
-                   void  (*free_func)    (void*)) ;
-VL_EXPORT void *vl_malloc (size_t n) ;
-VL_EXPORT void *vl_realloc (void *ptr, size_t n) ;
-VL_EXPORT void *vl_calloc (size_t n, size_t size) ;
-VL_EXPORT void *vl_memalign (size_t n, size_t size) ;
-VL_EXPORT void  vl_free (void* ptr) ;
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Logging
- ** @{ */
-/** @brief Customizable printf function pointer type */
-typedef int(*printf_func_t) (char const *format, ...) ;
-VL_EXPORT void vl_set_printf_func (printf_func_t printf_func) ;
-VL_EXPORT printf_func_t vl_get_printf_func (void) ;
-
-/** @def VL_PRINTF
- ** @brief Call user-customizable @c printf function
- **
- ** The function calls the user customizable @c printf.
- **/
-
-/** @def VL_PRINT
- ** @brief Same as ::VL_PRINTF (legacy code)
- **/
-
-#define VL_PRINTF (*vl_get_printf_func())
-#define VL_PRINT (*vl_get_printf_func())
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Common operations
- ** @{ */
-
-/** @brief Compute the minimum between two values
- ** @param x value
- ** @param y value
- ** @return the minimum of @a x and @a y.
- **/
-#define VL_MIN(x,y) (((x)<(y))?(x):(y))
-
-/** @brief Compute the maximum between two values
- ** @param x value.
- ** @param y value.
- ** @return the maximum of @a x and @a y.
- **/
-#define VL_MAX(x,y) (((x)>(y))?(x):(y))
-
-/** @brief Signed left shift operation
- ** @param x value.
- ** @param n number of shift positions.
- ** @return @c x << n .
- ** The macro is equivalent to the builtin @c << operator, but it
- ** supports negative shifts too.
- **/
-#define VL_SHIFT_LEFT(x,n) (((n)>=0)?((x)<<(n)):((x)>>-(n)))
-/* @} */
-
-/** ------------------------------------------------------------------
- ** @name Measuring time
- ** @{
- **/
-VL_EXPORT void vl_tic (void) ;
-VL_EXPORT double vl_toc (void) ;
-VL_EXPORT double vl_get_cpu_time (void) ;
-/** @} */
-
-/* VL_GENERIC_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/getopt_long.c b/opensfm/src/third_party/vlfeat/vl/getopt_long.c
deleted file mode 100644
index 0e860f386..000000000
--- a/opensfm/src/third_party/vlfeat/vl/getopt_long.c
+++ /dev/null
@@ -1,326 +0,0 @@
-/** @file getopt_long.c
- ** @brief getopt_long - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-@file   getopt_long.h
-@brief  getopt_long
-@author Andrea Vedaldi
-
-This is a drop-in replacament of GNU getopt_long meant to be used
-on platforms that do not support such functionality.
-**/
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "generic.h"
-#include "getopt_long.h"
-
-int    opterr = 1 ;
-int    optind = 1 ;
-int    optopt ;
-char * optarg ;
-int    optreset ;
-
-#define BADCH	'?'
-#define BADARG	':'
-#define EEND    -1
-#define EMSG	""
-
-/** @brief Parse long options (BSD style)
- ** @param argc number of arguments.
- ** @param argv pointer to the vector of arguments.
- ** @param optstring list of abbreviated options
- ** @param longopts list of long options.
- ** @param longindex index of current option in @a longopts.
- ** @return the code of the next option.
- **
- ** This function extract long and short options from the argument
- ** list @a argv of @a argc entries.
- **
- ** A short options sequence is introduced by a single dash character
- ** @c -. Each short option is described by a single character in the
- ** string @a optstring, possibly followed by a @c : character to
- ** denote a (mandatory) argument of the short option. A short option
- ** with an argument cannot appear in the middle of a short option
- ** sequence, but only at the end.
- **
- ** A long option is introduced by a double dash @c --. Each long
- ** option is described by an instance of the ::option structure in
- ** the @a longopts table (the last entry must be filled with zeroes
- ** to denote the end).
- **
- ** Illegal options and missing arguments cause the function to skip
- ** the option and return '?'. If ::opterr is @c true (default), the
- ** function prints an error message to @a stderr. Finally, if @a
- ** optstring has a leading @c :, then error messages are suppressed
- ** and a missing argument causes @a : to be returned.
- **
- ** @remark The function is currently <em>not</em> thread safe.
- **/
-
-VL_EXPORT int
-getopt_long(int argc, char *const argv[],
-            const char *optstring,
-            const struct option * longopts,
-            int *longindex)
-{
-  static char *place = EMSG;	/* option letter processing */
-  static int   optbegin  = 0 ;
-  static int   optend    = 0 ;
-  char        *oli;		/* option letter list index */
-  int          has_colon = 0 ;
-  int          ret_val   = 0 ;
-
-  /*
-     A semicolon at the beginning of optstring has a special meaning.
-     If we find one, we annote and remove it.
-  */
-  has_colon = optstring && optstring[0] == ':' ;
-  if (has_colon) ++ optstring ;
-
-  /*
-   Here we are either processing a short option sequence or
-   we start processing a new option. This is indicated by optreset.
-  */
-
-  if (optreset || *place == '\0') {
-
-    /* ---------------------------------------------------------------
-     *                                 Look for next short/long option
-     * ------------------------------------------------------------ */
-    optreset = 0 ;
-
-    /* no more arguments ? */
-    if (optind >= argc) {
-      place = EMSG ;
-      return -1 ;
-    }
-
-    /* next argument that may hold an option */
-    optbegin = optind ;
-
-    /* ---------------------------------------------------------------
-     *                                     Look for an option to parse
-     * ------------------------------------------------------------ */
-
-  parse_option_at_optbegin :
-
-    /* place points to the candidate option */
-    place = argv [optbegin] ;
-
-    /* an option is introduced by '-' */
-    if (place [0] != '-') {
-      /* this argument is not an option: try next argument */
-      ++ optbegin ;
-      if (optbegin >= argc) {
-        /* no more arguments to look for options */
-        place = EMSG ;
-        return -1 ;
-      }
-      goto parse_option_at_optbegin ;
-    }
-
-    /* consume leading `-' */
-    ++ place ;
-
-    /* assume the option is composed of one argument only */
-    optend = optbegin + 1 ;
-
-    /* assume no argument */
-    optarg = 0 ;
-
-    /* ---------------------------------------------------------------
-     *                                                     option `--'
-     * ------------------------------------------------------------ */
-
-    /* this special option (void long option) ends the option processing */
-    if (place[0]        &&
-        place[0] == '-' &&
-        place[1] == '\0') {
-
-      optind  = optend ;
-      place   = EMSG ;
-      ret_val = -1 ;
-      goto done_option ;
-    }
-
-    /* ---------------------------------------------------------------
-     *                                                     long option
-     * ------------------------------------------------------------ */
-
-    if (place[0]        &&
-        place[0] == '-' &&
-        place[1] ) {
-
-      size_t namelen ;
-      int i ;
-
-      /* consume second `-' */
-      ++ place ;
-
-      /* count characters before `=' */
-      namelen = strcspn(place, "=") ;
-
-      /* scan longopts for this option */
-      for (i = 0 ; longopts[i].name != NULL ; ++ i) {
-
-        if (strlen  (       longopts[i].name) == namelen &&
-            strncmp (place, longopts[i].name, namelen) == 0 ) {
-
-          /* save back long option index */
-          if (longindex) *longindex = i ;
-
-          /* process long option argument */
-          if (longopts[i].has_arg == required_argument ||
-              longopts[i].has_arg == optional_argument) {
-
-            /* --option=value style */
-            if (place[namelen] == '=') {
-              optarg = place + namelen + 1 ;
-            }
-
-            /* --option value style (only required_argument) */
-            else if (longopts[i].has_arg == required_argument) {
-              /* missing argument ? */
-              if (optbegin >= argc - 1) {
-                if (! has_colon && opterr)
-                  fprintf(stderr,
-                          "%s: option requires an argument -- %s\n",
-                          argv[0], place);
-                place   = EMSG ;
-                ret_val = has_colon ? BADARG : BADCH ;
-                goto done_option ;
-              }
-              optarg = argv [optend] ;
-              ++ optend ;
-            }
-          }
-
-          /* determine return value */
-          if (longopts[i].flag == NULL) {
-            ret_val = longopts[i].val ;
-          }
-          else {
-            *longopts[i].flag = longopts[i].val;
-            ret_val = 0 ;
-          }
-
-          /* mark sequence closed */
-          place = EMSG ;
-          goto done_option ;
-        } /* if match */
-
-      } /* scan longoptions */
-
-      /* no matching option found */
-      if (! has_colon && opterr)
-        fprintf(stderr,
-                "%s: illegal option -- %s\n", argv[0], place) ;
-      place   = EMSG ;
-      ret_val = BADCH ;
-      goto done_option ;
-    }
-  } /* end new option */
-
-  /* -----------------------------------------------------------------
-   *                                      Finish short option sequence
-   * -------------------------------------------------------------- */
-  optopt = (int) *place++ ;
-
-  /* search charcater in option list */
-  oli = strchr(optstring, optopt);
-
-  /* short option not found */
-  if (!oli) {
-
-    if (! has_colon && opterr)
-      fprintf(stderr,
-              "%s: illegal option -- %c\n",
-              argv[0], optopt);
-
-    if (*place) {
-      /* more short options in the list */
-      return BADCH ;
-    }
-
-    else {
-      /* error occured as last option in the list */
-      place   = EMSG ;
-      ret_val = BADCH ;
-      goto done_option ;
-    }
-  } /* end short option not found */
-
-  if (oli[1] != ':') {
-    /* short option with no argument */
-
-    if (*place) {
-      /* more short options in the list */
-      return optopt ;
-    }
-    else {
-      /* last option in the list */
-      place   = EMSG ;
-      ret_val = optopt ;
-      goto done_option ;
-    }
-
-  } else {
-    /* short option with argument */
-
-    /* -ovalue style */
-    if (*place) {
-      optarg  = place ;
-      place   = EMSG ;
-      ret_val = optopt ;
-      goto done_option ;
-    }
-    /* -o value style: missing argument */
-    else if (optbegin >= argc - 1) {
-      if (! has_colon && opterr)
-        fprintf(stderr,
-                "%s: option requires an argument -- %c\n",
-                argv[0], optopt);
-      place   = EMSG ;
-      ret_val = has_colon ? BADARG : BADCH ;
-      goto done_option ;
-    }
-
-    /* -o value style: process argument */
-    optarg = argv [optend] ;
-    ++ optend ;
-    place   = EMSG ;
-    ret_val = optopt ;
-    goto done_option ;
-  } /* short with argument */
-
- done_option :
-  {
-    int pos = optend - optbegin ;  /* n of circular shifts */
-    int c   = pos ;
-
-    while (c --) {
-      int i ;
-      char *tmp = argv [optend - 1] ;
-      for (i = optend - 1 ; i > optind ; -- i) {
-        ((char**)argv) [i] = argv [i-1] ;
-      }
-      ((char**)argv) [optind] = tmp ;
-    }
-    optind += pos ;
-  }
-
-  return ret_val ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/getopt_long.h b/opensfm/src/third_party/vlfeat/vl/getopt_long.h
deleted file mode 100644
index 421213546..000000000
--- a/opensfm/src/third_party/vlfeat/vl/getopt_long.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/** @file getopt_long.h
- ** @brief getopt_long
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_GETOPT_LONG_H
-#define VL_GETOPT_LONG_H
-
-#include "generic.h"
-
-VL_EXPORT int    opterr ;   /**< code of the last error occured while parsing an option */
-VL_EXPORT int    optind ;   /**< index of the next option to process in @c argv */
-VL_EXPORT int    optopt ;   /**< current option */
-VL_EXPORT char * optarg ;   /**< argument of the current option */
-VL_EXPORT int    optreset ; /**< reset flag */
-
-/** @brief ::getopt_long option */
-struct option
-{
-  const char *name ;  /**< option long name */
-  int	      has_arg ; /**< flag indicating whether the option has no, required or optional argument */
-  int	     *flag ;    /**< pointer to a variable to set (if @c NULL, the value is returned instead) */
-  int	      val ;     /**< value to set or to return */
-} ;
-
-#define no_argument       0 /**< ::option with no argument */
-#define required_argument 1 /**< ::option with required argument */
-#define optional_argument 2 /**< ::option with optional argument */
-
-VL_EXPORT int getopt_long(int argc, char * const argv[],
-                          const char * optstring,
-                          const struct option * longopts, int * longindex);
-
-/* VL_GETOPT_LONG_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/gmm.c b/opensfm/src/third_party/vlfeat/vl/gmm.c
deleted file mode 100644
index 585044576..000000000
--- a/opensfm/src/third_party/vlfeat/vl/gmm.c
+++ /dev/null
@@ -1,1709 +0,0 @@
-/** @file gmm.c
- ** @brief Gaussian Mixture Models - Implementation
- ** @author David Novotny
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page gmm Gaussian Mixture Models (GMM)
-@author David Novotny
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref gmm.h is an implementation of *Gaussian Mixture Models* (GMMs).
-The main functionality provided by this module is learning GMMs from
-data by maximum likelihood. Model optimization uses the Expectation
-Maximization (EM) algorithm @cite{dempster77maximum}. The
-implementation supports @c float or @c double data types, is
-parallelized, and is tuned to work reliably and effectively on
-datasets of visual features. Stability is obtained in part by
-regularizing and restricting the parameters of the GMM.
-
-@ref gmm-starting demonstreates how to use the C API to compute the FV
-representation of an image. For further details refer to:
-
-- @subpage gmm-fundamentals
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section gmm-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In order to use @ref gmm.h to learn a GMM from training data, create a
-new ::VlGMM object instance, set the parameters as desired, and run
-the training code. The following example learns @c numClusters
-Gaussian components from @c numData vectors of dimension @c dimension
-and storage class @c float using at most 100 EM iterations:
-
-@code
-float * means ;
-float * covariances ;
-float * priors ;
-float * posteriors ;
-
-double loglikelihood ;
-
-// create a new instance of a GMM object for float data
-gmm = vl_gmm_new (VL_TYPE_FLOAT, dimension, numClusters) ;
-
-// set the maximum number of EM iterations to 100
-vl_gmm_set_max_num_iterations (gmm, 100) ;
-
-// set the initialization to random selection
-vl_gmm_set_initialization (gmm,VlGMMRand);
-
-// cluster the data, i.e. learn the GMM
-vl_gmm_cluster (gmm, data, numData);
-
-// get the means, covariances, and priors of the GMM
-means = vl_gmm_get_means(gmm);
-covariances = vl_gmm_get_covariances(gmm);
-priors = vl_gmm_get_priors(gmm);
-
-// get loglikelihood of the estimated GMM
-loglikelihood = vl_gmm_get_loglikelihood(gmm) ;
-
-// get the soft assignments of the data points to each cluster
-posteriors = vl_gmm_get_posteriors(gmm) ;
-@endcode
-
-@note ::VlGMM assumes that the covariance matrices of the GMM are
-diagonal. This reduces significantly the number of parameters to learn
-and is usually an acceptable compromise in vision applications. If the
-data is significantly correlated, it can be beneficial to de-correlate
-it by PCA rotation or projection in pre-processing.
-
-::vl_gmm_get_loglikelihood is used to get the final loglikelihood of
-the estimated mixture, ::vl_gmm_get_means and ::vl_gmm_get_covariances
-to obtain the means and the diagonals of the covariance matrices of
-the estimated Gaussian modes, and ::vl_gmm_get_posteriors to get the
-posterior probabilities that a given point is associated to each of
-the modes (soft assignments).
-
-The learning algorithm, which uses EM, finds a local optimum of the
-objective function. Therefore the initialization is crucial in
-obtaining a good model, measured in term of the final
-loglikelihood. ::VlGMM supports a few methods (use
-::vl_gmm_set_initialization to choose one) as follows:
-
-Method                | ::VlGMMInitialization enumeration       | Description
-----------------------|-----------------------------------------|-----------------------------------------------
-Random initialization | ::VlGMMRand                             | Random initialization of the mixture parameters
-KMeans                | ::VlGMMKMeans                           | Initialization of the mixture parameters using ::VlKMeans
-Custom                | ::VlGMMCustom                           | User specified initialization
-
-Note that in the case of ::VlGMMKMeans initialization, an object of
-type ::VlKMeans object must be created and passed to the ::VlGMM
-instance (see @ref kmeans to see how to correctly set up this object).
-
-When a user wants to use the ::VlGMMCustom method, the initial means,
-covariances and priors have to be specified using the
-::vl_gmm_set_means, ::vl_gmm_set_covariances and ::vl_gmm_set_priors
-methods.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page gmm-fundamentals GMM fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A *Gaussian Mixture Model* (GMM) is a mixture of $K$ multivariate
-Gaussian distributions. In order to sample from a GMM, one samples
-first the component index $k \in \{1,\dots,K\}$ with *prior
-probability* $\pi_k$, and then samples the vector $\bx \in
-\mathbb{R}^d$ from the $k$-th Gaussian distribution
-$p(\bx|\mu_k,\Sigma_k)$. Here $\mu_k$ and $\Sigma_k$ are respectively
-the *mean* and *covariance* of the distribution. The GMM is completely
-specified by the parameters $\Theta=\{\pi_k,\mu_k,\Sigma_k; k =
-1,\dots,K\}$
-
-The density $p(\bx|\Theta)$ induced on the training data is obtained
-by marginalizing the component selector $k$, obtaining
-\[
-p(\bx|\Theta)
-= \sum_{k=1}^{K} \pi_k p( \bx_i |\mu_k,\Sigma_k),
-\qquad
-p( \bx |\mu_k,\Sigma_k)
-=
-\frac{1}{\sqrt{(2\pi)^d\det\Sigma_k}}
-\exp\left[
--\frac{1}{2} (\bx-\mu_k)^\top\Sigma_k^{-1}(\bx-\mu_k)
-\right].
-\]
-Learning a GMM to fit a dataset $X=(\bx_1, \dots, \bx_n)$ is usually
-done by maximizing the log-likelihood of the data:
-@f[
- \ell(\Theta;X)
- = E_{\bx\sim\hat p} [ \log p(\bx|\Theta) ]
- = \frac{1}{n}\sum_{i=1}^{n} \log \sum_{k=1}^{K} \pi_k p(\bx_i|\mu_k, \Sigma_k)
-@f]
-where $\hat p$ is the empirical distribution of the data. An algorithm
-to solve this problem is introduced next.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section gmm-em Learning a GMM by expectation maximization
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The direct maximization of the log-likelihood function of a GMM is
-difficult due to the fact that the assignments of points to Gaussian
-mode is not observable and, as such, must be treated as a latent
-variable.
-
-Usually, GMMs are learned by using the *Expectation Maximization* (EM)
-algorithm @cite{dempster77maximum}. Consider in general the problem of
-estimating to the maximum likelihood a distribution $p(x|\Theta) =
-\int p(x,h|\Theta)\,dh$, where $x$ is a measurement, $h$ is a *latent
-variable*, and $\Theta$ are the model parameters. By introducing an
-auxiliary distribution $q(h|x)$ on the latent variable, one can use
-Jensen inequality to obtain the following lower bound on the
-log-likelihood:
-
-@f{align*}
-\ell(\Theta;X) =
-E_{x\sim\hat p} \log p(x|\Theta)
-&= E_{x\sim\hat p} \log \int p(x,h|\Theta) \,dh \\
-&= E_{x\sim\hat p} \log \int \frac{p(x,h|\Theta)}{q(h|x)} q(h|x)\,dh \\
-&\geq E_{x\sim\hat p} \int q(h) \log \frac{p(x,h|\Theta)}{q(h|x)}\,dh \\
-&= E_{(x,q) \sim q(h|x) \hat p(x)} \log p(x,h|\Theta) -
-   E_{(x,q) \sim q(h|x) \hat p(x)} \log q(h|x)
-@f}
-
-The first term of the last expression is the log-likelihood of the
-model where both the $x$ and $h$ are observed and joinlty distributed
-as $q(x|h)\hat p(x)$; the second term is the a average entropy of the
-latent variable, which does not depend on $\Theta$. This lower bound
-is maximized and becomes tight by setting $q(h|x) = p(h|x,\Theta)$ to
-be the posterior distribution on the latent variable $h$ (given the
-current estimate of the parameters $\Theta$). In fact:
-
-\[
-E_{x \sim \hat p} \log p(x|\Theta)
-=
-E_{(x,h) \sim p(h|x,\Theta) \hat p(x)}\left[ \log \frac{p(x,h|\Theta)}{p(h|x,\Theta)} \right]
-=
-E_{(x,h) \sim p(h|x,\Theta) \hat p(x)} [ \log p(x|\Theta) ]
-=
-\ell(\Theta;X).
-\]
-
-EM alternates between updating the latent variable auxiliary
-distribution $q(h|x) = p(h|x,\Theta_t)$ (*expectation step*) given the
-current estimate of the parameters $\Theta_t$, and then updating the
-model parameters $\Theta_{t+1}$ by maximizing the log-likelihood lower
-bound derived (*maximization step*). The simplification is that in the
-maximization step both $x$ and $h$ are now ``observed'' quantities.
-This procedure converges to a local optimum of the model
-log-likelihood.
-
-@subsection gmm-expectation-step Expectation step
-
-In the case of a GMM, the latent variables are the point-to-cluster
-assignments $k_i, i=1,\dots,n$, one for each of $n$ data points. The
-auxiliary distribution $q(k_i|\bx_i) = q_{ik}$ is a matrix with $n
-\times K$ entries. Each row $q_{i,:}$ can be thought of as a vector of
-soft assignments of the data points $\bx_i$ to each of the Gaussian
-modes. Setting $q_{ik} = p(k_i | \bx_i, \Theta)$ yields
-
-\[
- q_{ik} =
-\frac
-{\pi_k p(\bx_i|\mu_k,\Sigma_k)}
-{\sum_{l=1}^K \pi_l p(\bx_i|\mu_l,\Sigma_l)}
-\]
-
-where the Gaussian density $p(\bx_i|\mu_k,\Sigma_k)$ was given above.
-
-One important point to keep in mind when these probabilities are
-computed is the fact that the Gaussian densities may attain very low
-values and underflow in a vanilla implementation. Furthermore, VLFeat
-GMM implementation restricts the covariance matrices to be
-diagonal. In this case, the computation of the determinant of
-$\Sigma_k$ reduces to computing the trace of the matrix and the
-inversion of $\Sigma_k$ could be obtained by inverting the elements on
-the diagonal of the covariance matrix.
-
-@subsection gmm-maximization-step  Maximization step
-
-The M step estimates the parameters of the Gaussian mixture components
-and the prior probabilities $\pi_k$ given the auxiliary distribution
-on the point-to-cluster assignments computed in the E step. Since all
-the variables are now ``observed'', the estimate is quite simple. For
-example, the mean $\mu_k$ of a Gaussian mode is obtained as the mean
-of the data points assigned to it (accounting for the strength of the
-soft assignments). The other quantities are obtained in a similar
-manner, yielding to:
-
-@f{align*}
- \mu_k &= { { \sum_{i=1}^n q_{ik} \bx_{i} } \over { \sum_{i=1}^n q_{ik} } },
-\\
- \Sigma_k &= { { \sum_{i=1}^n { q_{ik} (\bx_{i} - \mu_{k}) {(\bx_{i} - \mu_{k})}^T } } \over { \sum_{i=1}^n q_{ik} } },
-\\
- \pi_k &= { \sum_{i=1}^n { q_{ik} } \over { \sum_{i=1}^n \sum_{l=1}^K q_{il} } }.
-@f}
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section gmm-fundamentals-init Initialization algorithms
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The EM algorithm is a local optimization method. As such, the quality
-of the solution strongly depends on the quality of the initial values
-of the parameters (i.e.  of the locations and shapes of the Gaussian
-modes).
-
-@ref gmm.h supports the following cluster initialization algorithms:
-
-- <b>Random data points.</b> (::vl_gmm_init_with_rand_data) This method
-  sets the means of the modes by sampling at random a corresponding
-  number of data points, sets the covariance matrices of all the modes
-  are to the covariance of the entire dataset, and sets the prior
-  probabilities of the Gaussian modes to be uniform. This
-  initialization method is the fastest, simplest, as well as the one
-  most likely to end in a bad local minimum.
-
-- <b>KMeans initialization</b> (::vl_gmm_init_with_kmeans) This
-  method uses KMeans to pre-cluster the points. It then sets the means
-  and covariances of the Gaussian distributions the sample means and
-  covariances of each KMeans cluster. It also sets the prior
-  probabilities to be proportional to the mass of each cluster. In
-  order to use this initialization method, a user can specify an
-  instance of ::VlKMeans by using the function
-  ::vl_gmm_set_kmeans_init_object, or let ::VlGMM create one
-  automatically.
-
-Alternatively, one can manually specify a starting point
-(::vl_gmm_set_priors, ::vl_gmm_set_means, ::vl_gmm_set_covariances).
-**/
-
-#include "gmm.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _OPENMP
-#include <omp.h>
-#endif
-
-#ifndef VL_DISABLE_SSE2
-#include "mathop_sse2.h"
-#endif
-
-#ifndef VL_DISABLE_AVX
-#include "mathop_avx.h"
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_GMM_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-#define VL_GMM_MIN_VARIANCE 1e-6
-#define VL_GMM_MIN_POSTERIOR 1e-2
-#define VL_GMM_MIN_PRIOR 1e-6
-
-struct _VlGMM
-{
-  vl_type dataType ;                  /**< Data type. */
-  vl_size dimension ;                 /**< Data dimensionality. */
-  vl_size numClusters ;               /**< Number of clusters  */
-  vl_size numData ;                   /**< Number of last time clustered data points.  */
-  vl_size maxNumIterations ;          /**< Maximum number of refinement iterations. */
-  vl_size numRepetitions   ;          /**< Number of clustering repetitions. */
-  int     verbosity ;                 /**< Verbosity level. */
-  void *  means;                      /**< Means of Gaussian modes. */
-  void *  covariances;                /**< Diagonals of covariance matrices of Gaussian modes. */
-  void *  priors;                     /**< Weights of Gaussian modes. */
-  void *  posteriors;                 /**< Probabilities of correspondences of points to clusters. */
-  double * sigmaLowBound ;            /**< Lower bound on the diagonal covariance values. */
-  VlGMMInitialization initialization; /**< Initialization option */
-  VlKMeans * kmeansInit;              /**< Kmeans object for initialization of gaussians */
-  double LL ;                         /**< Current solution loglikelihood */
-  vl_bool kmeansInitIsOwner; /**< Indicates whether a user provided the kmeans initialization object */
-} ;
-
-/* ---------------------------------------------------------------- */
-/*                                                       Life-cycle */
-/* ---------------------------------------------------------------- */
-
-static void
-_vl_gmm_prepare_for_data (VlGMM* self, vl_size numData)
-{
-  if (self->numData < numData) {
-    vl_free(self->posteriors) ;
-    self->posteriors = vl_malloc(vl_get_type_size(self->dataType) * numData * self->numClusters) ;
-  }
-  self->numData = numData ;
-}
-
-/** @brief Create a new GMM object
- ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
- ** @param dimension dimension of the data.
- ** @param numComponents number of Gaussian mixture components.
- ** @return new GMM object instance.
- **/
-
-VlGMM *
-vl_gmm_new (vl_type dataType, vl_size dimension, vl_size numComponents)
-{
-  vl_index i ;
-  vl_size size = vl_get_type_size(dataType) ;
-  VlGMM * self = vl_calloc(1, sizeof(VlGMM)) ;
-  self->dataType = dataType;
-  self->numClusters = numComponents ;
-  self->numData = 0;
-  self->dimension = dimension ;
-  self->initialization = VlGMMRand;
-  self->verbosity = 0 ;
-  self->maxNumIterations = 50;
-  self->numRepetitions = 1;
-  self->sigmaLowBound =  NULL ;
-  self->priors = NULL ;
-  self->covariances = NULL ;
-  self->means = NULL ;
-  self->posteriors = NULL ;
-  self->kmeansInit = NULL ;
-  self->kmeansInitIsOwner = VL_FALSE;
-
-  self->priors = vl_calloc (numComponents, size) ;
-  self->means = vl_calloc (numComponents * dimension, size) ;
-  self->covariances = vl_calloc (numComponents * dimension, size) ;
-  self->sigmaLowBound = vl_calloc (dimension, sizeof(double)) ;
-
-  for (i = 0 ; i < (unsigned)self->dimension ; ++i)  { self->sigmaLowBound[i] = 1e-4 ; }
-  return self ;
-}
-
-/** @brief Reset state
- ** @param self object.
- **
- ** The function reset the state of the GMM object. It deletes
- ** any stored posterior and other internal state variables.
- **/
-
-void
-vl_gmm_reset (VlGMM * self)
-{
-  if (self->posteriors) {
-    vl_free(self->posteriors) ;
-    self->posteriors = NULL ;
-    self->numData = 0 ;
-  }
-  if (self->kmeansInit && self->kmeansInitIsOwner) {
-    vl_kmeans_delete(self->kmeansInit) ;
-    self->kmeansInit = NULL ;
-    self->kmeansInitIsOwner = VL_FALSE ;
-  }
-}
-
-/** @brief Deletes a GMM object
- ** @param self GMM object instance.
- **
- ** The function deletes the GMM object instance created
- ** by ::vl_gmm_new.
- **/
-
-void
-vl_gmm_delete (VlGMM * self)
-{
-  if(self->means) vl_free(self->means);
-  if(self->covariances) vl_free(self->covariances);
-  if(self->priors) vl_free(self->priors);
-  if(self->posteriors) vl_free(self->posteriors);
-  if(self->kmeansInit && self->kmeansInitIsOwner) {
-    vl_kmeans_delete(self->kmeansInit);
-  }
-  vl_free(self);
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Getters and setters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get data type
- ** @param self object
- ** @return data type.
- **/
-
-vl_type
-vl_gmm_get_data_type (VlGMM const * self)
-{
-  return self->dataType ;
-}
-
-/** @brief Get the number of clusters
- ** @param self object
- ** @return number of clusters.
- **/
-
-vl_size
-vl_gmm_get_num_clusters (VlGMM const * self)
-{
-  return self->numClusters ;
-}
-
-/** @brief Get the number of data points
- ** @param self object
- ** @return number of data points.
- **/
-
-vl_size
-vl_gmm_get_num_data (VlGMM const * self)
-{
-  return self->numData ;
-}
-
-/** @brief Get the log likelihood of the current mixture
- ** @param self object
- ** @return loglikelihood.
- **/
-
-double
-vl_gmm_get_loglikelihood (VlGMM const * self)
-{
-  return self->LL ;
-}
-
-/** @brief Get verbosity level
- ** @param self object
- ** @return verbosity level.
- **/
-
-int
-vl_gmm_get_verbosity (VlGMM const * self)
-{
-  return self->verbosity ;
-}
-
-/** @brief Set verbosity level
- ** @param self object
- ** @param verbosity verbosity level.
- **/
-
-void
-vl_gmm_set_verbosity (VlGMM * self, int verbosity)
-{
-  self->verbosity = verbosity ;
-}
-
-/** @brief Get means
- ** @param self object
- ** @return cluster means.
- **/
-
-void const *
-vl_gmm_get_means (VlGMM const * self)
-{
-  return self->means ;
-}
-
-/** @brief Get covariances
- ** @param self object
- ** @return diagonals of cluster covariance matrices.
- **/
-
-void const *
-vl_gmm_get_covariances (VlGMM const * self)
-{
-  return self->covariances ;
-}
-
-/** @brief Get priors
- ** @param self object
- ** @return priors of cluster gaussians.
- **/
-
-void const *
-vl_gmm_get_priors (VlGMM const * self)
-{
-  return self->priors ;
-}
-
-/** @brief Get posteriors
- ** @param self object
- ** @return posterior probabilities of cluster memberships.
- **/
-
-void const *
-vl_gmm_get_posteriors (VlGMM const * self)
-{
-  return self->posteriors ;
-}
-
-/** @brief Get maximum number of iterations
- ** @param self object
- ** @return maximum number of iterations.
- **/
-
-vl_size
-vl_gmm_get_max_num_iterations (VlGMM const * self)
-{
-  return self->maxNumIterations ;
-}
-
-/** @brief Set maximum number of iterations
- ** @param self VlGMM filter.
- ** @param maxNumIterations maximum number of iterations.
- **/
-
-void
-vl_gmm_set_max_num_iterations (VlGMM * self, vl_size maxNumIterations)
-{
-  self->maxNumIterations = maxNumIterations ;
-}
-
-/** @brief Get maximum number of repetitions.
- ** @param self object
- ** @return current number of repretitions for quantization.
- **/
-
-vl_size
-vl_gmm_get_num_repetitions (VlGMM const * self)
-{
-  return self->numRepetitions ;
-}
-
-/** @brief Set maximum number of repetitions
- ** @param self object
- ** @param numRepetitions maximum number of repetitions.
- ** The number of repetitions cannot be smaller than 1.
- **/
-
-void
-vl_gmm_set_num_repetitions (VlGMM * self, vl_size numRepetitions)
-{
-  assert (numRepetitions >= 1) ;
-  self->numRepetitions = numRepetitions ;
-}
-
-/** @brief Get data dimension
- ** @param self object
- ** @return data dimension.
- **/
-
-vl_size
-vl_gmm_get_dimension (VlGMM const * self)
-{
-  return self->dimension ;
-}
-
-/** @brief Get initialization algorithm
- ** @param self object
- ** @return initialization algorithm.
- **/
-
-VlGMMInitialization
-vl_gmm_get_initialization (VlGMM const * self)
-{
-  return self->initialization ;
-}
-
-/** @brief Set initialization algorithm.
- ** @param self object
- ** @param init initialization algorithm.
- **/
-void
-vl_gmm_set_initialization (VlGMM * self, VlGMMInitialization init)
-{
-  self->initialization = init;
-}
-
-/** @brief Get KMeans initialization object.
- ** @param self object
- ** @return kmeans initialization object.
- **/
-VlKMeans * vl_gmm_get_kmeans_init_object (VlGMM const * self)
-{
-  return self->kmeansInit;
-}
-
-/** @brief Set KMeans initialization object.
- ** @param self object
- ** @param kmeans initialization KMeans object.
- **/
-void vl_gmm_set_kmeans_init_object (VlGMM * self, VlKMeans * kmeans)
-{
-  if (self->kmeansInit && self->kmeansInitIsOwner) {
-    vl_kmeans_delete(self->kmeansInit) ;
-  }
-  self->kmeansInit = kmeans;
-  self->kmeansInitIsOwner = VL_FALSE;
-}
-
-/** @brief Get the lower bound on the diagonal covariance values.
- ** @param self object
- ** @return lower bound on covariances.
- **/
-double const * vl_gmm_get_covariance_lower_bounds (VlGMM const * self)
-{
-  return self->sigmaLowBound;
-}
-
-/** @brief Set the lower bounds on diagonal covariance values.
- ** @param self object.
- ** @param bounds bounds.
- **
- ** There is one lower bound per dimension. Use ::vl_gmm_set_covariance_lower_bound
- ** to set all of them to a given scalar.
- **/
-void vl_gmm_set_covariance_lower_bounds (VlGMM * self, double const * bounds)
-{
-  memcpy(self->sigmaLowBound, bounds, sizeof(double) * self->dimension) ;
-}
-
-/** @brief Set the lower bounds on diagonal covariance values.
- ** @param self object.
- ** @param bound bound.
- **
- ** While there is one lower bound per dimension, this function sets
- ** all of them to the specified scalar. Use ::vl_gmm_set_covariance_lower_bounds
- ** to set them individually.
- **/
-void vl_gmm_set_covariance_lower_bound (VlGMM * self, double bound)
-{
-  int i ;
-  for (i = 0 ; i < (signed)self->dimension ; ++i) {
-    self->sigmaLowBound[i] = bound ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/* Instantiate shuffle algorithm */
-
-#define VL_SHUFFLE_type vl_uindex
-#define VL_SHUFFLE_prefix _vl_gmm
-#include "shuffle-def.h"
-
-/* #ifdef VL_GMM_INSTANTITATING */
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifdef VL_GMM_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-/* ---------------------------------------------------------------- */
-/*                                            Posterior assignments */
-/* ---------------------------------------------------------------- */
-
-/** @fn vl_get_gmm_data_posterior_f(float*,vl_size,vl_size,float const*,float const*,vl_size,float const*,float const*)
- ** @brief Get Gaussian modes posterior probabilities
- ** @param posteriors posterior probabilities (output)/
- ** @param numClusters number of modes in the GMM model.
- ** @param numData number of data elements.
- ** @param priors prior mode probabilities of the GMM model.
- ** @param means means of the GMM model.
- ** @param dimension data dimension.
- ** @param covariances diagonal covariances of the GMM model.
- ** @param data data.
- ** @return data log-likelihood.
- **
- ** This is a helper function that does not require a ::VlGMM object
- ** instance to operate.
- **/
-
-double
-VL_XCAT(vl_get_gmm_data_posteriors_, SFX)
-(TYPE * posteriors,
- vl_size numClusters,
- vl_size numData,
- TYPE const * priors,
- TYPE const * means,
- vl_size dimension,
- TYPE const * covariances,
- TYPE const * data)
-{
-  vl_index i_d, i_cl;
-  vl_size dim;
-  double LL = 0;
-
-  TYPE halfDimLog2Pi = (dimension / 2.0) * log(2.0*VL_PI);
-  TYPE * logCovariances ;
-  TYPE * logWeights ;
-  TYPE * invCovariances ;
-
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVector3ComparisonFunction distFn = vl_get_vector_3_comparison_function_f(VlDistanceMahalanobis) ;
-#else
-  VlDoubleVector3ComparisonFunction distFn = vl_get_vector_3_comparison_function_d(VlDistanceMahalanobis) ;
-#endif
-
-  logCovariances = vl_malloc(sizeof(TYPE) * numClusters) ;
-  invCovariances = vl_malloc(sizeof(TYPE) * numClusters * dimension) ;
-  logWeights = vl_malloc(sizeof(TYPE) * numClusters) ;
-
-#if defined(_OPENMP)
-#pragma omp parallel for private(i_cl,dim) num_threads(vl_get_max_threads())
-#endif
-  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
-    TYPE logSigma = 0 ;
-    if (priors[i_cl] < VL_GMM_MIN_PRIOR) {
-      logWeights[i_cl] = - (TYPE) VL_INFINITY_D ;
-    } else {
-      logWeights[i_cl] = log(priors[i_cl]);
-    }
-    for(dim = 0 ; dim < dimension ; ++ dim) {
-      logSigma += log(covariances[i_cl*dimension + dim]);
-      invCovariances [i_cl*dimension + dim] = (TYPE) 1.0 / covariances[i_cl*dimension + dim];
-    }
-    logCovariances[i_cl] = logSigma;
-  } /* end of parallel region */
-
-#if defined(_OPENMP)
-#pragma omp parallel for private(i_cl,i_d) reduction(+:LL) \
-num_threads(vl_get_max_threads())
-#endif
-  for (i_d = 0 ; i_d < (signed)numData ; ++ i_d) {
-    TYPE clusterPosteriorsSum = 0;
-    TYPE maxPosterior = (TYPE)(-VL_INFINITY_D) ;
-
-    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
-      TYPE p =
-      logWeights[i_cl]
-      - halfDimLog2Pi
-      - 0.5 * logCovariances[i_cl]
-      - 0.5 * distFn (dimension,
-                      data + i_d * dimension,
-                      means + i_cl * dimension,
-                      invCovariances + i_cl * dimension) ;
-      posteriors[i_cl + i_d * numClusters] = p ;
-      if (p > maxPosterior) { maxPosterior = p ; }
-    }
-
-    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-      TYPE p = posteriors[i_cl + i_d * numClusters] ;
-      p =  exp(p - maxPosterior) ;
-      posteriors[i_cl + i_d * numClusters] = p ;
-      clusterPosteriorsSum += p ;
-    }
-
-    LL +=  log(clusterPosteriorsSum) + (double) maxPosterior ;
-
-    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-      posteriors[i_cl + i_d * numClusters] /= clusterPosteriorsSum ;
-    }
-  } /* end of parallel region */
-
-  vl_free(logCovariances);
-  vl_free(logWeights);
-  vl_free(invCovariances);
-
-  return LL;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                 Restarts zero-weighted Gaussians */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_gmm_maximization_, SFX)
-(VlGMM * self,
- TYPE * posteriors,
- TYPE * priors,
- TYPE * covariances,
- TYPE * means,
- TYPE const * data,
- vl_size numData) ;
-
-static vl_size
-VL_XCAT(_vl_gmm_restart_empty_modes_, SFX) (VlGMM * self, TYPE const * data)
-{
-  vl_size dimension = self->dimension;
-  vl_size numClusters = self->numClusters;
-  vl_index i_cl, j_cl, i_d, d;
-  vl_size zeroWNum = 0;
-  TYPE * priors = (TYPE*)self->priors ;
-  TYPE * means = (TYPE*)self->means ;
-  TYPE * covariances = (TYPE*)self->covariances ;
-  TYPE * posteriors = (TYPE*)self->posteriors ;
-
-  //VlRand * rand = vl_get_rand() ;
-
-  TYPE * mass = vl_calloc(sizeof(TYPE), self->numClusters) ;
-
-  if (numClusters <= 1) { return 0 ; }
-
-  /* compute statistics */
-  {
-    vl_uindex i, k ;
-    vl_size numNullAssignments = 0 ;
-    for (i = 0 ; i < self->numData ; ++i) {
-      for (k = 0 ; k < self->numClusters ; ++k) {
-        TYPE p = ((TYPE*)self->posteriors)[k + i * self->numClusters] ;
-        mass[k] += p ;
-        if (p < VL_GMM_MIN_POSTERIOR) {
-          numNullAssignments ++ ;
-        }
-      }
-    }
-    if (self->verbosity) {
-      VL_PRINTF("gmm: sparsity of data posterior: %.1f%%\n", (double)numNullAssignments / (self->numData * self->numClusters) * 100) ;
-    }
-  }
-
-#if 0
-  /* search for cluster with negligible weight and reassign them to fat clusters */
-  for (i_cl = 0 ; i_cl < numClusters ; ++i_cl) {
-    if (priors[i_cl] < 0.00001/numClusters) {
-      double mass = priors[0]  ;
-      vl_index best = 0 ;
-
-      for (j_cl = 1 ; j_cl < numClusters ; ++j_cl) {
-        if (priors[j_cl] > mass) { mass = priors[j_cl] ; best = j_cl ; }
-      }
-
-      if (j_cl == i_cl) {
-        /* this should never happen */
-        continue ;
-      }
-
-      j_cl = best ;
-      zeroWNum ++ ;
-
-      VL_PRINTF("gmm: restarting mode %d by splitting mode %d (with prior %f)\n", i_cl,j_cl,mass) ;
-
-      priors[i_cl] = mass/2 ;
-      priors[j_cl] = mass/2 ;
-      for (d = 0 ; d < dimension ; ++d) {
-        TYPE sigma2 =  covariances[j_cl*dimension + d] ;
-        TYPE sigma = VL_XCAT(vl_sqrt_,SFX)(sigma2) ;
-        means[i_cl*dimension + d] = means[j_cl*dimension + d] + 0.001 * (vl_rand_real1(rand) - 0.5) * sigma ;
-        covariances[i_cl*dimension + d] = sigma2 ;
-      }
-    }
-  }
-#endif
-
-  /* search for cluster with negligible weight and reassign them to fat clusters */
-  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-    double size = - VL_INFINITY_D ;
-    vl_index best = -1 ;
-
-    if (mass[i_cl] >= VL_GMM_MIN_POSTERIOR *
-        VL_MAX(1.0, (double) self->numData / self->numClusters))
-    {
-      continue ;
-    }
-
-    if (self->verbosity) {
-      VL_PRINTF("gmm: mode %d is nearly empty (mass %f)\n", i_cl, mass[i_cl]) ;
-    }
-
-    /*
-     Search for the Gaussian components that (approximately)
-     maximally contribute to make the negative log-likelihood of the data
-     large. Then split the worst offender.
-     
-     To do so, we approximate the exptected log-likelihood of the GMM:
-     
-     E[-log(f(x))] = H(f) = - log \int f(x) log f(x)
-    
-     where the density f(x) = sum_k pk gk(x) is a GMM. This is intractable
-     but it is easy to approximate if we suppose that supp gk is disjoint with
-     supp gq for all components k ~= q. In this canse
-     
-     H(f) ~= sum_k [ - pk log(pk) + pk H(gk) ]
-     
-     where H(gk) is the entropy of component k taken alone. The entropy of
-     the latter is given by:
-     
-     H(gk) = D/2 (1 + log(2pi) + 1/2 sum_{i=0}^D log sigma_i^2
-
-     */
-
-    for (j_cl = 0 ; j_cl < (signed)numClusters ; ++j_cl) {
-      double size_ ;
-      if (priors[j_cl] < VL_GMM_MIN_PRIOR) { continue ; }
-      size_ = + 0.5 * dimension * (1.0 + log(2*VL_PI)) ;
-      for(d = 0 ; d < (signed)dimension ; d++) {
-        double sigma2 = covariances[j_cl * dimension + d] ;
-        size_ += 0.5 * log(sigma2) ;
-      }
-      size_ = priors[j_cl] * (size_ - log(priors[j_cl])) ;
-
-      if (self->verbosity > 1) {
-        VL_PRINTF("gmm: mode %d: prior %f, mass %f, entropy contribution %f\n",
-                  j_cl, priors[j_cl], mass[j_cl], size_) ;
-      }
-
-      if (size_ > size) {
-        size = size_ ;
-        best = j_cl ;
-      }
-    }
-
-    j_cl = best ;
-
-    if (j_cl == i_cl || j_cl < 0) {
-      if (self->verbosity) {
-        VL_PRINTF("gmm: mode %d is empty, "
-                  "but no other mode to split could be found\n", i_cl) ;
-      }
-      continue ;
-    }
-
-    if (self->verbosity) {
-      VL_PRINTF("gmm: reinitializing empty mode %d with mode %d (prior %f, mass %f, score %f)\n",
-                i_cl, j_cl, priors[j_cl], mass[j_cl], size) ;
-    }
-
-    /*
-     Search for the dimension with maximum variance.
-     */
-
-    size = - VL_INFINITY_D ;
-    best = - 1 ;
-
-    for(d = 0; d < (signed)dimension; d++) {
-      double sigma2 = covariances[j_cl * dimension + d] ;
-      if (sigma2 > size) {
-        size = sigma2 ;
-        best = d ;
-      }
-    }
-
-    /*
-     Reassign points j_cl (mode to split) to i_cl (empty mode).
-     */
-    {
-      TYPE mu = means[best + j_cl * self->dimension] ;
-      for(i_d = 0 ; i_d < (signed)self->numData ; ++ i_d) {
-        TYPE p = posteriors[j_cl + self->numClusters * i_d] ;
-        TYPE q = posteriors[i_cl + self->numClusters * i_d] ; /* ~= 0 */
-        if (data[best + i_d * self->dimension] < mu) {
-          /* assign this point to i_cl */
-          posteriors[i_cl + self->numClusters * i_d] = p + q ;
-          posteriors[j_cl + self->numClusters * i_d] = 0 ;
-        } else {
-          /* assign this point to j_cl */
-          posteriors[i_cl + self->numClusters * i_d] = 0 ;
-          posteriors[j_cl + self->numClusters * i_d] = p + q ;
-        }
-      }
-    }
-
-    /*
-     Re-estimate.
-     */
-    VL_XCAT(_vl_gmm_maximization_, SFX)
-    (self,posteriors,priors,covariances,means,data,self->numData) ;
-  }
-
-  return zeroWNum;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                          Helpers */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_gmm_apply_bounds_, SFX)(VlGMM * self)
-{
-  vl_uindex dim ;
-  vl_uindex k ;
-  vl_size numAdjusted = 0 ;
-  TYPE * cov = (TYPE*)self->covariances ;
-  double const * lbs = self->sigmaLowBound ;
-
-  for (k = 0 ; k < self->numClusters ; ++k) {
-    vl_bool adjusted = VL_FALSE ;
-    for (dim = 0 ; dim < self->dimension ; ++dim) {
-      if (cov[k * self->dimension + dim] < lbs[dim] ) {
-        cov[k * self->dimension + dim] = lbs[dim] ;
-        adjusted = VL_TRUE ;
-      }
-    }
-    if (adjusted) { numAdjusted ++ ; }
-  }
-
-  if (numAdjusted > 0 && self->verbosity > 0) {
-    VL_PRINT("gmm: detected %d of %d modes with at least one dimension "
-             "with covariance too small (set to lower bound)\n",
-             numAdjusted, self->numClusters) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                           EM - Maximization step */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_gmm_maximization_, SFX)
-(VlGMM * self,
- TYPE * posteriors,
- TYPE * priors,
- TYPE * covariances,
- TYPE * means,
- TYPE const * data,
- vl_size numData)
-{
-  vl_size numClusters = self->numClusters;
-  vl_index i_d, i_cl;
-  vl_size dim ;
-  TYPE * oldMeans ;
-  double time = 0 ;
-
-  if (self->verbosity > 1) {
-    VL_PRINTF("gmm: em: entering maximization step\n") ;
-    time = vl_get_cpu_time() ;
-  }
-
-  oldMeans = vl_malloc(sizeof(TYPE) * self->dimension * numClusters) ;
-  memcpy(oldMeans, means, sizeof(TYPE) * self->dimension * numClusters) ;
-
-  memset(priors, 0, sizeof(TYPE) * numClusters) ;
-  memset(means, 0, sizeof(TYPE) * self->dimension * numClusters) ;
-  memset(covariances, 0, sizeof(TYPE) * self->dimension * numClusters) ;
-
-#if defined(_OPENMP)
-#pragma omp parallel default(shared) private(i_d, i_cl, dim) \
-                     num_threads(vl_get_max_threads())
-#endif
-  {
-    TYPE * clusterPosteriorSum_, * means_, * covariances_ ;
-
-#if defined(_OPENMP)
-#pragma omp critical
-#endif
-    {
-      clusterPosteriorSum_ = vl_calloc(sizeof(TYPE), numClusters) ;
-      means_ = vl_calloc(sizeof(TYPE), self->dimension * numClusters) ;
-      covariances_ = vl_calloc(sizeof(TYPE), self->dimension * numClusters) ;
-    }
-
-    /*
-      Accumulate weighted sums and sum of square differences. Once normalized,
-      these become the means and covariances of each Gaussian mode.
-
-      The squared differences will be taken w.r.t. the old means however. In this manner,
-      one avoids doing two passes across the data. Eventually, these are corrected to account
-      for the new means properly. In principle, one could set the old means to zero, but
-      this may cause numerical instabilities (by accumulating large squares).
-    */
-
-#if defined(_OPENMP)
-#pragma omp for
-#endif
-    for (i_d = 0 ; i_d < (signed)numData ; ++i_d) {
-      for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-        TYPE p = posteriors[i_cl + i_d * self->numClusters] ;
-        vl_bool calculated = VL_FALSE ;
-
-        /* skip very small associations for speed */
-        if (p < VL_GMM_MIN_POSTERIOR / numClusters) { continue ; }
-
-        clusterPosteriorSum_ [i_cl] += p ;
-
-        #ifndef VL_DISABLE_AVX
-        if (vl_get_simd_enabled() && vl_cpu_has_avx()) {
-          VL_XCAT(_vl_weighted_mean_avx_, SFX)
-          (self->dimension,
-           means_+ i_cl * self->dimension,
-           data + i_d * self->dimension,
-           p) ;
-
-          VL_XCAT(_vl_weighted_sigma_avx_, SFX)
-          (self->dimension,
-           covariances_ + i_cl * self->dimension,
-           data + i_d * self->dimension,
-           oldMeans + i_cl * self->dimension,
-           p) ;
-
-          calculated = VL_TRUE;
-        }
-        #endif
-        #ifndef VL_DISABLE_SSE2
-        if (vl_get_simd_enabled() && vl_cpu_has_sse2() && !calculated) {
-          VL_XCAT(_vl_weighted_mean_sse2_, SFX)
-          (self->dimension,
-           means_+ i_cl * self->dimension,
-           data + i_d * self->dimension,
-           p) ;
-
-           VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
-          (self->dimension,
-           covariances_ + i_cl * self->dimension,
-           data + i_d * self->dimension,
-           oldMeans + i_cl * self->dimension,
-           p) ;
-
-          calculated = VL_TRUE;
-        }
-        #endif
-        if(!calculated) {
-          for (dim = 0 ; dim < self->dimension ; ++dim) {
-            TYPE x = data[i_d * self->dimension + dim] ;
-            TYPE mu = oldMeans[i_cl * self->dimension + dim] ;
-            TYPE diff = x - mu ;
-            means_ [i_cl * self->dimension + dim] += p * x ;
-            covariances_ [i_cl * self->dimension + dim] += p * (diff*diff) ;
-          }
-        }
-      }
-    }
-
-    /* accumulate */
-#if defined(_OPENMP)
-#pragma omp critical
-#endif
-    {
-      for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-        priors [i_cl] += clusterPosteriorSum_ [i_cl];
-        for (dim = 0 ; dim < self->dimension ; ++dim) {
-          means [i_cl * self->dimension + dim] += means_ [i_cl * self->dimension + dim] ;
-          covariances [i_cl * self->dimension + dim] += covariances_ [i_cl * self->dimension + dim] ;
-        }
-      }
-      vl_free(means_);
-      vl_free(covariances_);
-      vl_free(clusterPosteriorSum_);
-    }
-  } /* parallel section */
-
-  /* at this stage priors[] contains the total mass of each cluster */
-  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
-    TYPE mass = priors[i_cl] ;
-    /* do not update modes that do not recieve mass */
-    if (mass >= 1e-6 / numClusters) {
-      for (dim = 0 ; dim < self->dimension ; ++dim) {
-        means[i_cl * self->dimension + dim] /= mass ;
-        covariances[i_cl * self->dimension + dim] /= mass ;
-      }
-    }
-  }
-
-  /* apply old to new means correction */
-  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
-    TYPE mass = priors[i_cl] ;
-    if (mass >= 1e-6 / numClusters) {
-      for (dim = 0 ; dim < self->dimension ; ++dim) {
-        TYPE mu = means[i_cl * self->dimension + dim] ;
-        TYPE oldMu = oldMeans[i_cl * self->dimension + dim] ;
-        TYPE diff = mu - oldMu ;
-        covariances[i_cl * self->dimension + dim] -= diff * diff ;
-      }
-    }
-  }
-
-  VL_XCAT(_vl_gmm_apply_bounds_,SFX)(self) ;
-
-  {
-    TYPE sum = 0;
-    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-      sum += priors[i_cl] ;
-    }
-    sum = VL_MAX(sum, 1e-12) ;
-    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
-      priors[i_cl] /= sum ;
-    }
-  }
-
-  if (self->verbosity > 1) {
-    VL_PRINTF("gmm: em: maximization step completed in %.2f s\n",
-              vl_get_cpu_time() - time) ;
-  }
-
-  vl_free(oldMeans);
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                    EM iterations */
-/* ---------------------------------------------------------------- */
-
-
-static double
-VL_XCAT(_vl_gmm_em_, SFX)
-(VlGMM * self,
- TYPE const * data,
- vl_size numData)
-{
-  vl_size iteration, restarted ;
-  double previousLL = (TYPE)(-VL_INFINITY_D) ;
-  double LL = (TYPE)(-VL_INFINITY_D) ;
-  double time = 0 ;
-
-  _vl_gmm_prepare_for_data (self, numData) ;
-
-  VL_XCAT(_vl_gmm_apply_bounds_,SFX)(self) ;
-
-  for (iteration = 0 ; 1 ; ++ iteration) {
-    double eps ;
-
-    /*
-     Expectation: assign data to Gaussian modes
-     and compute log-likelihood.
-     */
-
-    if (self->verbosity > 1) {
-      VL_PRINTF("gmm: em: entering expectation step\n") ;
-      time = vl_get_cpu_time() ;
-    }
-
-    LL = VL_XCAT(vl_get_gmm_data_posteriors_,SFX)
-    (self->posteriors,
-     self->numClusters,
-     numData,
-     self->priors,
-     self->means,
-     self->dimension,
-     self->covariances,
-     data) ;
-
-    if (self->verbosity > 1) {
-      VL_PRINTF("gmm: em: expectation step completed in %.2f s\n",
-                vl_get_cpu_time() - time) ;
-    }
-
-    /*
-     Check the termination conditions.
-     */
-    if (self->verbosity) {
-      VL_PRINTF("gmm: em: iteration %d: loglikelihood = %f (variation = %f)\n",
-                iteration, LL, LL - previousLL) ;
-    }
-    if (iteration >= self->maxNumIterations) {
-      if (self->verbosity) {
-        VL_PRINTF("gmm: em: terminating because "
-                  "the maximum number of iterations "
-                  "(%d) has been reached.\n", self->maxNumIterations) ;
-      }
-      break ;
-    }
-
-    eps = vl_abs_d ((LL - previousLL) / (LL));
-    if ((iteration > 0) && (eps < 0.00001)) {
-      if (self->verbosity) {
-        VL_PRINTF("gmm: em: terminating because the algorithm "
-                  "fully converged (log-likelihood variation = %f).\n", eps) ;
-      }
-      break ;
-    }
-    previousLL = LL ;
-
-    /*
-     Restart empty modes.
-     */
-    if (iteration > 1) {
-      restarted = VL_XCAT(_vl_gmm_restart_empty_modes_, SFX)
-        (self, data);
-      if ((restarted > 0) & (self->verbosity > 0)) {
-        VL_PRINTF("gmm: em: %d Gaussian modes restarted because "
-                  "they had become empty.\n", restarted);
-      }
-    }
-
-    /*
-      Maximization: reestimate the GMM parameters.
-    */
-    VL_XCAT(_vl_gmm_maximization_, SFX)
-      (self,self->posteriors,self->priors,self->covariances,self->means,data,numData) ;
-  }
-  return LL;
-}
-
-
-/* ---------------------------------------------------------------- */
-/*                                Kmeans initialization of mixtures */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_gmm_init_with_kmeans_, SFX)
-(VlGMM * self,
- TYPE const * data,
- vl_size numData,
- VlKMeans * kmeansInit)
-{
-  vl_size i_d ;
-  vl_uint32 * assignments = vl_malloc(sizeof(vl_uint32) * numData);
-
-  _vl_gmm_prepare_for_data (self, numData) ;
-
-  memset(self->means,0,sizeof(TYPE) * self->numClusters * self->dimension) ;
-  memset(self->priors,0,sizeof(TYPE) * self->numClusters) ;
-  memset(self->covariances,0,sizeof(TYPE) * self->numClusters * self->dimension) ;
-  memset(self->posteriors,0,sizeof(TYPE) * self->numClusters * numData) ;
-
-  /* setup speified KMeans initialization object if any */
-  if (kmeansInit) { vl_gmm_set_kmeans_init_object (self, kmeansInit) ; }
-
-  /* if a KMeans initalization object is still unavailable, create one */
-  if(self->kmeansInit == NULL) {
-    vl_size ncomparisons = VL_MAX(numData / 4, 10) ;
-    vl_size niter = 5 ;
-    vl_size ntrees = 1 ;
-    vl_size nrepetitions = 1 ;
-    VlKMeansAlgorithm algorithm = VlKMeansANN ;
-    VlKMeansInitialization initialization = VlKMeansRandomSelection ;
-
-    VlKMeans * kmeansInitDefault = vl_kmeans_new(self->dataType,VlDistanceL2) ;
-    vl_kmeans_set_initialization(kmeansInitDefault, initialization);
-    vl_kmeans_set_max_num_iterations (kmeansInitDefault, niter) ;
-    vl_kmeans_set_max_num_comparisons (kmeansInitDefault, ncomparisons) ;
-    vl_kmeans_set_num_trees (kmeansInitDefault, ntrees);
-    vl_kmeans_set_algorithm (kmeansInitDefault, algorithm);
-    vl_kmeans_set_num_repetitions(kmeansInitDefault, nrepetitions);
-    vl_kmeans_set_verbosity (kmeansInitDefault, self->verbosity);
-
-    self->kmeansInit = kmeansInitDefault;
-    self->kmeansInitIsOwner = VL_TRUE ;
-  }
-
-  /* Use k-means to assign data to clusters */
-  vl_kmeans_cluster (self->kmeansInit, data, self->dimension, numData, self->numClusters);
-  vl_kmeans_quantize (self->kmeansInit, assignments, NULL, data, numData) ;
-
-  /* Transform the k-means assignments in posteriors and estimates the mode parameters */
-  for(i_d = 0; i_d < numData; i_d++) {
-    ((TYPE*)self->posteriors)[assignments[i_d] + i_d * self->numClusters] = (TYPE) 1.0 ;
-  }
-
-  /* Update cluster parameters */
-  VL_XCAT(_vl_gmm_maximization_, SFX)
-    (self,self->posteriors,self->priors,self->covariances,self->means,data,numData);
-  vl_free(assignments) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                Random initialization of mixtures */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_gmm_compute_init_sigma_, SFX)
-(VlGMM * self,
- TYPE const * data,
- TYPE * initSigma,
- vl_size dimension,
- vl_size numData)
-{
-  vl_size dim;
-  vl_uindex i;
-
-  TYPE * dataMean ;
-
-  memset(initSigma,0,sizeof(TYPE)*dimension) ;
-  if (numData <= 1) return ;
-
-  dataMean = vl_malloc(sizeof(TYPE)*dimension);
-  memset(dataMean,0,sizeof(TYPE)*dimension) ;
-
-  /* find mean of the whole dataset */
-  for(dim = 0 ; dim < dimension ; dim++) {
-    for(i = 0 ; i < numData ; i++) {
-      dataMean[dim] += data[i*dimension + dim];
-    }
-    dataMean[dim] /= numData;
-  }
-
-  /* compute variance of the whole dataset */
-  for(dim = 0; dim < dimension; dim++) {
-    for(i = 0; i < numData; i++) {
-      TYPE diff = (data[i*self->dimension + dim] - dataMean[dim]) ;
-      initSigma[dim] += diff*diff ;
-    }
-    initSigma[dim] /= numData - 1 ;
-  }
-
-  vl_free(dataMean) ;
-}
-
-static void
-VL_XCAT(_vl_gmm_init_with_rand_data_, SFX)
-(VlGMM * self,
- TYPE const * data,
- vl_size numData)
-{
-  vl_uindex i, k, dim ;
-  VlKMeans * kmeans ;
-
-  _vl_gmm_prepare_for_data(self, numData) ;
-
-  /* initilaize priors of gaussians so they are equal and sum to one */
-  for (i = 0 ; i < self->numClusters ; ++i) { ((TYPE*)self->priors)[i] = (TYPE) (1.0 / self->numClusters) ; }
-
-  /* initialize diagonals of covariance matrices to data covariance */
-  VL_XCAT(_vl_gmm_compute_init_sigma_, SFX) (self, data, self->covariances, self->dimension, numData);
-  for (k = 1 ; k < self->numClusters ; ++ k) {
-    for(dim = 0; dim < self->dimension; dim++) {
-      *((TYPE*)self->covariances + k * self->dimension + dim) =
-      *((TYPE*)self->covariances + dim) ;
-    }
-  }
-
-  /* use kmeans++ initialization to pick points at random */
-  kmeans = vl_kmeans_new(self->dataType,VlDistanceL2) ;
-  vl_kmeans_init_centers_plus_plus(kmeans, data, self->dimension, numData, self->numClusters) ;
-  memcpy(self->means, vl_kmeans_get_centers(kmeans), sizeof(TYPE) * self->dimension * self->numClusters) ;
-  vl_kmeans_delete(kmeans) ;
-}
-
-/* ---------------------------------------------------------------- */
-#else /* VL_GMM_INSTANTIATING */
-/* ---------------------------------------------------------------- */
-
-#ifndef __DOXYGEN__
-#define FLT VL_TYPE_FLOAT
-#define TYPE float
-#define SFX f
-#define VL_GMM_INSTANTIATING
-#include "gmm.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define TYPE double
-#define SFX d
-#define VL_GMM_INSTANTIATING
-#include "gmm.c"
-#endif
-
-/* VL_GMM_INSTANTIATING */
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_GMM_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-/** @brief Create a new GMM object by copy
- ** @param self object.
- ** @return new copy.
- **
- ** Most parameters, including the cluster priors, means, and
- ** covariances are copied. Data posteriors (available after
- ** initalization or EM) are not; nor is the KMeans object used for
- ** initialization, if any.
- **/
-
-VlGMM *
-vl_gmm_new_copy (VlGMM const * self)
-{
-  vl_size size = vl_get_type_size(self->dataType) ;
-  VlGMM * gmm = vl_gmm_new(self->dataType, self->dimension, self->numClusters);
-  gmm->initialization = self->initialization;
-  gmm->maxNumIterations = self->maxNumIterations;
-  gmm->numRepetitions = self->numRepetitions;
-  gmm->verbosity = self->verbosity;
-  gmm->LL = self->LL;
-
-  memcpy(gmm->means, self->means, size*self->numClusters*self->dimension);
-  memcpy(gmm->covariances, self->covariances, size*self->numClusters*self->dimension);
-  memcpy(gmm->priors, self->priors, size*self->numClusters);
-  return gmm ;
-}
-
-/** @brief Initialize mixture before EM takes place using random initialization
- ** @param self GMM object instance.
- ** @param data data points which should be clustered.
- ** @param numData number of data points.
- **/
-
-void
-vl_gmm_init_with_rand_data
-(VlGMM * self,
- void const * data,
- vl_size numData)
-{
-  vl_gmm_reset (self) ;
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT : _vl_gmm_init_with_rand_data_f (self, (float const *)data, numData) ; break ;
-    case VL_TYPE_DOUBLE : _vl_gmm_init_with_rand_data_d (self, (double const *)data, numData) ; break ;
-    default:
-      abort() ;
-  }
-}
-
-/** @brief Initializes the GMM using KMeans
- ** @param self GMM object instance.
- ** @param data data points which should be clustered.
- ** @param numData number of data points.
- ** @param kmeansInit KMeans object to use.
- **/
-
-void
-vl_gmm_init_with_kmeans
-(VlGMM * self,
- void const * data,
- vl_size numData,
- VlKMeans * kmeansInit)
-{
-  vl_gmm_reset (self) ;
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_gmm_init_with_kmeans_f
-      (self, (float const *)data, numData, kmeansInit) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_gmm_init_with_kmeans_d
-      (self, (double const *)data, numData, kmeansInit) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-#if 0
-#include<fenv.h>
-#endif
-
-/** @brief Run GMM clustering - includes initialization and EM
- ** @param self GMM object instance.
- ** @param data data points which should be clustered.
- ** @param numData number of data points.
- **/
-
-double vl_gmm_cluster (VlGMM * self,
-                       void const * data,
-                       vl_size numData)
-{
-  void * bestPriors = NULL ;
-  void * bestMeans = NULL;
-  void * bestCovariances = NULL;
-  void * bestPosteriors = NULL;
-  vl_size size = vl_get_type_size(self->dataType) ;
-  double bestLL = -VL_INFINITY_D;
-  vl_uindex repetition;
-
-  assert(self->numRepetitions >=1) ;
-
-  bestPriors = vl_malloc(size * self->numClusters) ;
-  bestMeans = vl_malloc(size * self->dimension * self->numClusters) ;
-  bestCovariances = vl_malloc(size * self->dimension * self->numClusters) ;
-  bestPosteriors = vl_malloc(size * self->numClusters * numData) ;
-
-#if 0
-  feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
-#endif
-
-  for (repetition = 0 ; repetition < self->numRepetitions ; ++ repetition) {
-    double LL ;
-    double timeRef ;
-
-    if (self->verbosity) {
-      VL_PRINTF("gmm: clustering: starting repetition %d of %d\n", repetition + 1, self->numRepetitions) ;
-    }
-
-    /* initialize a new mixture model */
-    timeRef = vl_get_cpu_time() ;
-    switch (self->initialization) {
-      case VlGMMKMeans : vl_gmm_init_with_kmeans (self, data, numData, NULL) ; break ;
-      case VlGMMRand : vl_gmm_init_with_rand_data (self, data, numData) ; break ;
-      case VlGMMCustom : break ;
-      default: abort() ;
-    }
-    if (self->verbosity) {
-      VL_PRINTF("gmm: model initialized in %.2f s\n",
-                vl_get_cpu_time() - timeRef) ;
-    }
-
-    /* fit the model to data by running EM */
-    timeRef = vl_get_cpu_time () ;
-    LL = vl_gmm_em (self, data, numData) ;
-    if (self->verbosity) {
-      VL_PRINTF("gmm: optimization terminated in %.2f s with loglikelihood %f\n",
-                vl_get_cpu_time() - timeRef, LL) ;
-    }
-
-    if (LL > bestLL || repetition == 0) {
-      void * temp ;
-
-      temp = bestPriors ;
-      bestPriors = self->priors ;
-      self->priors = temp ;
-
-      temp = bestMeans ;
-      bestMeans = self->means ;
-      self->means = temp ;
-
-      temp = bestCovariances ;
-      bestCovariances = self->covariances ;
-      self->covariances = temp ;
-
-      temp = bestPosteriors ;
-      bestPosteriors = self->posteriors ;
-      self->posteriors = temp ;
-
-      bestLL = LL;
-    }
-  }
-
-  vl_free (self->priors) ;
-  vl_free (self->means) ;
-  vl_free (self->covariances) ;
-  vl_free (self->posteriors) ;
-
-  self->priors = bestPriors ;
-  self->means = bestMeans ;
-  self->covariances = bestCovariances ;
-  self->posteriors = bestPosteriors ;
-  self->LL = bestLL;
-
-  if (self->verbosity) {
-    VL_PRINTF("gmm: all repetitions terminated with final loglikelihood %f\n", self->LL) ;
-  }
-
-  return bestLL ;
-}
-
-/** @brief Invoke the EM algorithm.
- ** @param self GMM object instance.
- ** @param data data points which should be clustered.
- ** @param numData number of data points.
- **/
-
-double vl_gmm_em (VlGMM * self, void const * data, vl_size numData)
-{
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT:
-      return _vl_gmm_em_f (self, (float const *)data, numData) ; break ;
-    case VL_TYPE_DOUBLE:
-      return _vl_gmm_em_d (self, (double const *)data, numData) ; break ;
-    default:
-      abort() ;
-  }
-  return 0 ;
-}
-
-/** @brief Explicitly set the initial means for EM.
- ** @param self GMM object instance.
- ** @param means initial values of means.
- **/
-
-void
-vl_gmm_set_means (VlGMM * self, void const * means)
-{
-  memcpy(self->means,means,
-         self->dimension * self->numClusters * vl_get_type_size(self->dataType));
-}
-
-/** @brief Explicitly set the initial sigma diagonals for EM.
- ** @param self GMM object instance.
- ** @param covariances initial values of covariance matrix diagonals.
- **/
-
-void vl_gmm_set_covariances (VlGMM * self, void const * covariances)
-{
-  memcpy(self->covariances,covariances,
-         self->dimension * self->numClusters * vl_get_type_size(self->dataType));
-}
-
-/** @brief Explicitly set the initial priors of the gaussians.
- ** @param self GMM object instance.
- ** @param priors initial values of the gaussian priors.
- **/
-
-void vl_gmm_set_priors (VlGMM * self, void const * priors)
-{
-  memcpy(self->priors,priors,
-         self->numClusters * vl_get_type_size(self->dataType));
-}
-
-/* VL_GMM_INSTANTIATING */
-#endif
-
-#undef SFX
-#undef TYPE
-#undef FLT
-#undef VL_GMM_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/gmm.h b/opensfm/src/third_party/vlfeat/vl/gmm.h
deleted file mode 100644
index 3562d74c2..000000000
--- a/opensfm/src/third_party/vlfeat/vl/gmm.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/** @file gmm.h
- ** @brief GMM (@ref gmm)
- ** @author David Novotny
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_GMM_H
-#define VL_GMM_H
-
-#include "kmeans.h"
-
-/** @brief GMM initialization algorithms */
-typedef enum _VlGMMInitialization
-{
-  VlGMMKMeans, /**< Initialize GMM from KMeans clustering. */
-  VlGMMRand,   /**< Initialize GMM parameters by selecting points at random. */
-  VlGMMCustom  /**< User specifies the initial GMM parameters. */
-} VlGMMInitialization ;
-
-
-#ifndef __DOXYGEN__
-struct _VlGMM ;
-typedef struct _VlGMM VlGMM ;
-#else
-/** @brief GMM quantizer */
-typedef OPAQUE VlGMM ;
-#endif
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT VlGMM * vl_gmm_new (vl_type dataType, vl_size dimension, vl_size numComponents) ;
-VL_EXPORT VlGMM * vl_gmm_new_copy (VlGMM const * gmm) ;
-VL_EXPORT void vl_gmm_delete (VlGMM * self) ;
-VL_EXPORT void vl_gmm_reset (VlGMM * self);
-/** @} */
-
-/** @name Basic data processing
- ** @{
- **/
-VL_EXPORT double
-vl_gmm_cluster
-(VlGMM * self,
- void const * data,
- vl_size numData);
-/** @} */
-
-/** @name Fine grained data processing
- ** @{ */
-
-VL_EXPORT void
-vl_gmm_init_with_rand_data
-(VlGMM * self,
- void const * data,
- vl_size numData) ;
-
-VL_EXPORT void
-vl_gmm_init_with_kmeans
-(VlGMM * self,
- void const * data,
- vl_size numData,
- VlKMeans * kmeansInit);
-
-VL_EXPORT double
-vl_gmm_em
-(VlGMM * self,
- void const * data,
- vl_size numData);
-/** @} */
-
-VL_EXPORT void
-vl_gmm_set_means
-(VlGMM * self,
- void const * means);
-
-VL_EXPORT void
-vl_gmm_set_covariances
-(VlGMM * self,
- void const * covariances);
-
-VL_EXPORT void
-vl_gmm_set_priors
-(VlGMM * self,
- void const * priors);
-
-VL_EXPORT double
-vl_get_gmm_data_posteriors_f(float * posteriors,
-                             vl_size numClusters,
-                             vl_size numData,
-                             float const * priors,
-                             float const * means,
-                             vl_size dimension,
-                             float const * covariances,
-                             float const * data) ;
-
-VL_EXPORT double
-vl_get_gmm_data_posteriors_d(double * posteriors,
-                             vl_size numClusters,
-                             vl_size numData,
-                             double const * priors,
-                             double const * means,
-                             vl_size dimension,
-                             double const * covariances,
-                             double const * data) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_EXPORT void vl_gmm_set_num_repetitions (VlGMM * self, vl_size numRepetitions) ;
-VL_EXPORT void vl_gmm_set_max_num_iterations (VlGMM * self, vl_size maxNumIterations) ;
-VL_EXPORT void vl_gmm_set_verbosity (VlGMM * self, int verbosity) ;
-VL_EXPORT void vl_gmm_set_initialization (VlGMM * self, VlGMMInitialization init);
-VL_EXPORT void vl_gmm_set_kmeans_init_object (VlGMM * self, VlKMeans * kmeans);
-VL_EXPORT void vl_gmm_set_covariance_lower_bounds (VlGMM * self, double const * bounds);
-VL_EXPORT void vl_gmm_set_covariance_lower_bound (VlGMM * self, double bound) ;
-/** @} */
-
-/** @name Get parameters
- ** @{
- **/
-VL_EXPORT void const * vl_gmm_get_means (VlGMM const * self);
-VL_EXPORT void const * vl_gmm_get_covariances (VlGMM const * self);
-VL_EXPORT void const * vl_gmm_get_priors (VlGMM const * self);
-VL_EXPORT void const * vl_gmm_get_posteriors (VlGMM const * self);
-VL_EXPORT vl_type vl_gmm_get_data_type (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_dimension (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_num_repetitions (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_num_data (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_num_clusters (VlGMM const * self);
-VL_EXPORT double vl_gmm_get_loglikelihood (VlGMM const * self);
-VL_EXPORT int vl_gmm_get_verbosity (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_max_num_iterations (VlGMM const * self);
-VL_EXPORT vl_size vl_gmm_get_num_repetitions (VlGMM const * self);
-VL_EXPORT VlGMMInitialization vl_gmm_get_initialization (VlGMM const * self);
-VL_EXPORT VlKMeans * vl_gmm_get_kmeans_init_object (VlGMM const * self);
-VL_EXPORT double const * vl_gmm_get_covariance_lower_bounds (VlGMM const * self);
-/** @} */
-
-/* VL_GMM_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/heap-def.h b/opensfm/src/third_party/vlfeat/vl/heap-def.h
deleted file mode 100644
index bb56c6ceb..000000000
--- a/opensfm/src/third_party/vlfeat/vl/heap-def.h
+++ /dev/null
@@ -1,464 +0,0 @@
-/** @file   heap-def.h
- ** @brief  Heap preprocessor metaprogram
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file heap-def.h
-
- A heap organizes an array of objects in a priority queue. This module
- is a template metaprogram that defines heap operations on array of
- generic objects, or even generic object containers.
-
- - @ref heap-def-overview "Overview"
-   - @ref heap-def-overview-general "General usage"
- - @ref heap-def-tech "Technical details"
-
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
- @section heap-def-overview Overview
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
- To use @ref heap-def.h one must specify at least a prefix and the data
- type for the heap elements:
-
- @code
- #define VL_HEAP_prefix  my_heap
- #define VL_HEAP_type    float
- #include <vl/heap-def.h>
- @endcode
-
- This code fragment defines a number of functions prefixed by
- ::VL_HEAP_prefix, such as @c my_heap_push (::VL_HEAP_push) and @c
- my_heap_pop (::VL_HEAP_pop), that implement the heap operations.
- These functions operate on an array that has type ::VL_HEAP_array.
- By default, this is defined to be:
-
- @code
- #define VL_HEAP_array VL_HEAP_type*
- #define VL_HEAP_array_const VL_HEAP_type const*
- @endcode
-
- The array itself is accessed uniquely by means of two functions:
-
- - ::VL_HEAP_cmp, that compares two array elements. The default
-   implementation assumes that ::VL_HEAP_type is numeric.
- - ::VL_HEAP_swap, that swaps two array elements. The default
-   implementation assumes that ::VL_HEAP_type can be copied by the @c
-   = operator.
-
- The heap state is a integer @c numElements (of type ::vl_size) counting
- the number of elements of the array that are currently part of the heap
- and the content of the first @c numElements elements of the array. The
- portion of the array that constitutes the heap satisfies a certain
- invariant property (heap property, @ref heap-def-tech). From a user
- viewpoint, the most important consequence is that the first element
- of the array (the one of index 0) is also the smallest (according to
- ::VL_HEAP_cmp).
-
- Elements are added to the heap by ::VL_HEAP_push and removed from the
- heap by ::VL_HEAP_pop.  A push operation adds to the heap the array
- element immediately after the last element already in the heap
- (i.e. the element of index @c numElements) and increases the number of
- heap elements @c numElements. Elements in the heap are swapped as required in
- order to maintain the heap consistency.  Similarly, a pop operation
- removes the first (smaller) element from the heap and decreases the
- number of heap elements @c numElements.
-
- The values of nodes currently in the heap can be updated by
- ::VL_HEAP_update. Notice however that using this function requires
- knowing the index of the element that needs to be updated up to the
- swapping operations that the heap performs to maintain
- consistency. Typically, this requires redefining ::VL_HEAP_swap to
- keep track of such changes (@ref heap-def-overview-general).
-
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
- @subsection heap-def-overview-general General usage
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
- The heap container may be mapped to any type by reimplementing
- ::VL_HEAP_cmp and ::VL_HEAP_swap explicitly. For instance
- the following code redefines ::VL_HEAP_cmp to deal with the case
- in which the heap is an array of structures:
-
- @code
- typedef struct _S { int x ; } S ;
- int s_cmp (S const * v, vl_uindex a, vl_uindex b) {
-   return v[a].x - v[b].x ;
- }
- #define VL_HEAP_prefix  s_heap
- #define VL_HEAP_type    S
- #define VL_HEAP_cmp     s_cmp
- #include <vl/heap-def.h>
- @endcode
-
- In the following example, the heap itself is an arbitrary structure:
-
- @code
- typedef struct _H { int* array ; } H ;
- int h_cmp (H const * h, vl_uindex a, vl_uindex b) {
-   return h->array[a] - h->array[b] ;
- }
- int h_swap (H * h, vl_uindex a, vl_uindex b) {
-   int t = h->array[a] ;
-   h->array[a] = h->array[b] ;
-   h->array[b] = t ;
- }
- #define VL_HEAP_prefix  h_heap
- #define VL_HEAP_swap    h_swap
- #define VL_HEAP_cmp     h_cmp
- #include <vl/heap-def.h>
- @endcode
-
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
- @section heap-def-tech Technical details
- <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
- The heap is organised as a binary tree with the property (<em>heap
- property</em>) that any node is not larger than any of its
- children. In particular, the root is the smallest node.
-
- @ref heap-def.h uses the standard binary tree representation as a linear
- array. Tree nodes are mapped to array elements as follows:
- <code>array[0]</code> corresponds to the root, <code>array[1]</code>
- and <code>array[2]</code> to the root left and right children and so
- on.  In this way, the tree structure is fully specified by the total
- number of nodes <code>N</code>.
-
- Assuming that the heap has <code>N</code> nodes (from
- <code>array[0]</code> to <code>array[N-1]</code>), adding the node
- <code>array[N]</code> to the heap is done by a <em>push down</em>
- operation: if the node <code>array[N]</code> is smaller than its
- parent (violating the heap property) it is pushed down by swapping it
- with the parent, and so on recursively.
-
- Removing the smallest element <code>array[0]</code> with an heap of
- <code>N</code> nodes is done by swapping <code>array[0]</code> with
- <code>array[N-1]</code>. If then <code>array[0]</code> is larger than
- any of its children, it is swapped with the smallest of the two and
- so on recursively (<em>push up</em> operation).
-
- Restoring the heap property after an element <code>array[i]</code>
- has been modified can be done by a push up or push down operation on
- that node.
-
- **/
-
-#include "host.h"
-#include <assert.h>
-
-#ifndef VL_HEAP_prefix
-#error "VL_HEAP_prefix must be defined"
-#endif
-
-#ifndef VL_HEAP_array
-#ifndef VL_HEAP_type
-#error "VL_HEAP_type must be defined if VL_HEAP_array is not"
-#endif
-#define VL_HEAP_array       VL_HEAP_type*
-#define VL_HEAP_array_const VL_HEAP_type const*
-#endif
-
-#ifndef VL_HEAP_array_const
-#define VL_HEAP_array_const VL_HEAP_array
-#endif
-
-#ifdef __DOXYGEN__
-#define VL_HEAP_prefix  HeapObject       /**< Prefix of the heap functions */
-#define VL_HEAP_type    HeapType         /**< Data type of the heap elements */
-#define VL_HEAP_array   HeapType*        /**< Data type of the heap container */
-#define VL_HEAP_array   HeapType const*  /**< Const data type of the heap container */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#ifndef VL_HEAP_DEF_H
-#define VL_HEAP_DEF_H
-
-/** @internal @brief Get index of parent node
- ** @param index a node index.
- ** @return index of the parent node.
- **/
-
-VL_INLINE vl_uindex
-vl_heap_parent (vl_uindex index)
-{
-  if (index == 0) return 0 ;
-  return (index - 1) / 2 ;
-}
-
-/** @internal @brief Get index of left child
- ** @param index a node index.
- ** @return index of the left child.
- **/
-
-VL_INLINE vl_uindex
-vl_heap_left_child (vl_uindex index)
-{
-  return 2 * index + 1 ;
-}
-
-/** @internal @brief Get index of right child
- ** @param index a node index.
- ** @return index of the right child.
- **/
-
-VL_INLINE vl_uindex
-vl_heap_right_child (vl_uindex index)
-{
-  return vl_heap_left_child (index) + 1 ;
-}
-
-/* VL_HEAP_DEF_H */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_cmp) || defined(__DOXYGEN__)
-#define VL_HEAP_cmp VL_XCAT(VL_HEAP_prefix, _cmp)
-
-/** @brief Compare two heap elements
- ** @param array heap array.
- ** @param indexA index of the first element @c A to compare.
- ** @param indexB index of the second element @c B to comapre.
- ** @return a negative number if @c A<B, 0 if @c A==B, and
- ** a positive number if if @c A>B.
- **/
-
-VL_INLINE VL_HEAP_type
-VL_HEAP_cmp
-(VL_HEAP_array_const array,
- vl_uindex indexA,
- vl_uindex indexB)
-{
-  return array[indexA] - array[indexB] ;
-}
-
-/* VL_HEAP_cmp */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_swap) || defined(__DOXYGEN__)
-#define VL_HEAP_swap VL_XCAT(VL_HEAP_prefix, _swap)
-
-/** @brief Swap two heap elements
- ** @param array array of nodes.
- ** @param array heap array.
- ** @param indexA index of the first node to swap.
- ** @param indexB index of the second node to swap.
- **
- ** The function swaps the two heap elements @a a and @ b. The function
- ** uses a temporary element and the copy operator, which must be
- ** well defined for the heap elements.
- **/
-
-VL_INLINE void
-VL_HEAP_swap
-(VL_HEAP_array array,
- vl_uindex indexA,
- vl_uindex indexB)
-{
-  VL_HEAP_type t = array [indexA] ;
-  array [indexA] = array [indexB] ;
-  array [indexB] = t ;
-}
-
-/* VL_HEAP_swap */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_up) || defined(__DOXYGEN__)
-#define VL_HEAP_up VL_XCAT(VL_HEAP_prefix, _up)
-
-/** @brief Heap up operation
- ** @param array pointer to the heap array.
- ** @param heapSize size of the heap.
- ** @param index index of the node to push up.
- **/
-
-VL_INLINE void
-VL_HEAP_up
-(VL_HEAP_array array, vl_size heapSize, vl_uindex index)
-{
-  vl_uindex leftIndex  = vl_heap_left_child (index) ;
-  vl_uindex rightIndex = vl_heap_right_child (index) ;
-
-  /* no childer: stop */
-  if (leftIndex >= heapSize) return ;
-
-  /* only left childer: easy */
-  if (rightIndex >= heapSize) {
-    if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
-      VL_HEAP_swap (array, index, leftIndex) ;
-    }
-    return ;
-  }
-
-  /* both childern */
-  {
-    if (VL_HEAP_cmp (array, leftIndex, rightIndex) < 0) {
-      /* swap with left */
-      if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
-        VL_HEAP_swap (array, index, leftIndex) ;
-        VL_HEAP_up (array, heapSize, leftIndex) ;
-      }
-    } else {
-      /* swap with right */
-      if (VL_HEAP_cmp (array, index, rightIndex) > 0) {
-        VL_HEAP_swap (array, index, rightIndex) ;
-        VL_HEAP_up (array, heapSize, rightIndex) ;
-      }
-    }
-  }
-}
-
-/* VL_HEAP_up */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_down) || defined(__DOXYGEN__)
-#define VL_HEAP_down VL_XCAT(VL_HEAP_prefix, _down)
-
-/** @brief Heap down operation
- ** @param array pointer to the heap node array.
- ** @param index index of the node to push up.
- **/
-
-VL_INLINE void
-VL_HEAP_down
-(VL_HEAP_array array, vl_uindex index)
-{
-  vl_uindex parentIndex ;
-
-  if (index == 0) return  ;
-
-  parentIndex = vl_heap_parent (index) ;
-
-  if (VL_HEAP_cmp (array, index, parentIndex) < 0) {
-    VL_HEAP_swap (array, index, parentIndex) ;
-    VL_HEAP_down (array, parentIndex) ;
-  }
-}
-
-/* VL_HEAP_down */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_push) || defined(__DOXYGEN__)
-#define VL_HEAP_push VL_XCAT(VL_HEAP_prefix, _push)
-
-/** @brief Heap push operation
- ** @param array pointer to the heap array.
- ** @param heapSize (in/out) size of the heap.
- **
- ** The function adds to the heap the element of index @c heapSize
- ** and increments @c heapSize.
- **/
-
-VL_INLINE void
-VL_HEAP_push
-(VL_HEAP_array array, vl_size *heapSize)
-{
-  VL_HEAP_down (array, *heapSize) ;
-  *heapSize += 1 ;
-}
-
-/* VL_HEAP_push */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_pop) || defined(__DOXYGEN__)
-#define VL_HEAP_pop VL_XCAT(VL_HEAP_prefix, _pop)
-
-/** @brief Heap pop operation
- ** @param array pointer to the heap array.
- ** @param heapSize (in/out) size of the heap.
- ** @return index of the popped element.
- **
- ** The function extracts from the heap the element of index 0
- ** (the smallest element) and decreases @c heapSize.
- **
- ** The element extracted is moved as the first element after
- ** the heap end (thus it has index @c heapSize). For convenience,
- ** this index is returned by the function.
- **
- ** Popping from an empty heap is undefined.
- **/
-
-VL_INLINE vl_uindex
-VL_HEAP_pop
-(VL_HEAP_array array, vl_size *heapSize)
-{
-  assert (*heapSize) ;
-
-  *heapSize -= 1 ;
-
-  VL_HEAP_swap (array, 0, *heapSize) ;
-
-  if (*heapSize > 1) {
-    VL_HEAP_up (array, *heapSize, 0) ;
-  }
-
-  return *heapSize ;
-}
-
-/* VL_HEAP_pop */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_HEAP_update) || defined(__DOXYGEN__)
-#define VL_HEAP_update VL_XCAT(VL_HEAP_prefix, _update)
-
-/** @brief Heap update operation
- ** @param array pointer to the heap array.
- ** @param heapSize size of the heap.
- ** @param index index of the node to update.
- **
- ** The function updates the heap to account for a change to the
- ** element of index @c index in the heap.
- **
- ** Notice that using this
- ** function requires knowing the index of the heap index of
- ** element that was changed. Since the heap swaps elements in the
- ** array, this is in general different from the index that that
- ** element had originally.
- **/
-
-VL_INLINE void
-VL_HEAP_update
-(VL_HEAP_array array,
- vl_size heapSize,
- vl_uindex index)
-{
-  VL_HEAP_up (array, heapSize, index) ;
-  VL_HEAP_down (array, index) ;
-}
-
-/* VL_HEAP_update */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#undef VL_HEAP_cmp
-#undef VL_HEAP_swap
-#undef VL_HEAP_up
-#undef VL_HEAP_down
-#undef VL_HEAP_push
-#undef VL_HEAP_pop
-#undef VL_HEAP_update
-#undef VL_HEAP_prefix
-#undef VL_HEAP_type
-#undef VL_HEAP_array
-#undef VL_HEAP_array_const
diff --git a/opensfm/src/third_party/vlfeat/vl/hikmeans.c b/opensfm/src/third_party/vlfeat/vl/hikmeans.c
deleted file mode 100644
index c72720831..000000000
--- a/opensfm/src/third_party/vlfeat/vl/hikmeans.c
+++ /dev/null
@@ -1,371 +0,0 @@
-/** @file hikmeans.c
- ** @brief Hierarchical Integer K-Means Clustering - Declaration
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file hikmeans.h
- ** @brief Hierarchical integer K-Means clustering
- **
- ** Hierarchical integer K-Means clustering (HIKM) is a simple
- ** hierarchical version of integer K-Means (@ref ikmeans.h
- ** "IKM"). The algorithm recursively applies integer K-means to create
- ** more refined partitions of the data.
- **
- ** Create a tree with ::vl_hikm_new() and delete it with
- ** ::vl_hikm_delete(). Use ::vl_hikm_train() to build the tree
- ** from training data and ::vl_hikm_push() to project new data down
- ** a HIKM tree.
- **
- ** @section hikm-tree HIKM tree
- **
- ** The HIKM tree is represented by a ::VlHIKMTree structure, which
- ** contains a tree composed of ::VlHIKMNode. Each node is an
- ** integer K-means filter which partitions the data into @c K
- ** clusters.
- **/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-#include "hikmeans.h"
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Copy a subset of the data to a buffer
- ** @param data Data
- ** @param ids Data labels
- ** @param N Number of indices
- ** @param M Data dimensionality
- ** @param id Label of data to copy
- ** @param N2 Number of data copied (out)
- ** @return a new buffer with a copy of the selected data.
- **/
-
-vl_uint8*
-vl_hikm_copy_subset (vl_uint8 const * data,
-                     vl_uint32 *ids,
-                     vl_size N, vl_size M,
-                     vl_uint32 id, vl_size *N2)
-{
-  vl_uindex i ;
-  vl_size count = 0;
-
-  /* count how many data points with this label there are */
-  for (i = 0 ; i < N ; i++) {
-    if (ids[i] == id) {
-      count ++ ;
-    }
-  }
-  *N2 = count ;
-
-  /* copy each datum to the buffer */
-  {
-    vl_uint8 *new_data = vl_malloc (sizeof(*new_data) * M * count);
-    count = 0;
-    for (i = 0 ; i < N ; i ++) {
-      if (ids[i] == id) {
-        memcpy(new_data + count * M,
-               data + i * M,
-               sizeof(*new_data) * M);
-        count ++ ;
-      }
-    }
-    *N2 = count ;
-    return new_data ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Compute HIKM clustering.
- **
- ** @param tree   HIKM tree to initialize.
- ** @param data   Data to cluster.
- ** @param N      Number of data points.
- ** @param K      Number of clusters for this node.
- ** @param height Tree height.
- **
- ** @remark height cannot be smaller than 1.
- **
- ** @return a new HIKM node representing a sub-clustering.
- **/
-
-static VlHIKMNode *
-xmeans (VlHIKMTree *tree,
-        vl_uint8 const *data,
-        vl_size N, vl_size K, vl_size height)
-{
-  VlHIKMNode *node = vl_malloc (sizeof(*node)) ;
-  vl_uint32 *ids = vl_malloc (sizeof(*ids) * N) ;
-
-  node->filter = vl_ikm_new (tree -> method) ;
-  node->children = (height == 1) ? 0 : vl_malloc (sizeof(*node->children) * K) ;
-
-  vl_ikm_set_max_niters (node->filter, tree->max_niters) ;
-  vl_ikm_set_verbosity  (node->filter, tree->verb - 1  ) ;
-  vl_ikm_init_rand_data (node->filter, data, tree->M, N, K) ;
-  vl_ikm_train (node->filter, data, N) ;
-  vl_ikm_push (node->filter, ids, data, N) ;
-
-  /* recursively process each child */
-  if (height > 1) {
-    vl_uindex k ;
-    for (k = 0 ; k < K ; ++k) {
-      vl_size partition_N ;
-      vl_size partition_K ;
-      vl_uint8 *partition ;
-
-      partition = vl_hikm_copy_subset
-        (data, ids, N, tree->M, (vl_uint32)k, &partition_N) ;
-
-      partition_K = VL_MIN (K, partition_N) ;
-
-      node->children [k] = xmeans
-        (tree, partition, partition_N, partition_K, height - 1) ;
-
-      vl_free (partition) ;
-
-      if (tree->verb > (signed)tree->depth - (signed)height) {
-        VL_PRINTF("hikmeans: branch at depth %d: %6.1f %% completed\n",
-                  tree->depth - height,
-                  (double) (k+1) / K * 100) ;
-      }
-    }
-  }
-
-  vl_free (ids) ;
-  return node ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Delete node
- **
- ** @param node to delete.
- **
- ** The function deletes recursively @a node and all its descendent.
- **/
-
-static void
-xdelete (VlHIKMNode *node)
-{
-  if(node) {
-    vl_uindex k ;
-    if (node->children) {
-      for(k = 0 ; k < vl_ikm_get_K (node->filter) ; ++k)
-        xdelete (node->children[k]) ;
-      vl_free (node->children) ;
-    }
-    if (node->filter) {
-      vl_ikm_delete (node->filter) ;
-    }
-    vl_free(node);
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief New HIKM tree
- ** @param method clustering method.
- ** @return new HIKM tree.
- **/
-
-VlHIKMTree *
-vl_hikm_new (int method)
-{
-  VlHIKMTree *f = vl_calloc (sizeof(VlHIKMTree), 1) ;
-  f->max_niters = 200 ;
-  f->method = method ;
-  return f ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Delete HIKM tree
- ** @param f HIKM tree.
- **/
-
-void
-vl_hikm_delete (VlHIKMTree *f)
-{
-  if (f) {
-    xdelete (f->root) ;
-    vl_free (f) ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Initialize HIKM tree
- ** @param f HIKM tree.
- ** @param M Data dimensionality.
- ** @param K Number of clusters per node.
- ** @param depth Tree depth.
- ** @return a new HIKM tree representing the clustering.
- **
- ** @remark @a depth cannot be smaller than 1.
- **/
-
-void
-vl_hikm_init (VlHIKMTree *f, vl_size M, vl_size K, vl_size depth)
-{
-  assert(depth > 0) ;
-  assert(M > 0) ;
-  assert(K > 0) ;
-
-  xdelete (f -> root) ;
-  f->root = 0;
-  f->M = M ;
-  f->K = K ;
-  f->depth = depth ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Train HIKM tree
- ** @param f       HIKM tree.
- ** @param data    Data to cluster.
- ** @param N       Number of data.
- **/
-
-void
-vl_hikm_train (VlHIKMTree *f, vl_uint8 const *data, vl_size N)
-{
-  f->root= xmeans (f, data, N, VL_MIN(f->K, N), f->depth) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Project data down HIKM tree
- ** @param f HIKM tree.
- ** @param asgn Path down the tree (out).
- ** @param data Data to project.
- ** @param N Number of data.
- **
- ** The function writes to @a asgn the path of the data @a data
- ** down the HIKM tree @a f. The parameter @a asgn must point to
- ** an array of @c M by @c N elements, where @c M is the depth of
- ** the HIKM tree and @c N is the number of data point to process.
- **/
-
-void
-vl_hikm_push (VlHIKMTree *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N)
-{
-  vl_uindex i, d ;
-  vl_size M = vl_hikm_get_ndims (f) ;
-  vl_size depth = vl_hikm_get_depth (f) ;
-
-  /* for each datum */
-  for(i = 0 ; i < N ; i++) {
-    VlHIKMNode *node = f->root ;
-    d = 0 ;
-    while (node) {
-      vl_uint32 best ;
-      vl_ikm_push (node->filter,
-                   &best,
-                   data + i * M, 1) ;
-      asgn[i * depth + d] = best ;
-      ++ d ;
-      if (!node->children) break ;
-      node = node->children [best] ;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Setters and getters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get data dimensionality
- ** @param f HIKM tree.
- ** @return data dimensionality.
- **/
-
-vl_size
-vl_hikm_get_ndims (VlHIKMTree const* f)
-{
-  return f->M ;
-}
-
-/** @brief Get K
- ** @param f HIKM tree.
- ** @return K.
- **/
-
-vl_size
-vl_hikm_get_K (VlHIKMTree const *f)
-{
-  return f->K ;
-}
-
-/** @brief Get depth
- ** @param f HIKM tree.
- ** @return depth.
- **/
-
-vl_size
-vl_hikm_get_depth (VlHIKMTree const *f)
-{
-  return f->depth ;
-}
-
-
-/** @brief Get verbosity level
- ** @param f HIKM tree.
- ** @return verbosity level.
- **/
-
-int
-vl_hikm_get_verbosity (VlHIKMTree const *f)
-{
-  return f->verb ;
-}
-
-/** @brief Get maximum number of iterations
- ** @param f HIKM tree.
- ** @return maximum number of iterations.
- **/
-
-vl_size
-vl_hikm_get_max_niters (VlHIKMTree const *f)
-{
-  return f-> max_niters ;
-}
-
-/** @brief Get maximum number of iterations
- ** @param f HIKM tree.
- ** @return maximum number of iterations.
- **/
-
-VlHIKMNode const *
-vl_hikm_get_root (VlHIKMTree const *f)
-{
-  return f->root ;
-}
-
-/** @brief Set verbosity level
- ** @param f HIKM tree.
- ** @param verb verbosity level.
- **/
-
-void
-vl_hikm_set_verbosity (VlHIKMTree *f, int verb)
-{
-  f->verb = verb ;
-}
-
-/** @brief Set maximum number of iterations
- ** @param f HIKM tree.
- ** @param max_niters maximum number of iterations.
- **/
-
-void
-vl_hikm_set_max_niters (VlHIKMTree *f, int max_niters)
-{
-  f->max_niters = max_niters ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/hikmeans.h b/opensfm/src/third_party/vlfeat/vl/hikmeans.h
deleted file mode 100644
index 5da4f5ec8..000000000
--- a/opensfm/src/third_party/vlfeat/vl/hikmeans.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/** @file hikmeans.h
- ** @brief Hierarchical Integer K-Means Clustering
- ** @author Brian Fulkerson
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_HIKMEANS_H
-#define VL_HIKMEANS_H
-
-#include "generic.h"
-#include "ikmeans.h"
-
-struct _VLHIKMTree ;
-struct _VLHIKMNode ;
-
-/** @brief HIKM tree node
- **
- ** The number of children @a K is not bigger than the @a K parameter
- ** of the HIKM tree.
- **/
-typedef struct _VlHIKMNode
-{
-  VlIKMFilt *filter ; /**< IKM filter for this node*/
-  struct _VlHIKMNode **children ; /**< Node children (if any) */
-} VlHIKMNode ;
-
-/** @brief HIKM tree */
-typedef struct _VlHIKMTree {
-  vl_size M ; /**< IKM: data dimensionality */
-  vl_size K ; /**< IKM: K */
-  vl_size depth ; /**< Depth of the tree */
-  vl_size max_niters ;  /**< IKM: maximum # of iterations */
-  int method ; /**< IKM: method */
-  int verb ; /**< Verbosity level */
-  VlHIKMNode * root; /**< Tree root node */
-} VlHIKMTree ;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT VlHIKMTree *vl_hikm_new (int method) ;
-VL_EXPORT void vl_hikm_delete (VlHIKMTree *f) ;
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{
- **/
-VL_EXPORT vl_size vl_hikm_get_ndims (VlHIKMTree const *f) ;
-VL_EXPORT vl_size vl_hikm_get_K (VlHIKMTree const *f) ;
-VL_EXPORT vl_size vl_hikm_get_depth (VlHIKMTree const *f) ;
-VL_EXPORT int vl_hikm_get_verbosity (VlHIKMTree const *f) ;
-VL_EXPORT vl_size vl_hikm_get_max_niters (VlHIKMTree const *f) ;
-VL_EXPORT VlHIKMNode const * vl_hikm_get_root (VlHIKMTree const *f) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_EXPORT void vl_hikm_set_verbosity (VlHIKMTree *f, int verb) ;
-VL_EXPORT void vl_hikm_set_max_niters (VlHIKMTree *f, int max_niters) ;
-/** @} */
-
-/** @name Process data
- ** @{
- **/
-VL_EXPORT void vl_hikm_init (VlHIKMTree *f, vl_size M, vl_size K, vl_size depth) ;
-VL_EXPORT void vl_hikm_train (VlHIKMTree *f, vl_uint8 const *data, vl_size N) ;
-VL_EXPORT void vl_hikm_push (VlHIKMTree *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) ;
-/** @} */
-
-
-/* VL_HIKMEANS_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/hog.c b/opensfm/src/third_party/vlfeat/vl/hog.c
deleted file mode 100644
index 0a1487541..000000000
--- a/opensfm/src/third_party/vlfeat/vl/hog.c
+++ /dev/null
@@ -1,1072 +0,0 @@
-/** @file hog.c
- ** @brief Histogram of Oriented Gradients (HOG) - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
- Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
- All rights reserved.
-
- This file is part of the VLFeat library and is made available under
- the terms of the BSD license (see the COPYING file).
-*/
-
-#include "hog.h"
-#include "mathop.h"
-#include <string.h>
-
-/**
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page hog Histogram of Oriented Gradients (HOG) features
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref hog.h implements the Histogram of Oriented Gradients (HOG) features
-in the variants of Dalal Triggs @cite{dalal05histograms} and of UOCTTI
-@cite{felzenszwalb09object}. Applications include object detection
-and deformable object detection.
-
-- @ref hog-overview
-- @ref hog-tech
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section hog-overview Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-HOG is a standard image feature used, among others, in object detection
-and deformable object detection. It decomposes the image into square cells
-of a given size (typically eight pixels), compute a histogram of oriented
-gradient in each cell (similar to @ref sift), and then renormalizes
-the cells by looking into adjacent blocks.
-
-VLFeat implements two HOG variants: the original one of Dalal-Triggs
-@cite{dalal05histograms} and the one proposed in Felzenszwalb et al.
-@cite{felzenszwalb09object}.
-
-In order to use HOG, start by creating a new HOG object, set the desired
-parameters, pass a (color or grayscale) image, and read off the results.
-
-@code
-VlHog * hog = vl_hog_new(VlHogVariantDalalTriggs, numOrientations, VL_FALSE) ;
-vl_hog_put_image(hog, image, height, width, numChannels, cellSize) ;
-hogWidth = vl_hog_get_width(hog) ;
-hogHeight = vl_hog_get_height(hog) ;
-hogDimenison = vl_hog_get_dimension(hog) ;
-hogArray = vl_malloc(hogWidth*hogHeight*hogDimension*sizeof(float)) ;
-vl_hog_extract(hog, hogArray) ;
-vl_hog_delete(hog) ;
-@endcode
-
-HOG is a feature array of the dimension returned by ::vl_hog_get_width,
-::vl_hog_get_height, with each feature (histogram) having
-dimension ::vl_hog_get_dimension. The array is stored in row major order,
-with the slowest varying dimension beying the dimension indexing the histogram
-elements.
-
-The number of entreis in the histogram as well as their meaning depends
-on the HOG variant and is detailed later. However, it is usually
-unnecessary to know such details. @ref hog.h provides support for
-creating an inconic representation of a HOG feature array:
-
-@code
-glyphSize = vl_hog_get_glyph_size(hog) ;
-imageHeight = glyphSize * hogArrayHeight ;
-imageWidth = glyphSize * hogArrayWidth ;
-image = vl_malloc(sizeof(float)*imageWidth*imageHeight) ;
-vl_hog_render(hog, image, hogArray) ;
-@endcode
-
-It is often convenient to mirror HOG features from left to right. This
-can be obtained by mirroring an array of HOG cells, but the content
-of each cell must also be rearranged. This can be done by
-the permutation obtaiend by ::vl_hog_get_permutation.
-
-Furthermore, @ref hog.h suppots computing HOG features not from
-images but from vector fields.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section hog-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-HOG divdes the input image into square cells of size @c cellSize,
-fitting as many cells as possible, filling the image domain from
-the upper-left corner down to the right one. For each row and column,
-the last cell is at least half contained in the image.
-More precisely, the number of cells obtained in this manner is:
-
-@code
-hogWidth = (width + cellSize/2) / cellSize ;
-hogHeight = (height + cellSize/2) / cellSize ;
-@endcode
-
-Then the image gradient @f$ \nabla \ell(x,y) @f$
-is computed by using central difference (for colour image
-the channel with the largest gradient at that pixel is used).
-The gradient @f$ \nabla \ell(x,y) @f$ is assigned to one of @c 2*numOrientations orientation in the
-range @f$ [0,2\pi) @f$ (see @ref hog-conventions for details).
-Contributions are then accumulated by using bilinear interpolation
-to four neigbhour cells, as in @ref sift.
-This results in an histogram  @f$h_d@f$ of dimension
-2*numOrientations, called of @e directed orientations
-since it accounts for the direction as well as the orientation
-of the gradient. A second histogram @f$h_u@f$ of undirected orientations
-of half the size is obtained by folding @f$ h_d @f$ into two.
-
-Let a block of cell be a @f$ 2\times 2 @f$ sub-array of cells.
-Let the norm of a block be the @f$ l^2 @f$ norm of the stacking of the
-respective unoriented histogram. Given a HOG cell, four normalisation
-factors are then obtained as the inverse of the norm of the four
-blocks that contain the cell.
-
-For the Dalal-Triggs variant, each histogram @f$ h_d @f$ is copied
-four times, normalised using the four different normalisation factors,
-the four vectors are stacked, saturated at 0.2, and finally stored as the descriptor
-of the cell. This results in a @c numOrientations * 4 dimensional
-cell descriptor. Blocks are visited from left to right and top to bottom
-when forming the final descriptor.
-
-For the UOCCTI descriptor, the same is done for both the undirected
-as well as the directed orientation histograms. This would yield
-a dimension of @c 4*(2+1)*numOrientations elements, but the resulting
-vector is projected down to @c (2+1)*numOrientations elements
-by averaging corresponding histogram dimensions. This was shown to
-be an algebraic approximation of PCA for descriptors computed on natural
-images.
-
-In addition, for the UOCTTI variant the l1 norm of each of the
-four l2 normalised undirected histograms is computed and stored
-as additional four dimensions, for a total of
-@c 4+3*numOrientations dimensions.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection hog-conventions Conventions
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The orientation of a gradient is expressed as the angle it forms with the
-horizontal axis of the image. Angles are measured clock-wise (as the vertical
-image axis points downards), and the null angle corresponds to
-an horizontal vector pointing right. The quantized directed
-orientations are @f$ \mathrm{k} \pi / \mathrm{numOrientations} @f$, where
-@c k is an index that varies in the ingeger
-range @f$ \{0, \dots, 2\mathrm{numOrientations} - 1\} @f$.
-
-Note that the orientations capture the orientation of the gradeint;
-image edges would be oriented at 90 degrees from these.
-
-**/
-
-/* ---------------------------------------------------------------- */
-/** @brief Create a new HOG object
- ** @param variant HOG descriptor variant.
- ** @param numOrientations number of distinguished orientations.
- ** @param transposed wether images are transposed (column major).
- ** @return the new HOG object.
- **
- ** The function creates a new HOG object to extract descriptors of
- ** the prescribed @c variant. The angular resolution is set by
- ** @a numOrientations, which specifies the number of <em>undirected</em>
- ** orientations. The object can work with column major images
- ** by setting @a transposed to true.
- **/
-
-VlHog *
-vl_hog_new (VlHogVariant variant, vl_size numOrientations, vl_bool transposed)
-{
-  vl_index o, k ;
-  VlHog * self = vl_calloc(1, sizeof(VlHog)) ;
-
-  assert(numOrientations >= 1) ;
-
-  self->variant = variant ;
-  self->numOrientations = numOrientations ;
-  self->glyphSize = 21 ;
-  self->transposed = transposed ;
-  self->useBilinearOrientationAssigment = VL_FALSE ;
-  self->orientationX = vl_malloc(sizeof(float) * self->numOrientations) ;
-  self->orientationY = vl_malloc(sizeof(float) * self->numOrientations) ;
-
-  /*
-   Create a vector along the center of each orientation bin. These
-   are used to map gradients to bins. If the image is transposed,
-   then this can be adjusted here by swapping X and Y in these
-   vectors.
-   */
-  for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
-    double angle = o * VL_PI / self->numOrientations ;
-    if (!self->transposed) {
-      self->orientationX[o] = (float) cos(angle) ;
-      self->orientationY[o] = (float) sin(angle) ;
-    } else {
-      self->orientationX[o] = (float) sin(angle) ;
-      self->orientationY[o] = (float) cos(angle) ;
-    }
-  }
-
-  /*
-   If the number of orientation is equal to 9, one gets:
-
-   Uoccti:: 18 directed orientations + 9 undirected orientations + 4 texture
-   DalalTriggs:: 9 undirected orientations x 4 blocks.
-   */
-  switch (self->variant) {
-    case VlHogVariantUoctti:
-      self->dimension = 3*self->numOrientations + 4 ;
-      break ;
-
-    case VlHogVariantDalalTriggs:
-      self->dimension = 4*self->numOrientations ;
-      break ;
-
-    default:
-      assert(0) ;
-  }
-
-  /*
-   A permutation specifies how to permute elements in a HOG
-   descriptor to flip it horizontally. Since the first orientation
-   of index 0 points to the right, this must be swapped with orientation
-   self->numOrientation that points to the left (for the directed case,
-   and to itself for the undirected one).
-   */
-
-  self->permutation = vl_malloc(self->dimension * sizeof(vl_index)) ;
-  switch (self->variant) {
-    case VlHogVariantUoctti:
-      for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
-        vl_index op = self->numOrientations - o ;
-        self->permutation[o] = op ;
-        self->permutation[o + self->numOrientations] = (op + self->numOrientations) % (2*self->numOrientations) ;
-        self->permutation[o + 2*self->numOrientations] = (op % self->numOrientations) + 2*self->numOrientations ;
-      }
-      for (k = 0 ; k < 4 ; ++k) {
-        /* The texture features correspond to four displaced block around
-         a cell. These permute with a lr flip as for DalalTriggs. */
-        vl_index blockx = k % 2 ;
-        vl_index blocky = k / 2 ;
-        vl_index q = (1 - blockx) + blocky * 2 ;
-        self->permutation[k + self->numOrientations * 3] = q + self->numOrientations * 3 ;
-      }
-      break ;
-
-    case VlHogVariantDalalTriggs:
-      for(k = 0 ; k < 4 ; ++k) {
-        /* Find the corresponding block. Blocks are listed in order 1,2,3,4,...
-           from left to right and top to bottom */
-        vl_index blockx = k % 2 ;
-        vl_index blocky = k / 2 ;
-        vl_index q = (1 - blockx) + blocky * 2 ;
-        for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
-          vl_index op = self->numOrientations - o ;
-          self->permutation[o + k*self->numOrientations] = (op % self->numOrientations) + q*self->numOrientations ;
-        }
-      }
-      break ;
-
-    default:
-      assert(0) ;
-  }
-
-  /*
-   Create glyphs for representing the HOG features/ filters. The glyphs
-   are simple bars, oriented orthogonally to the gradients to represent
-   image edges. If the object is configured to work on transposed image,
-   the glyphs images are also stored in column-major.
-   */
-  self->glyphs = vl_calloc(self->glyphSize * self->glyphSize * self->numOrientations, sizeof(float)) ;
-#define atglyph(x,y,k) self->glyphs[(x) + self->glyphSize * (y) + self->glyphSize * self->glyphSize * (k)]
-  for (o = 0 ; o < (signed)self->numOrientations ; ++o) {
-    double angle = fmod(o * VL_PI / self->numOrientations + VL_PI/2, VL_PI) ;
-    double x2 = self->glyphSize * cos(angle) / 2 ;
-    double y2 = self->glyphSize * sin(angle) / 2 ;
-
-    if (angle <= VL_PI / 4 || angle >= VL_PI * 3 / 4) {
-      /* along horizontal direction */
-      double slope = y2 / x2 ;
-      double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
-      vl_index skip = (1 - fabs(cos(angle))) / 2 * self->glyphSize ;
-      vl_index i, j ;
-      for (i = skip ; i < (signed)self->glyphSize - skip ; ++i) {
-        j = vl_round_d(slope * i + offset) ;
-        if (! self->transposed) {
-          atglyph(i,j,o) = 1 ;
-        } else {
-          atglyph(j,i,o) = 1 ;
-        }
-      }
-    } else {
-      /* along vertical direction */
-      double slope = x2 / y2 ;
-      double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
-      vl_index skip = (1 - sin(angle)) / 2 * self->glyphSize ;
-      vl_index i, j ;
-      for (j = skip ; j < (signed)self->glyphSize - skip; ++j) {
-        i = vl_round_d(slope * j + offset) ;
-        if (! self->transposed) {
-          atglyph(i,j,o) = 1 ;
-        } else {
-          atglyph(j,i,o) = 1 ;
-        }
-      }
-    }
-  }
-  return self ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Delete a HOG object
- ** @param self HOG object to delete.
- **/
-
-void
-vl_hog_delete (VlHog * self)
-{
-  if (self->orientationX) {
-    vl_free(self->orientationX) ;
-    self->orientationX = NULL ;
-  }
-
-  if (self->orientationY) {
-    vl_free(self->orientationY) ;
-    self->orientationY = NULL ;
-  }
-
-  if (self->glyphs) {
-    vl_free(self->glyphs) ;
-    self->glyphs = NULL ;
-  }
-
-  if (self->permutation) {
-    vl_free(self->permutation) ;
-    self->permutation = NULL ;
-  }
-
-  if (self->hog) {
-    vl_free(self->hog) ;
-    self->hog = NULL ;
-  }
-
-  if (self->hogNorm) {
-    vl_free(self->hogNorm) ;
-    self->hogNorm = NULL ;
-  }
-
-  vl_free(self) ;
-}
-
-
-/* ---------------------------------------------------------------- */
-/** @brief Get HOG glyph size
- ** @param self HOG object.
- ** @return size (height and width) of a glyph.
- **/
-
-vl_size
-vl_hog_get_glyph_size (VlHog const * self)
-{
-  return self->glyphSize ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get HOG left-right flip permutation
- ** @param self HOG object.
- ** @return left-right permutation.
- **
- ** The function returns a pointer to an array @c permutation of ::vl_hog_get_dimension
- ** elements. Given a HOG descriptor (for a cell) @c hog, which is also
- ** a vector of ::vl_hog_get_dimension elements, the
- ** descriptor obtained for the same image flipped horizotnally is
- ** given by <code>flippedHog[i] = hog[permutation[i]]</code>.
- **/
-
-vl_index const *
-vl_hog_get_permutation (VlHog const * self)
-{
-  return self->permutation ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Turn bilinear interpolation of assignments on or off
- ** @param self HOG object.
- ** @param x @c true if orientations should be assigned with bilinear interpolation.
- **/
-
-void
-vl_hog_set_use_bilinear_orientation_assignments (VlHog * self, vl_bool x) {
-  self->useBilinearOrientationAssigment = x ;
-}
-
-/** @brief Tell whether assignments use bilinear interpolation or not
- ** @param self HOG object.
- ** @return @c true if orientations are be assigned with bilinear interpolation.
- **/
-
-vl_bool
-vl_hog_get_use_bilinear_orientation_assignments (VlHog const * self) {
-  return self->useBilinearOrientationAssigment ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Render a HOG descriptor to a glyph image
- ** @param self HOG object.
- ** @param image glyph image (output).
- ** @param descriptor HOG descriptor.
- ** @param width HOG descriptor width.
- ** @param height HOG descriptor height.
- **
- ** The function renders the HOG descriptor or filter
- ** @a descriptor as an image (for visualization) and stores the result in
- ** the buffer @a image. This buffer
- ** must be an array of dimensions @c width*glyphSize
- ** by @c height*glyphSize elements, where @c glyphSize is
- ** obtained from ::vl_hog_get_glyph_size and is the size in pixels
- ** of the image element used to represent the descriptor of one
- ** HOG cell.
- **/
-
-void
-vl_hog_render (VlHog const * self,
-               float * image,
-               float const * descriptor,
-               vl_size width,
-               vl_size height)
-{
-  vl_index x, y, k, cx, cy ;
-  vl_size hogStride = width * height ;
-
-  assert(self) ;
-  assert(image) ;
-  assert(descriptor) ;
-  assert(width > 0) ;
-  assert(height > 0) ;
-
-  for (y = 0 ; y < (signed)height ; ++y) {
-    for (x = 0 ; x < (signed)width ; ++x) {
-      float minWeight = 0 ;
-      float maxWeight = 0 ;
-
-      for (k = 0 ; k < (signed)self->numOrientations ; ++k) {
-        float weight ;
-        float const * glyph = self->glyphs + k * (self->glyphSize*self->glyphSize) ;
-        float * glyphImage = image + self->glyphSize * x + y * width * (self->glyphSize*self->glyphSize) ;
-
-        switch (self->variant) {
-          case VlHogVariantUoctti:
-            weight =
-            descriptor[k * hogStride] +
-            descriptor[(k + self->numOrientations) * hogStride] +
-            descriptor[(k + 2 * self->numOrientations) * hogStride] ;
-            break ;
-          case VlHogVariantDalalTriggs:
-            weight =
-            descriptor[k * hogStride] +
-            descriptor[(k + self->numOrientations) * hogStride] +
-            descriptor[(k + 2 * self->numOrientations) * hogStride] +
-            descriptor[(k + 3 * self->numOrientations) * hogStride] ;
-            break ;
-          default:
-            abort() ;
-        }
-        maxWeight = VL_MAX(weight, maxWeight) ;
-        minWeight = VL_MIN(weight, minWeight);
-
-        for (cy = 0 ; cy < (signed)self->glyphSize ; ++cy) {
-          for (cx = 0 ; cx < (signed)self->glyphSize ; ++cx) {
-            *glyphImage++ += weight * (*glyph++) ;
-          }
-          glyphImage += (width - 1) * self->glyphSize  ;
-        }
-      } /* next orientation */
-
-      {
-        float * glyphImage = image + self->glyphSize * x + y * width * (self->glyphSize*self->glyphSize) ;
-        for (cy = 0 ; cy < (signed)self->glyphSize ; ++cy) {
-          for (cx = 0 ; cx < (signed)self->glyphSize ; ++cx) {
-            float value = *glyphImage ;
-            *glyphImage++ = VL_MAX(minWeight, VL_MIN(maxWeight, value)) ;
-          }
-          glyphImage += (width - 1) * self->glyphSize  ;
-        }
-      }
-
-      ++ descriptor ;
-    } /* next column of cells (x) */
-  } /* next row of cells (y) */
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the dimension of the HOG features
- ** @param self HOG object.
- ** @return imension of a HOG cell descriptors.
- **/
-
-vl_size
-vl_hog_get_dimension (VlHog const * self)
-{
-  return self->dimension ;
-}
-
-/** @brief Get the width of the HOG cell array
- ** @param self HOG object.
- ** @return number of HOG cells in the horizontal direction.
- **/
-
-vl_size
-vl_hog_get_width (VlHog * self)
-{
-  return self->hogWidth ;
-}
-
-/** @brief Get the height of the HOG cell array
- ** @param self HOG object.
- ** @return number of HOG cells in the vertical direction.
- **/
-
-vl_size
-vl_hog_get_height (VlHog * self)
-{
-  return self->hogHeight ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @internal @brief Prepare internal buffers
- ** @param self HOG object.
- ** @param width image width.
- ** @param height image height.
- ** @param cellSize size of a HOG cell.
- **/
-
-static void
-vl_hog_prepare_buffers (VlHog * self, vl_size width, vl_size height, vl_size cellSize)
-{
-  vl_size hogWidth = (width + cellSize/2) / cellSize ;
-  vl_size hogHeight = (height + cellSize/2) / cellSize ;
-
-  assert(width > 3) ;
-  assert(height > 3) ;
-  assert(hogWidth > 0) ;
-  assert(hogHeight > 0) ;
-
-  if (self->hog &&
-      self->hogWidth == hogWidth &&
-      self->hogHeight == hogHeight) {
-    /* a suitable buffer is already allocated */
-    memset(self->hog, 0, sizeof(float) * hogWidth * hogHeight * self->numOrientations * 2) ;
-    memset(self->hogNorm, 0, sizeof(float) * hogWidth * hogHeight) ;
-    return ;
-  }
-
-  if (self->hog) {
-    vl_free(self->hog) ;
-    self->hog = NULL ;
-  }
-
-  if (self->hogNorm) {
-    vl_free(self->hogNorm) ;
-    self->hogNorm = NULL ;
-  }
-
-  self->hog = vl_calloc(hogWidth * hogHeight * self->numOrientations * 2, sizeof(float)) ;
-  self->hogNorm = vl_calloc(hogWidth * hogHeight, sizeof(float)) ;
-  self->hogWidth = hogWidth ;
-  self->hogHeight = hogHeight ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Process features starting from an image
- ** @param self HOG object.
- ** @param image image to process.
- ** @param width image width.
- ** @param height image height.
- ** @param numChannels number of image channles.
- ** @param cellSize size of a HOG cell.
- **
- ** The buffer @c hog must be a three-dimensional array.
- ** The first two dimensions are @c (width + cellSize/2)/cellSize and
- ** @c (height + cellSize/2)/cellSize, where divisions are integer.
- ** This is approximately @c width/cellSize and @c height/cellSize,
- ** adjusted so that the last cell is at least half contained in the
- ** image.
- **
- ** The image @c width and @c height must be not smaller than three
- ** pixels and not smaller than @c cellSize.
- **/
-
-void
-vl_hog_put_image (VlHog * self,
-                  float const * image,
-                  vl_size width, vl_size height, vl_size numChannels,
-                  vl_size cellSize)
-{
-  vl_size hogStride ;
-  vl_size channelStride = width * height ;
-  vl_index x, y ;
-  vl_uindex k ;
-
-  assert(self) ;
-  assert(image) ;
-
-  /* clear features */
-  vl_hog_prepare_buffers(self, width, height, cellSize) ;
-  hogStride = self->hogWidth * self->hogHeight ;
-
-#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
-
-  /* compute gradients and map the to HOG cells by bilinear interpolation */
-  for (y = 1 ; y < (signed)height - 1 ; ++y) {
-    for (x = 1 ; x < (signed)width - 1 ; ++x) {
-      float gradx = 0 ;
-      float grady = 0 ;
-      float gradNorm ;
-      float orientationWeights [2] = {-1, -1} ;
-      vl_index orientationBins [2] = {-1, -1} ;
-      vl_index orientation = 0 ;
-      float hx, hy, wx1, wx2, wy1, wy2 ;
-      vl_index binx, biny, o ;
-
-      /*
-       Compute the gradient at (x,y). The image channel with
-       the maximum gradient at each location is selected.
-       */
-      {
-        float const * iter = image + y * width + x ;
-        float gradNorm2 = 0 ;
-        for (k = 0 ; k < numChannels ; ++k) {
-          float gradx_ = *(iter + 1) - *(iter - 1) ;
-          float grady_ = *(iter + width)  - *(iter - width) ;
-          float gradNorm2_ = gradx_ * gradx_ + grady_ * grady_ ;
-          if (gradNorm2_ > gradNorm2) {
-            gradx = gradx_ ;
-            grady = grady_ ;
-            gradNorm2 = gradNorm2_ ;
-          }
-          iter += channelStride ;
-        }
-        gradNorm = sqrtf(gradNorm2) ;
-      }
-
-      /*
-       Map the gradient to the closest and second closets orientation bins.
-       There are numOrientations orientation in the interval [0,pi).
-       The next numOriantations are the symmetric ones, for a total
-       of 2*numOrientation directed orientations.
-       */
-      for (k = 0 ; k < self->numOrientations ; ++k) {
-        float orientationScore_ = gradx * self->orientationX[k] +  grady * self->orientationY[k] ;
-        vl_index orientationBin_ = k ;
-        if (orientationScore_ < 0) {
-          orientationScore_ = - orientationScore_ ;
-          orientationBin_ += self->numOrientations ;
-        }
-        if (orientationScore_ > orientationWeights[0]) {
-          orientationBins[1] = orientationBins[0] ;
-          orientationWeights[1] = orientationWeights[0] ;
-          orientationBins[0] = orientationBin_ ; ;
-          orientationWeights[0] = orientationScore_ ;
-        } else if (orientationScore_ > orientationWeights[1]) {
-          orientationBins[1] = orientationBin_ ;
-          orientationWeights[1] = orientationScore_ ;
-        }
-      }
-
-      if (self->useBilinearOrientationAssigment) {
-        /* min(1.0,...) guards against small overflows causing NaNs */
-        float angle0 = acosf(VL_MIN(orientationWeights[0] / VL_MAX(gradNorm, 1e-10),1.0)) ;
-        orientationWeights[1] = angle0 / (VL_PI / self->numOrientations) ;
-        orientationWeights[0] = 1 - orientationWeights[1] ;
-      } else {
-        orientationWeights[0] = 1 ;
-        orientationBins[1] = -1 ;
-      }
-
-      for (o = 0 ; o < 2 ; ++o) {
-        float ow ;
-        /*
-         Accumulate the gradient. hx is the distance of the
-         pixel x to the cell center at its left, in units of cellSize.
-         With this parametrixation, a pixel on the cell center
-         has hx = 0, which gradually increases to 1 moving to the next
-         center.
-         */
-
-        orientation = orientationBins[o] ;
-        if (orientation < 0) continue ;
-
-        /*  (x - (w-1)/2) / w = (x + 0.5)/w - 0.5 */
-        hx = (x + 0.5) / cellSize - 0.5 ;
-        hy = (y + 0.5) / cellSize - 0.5 ;
-        binx = vl_floor_f(hx) ;
-        biny = vl_floor_f(hy) ;
-        wx2 = hx - binx ;
-        wy2 = hy - biny ;
-        wx1 = 1.0 - wx2 ;
-        wy1 = 1.0 - wy2 ;
-
-        ow = orientationWeights[o] ;
-
-        /*VL_PRINTF("%d %d - %d %d %f %f - %f %f %f %f - %d \n ",x,y,binx,biny,hx,hy,wx1,wx2,wy1,wy2,o);*/
-
-        if (binx >= 0 && biny >=0) {
-          at(binx,biny,orientation) += gradNorm * ow * wx1 * wy1 ;
-        }
-        if (binx < (signed)self->hogWidth - 1 && biny >=0) {
-          at(binx+1,biny,orientation) += gradNorm * ow * wx2 * wy1 ;
-        }
-        if (binx < (signed)self->hogWidth - 1 && biny < (signed)self->hogHeight - 1) {
-          at(binx+1,biny+1,orientation) += gradNorm * ow * wx2 * wy2 ;
-        }
-        if (binx >= 0 && biny < (signed)self->hogHeight - 1) {
-          at(binx,biny+1,orientation) += gradNorm * ow * wx1 * wy2 ;
-        }
-      } /* next o */
-    } /* next x */
-  } /* next y */
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Process features starting from a field in polar notation
- ** @param self HOG object.
- ** @param modulus image gradient modulus.
- ** @param angle image gradient angle.
- ** @param directed wrap the gradient angles at 2pi (directed) or pi (undirected).
- ** @param width image width.
- ** @param height image height.
- ** @param cellSize size of a HOG cell.
- **
- ** The function behaves like ::vl_hog_put_image, but foregoes the internal
- ** computation of the gradient field, allowing the user to specify
- ** their own. Angles are measure clockwise, the y axis pointing downwards,
- ** starting from the x axis (pointing to the right).
- **/
-
-void vl_hog_put_polar_field (VlHog * self,
-                             float const * modulus,
-                             float const * angle,
-                             vl_bool directed,
-                             vl_size width, vl_size height,
-                             vl_size cellSize)
-{
-  vl_size hogStride ;
-  vl_index x, y, o ;
-  vl_index period = self->numOrientations * (directed ? 2 : 1) ;
-  double angleStep = VL_PI / self->numOrientations ;
-
-  assert(self) ;
-  assert(modulus) ;
-  assert(angle) ;
-
-  /* clear features */
-  vl_hog_prepare_buffers(self, width, height, cellSize) ;
-  hogStride = self->hogWidth * self->hogHeight ;
-
-#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
-#define atNorm(x,y) (self->hogNorm[(x) + (y) * self->hogWidth])
-
-  /* fill HOG cells from gradient field */
-  for (y = 0 ; y < (signed)height ; ++y) {
-    for (x = 0 ; x < (signed)width ; ++x) {
-      float ho, hx, hy, wo1, wo2, wx1, wx2, wy1, wy2 ;
-      vl_index bino, binx, biny ;
-      float orientationWeights [2] = {0,0} ;
-      vl_index orientationBins [2] = {-1,-1} ;
-      vl_index orientation = 0 ;
-      float thisAngle = *angle++ ;
-      float thisModulus = *modulus++ ;
-
-      if (thisModulus <= 0.0f) continue ;
-
-      /*  (x - (w-1)/2) / w = (x + 0.5)/w - 0.5 */
-
-      ho = (float)thisAngle / angleStep ;
-      bino = vl_floor_f(ho) ;
-      wo2 = ho - bino ;
-      wo1 = 1.0f - wo2 ;
-
-      while (bino < 0) { bino += self->numOrientations * 2 ; }
-
-      if (self->useBilinearOrientationAssigment) {
-        orientationBins[0] = bino % period ;
-        orientationBins[1] = (bino + 1) % period ;
-        orientationWeights[0] = wo1 ;
-        orientationWeights[1] = wo2 ;
-      } else {
-        orientationBins[0] = (bino + ((wo1 > wo2) ? 0 : 1)) % period ;
-        orientationWeights[0] = 1 ;
-        orientationBins[1] = -1 ;
-      }
-
-      for (o = 0 ; o < 2 ; ++o) {
-        /*
-         Accumulate the gradient. hx is the distance of the
-         pixel x to the cell center at its left, in units of cellSize.
-         With this parametrixation, a pixel on the cell center
-         has hx = 0, which gradually increases to 1 moving to the next
-         center.
-         */
-
-        orientation = orientationBins[o] ;
-        if (orientation < 0) continue ;
-
-        hx = (x + 0.5) / cellSize - 0.5 ;
-        hy = (y + 0.5) / cellSize - 0.5 ;
-        binx = vl_floor_f(hx) ;
-        biny = vl_floor_f(hy) ;
-        wx2 = hx - binx ;
-        wy2 = hy - biny ;
-        wx1 = 1.0 - wx2 ;
-        wy1 = 1.0 - wy2 ;
-
-        wx1 *= orientationWeights[o] ;
-        wx2 *= orientationWeights[o] ;
-        wy1 *= orientationWeights[o] ;
-        wy2 *= orientationWeights[o] ;
-
-        /*VL_PRINTF("%d %d - %d %d %f %f - %f %f %f %f - %d \n ",x,y,binx,biny,hx,hy,wx1,wx2,wy1,wy2,o);*/
-
-        if (binx >= 0 && biny >=0) {
-          at(binx,biny,orientation) += thisModulus * wx1 * wy1 ;
-        }
-        if (binx < (signed)self->hogWidth - 1 && biny >=0) {
-          at(binx+1,biny,orientation) += thisModulus * wx2 * wy1 ;
-        }
-        if (binx < (signed)self->hogWidth - 1 && biny < (signed)self->hogHeight - 1) {
-          at(binx+1,biny+1,orientation) += thisModulus * wx2 * wy2 ;
-        }
-        if (binx >= 0 && biny < (signed)self->hogHeight - 1) {
-          at(binx,biny+1,orientation) += thisModulus * wx1 * wy2 ;
-        }
-      } /* next o */
-    } /* next x */
-  } /* next y */
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Extract HOG features
- ** @param self HOG object.
- ** @param features HOG features (output).
- **
- ** This method is called after ::vl_hog_put_image or ::vl_hog_put_polar_field
- ** in order to retrieve the computed HOG features. The buffer @c features must have the dimensions returned by
- ** ::vl_hog_get_width, ::vl_hog_get_height, and ::vl_hog_get_dimension.
- **/
-
-void
-vl_hog_extract (VlHog * self, float * features)
-{
-  vl_index x, y ;
-  vl_uindex k ;
-  vl_size hogStride = self->hogWidth * self->hogHeight ;
-
-  assert(features) ;
-
-#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
-#define atNorm(x,y) (self->hogNorm[(x) + (y) * self->hogWidth])
-
-  /*
-   Compute the squared L2 norm of the unoriented version of each HOG
-   cell histogram. The unoriented version is obtained by folding
-   the 2*numOrientations compotnent into numOrientations only.
-   */
-  {
-    float const * iter = self->hog ;
-    for (k = 0 ; k < self->numOrientations ; ++k) {
-      float * niter = self->hogNorm ;
-      float * niterEnd = self->hogNorm + self->hogWidth * self->hogHeight ;
-      vl_size stride = self->hogWidth*self->hogHeight*self->numOrientations ;
-      while (niter != niterEnd) {
-        float h1 = *iter ;
-        float h2 = *(iter + stride) ;
-        float h = h1 + h2 ;
-        *niter += h * h ;
-        niter++ ;
-        iter++ ;
-      }
-    }
-  }
-
-  /*
-   HOG block-normalisation.
-
-   The Dalal-Triggs implementation computes a normalized descriptor for
-   each block of 2x2 cells, by stacking the histograms of each cell
-   into a vector and L2-normalizing and truncating the result.
-   
-   Each block-level descriptor is then decomposed back into cells
-   and corresponding parts are stacked into cell-level descritpors.
-   Each HOG cell is contained in exactly
-   four 2x2 cell blocks. For example, the cell number 5 in the following
-   figure is contained in blocks 1245, 2356, 4578, 5689:
-
-   +---+---+---+
-   | 1 | 2 | 3 |
-   +---+---+---+
-   | 4 | 5 | 6 |
-   +---+---+---+
-   | 7 | 8 | 9 |
-   +---+---+---+
-
-   Hence, when block-level descriptors are decomposed back
-   into cells, each cell receives contributions from four blocks. So,
-   if each cell started with a D-dimensional histogram, it
-   ends up with a 4D dimesional descriptor vector.
-
-   Note however that this is just a convenient way of rewriting the 
-   blocks as per-cell contributions, but the block information
-   is unchanged. In particular, barring boundary effects,
-   in an array of H x W cells there are approximately HW blocks;
-   hence the L2 norm of all the blocks stacked is approximately HW
-   (because individual blocks are L2-normalized). Since this does
-   not change in the final HOG descriptor,
-   the L2 norm of the HOG descriptor of an image should be approximately
-   the same as the area of the image divided by the
-   area of a HOG cell. This can be used as a sanity check.
-
-   The UoCTTI variant differs in some non-negligible ways. First, 
-   it includes both oriented and unoriented histograms, as well
-   as four components capturing texture. Second, and most importantly, 
-   it merges the four chunks of block-level descirptors landing in
-   each cell into one by taking their average. This makes sense
-   because, ultimately, these four sub-descriptors are identical
-   to the original cell histogram, just with four different normalisations
-   applied.
-   */
-  {
-    float const * iter = self->hog ;
-    for (y = 0 ; y < (signed)self->hogHeight ; ++y) {
-      for (x = 0 ; x < (signed)self->hogWidth ; ++x) {
-
-        /* norm of upper-left, upper-right, ... cells */
-        vl_index xm = VL_MAX(x - 1, 0) ;
-        vl_index xp = VL_MIN(x + 1, (signed)self->hogWidth - 1) ;
-        vl_index ym = VL_MAX(y - 1, 0) ;
-        vl_index yp = VL_MIN(y + 1, (signed)self->hogHeight - 1) ;
-
-        double norm1 = atNorm(xm,ym) ;
-        double norm2 = atNorm(x,ym) ;
-        double norm3 = atNorm(xp,ym) ;
-        double norm4 = atNorm(xm,y) ;
-        double norm5 = atNorm(x,y) ;
-        double norm6 = atNorm(xp,y) ;
-        double norm7 = atNorm(xm,yp) ;
-        double norm8 = atNorm(x,yp) ;
-        double norm9 = atNorm(xp,yp) ;
-
-        double factor1, factor2, factor3, factor4 ;
-
-        double t1 = 0 ;
-        double t2 = 0 ;
-        double t3 = 0 ;
-        double t4 = 0 ;
-
-        float * oiter = features + x + self->hogWidth * y ;
-
-        /* each factor is the inverse of the l2 norm of one of the 2x2 blocks surrounding
-           cell x,y */
-#if 0
-        if (self->transposed) {
-          /* if the image is transposed, y and x are swapped */
-          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
-          factor3 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
-          factor2 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
-          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
-        } else {
-          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
-          factor2 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
-          factor3 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
-          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
-        }
-#else
-        /* as implemented in UOCTTI code */
-        if (self->transposed) {
-          /* if the image is transposed, y and x are swapped */
-          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
-          factor3 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
-          factor2 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
-          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
-        } else {
-          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
-          factor2 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
-          factor3 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
-          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
-        }
-#endif
-
-        for (k = 0 ; k < self->numOrientations ; ++k) {
-          double ha = iter[hogStride * k] ;
-          double hb = iter[hogStride * (k + self->numOrientations)] ;
-          double hc ;
-
-          double ha1 = factor1 * ha ;
-          double ha2 = factor2 * ha ;
-          double ha3 = factor3 * ha ;
-          double ha4 = factor4 * ha ;
-
-          double hb1 = factor1 * hb ;
-          double hb2 = factor2 * hb ;
-          double hb3 = factor3 * hb ;
-          double hb4 = factor4 * hb ;
-
-          double hc1 = ha1 + hb1 ;
-          double hc2 = ha2 + hb2 ;
-          double hc3 = ha3 + hb3 ;
-          double hc4 = ha4 + hb4 ;
-
-          ha1 = VL_MIN(0.2, ha1) ;
-          ha2 = VL_MIN(0.2, ha2) ;
-          ha3 = VL_MIN(0.2, ha3) ;
-          ha4 = VL_MIN(0.2, ha4) ;
-
-          hb1 = VL_MIN(0.2, hb1) ;
-          hb2 = VL_MIN(0.2, hb2) ;
-          hb3 = VL_MIN(0.2, hb3) ;
-          hb4 = VL_MIN(0.2, hb4) ;
-
-          hc1 = VL_MIN(0.2, hc1) ;
-          hc2 = VL_MIN(0.2, hc2) ;
-          hc3 = VL_MIN(0.2, hc3) ;
-          hc4 = VL_MIN(0.2, hc4) ;
-
-          t1 += hc1 ;
-          t2 += hc2 ;
-          t3 += hc3 ;
-          t4 += hc4 ;
-
-          switch (self->variant) {
-            case VlHogVariantUoctti :
-              ha = 0.5 * (ha1 + ha2 + ha3 + ha4) ;
-              hb = 0.5 * (hb1 + hb2 + hb3 + hb4) ;
-              hc = 0.5 * (hc1 + hc2 + hc3 + hc4) ;
-              *oiter = ha ;
-              *(oiter + hogStride * self->numOrientations) = hb ;
-              *(oiter + 2 * hogStride * self->numOrientations) = hc ;
-              break ;
-
-            case VlHogVariantDalalTriggs :
-              *oiter = hc1 ;
-              *(oiter + hogStride * self->numOrientations) = hc2 ;
-              *(oiter + 2 * hogStride * self->numOrientations) = hc3 ;
-              *(oiter + 3 * hogStride * self->numOrientations) = hc4 ;
-              break ;
-          }
-          oiter += hogStride ;
-
-        } /* next orientation */
-
-        switch (self->variant) {
-          case VlHogVariantUoctti :
-            oiter += 2 * hogStride * self->numOrientations ;
-            *oiter = (1.0f/sqrtf(18.0f)) * t1 ; oiter += hogStride ;
-            *oiter = (1.0f/sqrtf(18.0f)) * t2 ; oiter += hogStride ;
-            *oiter = (1.0f/sqrtf(18.0f)) * t3 ; oiter += hogStride ;
-            *oiter = (1.0f/sqrtf(18.0f)) * t4 ; oiter += hogStride ;
-            break ;
-
-          case VlHogVariantDalalTriggs :
-            break ;
-        }
-        ++iter ;
-      } /* next x */
-    } /* next y */
-  } /* block normalization */
-}
-
diff --git a/opensfm/src/third_party/vlfeat/vl/hog.h b/opensfm/src/third_party/vlfeat/vl/hog.h
deleted file mode 100644
index 0a513d41e..000000000
--- a/opensfm/src/third_party/vlfeat/vl/hog.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/** @file hog.h
- ** @brief Histogram of Oriented Gradients (@ref hog)
- ** @author Andrea Vedaldi
- **/
-
-/*
- Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
- All rights reserved.
-
- This file is part of the VLFeat library and is made available under
- the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_HOG_H
-#define VL_HOG_H
-
-#include "generic.h"
-
-enum VlHogVariant_ { VlHogVariantDalalTriggs, VlHogVariantUoctti } ;
-
-typedef enum VlHogVariant_ VlHogVariant ;
-
-struct VlHog_
-{
-  VlHogVariant variant ;
-  vl_size dimension ;
-  vl_size numOrientations ;
-  vl_bool transposed ;
-  vl_bool useBilinearOrientationAssigment ;
-
-  /* left-right flip permutation */
-  vl_index * permutation ;
-
-  /* glyphs */
-  float * glyphs ;
-  vl_size glyphSize ;
-
-  /* helper vectors */
-  float * orientationX ;
-  float * orientationY ;
-
-  /* buffers */
-  float * hog ;
-  float * hogNorm ;
-  vl_size hogWidth ;
-  vl_size hogHeight ;
-} ;
-
-typedef struct VlHog_ VlHog ;
-
-VL_EXPORT VlHog * vl_hog_new (VlHogVariant variant, vl_size numOrientations, vl_bool transposed) ;
-VL_EXPORT void vl_hog_delete (VlHog * self) ;
-VL_EXPORT void vl_hog_process (VlHog * self,
-                               float * features,
-                               float const * image,
-                               vl_size width, vl_size height, vl_size numChannels,
-                               vl_size cellSize) ;
-
-VL_EXPORT void vl_hog_put_image (VlHog * self,
-                                 float const * image,
-                                 vl_size width, vl_size height, vl_size numChannels,
-                                 vl_size cellSize) ;
-
-VL_EXPORT void vl_hog_put_polar_field (VlHog * self,
-                                       float const * modulus,
-                                       float const * angle,
-                                       vl_bool directed,
-                                       vl_size width, vl_size height, vl_size cellSize) ;
-
-VL_EXPORT void vl_hog_extract (VlHog * self, float * features) ;
-VL_EXPORT vl_size vl_hog_get_height (VlHog * self) ;
-VL_EXPORT vl_size vl_hog_get_width (VlHog * self) ;
-
-
-VL_EXPORT void vl_hog_render (VlHog const * self,
-                              float * image,
-                              float const * features,
-                              vl_size width,
-                              vl_size height) ;
-
-VL_EXPORT vl_size vl_hog_get_dimension (VlHog const * self) ;
-VL_EXPORT vl_index const * vl_hog_get_permutation (VlHog const * self) ;
-VL_EXPORT vl_size vl_hog_get_glyph_size (VlHog const * self) ;
-
-VL_EXPORT vl_bool vl_hog_get_use_bilinear_orientation_assignments (VlHog const * self) ;
-VL_EXPORT void vl_hog_set_use_bilinear_orientation_assignments (VlHog * self, vl_bool x) ;
-
-/* VL_HOG_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/homkermap.c b/opensfm/src/third_party/vlfeat/vl/homkermap.c
deleted file mode 100644
index 9113990fb..000000000
--- a/opensfm/src/third_party/vlfeat/vl/homkermap.c
+++ /dev/null
@@ -1,580 +0,0 @@
-/** @file homkermap.c
- ** @brief Homogeneous kernel map - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file homkermap.h
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@page homkermap Homogeneous kernel map
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-@ref homkermap.h implements the homogeneous kernel maps introduced in
-@cite{vedaldi10efficient},@cite{vedaldi12efficient}.  Such maps are
-efficient linear representations of popular kernels such as the
-intersection, $\chi^2$, and Jensen-Shannon ones.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section homkermap-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The homogeneous kernel map is implemented as an object of type
-::VlHomogeneousKernelMap. To use thois object, first create an
-instance by using ::vl_homogeneouskernelmap_new, then use
-::vl_homogeneouskernelmap_evaluate_d or
-::vl_homogeneouskernelmap_evaluate_f (depdening on whether the data is
-@c double or @c float) to compute the feature map $ \Psi(x)
-$. When done, dispose of the object by calling
-::vl_homogeneouskernelmap_delete.
-
-@code
-double gamma = 1.0 ;
-int order = 1 ;
-double period = -1 ; // use default
-double psi [3] ;
-vl_size psiStride = 1 ;
-double x = 0.5 ;
-VlHomogeneousKernelMap * hom = vl_homogeneouskernelmap_new(
-  VlHomogeneousKernelChi2, gamma, order, period,
-  VlHomogeneousKernelMapWindowRectangular) ;
-vl_homogeneouskernelmap_evaluate_d(hom, psi, psiStride, x) ;
-vl_homogeneouskernelmap_delete(x) ;
-@endcode
-
-The constructor ::vl_homogeneouskernelmap_new takes the kernel type @c
-kernel (see ::VlHomogeneousKernelType), the homogeneity order @c gamma
-(use one for the standard $1$-homogeneous kernels), the approximation
-order @c order (usually order one is enough), the period @a period
-(use a negative value to use the default period), and a window type @c
-window (use ::VlHomogeneousKernelMapWindowRectangular if unsure). The
-approximation order trades off the quality and dimensionality of the
-approximation. The resulting feature map $ \Psi(x) $, computed by
-::vl_homogeneouskernelmap_evaluate_d or
-::vl_homogeneouskernelmap_evaluate_f , is <code>2*order+1</code>
-dimensional.
-
-The code pre-computes the map $ \Psi(x) $ for efficient
-evaluation. The table spans values of $ x $ in the range
-$[2^{-20}, 2^{8}) $. In particular, values smaller than $
-2^{-20} $ are treated as zeroes (which results in a null feature).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section homkermap-fundamentals Fundamentals
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-The <em>homogeneous kernel map</em> is a finite dimensional linear
-approximation of homogeneous kernels, including the intersection,
-$\chi^2$, and Jensen-Shannon kernels. These kernels are frequently
-used in computer vision applications because they are particular
-suited to data in the format of histograms, which includes many common
-visual descriptors.
-
-Let $x,y \in \mathbb{R}_+$ be non-negative scalars and let $k(x,y) \in
-\mathbb{R}$ be an homogeneous kernel such as the $\chi^2$ and or the
-intersection ones:
-
-@f[
-  k_{\mathrm{inters}}(x,y) = \min\{x, y\},
-  \quad
-  k_{\chi^2}(x,y) = 2 \frac{(x - y)^2}{x+y}.
-@f]
-
-For vectorial data $ \mathbf{x},\mathbf{y} \in \mathbb{R}_+^d $, the
-homogeneous kernels is defined as an <em>additive combination</em> of
-scalar kernels $K(\mathbf{x},\mathbf{y}) = \sum_{i=1}^d k(x_i,y_i)$.
-
-The <em>homogeneous kernel map</em> of order $n$ is a vector function
-$\Psi(x) \in \mathbb{R}^{2n+1}$ such that, for any choice of $x, y \in
-\mathbb{R}_+$, the following approximation holds:
-
-@f[
-  k(x,y) \approx \langle \Psi(x), \Psi(y) \rangle.
-@f]
-
-Given the feature map for the scalar case, the corresponding feature
-map $\Psi(\mathbf{x})$ for the vectorial case is obtained by stacking
-$[\Psi(x_1), \dots, \Psi(x_n)]$.  Note that the stacked feature
-$\Psi(\mathbf{x})$ has dimension $d(2n+1)$.
-
-Using linear analysis tools (e.g. a linear support vector machine)
-on top of dataset that has been encoded by the homogeneous kernel map
-is therefore approximately equivalent to using a method based
-on the corresponding non-linear kernel.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection homkermap-overview-negative Extension to the negative reals
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-Any positive (semi-)definite kernel $k(x,y)$ defined on the
-non-negative reals $x,y \in \mathbb{R}_+$ can be extended to the
-entire real line by using the definition:
-
-@f[
-k_\pm(x,y) = \operatorname{sign}(x) \operatorname{sign}(y) k(|x|,|y|).
-@f]
-
-The homogeneous kernel map implements this extension by defining
-$\Psi_\pm(x) = \operatorname{sign}(x) \Psi(|x|)$. Note that other
-extensions are possible, such as
-
-@f[
-k_\pm(x,y) = H(xy) \operatorname{sign}(y) k(|x|,|y|)
-@f]
-
-where $H$ is the Heaviside function, but may result in higher
-dimensional feature maps.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection homkermap-overview-homogeneity Homogeneity degree
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-Any (1-)homogeneous kernel $k_1(x,y)$ can be extended to a so called
-$\gamma$-homgeneous kernel $k_\gamma(x,y)$ by the definition
-
-@f[
-  k_\gamma(x,y) = (xy)^{\frac{\gamma}{2}} \frac{k_1(x,y)}{\sqrt{xy}}
-@f]
-
-Smaller values of $\gamma$ enhance the kernel non-linearity and are
-sometimes beneficial in applications (see
-@cite{vedaldi10efficient},@cite{vedaldi12efficient} for details).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@subsection homkermap-overview-window Windowing and period
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-This section discusses aspects of the homogeneous kernel map which are
-more technical and may be skipped. The homogeneous kernel map
-approximation is based on periodizing the kernel; given the kernel
-signature
-
-@f[
-    \mathcal{K}(\lambda) = k(e^{\frac{\lambda}{2}}, e^{-\frac{\lambda}{2}})
-@f]
-
-the homogeneous kernel map is a feature map for the windowed and
-periodized kernel whose signature is given by
-
-@f[
-   \hat{\mathcal{K}}(\lambda)
-   =
-   \sum_{i=-\infty}^{+\infty} \mathcal{K}(\lambda + k \Lambda) W(\lambda + k \Lambda)
-@f]
-
-where $W(\lambda)$ is a windowing function and $\Lambda$ is the
-period. This implementation of the homogeneous kernel map supports the
-use of a <em>uniform window</em> ($ W(\lambda) = 1 $) or of a
-<em>rectangular window</em> ($ W(\lambda) =
-\operatorname{rect}(\lambda/\Lambda) $). Note that $ \lambda =
-\log(y/x) $ is equal to the logarithmic ratio of the arguments of the
-kernel. Empirically, the rectangular window seems to have a slight
-edge in applications.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section homkermap-details Implementation details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-This implementation uses the expressions given in
-@cite{vedaldi10efficient},@cite{vedaldi11efficient} to compute in
-closed form the maps $\Psi(x)$ for the supported kernel types. For
-efficiency reasons, it precomputes $\Psi(x)$ for a large range of
-values of the argument when the homogeneous kernel map object is
-created.
-
-The internal table stores $\Psi(x) \in \mathbb{R}^{2n+1}$ by sampling
-$x\geq 0$. This uses the internal decomposition of IEEE floating point
-representations (@c float and @c double) in mantissa and exponent:
-<pre>
-  x = mantissa * (2**exponent),
-  minExponent <= exponent <= maxExponent,
-  1 <= matnissa < 2.
-</pre>
-Each octave is further sampled in @c numSubdivisions sublevels.
-
-When the map $\Psi(x)$ is evaluated, @c x is decomposed again into
-exponent and mantissa to index the table. The output is obtained by
-bilinear interpolation from the appropriate table entries.
-
-**/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_HOMKERMAP_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-#include "homkermap.h"
-#include "mathop.h"
-#include <math.h>
-
-struct _VlHomogeneousKernelMap
-{
-  VlHomogeneousKernelType kernelType ;
-  double gamma ;
-  VlHomogeneousKernelMapWindowType windowType ;
-  vl_size order ;
-  double period ;
-  vl_size numSubdivisions ;
-  double subdivision  ;
-  vl_index minExponent ;
-  vl_index maxExponent ;
-  double * table ;
-} ;
-
-/** @internal @brief Sample the kernel specturm
- ** @param self homogeneous kernel map.
- ** @param omega sampling frequency.
- ** @return the spectrum sampled at @a omega.
- **/
-
-VL_INLINE double
-vl_homogeneouskernelmap_get_spectrum (VlHomogeneousKernelMap const * self, double omega)
-{
-  assert (self) ;
-  switch (self->kernelType) {
-    case VlHomogeneousKernelIntersection:
-      return (2.0 / VL_PI) / (1 + 4 * omega*omega) ;
-    case VlHomogeneousKernelChi2:
-      return 2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) ;
-    case VlHomogeneousKernelJS:
-      return (2.0 / log(4.0)) *
-      2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) /
-      (1 + 4 * omega*omega) ;
-    default:
-      abort() ;
-  }
-}
-
-/* helper */
-VL_INLINE double sinc(double x)
-{
-  if (x == 0.0) return 1.0 ;
-  return sin(x) / x ;
-}
-
-/** @internal @brief Sample the smoothed kernel spectrum
- ** @param self homogeneous kernel map.
- ** @param omega sampling frequency.
- ** @return the spectrum sampled at @a omega after smoothing.
- **/
-
-VL_INLINE double
-vl_homogeneouskernelmap_get_smooth_spectrum (VlHomogeneousKernelMap const * self, double omega)
-{
-  double kappa_hat = 0 ;
-  double omegap ;
-  double epsilon = 1e-2 ;
-  double const omegaRange = 2.0 / (self->period * epsilon) ;
-  double const domega = 2 * omegaRange / (2 * 1024.0 + 1) ;
-  assert (self) ;
-  switch (self->windowType) {
-    case VlHomogeneousKernelMapWindowUniform:
-      kappa_hat = vl_homogeneouskernelmap_get_spectrum(self, omega) ;
-      break ;
-    case VlHomogeneousKernelMapWindowRectangular:
-      for (omegap = - omegaRange ; omegap <= omegaRange ; omegap += domega) {
-        double win = sinc((self->period/2.0) * omegap) ;
-        win *= (self->period/(2.0*VL_PI)) ;
-        kappa_hat += win * vl_homogeneouskernelmap_get_spectrum(self, omegap + omega) ;
-      }
-      kappa_hat *= domega ;
-      /* project on the postivie orthant (see PAMI) */
-      kappa_hat = VL_MAX(kappa_hat, 0.0) ;
-      break ;
-    default:
-      abort() ;
-  }
-  return kappa_hat ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                     Constructors and destructors */
-/* ---------------------------------------------------------------- */
-
-/** @brief Create a new homgeneous kernel map
- ** @param kernelType type of homogeneous kernel.
- ** @param gamma kernel homogeneity degree.
- ** @param order approximation order.
- ** @param period kernel period.
- ** @param windowType type of window used to truncate the kernel.
- ** @return the new homogeneous kernel map.
- **
- ** The function intializes a new homogeneous kernel map for the
- ** specified kernel type, homogeneity degree, approximation order,
- ** period, and truncation window. See @ref homkermap-fundamentals for
- ** details.
- **
- ** The homogeneity degree @c gamma must be positive (the standard
- ** kernels are obtained by setting @c gamma to 1). When unsure, set
- ** @c windowType to ::VlHomogeneousKernelMapWindowRectangular. The @c
- ** period should be non-negative; specifying a negative or null value
- ** causes the function to switch to a default value.
- **
- ** The function returns @c NULL if there is not enough free memory.
- **/
-
-VlHomogeneousKernelMap *
-vl_homogeneouskernelmap_new (VlHomogeneousKernelType kernelType,
-                             double gamma,
-                             vl_size order,
-                             double period,
-                             VlHomogeneousKernelMapWindowType windowType)
-{
-  int tableWidth, tableHeight ;
-  VlHomogeneousKernelMap * self = vl_malloc(sizeof(VlHomogeneousKernelMap)) ;
-  if (! self) return NULL ;
-
-  assert(gamma > 0) ;
-
-  assert(kernelType == VlHomogeneousKernelIntersection ||
-         kernelType == VlHomogeneousKernelChi2 ||
-         kernelType == VlHomogeneousKernelJS) ;
-
-  assert(windowType == VlHomogeneousKernelMapWindowUniform ||
-         windowType == VlHomogeneousKernelMapWindowRectangular) ;
-
-  if (period < 0) {
-    switch (windowType) {
-    case VlHomogeneousKernelMapWindowUniform:
-      switch (kernelType) {
-      case VlHomogeneousKernelChi2:         period = 5.86 * sqrt(order + 0)  + 3.65 ; break ;
-      case VlHomogeneousKernelJS:           period = 6.64 * sqrt(order + 0)  + 7.24 ; break ;
-      case VlHomogeneousKernelIntersection: period = 2.38 * log(order + 0.8) + 5.6 ; break ;
-      }
-      break ;
-    case VlHomogeneousKernelMapWindowRectangular:
-      switch (kernelType) {
-      case VlHomogeneousKernelChi2:         period = 8.80 * sqrt(order + 4.44) - 12.6 ; break ;
-      case VlHomogeneousKernelJS:           period = 9.63 * sqrt(order + 1.00) - 2.93;  break ;
-      case VlHomogeneousKernelIntersection: period = 2.00 * log(order + 0.99)  + 3.52 ; break ;
-      }
-      break ;
-    }
-    period = VL_MAX(period, 1.0) ;
-  }
-
-  self->kernelType = kernelType ;
-  self->windowType = windowType ;
-  self->gamma = gamma ;
-  self->order = order ;
-  self->period = period ;
-  self->numSubdivisions = 8 + 8*order ;
-  self->subdivision = 1.0 / self->numSubdivisions ;
-  self->minExponent = -20 ;
-  self->maxExponent = 8 ;
-
-  tableHeight = (int) (2*self->order + 1) ;
-  tableWidth = (int) (self->numSubdivisions * (self->maxExponent - self->minExponent + 1)) ;
-  self->table = vl_malloc (sizeof(double) *
-                           (tableHeight * tableWidth + 2*(1+self->order))) ;
-  if (! self->table) {
-    vl_free(self) ;
-    return NULL ;
-  }
-
-  {
-    vl_index exponent ;
-    vl_uindex i, j ;
-    double * tablep = self->table ;
-    double * kappa = self->table + tableHeight * tableWidth ;
-    double * freq = kappa + (1+self->order) ;
-    double L = 2.0 * VL_PI / self->period ;
-
-    /* precompute the sampled periodicized spectrum */
-    j = 0 ;
-    i = 0 ;
-    while (i <= self->order) {
-      freq[i] = j ;
-      kappa[i] = vl_homogeneouskernelmap_get_smooth_spectrum(self, j * L) ;
-      ++ j ;
-      if (kappa[i] > 0 || j >= 3*i) ++ i ;
-    }
-
-    /* fill table */
-    for (exponent  = self->minExponent ;
-         exponent <= self->maxExponent ; ++ exponent) {
-
-      double x, Lxgamma, Llogx, xgamma ;
-      double sqrt2kappaLxgamma ;
-      double mantissa = 1.0 ;
-
-      for (i = 0 ; i < self->numSubdivisions ;
-           ++i, mantissa += self->subdivision) {
-        x = ldexp(mantissa, (int)exponent) ;
-        xgamma = pow(x, self->gamma) ;
-        Lxgamma = L * xgamma ;
-        Llogx = L * log(x) ;
-
-        *tablep++ = sqrt(Lxgamma * kappa[0]) ;
-        for (j = 1 ; j <= self->order ; ++j) {
-          sqrt2kappaLxgamma = sqrt(2.0 * Lxgamma * kappa[j]) ;
-          *tablep++ = sqrt2kappaLxgamma * cos(freq[j] * Llogx) ;
-          *tablep++ = sqrt2kappaLxgamma * sin(freq[j] * Llogx) ;
-        }
-      } /* next mantissa */
-    } /* next exponent */
-  }
-  return self ;
-}
-
-/** @brief Delete an object instance.
- ** @param self object.
- ** The function deletes the specified map object.
- **/
-
-void
-vl_homogeneouskernelmap_delete (VlHomogeneousKernelMap * self)
-{
-  vl_free(self->table) ;
-  self->table = NULL ;
-  vl_free(self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                     Retrieve data and parameters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get the map order.
- ** @param self object.
- ** @return the map order.
- **/
-
-vl_size
-vl_homogeneouskernelmap_get_order (VlHomogeneousKernelMap const * self)
-{
-  assert(self) ;
-  return self->order ;
-}
-
-/** @brief Get the map dimension.
- ** @param self object.
- ** @return the map dimension (2 @c order  +1).
- **/
-
-vl_size
-vl_homogeneouskernelmap_get_dimension (VlHomogeneousKernelMap const * self)
-{
-  assert(self) ;
-  return 2 * self->order + 1 ;
-}
-
-/** @brief Get the kernel type.
- ** @param self object.
- ** @return kernel type.
- **/
-
-VlHomogeneousKernelType
-vl_homogeneouskernelmap_get_kernel_type (VlHomogeneousKernelMap const * self)
-{
-  assert(self) ;
-  return self->kernelType ;
-}
-
-/** @brief Get the window type.
- ** @param self object.
- ** @return window type.
- **/
-
-VlHomogeneousKernelMapWindowType
-vl_homogeneouskernelmap_get_window_type (VlHomogeneousKernelMap const * self)
-{
-  assert(self) ;
-  return self->windowType ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                     Process data */
-/* ---------------------------------------------------------------- */
-
-/** @fn ::vl_homogeneouskernelmap_evaluate_d(VlHomogeneousKernelMap const*,double*,vl_size,double)
- ** @brief Evaluate map
- ** @param self map object.
- ** @param destination output buffer.
- ** @param stride stride of the output buffer.
- ** @param x value to expand.
- **
- ** The function evaluates the feature map on @a x and stores the
- ** resulting <code>2*order+1</code> dimensional vector to
- ** @a destination[0], @a destination[stride], @a destination[2*stride], ....
- **/
-
-/** @fn ::vl_homogeneouskernelmap_evaluate_f(VlHomogeneousKernelMap const*,float*,vl_size,double)
- ** @copydetails ::vl_homogeneouskernelmap_evaluate_d(VlHomogeneousKernelMap const*,double*,vl_size,double)
- **/
-
-#define FLT VL_TYPE_FLOAT
-#define VL_HOMKERMAP_INSTANTIATING
-#include "homkermap.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define VL_HOMKERMAP_INSTANTIATING
-#include "homkermap.c"
-
-/* VL_HOMKERMAP_INSTANTIATING */
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifdef VL_HOMKERMAP_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-#include "float.h"
-
-void
-VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)
-(VlHomogeneousKernelMap const * self,
- T * destination,
- vl_size stride,
- double x)
-{
-  /* break value into exponent and mantissa */
-  int exponent ;
-  int unsigned j ;
-  double mantissa = frexp(x, &exponent) ;
-  double sign = (mantissa >= 0.0) ? +1.0 : -1.0 ;
-  mantissa *= 2*sign ;
-  exponent -- ;
-
-  if (mantissa == 0 ||
-      exponent <= self->minExponent ||
-      exponent >= self->maxExponent) {
-    for (j = 0 ; j < 2*self->order+1 ; ++j) {
-      *destination = (T) 0.0 ;
-      destination += stride ;
-    }
-    return  ;
-  }
-  {
-    vl_size featureDimension = 2*self->order + 1 ;
-    double const * v1 = self->table +
-    (exponent - self->minExponent) * self->numSubdivisions * featureDimension ;
-    double const * v2 ;
-    double f1, f2 ;
-
-    mantissa -= 1.0 ;
-    while (mantissa >= self->subdivision) {
-      mantissa -= self->subdivision ;
-      v1 += featureDimension ;
-    }
-    v2 = v1 + featureDimension ;
-    for (j = 0 ; j < featureDimension ; ++j) {
-      f1 = *v1++ ;
-      f2 = *v2++ ;
-      *destination = (T) sign * ((f2 - f1) * (self->numSubdivisions * mantissa) + f1) ;
-      destination += stride ;
-    }
-  }
-}
-
-#undef FLT
-#undef VL_HOMKERMAP_INSTANTIATING
-/* VL_HOMKERMAP_INSTANTIATING */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/homkermap.h b/opensfm/src/third_party/vlfeat/vl/homkermap.h
deleted file mode 100644
index e16a7167e..000000000
--- a/opensfm/src/third_party/vlfeat/vl/homkermap.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/** @file homkermap.h
- ** @brief Homogeneous kernel map (@ref homkermap)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_HOMKERMAP_H
-#define VL_HOMKERMAP_H
-
-#include "generic.h"
-
-#include <math.h>
-
-/** @brief Type of kernel */
-typedef enum {
-  VlHomogeneousKernelIntersection = 0, /**< intersection kernel */
-  VlHomogeneousKernelChi2, /**< Chi2 kernel */
-  VlHomogeneousKernelJS /**< Jensen-Shannon kernel */
-} VlHomogeneousKernelType ;
-
-/** @brief Type of spectral windowing function  */
-typedef enum {
-  VlHomogeneousKernelMapWindowUniform = 0, /**< uniform window */
-  VlHomogeneousKernelMapWindowRectangular = 1, /**< rectangular window */
-} VlHomogeneousKernelMapWindowType ;
-
-#ifndef __DOXYGEN__
-struct _VlHomogeneousKernelMap ;
-typedef struct _VlHomogeneousKernelMap VlHomogeneousKernelMap ;
-#else
-/** @brief Homogeneous kernel map object */
-typedef OPAQUE VlHomogeneousKernelMap ;
-#endif
-
-/** @name Create and destroy
- ** @{ */
-VL_EXPORT VlHomogeneousKernelMap *
-vl_homogeneouskernelmap_new (VlHomogeneousKernelType kernelType,
-                             double gamma,
-                             vl_size order,
-                             double period,
-                             VlHomogeneousKernelMapWindowType windowType) ;
-VL_EXPORT void
-vl_homogeneouskernelmap_delete (VlHomogeneousKernelMap * self) ;
-/** @} */
-
-/** @name Process data
- ** @{ */
-VL_EXPORT void
-vl_homogeneouskernelmap_evaluate_d (VlHomogeneousKernelMap const * self,
-                                    double * destination,
-                                    vl_size stride,
-                                    double x) ;
-
-VL_EXPORT void
-vl_homogeneouskernelmap_evaluate_f (VlHomogeneousKernelMap const * self,
-                                    float * destination,
-                                    vl_size stride,
-                                    double x) ;
-/** @} */
-
-
-/** @name Retrieve data and parameters
- ** @{ */
-VL_EXPORT vl_size
-vl_homogeneouskernelmap_get_order (VlHomogeneousKernelMap const * self) ;
-
-VL_EXPORT vl_size
-vl_homogeneouskernelmap_get_dimension (VlHomogeneousKernelMap const * self) ;
-
-VL_EXPORT VlHomogeneousKernelType
-vl_homogeneouskernelmap_get_kernel_type (VlHomogeneousKernelMap const * self) ;
-
-VL_EXPORT VlHomogeneousKernelMapWindowType
-vl_homogeneouskernelmap_get_window_type (VlHomogeneousKernelMap const * self) ;
-/** @} */
-
-/* VL_HOMKERMAP_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/host.c b/opensfm/src/third_party/vlfeat/vl/host.c
deleted file mode 100644
index 50a0f0f40..000000000
--- a/opensfm/src/third_party/vlfeat/vl/host.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/** @file host.c
- ** @brief Host - Definition
- ** @author Andrea Vedaldi
- ** @see @ref portability
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page portability Portability features
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Platform dependent details are isolated in the @ref host.h.  This
-module provides functionalities to identify the host operating system,
-C compiler, and CPU architecture. It also provides a few features to
-abstract from such details.
-
-@see http://predef.sourceforge.net/index.php
-@see http://en.wikipedia.org/wiki/64-bit_computing
-
-@section host-os Host operating system
-
-The module defines a symbol to identify the host operating system:
-::VL_OS_WIN for Windows, ::VL_OS_LINUX for Linux, ::VL_OS_MACOSX for
-Mac OS X, and so on.
-
-@section host-compiler Host compiler
-
-The module defines a symbol to identify the host compiler:
-::VL_COMPILER_MSC for Microsoft Visual C++, ::VL_COMPILER_GNUC for
-GNU C, and so on. The (integer) value of such symbols corresponds the
-version of the compiler.
-
-The module defines a symbol to identify the data model of the
-compiler: ::VL_COMPILER_ILP32, ::VL_COMPILER_LP64, or
-::VL_COMPILER_LLP64 (see Sect. @ref host-compiler-data-model).  For
-convenience, it also defines a number of atomic types of prescribed
-width (::vl_int8, ::vl_int16, ::vl_int32, etc.).
-
-@remark While some of such functionalities are provided by the
-standard header @c stdint.h, the latter is not supported by all
-platforms.
-
-@subsection host-compiler-data-model Data models
-
-The C language defines a number of atomic data types (such as @c char,
-@c short, @c int and so on). The number of bits (width) used to
-represent each data type depends on the compiler data model. The
-different models are *ILP32* (@c int, @c long, and pointer 32 bit),
-*LP64* (@c int 32 bit, @c long and pointer 64 bit), *ILP64* (@c int,
-@c long, and pointer 64 bit), and *LLP64* (@c int, @c long 32 bit and
-pointer 64 -- and `long long` -- 64 bit). Note in particular that
-`long long` is 64 bit in all models of interest. The following table
-summarizes them:
-
-<table><caption><b>Compiler data models.</b> </caption>
-<tr style="font-weight:bold;">
-<td>Data model</td>
-<td><code>short</code></td>
-<td><code>int</code></td>
-<td><code>long</code></td>
-<td><code>long long</code></td>
-<td><code>void*</code></td>
-<td>Compiler</td>
-</tr>
-<tr>
-<td>ILP32</td>
-<td style="background-color:#ffa;">16</td>
-<td style="background-color:#afa;">32</td>
-<td style="background-color:#afa;">32</td>
-<td>64</td>
-<td style="background-color:#afa;">32</td>
-<td>Most 32 bit architectures.</td>
-</tr>
-<tr>
-<td>LP64</td>
-<td style="background-color:#ffa;">16</td>
-<td style="background-color:#afa;">32</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td>UNIX-64 (Linux, Mac OS X)</td>
-</tr>
-<tr>
-<td>ILP64</td>
-<td style="background-color:#ffa;">16</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td>Alpha, Cray</td>
-</tr>
-<tr>
-<td>SLIP64</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td>64</td>
-<td></td>
-</tr>
-<tr>
-<td>LLP64</td>
-<td style="background-color:#ffa;">16</td>
-<td style="background-color:#afa;">32</td>
-<td style="background-color:#afa;">32</td>
-<td>64</td>
-<td>64</td>
-<td>Windows-64</td>
-</tr>
-</table>
-
-Macros such as ::VL_UINT32_C can be used to generate integer literal
-with the correct suffix for a type of a given width.
-
-@subsection host-compiler-other Other compiler-specific features
-
-The module provides the macro ::VL_EXPORT to declare symbols exported
-from the library and the macro ::VL_INLINE to declare inline
-functions.  Such features are not part of the C89 standard, and
-change depending on the compiler.
-
-@par "Example:"
-The following header file declares a function @c f that
-should be visible from outside the library.
-@code
-#include <vl/generic.h>
-VL_EXPORT void f () ;
-VL_EXPORT int i ;
-@endcode
-Notice that the macro ::VL_EXPORT needs not to be included again
-when the function is defined.
-
-@par "Example:"
-The following header file declares an inline function @c f:
-@code
-#include <vl/generic.h>
-VL_INLINE int f() ;
-
-VL_INLINE int f() { return 1 ; }
-@endcode
-
-Here the first instruction defines the function @c f, where the
-second declares it. Notice that since this is an inline function, its
-definition must be found in the header file rather than in an
-implementation file.  Notice also that definition and declaration can
-be merged.
-
-These macros translate according to the following tables:
-
-<table class="doxtable" style="font-size:70%;">
-<caption>Macros for exporting library symbols</caption>
-<tr>
-<td>Platform</td>
-<td>Macro name</td>
-<td>Value when building the library</td>
-<td>Value when importing the library</td>
-</tr>
-<tr>
-<td>Unix/GCC</td>
-<td>::VL_EXPORT</td>
-<td>empty (assumes <c>-visibility=hidden</c> GCC option)</td>
-<td><c>__attribute__((visibility ("default")))</c></td>
-</tr>
-<tr>
-<td>Win/Visual C++</td>
-<td>::VL_EXPORT</td>
-<td>@c __declspec(dllexport)</td>
-<td>@c __declspec(dllimport)</td>
-</tr>
-</table>
-
-<table class="doxtable" style="font-size:70%;">
-<caption>Macros for declaring inline functions</caption>
-<tr>
-<td>Platform</td>
-<td>Macro name</td>
-<td>Value</td>
-</tr>
-<tr>
-<td>Unix/GCC</td>
-<td>::VL_INLINE</td>
-<td>static inline</td>
-</tr>
-<tr>
-<td>Win/Visual C++</td>
-<td>::VL_INLINE</td>
-<td>static __inline</td>
-</tr>
-</table>
-
-@section host-arch Host CPU architecture
-
-The module defines a symbol to identify the host CPU architecture:
-::VL_ARCH_IX86 for Intel x86, ::VL_ARCH_IA64 for Intel 64, and so on.
-
-@subsection host-arch-endianness Endianness
-
-The module defines a symbol to identify the host CPU endianness:
-::VL_ARCH_BIG_ENDIAN for big endian and ::VL_ARCH_LITTLE_ENDIAN for
-little endian. The functions ::vl_swap_host_big_endianness_8(),
-::vl_swap_host_big_endianness_4(), ::vl_swap_host_big_endianness_2()
-to change the endianness of data (from/to host and network order).
-
-Recall that <em>endianness</em> concerns the way multi-byte data
-types (such as 16, 32 and 64 bits integers) are stored into the
-addressable memory.  All CPUs uses a contiguous address range to
-store atomic data types (e.g. a 16-bit integer could be assigned to
-the addresses <c>0x10001</c> and <c>0x10002</c>), but the order may
-differ.
-
-- The convention is <em>big endian</em>, or in <em>network
-  order</em>, if the most significant byte of the multi-byte data
-  types is assigned to the smaller memory address. This is the
-  convention used for instance by the PPC architecture.
-
-- The convention is <em>little endian</em> if the least significant
-  byte is assigned to the smaller memory address. This is the
-  convention used for instance by the x86 architecture.
-
-@remark The names &ldquo;big endian&rdquo; and &ldquo;little
-endian&rdquo; are a little confusing. &ldquo;Big endian&rdquo; means
-&ldquo;big endian first&rdquo;, i.e.  the address of the most
-significant byte comes first. Similarly, &ldquo;little endian&rdquo;
-means &ldquo;little endian first&rdquo;, in the sense that the
-address of the least significant byte comes first.
-
-Endianness is a concern when data is either exchanged with processors
-that use different conventions, transmitted over a network, or stored
-to a file. For the latter two cases, one usually saves data in big
-endian (network) order regardless of the host CPU.
-
-@section host-threads Multi-threading
-
-The file defines #VL_THREADS_WIN if multi-threading support is
-enabled and the host supports Windows threads and #VL_THREADS_POSIX if
-it supports POSIX threads.
-**/
-
-/** @def VL_OS_LINUX
- ** @brief Defined if the host operating system is Linux.
- **/
-
-/** @def VL_OS_MACOSX
- ** @brief Defined if the host operating system is Mac OS X.
- **/
-
-/** @def VL_OS_WIN
- ** @brief Defined if the host operating system is Windows (32 or 64)
- **/
-
-/** @def VL_OS_WIN64
- ** @brief Defined if the host operating system is Windows-64.
- **/
-
-/** @def VL_COMPILER_GNUC
- ** @brief Defined if the host compiler is GNU C.
- **
- ** This macro is defined if the compiler is GNUC.
- ** Its value is calculated as
- ** @code
- ** 10000 * MAJOR + 100 * MINOR + PATCHLEVEL
- ** @endcode
- ** @see @ref host-compiler
- **/
-
-/** @def VL_COMPILER_MSC
- ** @brief Defined if the host compiler is Microsoft Visual C++.
- ** @see @ref host-compiler
- **/
-
-/** @def VL_COMPILER_LCC
- ** @brief Defined if the host compiler is LCC.
- ** @deprecated The LCC is not supported anymore.
- ** @see @ref host-compiler
- **/
-
-/** @def VL_COMPILER_LLP64
- ** @brief Defined if the host compiler data model is LLP64.
- ** @see @ref host-compiler-data-model
- **/
-
-/** @def VL_COMPILER_LP64
- ** @brief Defined if the host compiler data model is LP64.
- ** @see @ref host-compiler-data-model
- **/
-
-/** @def VL_COMPILER_ILP32
- ** @brief Defined if the host compiler data model is ILP32.
- ** @see @ref host-compiler-data-model
- **/
-
-/** @def VL_INT8_C(x)
- ** @brief Create an integer constant of the specified width and sign
- ** @param x integer constant.
- ** @return @a x with the correct suffix for the given sign and size.
- ** The suffix used depends on the @ref host-compiler-data-model.
- ** @par "Example:"
- ** The macro <code>VL_INT64_C(1234)</code> is expanded as @c 123L in
- ** a LP64 system and as @c 123LL in a LLP64 system.
- **/
-
-/** @def VL_INT16_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_INT32_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_INT64_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_UINT8_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_UINT16_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_UINT32_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_UINT64_C(x)
- ** @copydoc VL_INT8_C */
-
-/** @def VL_ARCH_IX86
- ** @brief Defined if the host CPU is of the Intel x86 family.
- ** @see @ref host-arch
- **/
-
-/** @def VL_ARCH_IA64
- ** @brief Defined if the host CPU is of the Intel Architecture-64 family.
- ** @see @ref host-arch
- **/
-
-/** @def VL_ARCH_LITTLE_ENDIAN
- ** @brief Defined if the host CPU is little endian
- ** @see @ref host-arch-endianness
- **/
-
-/** @def VL_ARCH_BIG_ENDIAN
- ** @brief Defined if the host CPU is big endian
- ** @see @ref host-arch-endianness
- **/
-
-/** @def VL_INLINE
- ** @brief Adds appropriate inline function qualifier
- ** @see @ref host-compiler-other
- **/
-
-/** @def VL_EXPORT
- ** @brief Declares a DLL exported symbol
- ** @see @ref host-compiler-other
- **/
-
-/** @def VL_DISABLE_SSE2
- ** @brief Defined if SSE2 support if disabled
- **
- ** Define this symbol during compliation of the library and linking
- ** to another project to disable VLFeat SSE2 support.
- **/
-
-/** @def VL_DISABLE_THREADS
- ** @brief Defined if multi-threading support is disabled
- **
- ** Define this symbol during compilation of the library and linking
- ** to another project to disable VLFeat multi-threading support.
- **/
-
-/** @def VL_DISABLE_OPENMP
- ** @brief Defined if OpenMP support is disabled
- **
- ** Define this symbol during compilation of the library and linking
- ** to another project to disable VLFeat OpenMP support.
- **/
-
-/** @def VL_THREADS_WIN
- ** @brief Defined if the host uses Windows threads.
- ** @see @ref host-threads
- **/
-
-/** @def VL_THREADS_POSIX
- ** @brief Defiend if the host uses POISX threads.
- ** @see @ref host-threads
- **/
-
-/** --------------------------------------------------------------- */
-
-#include "host.h"
-#include "generic.h"
-#include <stdio.h>
-
-#if defined(VL_ARCH_IX86) || defined(VL_ARCH_IA64) || defined(VL_ARCH_X64)
-#define HAS_CPUID
-#else
-#undef HAS_CPUID
-#endif
-
-#if defined(HAS_CPUID) & defined(VL_COMPILER_MSC)
-#include <intrin.h>
-VL_INLINE void
-_vl_cpuid (vl_int32* info, int function)
-{
-  __cpuid(info, function) ;
-}
-#endif
-
-#if defined(HAS_CPUID) & defined(VL_COMPILER_GNUC)
-VL_INLINE void
-_vl_cpuid (vl_int32* info, int function)
-{
-#if defined(VL_ARCH_IX86) && (defined(__PIC__) || defined(__pic__))
-  /* This version is compatible with -fPIC on x386 targets. This special
-   * case is required becaus
-   * on such platform -fPIC alocates ebx as global offset table pointer.
-   * Note that =r below will be mapped to a register different from ebx,
-   * so the code is sound. */
-  __asm__ __volatile__
-  ("pushl %%ebx      \n" /* save %ebx */
-   "cpuid            \n"
-   "movl %%ebx, %1   \n" /* save what cpuid just put in %ebx */
-   "popl %%ebx       \n" /* restore the old %ebx */
-   : "=a"(info[0]), "=r"(info[1]), "=c"(info[2]), "=d"(info[3])
-   : "a"(function)
-   : "cc") ; /* clobbered (cc=condition codes) */
-#else /* no -fPIC or -fPIC with a 64-bit target */
-  __asm__ __volatile__
-  ("cpuid"
-   : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3])
-   : "a"(function)
-   : "cc") ;
-#endif
-}
-
-#endif
-
-#if defined(HAS_CPUID)
-
-void
-_vl_x86cpu_info_init (VlX86CpuInfo *self)
-{
-  vl_int32 info [4] ;
-  int max_func = 0 ;
-  _vl_cpuid(info, 0) ;
-  max_func = info[0] ;
-  self->vendor.words[0] = info[1] ;
-  self->vendor.words[1] = info[3] ;
-  self->vendor.words[2] = info[2] ;
-
-  if (max_func >= 1) {
-    _vl_cpuid(info, 1) ;
-    self->hasMMX   = info[3] & (1 << 23) ;
-    self->hasSSE   = info[3] & (1 << 25) ;
-    self->hasSSE2  = info[3] & (1 << 26) ;
-    self->hasSSE3  = info[2] & (1 <<  0) ;
-    self->hasSSE41 = info[2] & (1 << 19) ;
-    self->hasSSE42 = info[2] & (1 << 20) ;
-    self->hasAVX   = info[2] & (1 << 28) ;
-  }
-}
-
-#endif
-
-char *
-_vl_x86cpu_info_to_string_copy (VlX86CpuInfo const *self)
-{
-  char * string = 0 ;
-  int length = 0 ;
-  while (string == 0) {
-    if (length > 0) {
-      string = vl_malloc(sizeof(char) * length) ;
-      if (string == NULL) break ;
-    }
-    length = snprintf(string, length, "%s%s%s%s%s%s%s%s",
-                      self->vendor.string,
-                      self->hasMMX   ? " MMX" : "",
-                      self->hasSSE   ? " SSE" : "",
-                      self->hasSSE2  ? " SSE2" : "",
-                      self->hasSSE3  ? " SSE3" : "",
-                      self->hasSSE41 ? " SSE41" : "",
-                      self->hasSSE42 ? " SSE42" : "",
-                      self->hasAVX   ? " AVX" : "") ;
-    length += 1 ;
-  }
-  return string ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Human readable static library configuration
- ** @return a new string with the static configuration.
- **
- ** The string includes information about the compiler, the host, and
- ** other static configuration parameters. The string must be released
- ** by ::vl_free.
- **/
-
-VL_EXPORT char *
-vl_static_configuration_to_string_copy ()
-{
-  char const * hostString =
-#ifdef VL_ARCH_X64
-  "X64"
-#endif
-#ifdef VL_ARCH_IA64
-  "IA64"
-#endif
-#ifdef VL_ARCH_IX86
-  "IX86"
-#endif
-#ifdef VL_ARCH_PPC
-  "PPC"
-#endif
-  ", "
-#ifdef VL_ARCH_BIG_ENDIAN
-  "big_endian"
-#endif
-#ifdef VL_ARCH_LITTLE_ENDIAN
-  "little_endian"
-#endif
-  ;
-
-  char compilerString [1024] ;
-
-  char const * libraryString =
-#ifndef VL_DISABLE_THREADS
-#ifdef VL_THREADS_WIN
-  "Windows_threads"
-#elif VL_THREADS_POSIX
-  "POSIX_threads"
-#endif
-#else
-  "No_threads"
-#endif
-#ifndef VL_DISABLE_SSE2
-  ", SSE2"
-#endif
-#if defined(_OPENMP)
-  ", OpenMP"
-#endif
-  ;
-
-snprintf(compilerString, 1024,
-#ifdef VL_COMPILER_MSC
-  "Microsoft Visual C++ %d"
-#define v VL_COMPILER_MSC
-#endif
-#ifdef VL_COMPILER_GNUC
-  "GNU C %d"
-#define v VL_COMPILER_GNUC
-#endif
-  " "
-#ifdef VL_COMPILER_LP64
-  "LP64"
-#endif
-#ifdef VL_COMPILER_LLP64
-  "LP64"
-#endif
-#ifdef VL_COMPILER_ILP32
-  "ILP32"
-#endif
-           , v) ;
-
-  {
-    char * string = 0 ;
-    int length = 0 ;
-    while (string == 0) {
-      if (length > 0) {
-        string = vl_malloc(sizeof(char) * length) ;
-        if (string == NULL) break ;
-      }
-      length = snprintf(string, length, "%s, %s, %s",
-                        hostString,
-                        compilerString,
-                        libraryString) ;
-      length += 1 ;
-    }
-    return string ;
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/host.h b/opensfm/src/third_party/vlfeat/vl/host.h
deleted file mode 100644
index fb2700c77..000000000
--- a/opensfm/src/third_party/vlfeat/vl/host.h
+++ /dev/null
@@ -1,662 +0,0 @@
-/** @file host.h
- ** @brief Host
- ** @author Andrea Vedaldi
- ** @sa @ref portability
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_HOST_H
-#define VL_HOST_H
-
-/** ------------------------------------------------------------------
- ** @name Configuration options
- ** @{ */
-
-#if defined(__DOXYGEN__)
-#define VL_DISABLE_THREADS
-#define VL_DISABLE_SSE2
-#define VL_DISABLE_OPENMP
-#endif
-
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Defining functions
- ** @{ */
-
-#if defined(__DOXYGEN__)
-#define VL_EXPORT
-#define VL_INLINE
-#endif
-
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name C preprocessor helper macros
- ** @{ */
-
-/** @brief Convert the argument to a string
- ** @param x value to be stringified.
- **
- ** This macro stringifies the argument @a x by means of the
- ** <code>#</code> prerpocessor operator.
- **
- ** The standard C preprocessor does not prescan arguments which are
- ** stringified, so
- **
- ** @code
- ** #define A B
- ** char const * str = VL_STRINGIFY(A) ;
- ** @endcode
- **
- ** initializes <code>str</code> with a pointer to the string
- ** <code>"A"</code>, which mihgt be unexpected. To fix this issue,
- ** you can use ::VL_XSTRINGIFY.
- **
- ** @sa ::VL_XSTRINGIFY
- **/
-
-#define VL_STRINGIFY(x) # x
-
-/** @brief Expand and then convert the argument to a string
- ** @param x value to be macro-expanded and converted.
- **
- ** This macro macro-expands the argument @a x and stringifies the
- ** result of the expansion. For instance
- **
- ** @code
- ** #define A B
- ** char const * str = VL_STRINGIFY(A) ;
- ** @endcode
- **
- ** initializes <code>str</code> with a pointer to the string
- ** <code>"B"</code>.
- **
- ** @sa ::VL_STRINGIFY
- **/
-
-#define VL_XSTRINGIFY(x) VL_STRINGIFY(x)
-
-/** @brief Concatenate two arguments into a lexical unit
- ** @param x first argument to be concatenated.
- ** @param y second argument to be concatenated.
- **
- ** This macro concatenates its arguments into a single lexical unit
- ** by means of the <code>##</code> preprocessor operator. Notice that
- ** arguments concatenated by <code>##</code> are not pre-expanded by
- ** the C preprocessor. To macro-expand the arguments and then
- ** concatenate them,use ::VL_XCAT.
- **
- ** @see ::VL_XCAT
- **/
-
-#define VL_CAT(x,y) x ## y
-
-/** @brief Expand and then concatenate two arguments into a lexical unit
- ** @param x first argument to be concatenated.
- ** @param y second argument to be concatenated.
- **
- ** This macro is the same as ::VL_CAT, except that the arguments are
- ** macro expanded before being concatenated.
- **
- ** @see ::VL_CAT
- **/
-
-#define VL_XCAT(x,y) VL_CAT(x,y)
-
-/** @brief Expand and then concatenate three arguments into a lexical unit
- ** @param x first argument to be concatenated.
- ** @param y second argument to be concatenated.
- ** @param z third argument to be concatenated.
- **
- ** This macro is the same as ::VL_XCAT, except that it has three arguments.
- **
- ** @see ::VL_XCAT
- **/
-
-#define VL_XCAT3(x,y,z) VL_XCAT(VL_XCAT(x,y),z)
-
-/** @brief Expand and then concatenate four arguments into a lexical unit
- ** @param x first argument to be concatenated.
- ** @param y second argument to be concatenated.
- ** @param z third argument to be concatenated.
- ** @param u fourth argument to be concatenated.
- **
- ** This macro is the same as ::VL_XCAT, except that it has four arguments.
- **
- ** @see ::VL_XCAT
- **/
-
-#define VL_XCAT4(x,y,z,u) VL_XCAT(VL_XCAT3(x,y,z),u)
-
-/** @brief Expand and then concatenate five arguments into a lexical unit
- ** @param x first argument to be concatenated.
- ** @param y second argument to be concatenated.
- ** @param z third argument to be concatenated.
- ** @param u fourth argument to be concatenated.
- ** @param v fifth argument to be concatenated.
- **
- ** This macro is the same as ::VL_XCAT, except that it has five arguments.
- **
- ** @see ::VL_XCAT
- **/
-
-#define VL_XCAT5(x,y,z,u,v) VL_XCAT(VL_XCAT4(x,y,z,u),v)
-
-/** @brief Convert a boolean to "yes" or "no" strings
- ** @param x boolean to convert.
- **
- ** A pointer to either the string "yes" (if @a x is true)
- ** or the string "no".
- **
- ** @par Example
- ** @code
- ** VL_PRINTF("Is x true? %s.", VL_YESNO(x))
- ** @endcode
- **/
-
-#define VL_YESNO(x) ((x)?"yes":"no")
-
-/** @} */
-
-/*
- The following macros identify the host OS, architecture and compiler.
- They are derived from http://predef.sourceforge.net/
- */
-
-/** @name Identifying the host operating system
- ** @{ */
-#if defined(linux)     || \
-    defined(__linux)   || \
-    defined(__linux__) || \
-    defined(__DOXYGEN__)
-#define VL_OS_LINUX 1
-#endif
-
-#if (defined(__APPLE__) & defined(__MACH__)) || \
-     defined(__DOXYGEN__)
-#define VL_OS_MACOSX 1
-#endif
-
-#if defined(__WIN32__) || \
-    defined(_WIN32)    || \
-    defined(__DOXYGEN__)
-#define VL_OS_WIN 1
-#endif
-
-#if defined(_WIN64) || \
-    defined(__DOXYGEN__)
-#define VL_OS_WIN64 1
-#endif
-/** @} */
-
-/** @name Identifying the host threading library
- ** @{ */
-#if !defined(VL_OS_WIN) && !defined(VL_OS_WIN64) || \
-defined(__DOXYGEN__)
-#define VL_THREADS_POSIX 1
-#endif
-
-#if defined(VL_OS_WIN) || defined(VL_OS_WIN64) || \
-defined(__DOXYGEN__)
-#define VL_THREADS_WIN 1
-#endif
-/** @} */
-
-/** @name Identifying the host compiler
- ** @{ */
-#if defined(__GNUC__) || defined(__DOXYGEN__)
-# if defined(__GNUC_PATCHLEVEL__)
-#  define VL_COMPILER_GNUC (__GNUC__ * 10000 \
-+ __GNUC_MINOR__ * 100 \
-+ __GNUC_PATCHLEVEL__)
-# else
-#  define VL_COMPILER_GNUC (__GNUC__ * 10000 \
-+ __GNUC_MINOR__ * 100)
-# endif
-#endif
-
-#if defined(_MSC_VER) || defined(__DOXYGEN__)
-#define VL_COMPILER_MSC _MSC_VER
-#endif
-
-#if defined(__LCC__) || defined(__DOXYGEN__)
-#warning "LCC support is experimental!"
-#define VL_COMPILER_LCC 1
-#endif
-
-/** @} */
-
-/** @name Identifying the host CPU architecture
- ** @{ */
-#if defined(i386)     || \
-    defined(__i386__) || \
-    defined(__DOXYGEN__)
-#define VL_ARCH_IX86 300
-#elif defined(__i486__)
-#define VL_ARCH_IX86 400
-#elif defined(__i586__)
-#define VL_ARCH_IX86 500
-#elif defined(__i686__)
-#define VL_ARCH_IX86 600
-#elif defined(_M_IX86)
-#define VL_ARCH_IX86 _M_IX86
-#endif
-
-#if defined(_M_X64)    || \
-    defined(__amd64__) || \
-    defined(__amd64)   || \
-    defined(__x86_64)  || \
-    defined(__x86_64)
-#define VL_ARCH_X64
-#endif
-
-#if defined(__ia64__)   || \
-    defined(_IA64)      || \
-    defined(__IA64)     || \
-    defined(__ia64)     || \
-    defined(_M_IA64)    || \
-    defined(__DOXYGEN__)
-#define VL_ARCH_IA64
-#endif
-/** @} */
-
-/** @name Identifying the host data model
- ** @{ */
-#if defined(__LLP64__) || \
-    defined(__LLP64)   || \
-    defined(__LLP64)   || \
-    (defined(VL_COMPILER_MSC) & defined(VL_OS_WIN64)) || \
-    (defined(VL_COMPILER_LCC) & defined(VL_OS_WIN64)) || \
-    defined(__DOXYGEN__)
-#define VL_COMPILER_LLP64
-#endif
-
-#if defined(__LP64__) || \
-    defined(__LP64)   || \
-    defined(__LP64)   || \
-    (defined(VL_OS_MACOSX) & defined(VL_ARCH_IA64)) || \
-    defined(__DOXYGEN__)
-#define VL_COMPILER_LP64
-#endif
-
-#if (!defined(VL_COMPILER_LLP64) & !defined(VL_COMPILER_LP64)) || \
-    defined(__DOXYGEN__)
-#define VL_COMPILER_ILP32
-#endif
-/** @} */
-
-/** @name Identifying the host endianness
- ** @{ */
-#if defined(__LITTLE_ENDIAN__) || \
-    defined(VL_ARCH_IX86)      || \
-    defined(VL_ARCH_IA64)      || \
-    defined(VL_ARCH_X64)       || \
-    defined(__DOXYGEN__)
-#define VL_ARCH_LITTLE_ENDIAN
-#endif
-
-#if  defined(__DOXYGEN__) || \
-    !defined(VL_ARCH_LITTLE_ENDIAN)
-#define VL_ARCH_BIG_ENDIAN
-#endif
-/** @} */
-
-#if defined(VL_COMPILER_MSC) & ! defined(__DOXYGEN__)
-#  define VL_UNUSED
-#  define VL_INLINE static __inline
-#if defined _MSC_VER && _MSC_VER < 1900
-#  define snprintf _snprintf
-#endif
-#  define isnan _isnan
-#  ifdef VL_BUILD_DLL
-#    ifdef __cplusplus
-#      define VL_EXPORT extern "C" __declspec(dllexport)
-#    else
-#      define VL_EXPORT extern __declspec(dllexport)
-#    endif
-#  else
-#    ifdef __cplusplus
-#      define VL_EXPORT extern "C"
-#    else
-#      define VL_EXPORT extern
-#    endif
-#  endif
-#endif
-
-#if defined(VL_COMPILER_LCC) & ! defined(__DOXYGEN__)
-#  define VL_UNUSED
-#  define VL_INLINE static __inline
-#  define snprintf _snprintf
-#  define isnan _isnan
-VL_INLINE float fabsf(float x) { return (float) fabs((double) x) ; }
-#  ifdef VL_BUILD_DLL
-#    define VL_EXPORT extern __declspec(dllexport)
-#  else
-#    define VL_EXPORT extern
-#  endif
-#endif
-
-#if defined(VL_COMPILER_GNUC) & ! defined(__DOXYGEN__)
-#  define VL_UNUSED __attribute__((unused))
-#  define VL_INLINE static __inline__
-#  ifdef VL_BUILD_DLL
-#    ifdef __cplusplus
-#      define VL_EXPORT __attribute__((visibility ("default"))) extern "C"
-#    else
-#      define VL_EXPORT __attribute__((visibility ("default"))) extern
-#    endif
-#  else
-#    ifdef __cplusplus
-#      define VL_EXPORT extern "C"
-#    else
-#      define VL_EXPORT extern
-#    endif
-#  endif
-#endif
-
-VL_EXPORT char * vl_static_configuration_to_string_copy () ;
-
-/** ------------------------------------------------------------------
- ** @name Atomic data types
- ** @{
- **/
-
-#define VL_TRUE 1   /**< @brief @c true (1) constant */
-#define VL_FALSE 0  /**< @brief @c false (0) constant */
-
-#if defined(VL_COMPILER_LP64) || defined(VL_COMPILER_LLP64)
-typedef long long           vl_int64 ;   /**< @brief Signed 64-bit integer. */
-typedef int                 vl_int32 ;   /**< @brief Signed 32-bit integer. */
-typedef short               vl_int16 ;   /**< @brief Signed 16-bit integer. */
-typedef char                vl_int8  ;   /**< @brief Signed  8-bit integer. */
-
-typedef long long unsigned  vl_uint64 ;  /**< @brief Unsigned 64-bit integer. */
-typedef int       unsigned  vl_uint32 ;  /**< @brief Unsigned 32-bit integer. */
-typedef short     unsigned  vl_uint16 ;  /**< @brief Unsigned 16-bit integer. */
-typedef char      unsigned  vl_uint8 ;   /**< @brief Unsigned  8-bit integer. */
-
-typedef int                 vl_int ;     /**< @brief Same as @c int. */
-typedef unsigned int        vl_uint ;    /**< @brief Same as <code>unsigned int</code>. */
-
-typedef int                 vl_bool ;    /**< @brief Boolean. */
-typedef vl_int64            vl_intptr ;  /**< @brief Integer holding a pointer. */
-typedef vl_uint64           vl_uintptr ; /**< @brief Unsigned integer holding a pointer. */
-typedef vl_int64            vl_size ;    /**< @brief Signed integer holding the size of a memory block. */
-typedef vl_int64            vl_index ;   /**< @brief Signed version of ::vl_size and ::vl_uindex */
-typedef vl_uint64           vl_uindex ;  /**< @brief Same as ::vl_size */
-#endif
-
-#if defined(VL_COMPILER_ILP32)
-
-#ifdef VL_COMPILER_MSC
-typedef __int64             vl_int64 ;
-#else
-typedef long long           vl_int64 ;
-#endif
-
-typedef int                 vl_int32 ;
-typedef short               vl_int16 ;
-typedef char                vl_int8  ;
-
-#ifdef VL_COMPILER_MSC
-typedef __int64   unsigned  vl_uint64 ;
-#else
-typedef long long unsigned  vl_uint64 ;
-#endif
-typedef int       unsigned  vl_uint32 ;
-typedef short     unsigned  vl_uint16 ;
-typedef char      unsigned  vl_uint8 ;
-
-typedef int                 vl_int ;
-typedef unsigned int        vl_uint ;
-
-typedef int                 vl_bool ;
-typedef vl_int32            vl_intptr ;
-typedef vl_uint32           vl_uintptr ;
-typedef vl_uint32           vl_size ;
-typedef vl_int32            vl_index ;
-typedef vl_uint32           vl_uindex ;
-#endif
-/** @} */
-
-/** @name Creating integer constants
- ** @{ */
-#if defined(VL_COMPILER_LP64) || defined(__DOXYGEN__)
-#define VL_INT8_C(x) x
-#define VL_INT16_C(x) x
-#define VL_INT32_C(x) x
-#define VL_INT64_C(x) x ## L
-
-#define VL_UINT8_C(x) x
-#define VL_UINT16_C(x) x
-#define VL_UINT32_C(x) x ## U
-#define VL_UINT64_C(x) x ## UL
-#endif
-
-#if (defined(VL_COMPILER_LLP64) || defined(VL_COMPILER_ILP32)) \
-    & !defined(__DOXYGEN__)
-#define VL_INT8_C(x) x
-#define VL_INT16_C(x) x
-#define VL_INT32_C(x) x
-#define VL_INT64_C(x) x ## LL
-
-#define VL_UINT8_C(x) x
-#define VL_UINT16_C(x) x
-#define VL_UINT32_C(x) x ## U
-#define VL_UINT64_C(x) x ## ULL
-#endif
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Printing the atomic data types
- ** @{ */
-
-/* Lengths only: */
-
-/** @def VL_FL_INT64
- ** @brief @c printf length flag for ::vl_int64 and ::vl_uint64.
- **/
-
-/** @def VL_FL_INT32
- ** @brief @c printf length flag for ::vl_int32 and ::vl_uint32.
- **/
-
-/** @def VL_FL_INT16
- ** @brief @c printf length flag for ::vl_int16 and ::vl_uint16.
- **/
-
-/** @def VL_FL_INT8
- ** @brief @c printf length flag for ::vl_int8 and ::vl_uint8.
- **/
-
-/** @def VL_FL_INDEX
- ** @brief @c printf length flag for ::vl_index and ::vl_uindex
- **/
-
-#ifdef VL_COMPILER_MSC
-#define VL_FL_INT64  "I64"
-#else
-#define VL_FL_INT64  "ll"
-#endif
-#define VL_FL_INT32  ""
-#define VL_FL_INT16  "h"
-#define VL_FL_INT8   "hh"
-
-#if defined(VL_COMPILER_LP64) || defined(VL_COMPILER_LLP64)
-#define VL_FL_INDEX VL_FL_INT64
-#endif
-
-#if defined(VL_COMPILER_ILP32)
-#define VL_FL_INDEX VL_FL_INT32
-#endif
-
-/* Formats (but not conversions!): */
-
-/** @def VL_FMT_SIZE
- ** @brief @c printf flag for ::vl_size
- **/
-
-/** @def VL_FMT_INDEX
- ** @brief @c printf flag for ::vl_index
- **/
-
-/** @def VL_FMT_UINDEX
- ** @brief @c printf flag for ::vl_uindex
- **/
-
-/** @def VL_FMT_INTPTR
- ** @brief @c printf flag for ::vl_intptr
- **/
-
-/** @def VL_FMT_UINTPTR
- ** @brief @c printf flag for ::vl_uintptr
- **/
-
-#define VL_FMT_INDEX   VL_FL_INDEX "d"
-#define VL_FMT_INTPTR  VL_FMT_INDEX
-#define VL_FMT_UINDEX  VL_FL_INDEX "u"
-#define VL_FMT_SIZE    VL_FMT_UINDEX
-#define VL_FMT_UINTPTR VL_FMT_UINDEX
-
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Atomic data types limits
- ** @{ */
-
-/** @brief Largest integer (math constant) */
-#define VL_BIG_INT  0x7FFFFFFFL
-
-/** @brief Smallest integer (math constant) */
-#define VL_SMALL_INT  (- VL_BIG_INT - 1)
-
-/** @brief Largest unsigned integer (math constant) */
-#define VL_BIG_UINT 0xFFFFFFFFUL
-
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Endianness detection and conversion
- ** @{
- **/
-VL_INLINE void vl_swap_host_big_endianness_8 (void *dst, void* src) ;
-VL_INLINE void vl_swap_host_big_endianness_4 (void *dst, void* src) ;
-VL_INLINE void vl_swap_host_big_endianness_2 (void *dst, void* src) ;
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @name Obtaining host info at run time
- ** @{ */
-
-typedef struct _VlX86CpuInfo
-{
-  union {
-    char string [0x20] ;
-    vl_uint32 words [0x20 / 4] ;
-  } vendor ;
-  vl_bool hasAVX ;
-  vl_bool hasSSE42 ;
-  vl_bool hasSSE41 ;
-  vl_bool hasSSE3 ;
-  vl_bool hasSSE2 ;
-  vl_bool hasSSE ;
-  vl_bool hasMMX ;
-} VlX86CpuInfo ;
-
-void _vl_x86cpu_info_init (VlX86CpuInfo *self) ;
-char * _vl_x86cpu_info_to_string_copy (VlX86CpuInfo const *self) ;
-
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @brief Host <-> big endian transformation for 8-bytes value
- **
- ** @param dst destination 8-byte buffer.
- ** @param src source 8-byte bufffer.
- ** @see @ref host-arch-endianness.
- **/
-
-VL_INLINE void
-vl_swap_host_big_endianness_8 (void *dst, void* src)
-{
-  char *dst_ = (char*) dst ;
-  char *src_ = (char*) src ;
-#if defined(VL_ARCH_BIG_ENDIAN)
-    dst_ [0] = src_ [0] ;
-    dst_ [1] = src_ [1] ;
-    dst_ [2] = src_ [2] ;
-    dst_ [3] = src_ [3] ;
-    dst_ [4] = src_ [4] ;
-    dst_ [5] = src_ [5] ;
-    dst_ [6] = src_ [6] ;
-    dst_ [7] = src_ [7] ;
-#else
-    dst_ [0] = src_ [7] ;
-    dst_ [1] = src_ [6] ;
-    dst_ [2] = src_ [5] ;
-    dst_ [3] = src_ [4] ;
-    dst_ [4] = src_ [3] ;
-    dst_ [5] = src_ [2] ;
-    dst_ [6] = src_ [1] ;
-    dst_ [7] = src_ [0] ;
-#endif
-}
-
-/** ------------------------------------------------------------------
- ** @brief Host <-> big endian transformation for 4-bytes value
- **
- ** @param dst destination 4-byte buffer.
- ** @param src source 4-byte bufffer.
- ** @sa @ref host-arch-endianness.
- **/
-
-VL_INLINE void
-vl_swap_host_big_endianness_4 (void *dst, void* src)
-{
-  char *dst_ = (char*) dst ;
-  char *src_ = (char*) src ;
-#if defined(VL_ARCH_BIG_ENDIAN)
-    dst_ [0] = src_ [0] ;
-    dst_ [1] = src_ [1] ;
-    dst_ [2] = src_ [2] ;
-    dst_ [3] = src_ [3] ;
-#else
-    dst_ [0] = src_ [3] ;
-    dst_ [1] = src_ [2] ;
-    dst_ [2] = src_ [1] ;
-    dst_ [3] = src_ [0] ;
-#endif
-}
-
-/** ------------------------------------------------------------------
- ** @brief Host <-> big endian transformation for 2-bytes value
- **
- ** @param dst destination 2-byte buffer.
- ** @param src source 2-byte bufffer.
- ** @see @ref host-arch-endianness.
- **/
-
-VL_INLINE void
-vl_swap_host_big_endianness_2 (void *dst, void* src)
-{
-  char *dst_ = (char*) dst ;
-  char *src_ = (char*) src ;
-#if defined(VL_ARCH_BIG_ENDIAN)
-    dst_ [0] = src_ [0] ;
-    dst_ [1] = src_ [1] ;
-#else
-    dst_ [0] = src_ [1] ;
-    dst_ [1] = src_ [0] ;
-#endif
-}
-
-/* VL_HOST_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/ikmeans.c b/opensfm/src/third_party/vlfeat/vl/ikmeans.c
deleted file mode 100644
index 4eb7c4687..000000000
--- a/opensfm/src/third_party/vlfeat/vl/ikmeans.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/** @file ikmeans.c
- ** @brief Integer K-Means clustering - Definition
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file ikmeans.h
- **
- ** Integer K-means (IKM) is an implementation of K-means clustering
- ** (or Vector Quantization, VQ) for integer data. This is
- ** particularly useful for clustering large collections of visual
- ** descriptors.
- **
- ** Use the function ::vl_ikm_new() to create a IKM
- ** quantizer. Initialize the IKM quantizer with @c K clusters by
- ** ::vl_ikm_init() or similar function. Use ::vl_ikm_train() to train
- ** the quantizer. Use ::vl_ikm_push() or ::vl_ikm_push_one() to
- ** quantize new data.
- **
- ** Given data @f$x_1,\dots,x_N\in R^d@f$ and a number of clusters
- ** @f$K@f$, the goal is to find assignments @f$a_i\in\{1,\dots,K\},@f$
- ** and centers @f$c_1,\dots,c_K\in R^d@f$ so that the <em>expected
- ** distortion</em>
- **
- ** @f[
- **   E(\{a_{i}, c_j\}) = \frac{1}{N} \sum_{i=1}^N d(x_i, c_{a_i})
- ** @f]
- **
- ** is minimized. Here @f$d(x_i, c_{a_i})@f$ is the
- ** <em>distortion</em>, i.e. the cost we pay for representing @f$ x_i
- ** @f$ by @f$ c_{a_i} @f$. IKM uses the squared distortion
- ** @f$d(x,y)=\|x-y\|^2_2@f$.
- **
- ** @section ikmeans-algo Algorithms
- **
- ** @subsection ikmeans-alg-init Initialization
- **
- ** Most K-means algorithms are iterative and needs an initialization
- ** in the form of an initial choice of the centers
- ** @f$c_1,\dots,c_K@f$. We include the following options:
- **
- ** - User specified centers (::vl_ikm_init);
- ** - Random centers (::vl_ikm_init_rand);
- ** - Centers from @c K randomly selected data points (::vl_ikm_init_rand_data).
- **
- ** @subsection ikmeans-alg-lloyd Lloyd
- **
- ** The Lloyd (also known as Lloyd-Max and LBG) algorithm iteratively:
- **
- ** - Fixes the centers, optimizing the assignments (minimizing by
- **   exhaustive search the association of each data point to the
- **   centers);
- ** - Fixes the assignments and optimizes the centers (by descending
- **   the distortion error function). For the squared distortion, this
- **   step is in closed form.
- **
- ** This algorithm is not particularly efficient because all data
- ** points need to be compared to all centers, for a complexity
- ** @f$O(dNKT)@f$, where <em>T</em> is the total number of iterations.
- **
- ** @subsection ikmeans-alg-elkan Elkan
- **
- ** The Elkan algorithm is an optimized variant of Lloyd. By making
- ** use of the triangle inequality, many comparisons of data points
- ** and centers are avoided, especially at later iterations.
- ** Usually 4-5 times less comparisons than Lloyd are preformed,
- ** providing a dramatic speedup in the execution time.
- **
- **/
-
-#include "ikmeans.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h> /* memset */
-#include "assert.h"
-
-static void vl_ikm_init_lloyd (VlIKMFilt*) ;
-static void vl_ikm_init_elkan (VlIKMFilt*) ;
-static int vl_ikm_train_lloyd (VlIKMFilt*, vl_uint8 const*, vl_size) ;
-static int vl_ikm_train_elkan (VlIKMFilt*, vl_uint8 const*, vl_size) ;
-static void vl_ikm_push_lloyd (VlIKMFilt*, vl_uint32*, vl_uint8 const*, vl_size) ;
-static void  vl_ikm_push_elkan  (VlIKMFilt*, vl_uint32*, vl_uint8 const*, vl_size) ;
-
-/** @brief Create a new IKM quantizer
- ** @param method Clustering algorithm.
- ** @return new IKM quantizer.
- **
- ** The function allocates initializes a new IKM quantizer to
- ** operate based algorithm @a method.
- **
- ** @a method has values in the enumerations ::VlIKMAlgorithms.
- **/
-
-VlIKMFilt *
-vl_ikm_new (int method)
-{
-  VlIKMFilt *f = vl_calloc (sizeof(VlIKMFilt), 1) ;
-  f -> method = method ;
-  f -> max_niters = 200 ;
-  return f ;
-}
-
-/** @brief Delete IKM quantizer
- ** @param f IKM quantizer.
- **/
-
-void
-vl_ikm_delete (VlIKMFilt* f)
-{
-  if (f) {
-    if (f->centers) vl_free(f->centers) ;
-    if (f->inter_dist) vl_free(f->inter_dist) ;
-    vl_free(f) ;
-  }
-}
-
-/** @brief Train clusters
- ** @param f IKM quantizer.
- ** @param data data.
- ** @param N number of data (@a N @c >= 1).
- ** @return -1 if an overflow may have occurred.
- **/
-
-int
-vl_ikm_train (VlIKMFilt *f, vl_uint8 const *data, vl_size N)
-{
-  int err ;
-
-  if (f-> verb) {
-    VL_PRINTF ("ikm: training with %d data\n",  N) ;
-    VL_PRINTF ("ikm: %d clusters\n",  f -> K) ;
-  }
-
-  switch (f -> method) {
-  case VL_IKM_LLOYD : err = vl_ikm_train_lloyd (f, data, N) ; break ;
-  case VL_IKM_ELKAN : err = vl_ikm_train_elkan (f, data, N) ; break ;
-  default :
-    abort() ;
-  }
-  return err ;
-}
-
-/** @brief Project data to clusters
- ** @param f     IKM quantizer.
- ** @param asgn  Assignments (out).
- ** @param data  data.
- ** @param N     number of data (@a N @c >= 1).
- **
- ** The function projects the data @a data on the integer K-means
- ** clusters specified by the IKM quantizer @a f. Notice that the
- ** quantizer must be initialized.
- **/
-
-void
-vl_ikm_push (VlIKMFilt *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) {
-  switch (f -> method) {
-  case VL_IKM_LLOYD : vl_ikm_push_lloyd (f, asgn, data, N) ; break ;
-  case VL_IKM_ELKAN : vl_ikm_push_elkan (f, asgn, data, N) ; break ;
-  default :
-    abort() ;
-  }
-}
-
-/** @brief Project one datum to clusters
- ** @param centers centers.
- ** @param data datum to project.
- ** @param K number of centers.
- ** @param M dimensionality of the datum.
- ** @return the cluster index.
- **
- ** The function projects the specified datum @a data on the clusters
- ** specified by the centers @a centers.
- **/
-
-vl_uint32
-vl_ikm_push_one (vl_ikmacc_t const *centers,
-		 vl_uint8 const *data,
-		 vl_size M, vl_size K)
-{
-  vl_uindex i,k ;
-
-  /* assign data to centers */
-  vl_uindex best = (vl_uindex) -1 ;
-  vl_ikmacc_t best_dist = 0 ;
-
-  for(k = 0 ; k < K ; ++k) {
-    vl_ikmacc_t dist = 0 ;
-
-    /* compute distance with this center */
-    for(i = 0 ; i < M ; ++i) {
-      vl_ikmacc_t delta = (vl_ikmacc_t)data[i] - centers[k*M + i] ;
-      dist += delta * delta ;
-    }
-
-    /* compare with current best */
-    if (best == (vl_uindex) -1 || dist < best_dist) {
-      best = k  ;
-      best_dist = dist ;
-    }
-  }
-  return (vl_uint32)best;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Getters and setters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get data dimensionality
- ** @param f IKM filter.
- ** @return data dimensionality.
- **/
-
-vl_size
-vl_ikm_get_ndims (VlIKMFilt const* f)
-{
-  return f->M ;
-}
-
-
-/** @brief Get the number of centers K
- ** @param f IKM filter.
- ** @return number of centers K.
- **/
-
-vl_size
-vl_ikm_get_K (VlIKMFilt const* f)
-{
-  return f->K ;
-}
-
-/** @brief Get verbosity level
- ** @param f IKM filter.
- ** @return verbosity level.
- **/
-
-int
-vl_ikm_get_verbosity (VlIKMFilt const* f)
-{
-  return f->verb ;
-}
-
-/** @brief Get maximum number of iterations
- ** @param f IKM filter.
- ** @return maximum number of iterations.
- **/
-
-vl_size
-vl_ikm_get_max_niters (VlIKMFilt const* f)
-{
-  return f->max_niters ;
-}
-
-/** @brief Get maximum number of iterations
- ** @param f IKM filter.
- ** @return maximum number of iterations.
- **/
-
-vl_ikmacc_t const *
-vl_ikm_get_centers (VlIKMFilt const* f)
-{
-  return f-> centers ;
-}
-
-/** @brief Set verbosity level
- ** @param f IKM filter.
- ** @param verb verbosity level.
- **/
-
-void
-vl_ikm_set_verbosity (VlIKMFilt *f, int verb)
-{
-  f-> verb = VL_MAX(0,verb) ;
-}
-
-/** @brief Set maximum number of iterations
- ** @param f IKM filter.
- ** @param max_niters maximum number of iterations.
- **/
-
-void
-vl_ikm_set_max_niters (VlIKMFilt *f, vl_size max_niters)
-{
-  f-> max_niters = max_niters ;
-}
-
-#include "ikmeans_init.tc"
-#include "ikmeans_lloyd.tc"
-#include "ikmeans_elkan.tc"
diff --git a/opensfm/src/third_party/vlfeat/vl/ikmeans.h b/opensfm/src/third_party/vlfeat/vl/ikmeans.h
deleted file mode 100644
index e79908056..000000000
--- a/opensfm/src/third_party/vlfeat/vl/ikmeans.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/** @file ikmeans.h
- ** @brief Integer K-Means clustering
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2014 Andrea Vedaldi.
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_IKMEANS_H
-#define VL_IKMEANS_H
-
-#include "generic.h"
-#include "random.h"
-
-#if 0
-typedef vl_int64 vl_ikmacc_t ; /**< IKM accumulator data type */
-#define VL_IKMACC_MAX 0x7fffffffffffffffULL
-#else
-typedef vl_int32 vl_ikmacc_t ; /**< IKM accumulator data type */
-#define VL_IKMACC_MAX 0x7fffffffUL
-#endif
-
-
-/** ------------------------------------------------------------------
- ** @brief IKM algorithms
- **/
-
-enum VlIKMAlgorithms {
-  VL_IKM_LLOYD, /**< Lloyd algorithm */
-  VL_IKM_ELKAN, /**< Elkan algorithm */
-} ;
-
-/** ------------------------------------------------------------------
- ** @brief IKM quantizer
- **/
-
-typedef struct _VlIKMFilt
-{
-  vl_size M ; /**< data dimensionality */
-  vl_size K ; /**< number of centers   */
-  vl_size max_niters ; /**< Lloyd: maximum number of iterations */
-  int method ; /**< Learning method */
-  int verb ; /**< verbosity level */
-  vl_ikmacc_t *centers ; /**< centers */
-  vl_ikmacc_t *inter_dist ; /**< centers inter-distances */
-} VlIKMFilt ;
-
-/** @name Create and destroy
- ** @{ */
-VL_EXPORT VlIKMFilt *vl_ikm_new (int method) ;
-VL_EXPORT void vl_ikm_delete (VlIKMFilt *f) ;
-/** @} */
-
-/** @name Process data
- ** @{ */
-VL_EXPORT void vl_ikm_init (VlIKMFilt *f, vl_ikmacc_t const *centers, vl_size M, vl_size K) ;
-VL_EXPORT void vl_ikm_init_rand (VlIKMFilt *f, vl_size M, vl_size K) ;
-VL_EXPORT void vl_ikm_init_rand_data (VlIKMFilt *f, vl_uint8 const *data, vl_size M, vl_size N, vl_size K) ;
-VL_EXPORT int  vl_ikm_train (VlIKMFilt *f, vl_uint8 const *data, vl_size N) ;
-VL_EXPORT void vl_ikm_push (VlIKMFilt *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) ;
-VL_EXPORT vl_uint vl_ikm_push_one (vl_ikmacc_t const *centers, vl_uint8 const *data, vl_size M, vl_size K) ;
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{ */
-VL_EXPORT vl_size vl_ikm_get_ndims (VlIKMFilt const *f) ;
-VL_EXPORT vl_size vl_ikm_get_K (VlIKMFilt const *f) ;
-VL_EXPORT int vl_ikm_get_verbosity (VlIKMFilt const *f) ;
-VL_EXPORT vl_size vl_ikm_get_max_niters (VlIKMFilt const *f) ;
-VL_EXPORT vl_ikmacc_t const *vl_ikm_get_centers (VlIKMFilt const *f) ;
-/** @} */
-
-/** @name Set parameters
- ** @{ */
-VL_EXPORT void vl_ikm_set_verbosity (VlIKMFilt *f, int verb) ;
-VL_EXPORT void vl_ikm_set_max_niters (VlIKMFilt *f, vl_size max_niters) ;
-/** @} */
-
-/* VL_IKMEANS_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv.c b/opensfm/src/third_party/vlfeat/vl/imopv.c
deleted file mode 100644
index 984b5061a..000000000
--- a/opensfm/src/third_party/vlfeat/vl/imopv.c
+++ /dev/null
@@ -1,1074 +0,0 @@
-/** @file imopv.c
- ** @brief Vectorized image operations - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file imopv.h
- **
- ** This module provides the following image operations:
- **
- ** - <b>Separable convolution.</b> The function ::vl_imconvcol_vf()
- **   can be used to compute separable convolutions.
- **
- ** - <b>Convolution by a triangular kernel.</b> The function
- **   vl_imconvcoltri_vf() is an optimized convolution routine for
- **   triangular kernels.
- **
- ** - <b>Distance transform.</b> ::vl_image_distance_transform_f() is
- **   a linear algorithm to compute the distance transform of an
- **   image.
- **
- ** @remark  Some operations are optimized to exploit possible SIMD
- ** instructions. This requires image data to be properly aligned (typically
- ** to 16 bytes). Similalry, the image stride (the number of bytes to skip to move
- ** to the next image row), must be aligned.
-  **/
-
-#ifndef VL_IMOPV_INSTANTIATING
-
-#include "imopv.h"
-#include "imopv_sse2.h"
-#include "mathop.h"
-
-#define FLT VL_TYPE_FLOAT
-#define VL_IMOPV_INSTANTIATING
-#include "imopv.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define VL_IMOPV_INSTANTIATING
-#include "imopv.c"
-
-#define FLT VL_TYPE_UINT32
-#define VL_IMOPV_INSTANTIATING
-#include "imopv.c"
-
-#define FLT VL_TYPE_INT32
-#define VL_IMOPV_INSTANTIATING
-#include "imopv.c"
-
-/* VL_IMOPV_INSTANTIATING */
-#endif
-
-#if defined(VL_IMOPV_INSTANTIATING) || defined(__DOXYGEN__)
-
-#include "float.h"
-
-/* ---------------------------------------------------------------- */
-/*                                                Image Convolution */
-/* ---------------------------------------------------------------- */
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-/** @fn vl_imconvcol_vd(double*,vl_size,double const*,vl_size,vl_size,vl_size,double const*,vl_index,vl_index,int,unsigned int)
- ** @brief Convolve image along columns
- **
- ** @param dst destination image.
- ** @param dst_stride width of the destination image including padding.
- ** @param src source image.
- ** @param src_width width of the source image.
- ** @param src_height height of the source image.
- ** @param src_stride width of the source image including padding.
- ** @param filt filter kernel.
- ** @param filt_begin coordinate of the first filter element.
- ** @param filt_end coordinate of the last filter element.
- ** @param step sub-sampling step.
- ** @param flags operation modes.
- **
- ** The function convolves the column of the image @a src by the
- ** filter @a filt and saves the result to the image @a dst. The size
- ** of @a dst must be equal to the size of @a src.  Formally, this
- ** results in the calculation
- **
- ** @f[
- ** \mathrm{dst} [x,y] = \sum_{p=y-\mathrm{filt\_end}}^{y-\mathrm{filt\_begin}}
- ** \mathrm{src}[x,y] \mathrm{filt}[y - p - \mathrm{filt\_begin}]
- ** @f]
- **
- ** The function subsamples the image along the columns according to
- ** the parameter @a step. Setting @a step to 1 (one) computes the
- ** elements @f$\mathrm{dst}[x,y]@f$ for all pairs (x,0), (x,1), (x,2)
- ** and so on. Setting @a step two 2 (two) computes only (x,0), (x,2)
- ** and so on (in this case the height of the destination image is
- ** <code>floor(src_height/step)+1)</code>.
- **
- ** Calling twice the function can be used to compute 2-D separable
- ** convolutions.  Use the flag ::VL_TRANSPOSE to transpose the result
- ** (in this case @a dst has transposed dimension as well).
- **
- ** The function allows the support of the filter to be any range.
- ** Usually the support is <code>@a filt_end = -@a filt_begin</code>.
- **
- ** The convolution operation may pick up values outside the image
- ** boundary. To cope with this edge cases, the function either pads
- ** the image by zero (::VL_PAD_BY_ZERO) or with the values at the
- ** boundary (::VL_PAD_BY_CONTINUITY).
- **/
-
-/** @fn vl_imconvcol_vf(float*,vl_size,float const*,vl_size,vl_size,vl_size,float const*,vl_index,vl_index,int,unsigned int)
- ** @see ::vl_imconvcol_vd
- **/
-
-VL_EXPORT void
-VL_XCAT(vl_imconvcol_v, SFX)
-(T* dst, vl_size dst_stride,
- T const* src,
- vl_size src_width, vl_size src_height, vl_size src_stride,
- T const* filt, vl_index filt_begin, vl_index filt_end,
- int step, unsigned int flags)
-{
-  vl_index x = 0 ;
-  vl_index y ;
-  vl_index dheight = (src_height - 1) / step + 1 ;
-  vl_bool transp = flags & VL_TRANSPOSE ;
-  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
-
-  /* dispatch to accelerated version */
-#ifndef VL_DISABLE_SSE2
-  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
-    VL_XCAT3(_vl_imconvcol_v,SFX,_sse2)
-    (dst,dst_stride,
-     src,src_width,src_height,src_stride,
-     filt,filt_begin,filt_end,
-     step,flags) ;
-    return ;
-  }
-#endif
-
-  /* let filt point to the last sample of the filter */
-  filt += filt_end - filt_begin ;
-
-  while (x < (signed)src_width) {
-    /* Calculate dest[x,y] = sum_p image[x,p] filt[y - p]
-     * where supp(filt) = [filt_begin, filt_end] = [fb,fe].
-     *
-     * CHUNK_A: y - fe <= p < 0
-     *          completes VL_MAX(fe - y, 0) samples
-     * CHUNK_B: VL_MAX(y - fe, 0) <= p < VL_MIN(y - fb, height - 1)
-     *          completes fe - VL_MAX(fb, height - y) + 1 samples
-     * CHUNK_C: completes all samples
-     */
-    T const *filti ;
-    vl_index stop ;
-
-    for (y = 0 ; y < (signed)src_height ; y += step) {
-      T acc = 0 ;
-      T v = 0, c ;
-      T const* srci ;
-
-      filti = filt ;
-      stop = filt_end - y ;
-      srci = src + x - stop * src_stride ;
-
-      if (stop > 0) {
-        if (zeropad) {
-          v = 0 ;
-        } else {
-          v = *(src + x) ;
-        }
-        while (filti > filt - stop) {
-          c = *filti-- ;
-          acc += v * c ;
-          srci += src_stride ;
-        }
-      }
-
-      stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
-      while (filti > filt - stop) {
-        v = *srci ;
-        c = *filti-- ;
-        acc += v * c ;
-        srci += src_stride ;
-      }
-
-      if (zeropad) v = 0 ;
-
-      stop = filt_end - filt_begin + 1 ;
-      while (filti > filt - stop) {
-        c = *filti-- ;
-        acc += v * c ;
-      }
-
-      if (transp) {
-        *dst = acc ; dst += 1 ;
-      } else {
-        *dst = acc ; dst += dst_stride ;
-      }
-    } /* next y */
-    if (transp) {
-      dst += 1 * dst_stride - dheight * 1 ;
-    } else {
-      dst += 1 * 1 - dheight * dst_stride ;
-    }
-    x += 1 ;
-  } /* next x */
-}
-
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                         Image distance transform */
-/* ---------------------------------------------------------------- */
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-/** @fn ::vl_image_distance_transform_d(double const*,vl_size,vl_size,vl_size,vl_size,double*,vl_uindex*,double,double)
- ** @brief Compute the distance transform of an image
- ** @param image image.
- ** @param numColumns number of columns of the image.
- ** @param numRows number of rows of the image.
- ** @param columnStride offset from one column to the next.
- ** @param rowStride offset from one row to the next.
- ** @param distanceTransform distance transform (out).
- ** @param indexes nearest neighbor indexes (in/out).
- ** @param coeff quadratic cost coefficient (non-negative).
- ** @param offset quadratic cost offset.
- **
- ** The function computes the distance transform along the first
- ** dimension of the image @a image. Let @f$ I(u,v) @f$ be @a image.
- ** Its distance transfrom @f$ D(u,v) @f$ is given by:
- **
- ** @f[
- **   u^*(u,v) = \min_{u'} I(u',v) + \mathtt{coeff} (u' - u - \mathtt{offset})^2,
- **   \quad D(u,v) = I(u^*(u,v),v).
- ** @f]
- **
- ** Notice that @a coeff must be non negative.
- **
- ** The function fills in the buffer @a distanceTransform with @f$ D
- ** @f$.  This buffer must have the same size as @a image.
- **
- ** If @a indexes is not @c NULL, it must be a matrix of the same size
- ** o the image. The function interprets the value of this matrix as
- ** indexes of the pixels, i.e @f$ \mathtt{indexes}(u,v) @f$ is the
- ** index of pixel @f$ (u,v) @f$. On output, the matrix @a indexes
- ** contains @f$ \mathtt{indexes}(u^*(u,v),v) @f$. This information
- ** can be used to determine for each pixel @f$ (u,v) @f$ its
- ** &ldquo;nearest neighbor&rdquo.
- **
- ** Notice that by swapping @a numRows and @a numColumns and @a
- ** columnStride and @a rowStride, the function can be made to operate
- ** along the other image dimension. Specifically, to compute the
- ** distance transform along columns and rows, call the functinon
- ** twice:
- ***
- ** @code
- **   for (i = 0 ; i < numColumns * numRows ; ++i) indexes[i] = i ;
- **   vl_image_distance_transform_d(image,numColumns,numRows,1,numColumns,
- **                                 distanceTransform,indexes,u_coeff,u_offset) ;
- **   vl_image_distance_transform_d(distanceTransform,numRows,numColumns,numColumns,1,
- **                                 distanceTransform,indexes,u_coeff,u_offset) ;
- ** @endcode
- **
- ** @par Algorithm
- **
- ** The function implements the algorithm described in:
- ** P. F. Felzenszwalb and D. P. Huttenlocher, <em>Distance Transforms
- ** of Sampled Functions,</em> Technical Report, Cornell University,
- ** 2004.
- **
- ** Since the algorithm operates along one dimension per time,
- ** consider the 1D version of the problem for simplicity:
- **
- ** @f[
- **  d(y) = \min_{x} g(y;x), \quad g(y;x) = f(x) + \alpha (y - x - \beta)^2,
- **  \quad x,y \in \{0,1,\dots,N-1\}.
- ** @f]
- **
- ** Hence the distance transform @f$ d(y) @f$ is the lower envelope of
- ** the family of parabolas @f$ g(y;x) @f$ indexed by @f$ x
- ** @f$. Notice that all parabolas have the same curvature and that
- ** their centers are located at @f$ x + \beta, @f$ @f$ x=0,\dots,N-1
- ** @f$. The algorithm considers one parabola per time, from left to
- ** right, and finds the interval for which the parabola belongs to
- ** the lower envelope (if any).
- **
- ** Initially, only the leftmost parabola @f$ g(y;0) @f$ has been
- ** considered, and its validity interval is @f$(-\infty, \infty) @f$.
- ** Then the second parabola @f$ g(y;1) @f$ is considered. As long as
- ** @f$ \alpha > 0 @f$, the two parabolas @f$ g(y;0),\ g(y;1) @f$
- ** intersect at a unique point @f$ \bar y @f$. Then the first
- ** parabola belongs to the envelope in the interval @f$ (-\infty,
- ** \bar y] @f$ and the second one in the interval @f$ (\bar y,
- ** +\infty] @f$. When the third parabola @f$ g(y;2) @f$ is
- ** considered, the intersection point @f$ \hat y @f$ with the
- ** previously added parabola @f$ g(y;1) @f$ is found. Now two cases
- ** may arise:
- **
- ** - @f$ \hat y > \bar y @f$, in which case all three parabolas
- **   belong to the envelope in the intervals @f$ (-\infty,\bar y],
- **   (\bar y, \hat y], (\hat y, +\infty] @f$.
- **
- ** - @f$ \hat y \leq \bar y @f$, in which case the second parabola
- **   @f$ g(y;1) @f$ has no point beloning to the envelope, and it is
- **   removed.  One then remains with the two parabolas @f$ g(y;0),\
- **   g(y;2) @f$ and the algorithm is re-iterated.
- **
- ** The algorithm proceeds in this fashion. Every time a new parabola
- ** is considered, its intersection point with the previously added
- ** parabola on the left is computed, and that parabola is potentially
- ** removed.  The cost of an iteration is 1 plus the number of deleted
- ** parabolas. Since there are @f$ N @f$ iterations and at most @f$ N
- ** @f$ parabolas to delete overall, the complexity is linear,
- ** i.e. @f$ O(N) @f$.
- **/
-
-/** @fn ::vl_image_distance_transform_f(float const*,vl_size,vl_size,vl_size,vl_size,float*,vl_uindex*,float,float)
- ** @see ::vl_image_distance_transform_d
- **/
-
-VL_EXPORT void
-VL_XCAT(vl_image_distance_transform_,SFX)
-(T const * image,
- vl_size numColumns,
- vl_size numRows,
- vl_size columnStride,
- vl_size rowStride,
- T * distanceTransform,
- vl_uindex * indexes,
- T coeff,
- T offset)
-{
-  /* Each image pixel corresponds to a parabola. The algorithm scans
-   such parabolas from left to right, keeping track of which
-   parabolas belong to the lower envelope and in which interval. There are
-   NUM active parabolas, FROM stores the beginning of the interval
-   for which a certain parabola is part of the envoelope, and WHICH store
-   the index of the parabola (that is, the pixel x from which the parabola
-   originated).
-   */
-  vl_uindex x, y ;
-  T * from = vl_malloc (sizeof(T) * (numColumns + 1)) ;
-  T * base = vl_malloc (sizeof(T) * numColumns) ;
-  vl_uindex * baseIndexes = vl_malloc (sizeof(vl_uindex) * numColumns) ;
-  vl_uindex * which = vl_malloc (sizeof(vl_uindex) * numColumns) ;
-  vl_uindex num = 0 ;
-
-  for (y = 0 ; y < numRows ; ++y) {
-    num = 0 ;
-    for (x = 0 ; x < numColumns ; ++x) {
-      T r = image[x  * columnStride + y * rowStride] ;
-      T x2 = x * x ;
-#if (FLT == VL_TYPE_FLOAT)
-      T from_ = - VL_INFINITY_F ;
-#else
-      T from_ = - VL_INFINITY_D ;
-#endif
-
-      /*
-       Add next parabola (there are NUM so far). The algorithm finds
-       intersection INTERS with the previously added parabola. If
-       the intersection is on the right of the "starting point" of
-       this parabola, then the previous parabola is kept, and the
-       new one is added to its right. Otherwise the new parabola
-       "eats" the old one, which gets deleted and the check is
-       repeated with the parabola added before the deleted one.
-       */
-
-      while (num >= 1) {
-        vl_uindex x_ = which[num - 1] ;
-        T x2_ = x_ * x_ ;
-        T r_ = image[x_ * columnStride + y * rowStride] ;
-        T inters ;
-        if (r == r_) {
-          /* handles the case r = r_ = \pm inf */
-          inters = (x + x_) / 2.0 + offset ;
-        }
-#if (FLT == VL_TYPE_FLOAT)
-        else if (coeff > VL_EPSILON_F)
-#else
-        else if (coeff > VL_EPSILON_D)
-#endif
-        {
-          inters = ((r - r_) + coeff * (x2 - x2_)) / (x - x_) / (2*coeff) + offset ;
-        } else {
-          /* If coeff is very small, the parabolas are flat (= lines).
-           In this case the previous parabola should be deleted if the current
-           pixel has lower score */
-#if (FLT == VL_TYPE_FLOAT)
-          inters = (r < r_) ? - VL_INFINITY_F : VL_INFINITY_F ;
-#else
-          inters = (r < r_) ? - VL_INFINITY_D : VL_INFINITY_D ;
-#endif
-        }
-        if (inters <= from [num - 1]) {
-          /* delete a previous parabola */
-          -- num ;
-        } else {
-          /* accept intersection */
-          from_ = inters ;
-          break ;
-        }
-      }
-
-      /* add a new parabola */
-      which[num] = x ;
-      from[num] = from_ ;
-      base[num] = r ;
-      if (indexes) baseIndexes[num] = indexes[x  * columnStride + y * rowStride] ;
-      num ++ ;
-    } /* next column */
-
-#if (FLT == VL_TYPE_FLOAT)
-    from[num] = VL_INFINITY_F ;
-#else
-    from[num] = VL_INFINITY_D ;
-#endif
-
-    /* fill in */
-    num = 0 ;
-    for (x = 0 ; x < numColumns ; ++x) {
-      double delta ;
-      while (x >= from[num + 1]) ++ num ;
-      delta = (double) x - (double) which[num] - offset ;
-      distanceTransform[x  * columnStride + y * rowStride]
-      = base[num] + coeff * delta * delta ;
-      if (indexes) {
-        indexes[x  * columnStride + y * rowStride]
-        = baseIndexes[num] ;
-      }
-    }
-  } /* next row */
-
-  vl_free (from) ;
-  vl_free (which) ;
-  vl_free (base) ;
-  vl_free (baseIndexes) ;
-}
-
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                         Image convolution by a triangular kernel */
-/* ---------------------------------------------------------------- */
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-/** @fn vl_imconvcoltri_d(double*,vl_size,double const*,vl_size,vl_size,vl_size,vl_size,vl_size,int unsigned)
- ** @brief Convolve an image along the columns with a triangular kernel
- ** @param dest destination image.
- ** @param destStride destination image stride.
- ** @param image image to convolve.
- ** @param imageWidth width of the image.
- ** @param imageHeight height of the image.
- ** @param imageStride width of the image including padding.
- ** @param filterSize size of the triangular filter.
- ** @param step sub-sampling step.
- ** @param flags operation modes.
- **
- ** The function convolves the columns of the image @a image with the
- ** triangular kernel
- **
- ** @f[
- **   k(t) = \frac{1}{\Delta^2} \max\{ \Delta -  |t|, 0 \},
- **   \quad t \in \mathbb{Z}
- ** @f]
- **
- ** The paramter @f$ \Delta @f$, equal to the function argument @a
- ** filterSize, controls the width of the kernel. Notice that the
- ** support of @f$ k(x) @f$ as a continuous function of @f$ x @f$ is
- ** the open interval @f$ (-\Delta,\Delta) @f$, which has length @f$
- ** 2\Delta @f$.  However, @f$ k(x) @f$ restricted to the ingeter
- ** domain @f$ x \in \mathcal{Z} @f$ has support @f$ \{ -\Delta + 1,
- ** \Delta +2, \dots, \Delta-1 \} @f$, which counts @f$ 2 \Delta - 1
- ** @f$ elements only. In particular, the discrete kernel is symmetric
- ** about the origin for all values of @f$ \Delta @f$.
- **
- ** The normalization factor @f$ 1 / \Delta^2 @f$ guaratnees that the
- ** filter is normalized to one, i.e.:
- **
- ** @f[
- **   \sum_{t=-\infty}^{+\infty} k(t) = 1
- ** @f]
- **
- ** @par Algorithm
- **
- ** The function exploits the fact that convolution by a triangular
- ** kernel can be expressed as the repeated convolution by a
- ** rectangular kernel, and that the latter can be performed in time
- ** indepenedent on the fiter width by using an integral-image type
- ** trick. Overall, the algorithm complexity is independent on the
- ** parameter @a filterSize and linear in the nubmer of image pixels.
- **
- ** @see ::vl_imconvcol_vd for details on the meaning of the other parameters.
- **/
-
-/** @fn vl_imconvcoltri_f(float*,vl_size,float const*,vl_size,vl_size,vl_size,vl_size,vl_size,int unsigned)
- ** @brief Convolve an image along the columns with a triangular kernel
- ** @see ::vl_imconvcoltri_d()
- **/
-
-VL_EXPORT void
-VL_XCAT(vl_imconvcoltri_, SFX)
-(T * dest, vl_size destStride,
- T const * image,
- vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
- vl_size filterSize,
- vl_size step, unsigned int flags)
-{
-  vl_index x, y, dheight ;
-  vl_bool transp = flags & VL_TRANSPOSE ;
-  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
-  T scale = (T) (1.0 / ((double)filterSize * (double)filterSize)) ;
-  T * buffer = vl_malloc (sizeof(T) * (imageHeight + filterSize)) ;
-  buffer += filterSize ;
-
-  if (imageHeight == 0) {
-    return  ;
-  }
-
-  x = 0 ;
-  dheight = (imageHeight - 1) / step + 1 ;
-
-  while (x < (signed)imageWidth) {
-    T const * imagei ;
-    imagei = image + x + imageStride * (imageHeight - 1) ;
-
-    /* We decompose the convolution by a triangluar signal as the convolution
-     * by two rectangular signals. The rectangular convolutions are computed
-     * quickly by computing the integral signals. Each rectangular convolution
-     * introduces a delay, which is compensated by convolving each in opposite
-     * directions.
-     */
-
-    /* integrate backward the column */
-    buffer[imageHeight - 1] = *imagei ;
-    for (y = (signed)imageHeight - 2 ; y >=  0 ; --y) {
-      imagei -= imageStride ;
-      buffer[y] = buffer[y + 1] + *imagei ;
-    }
-    if (zeropad) {
-      for ( ; y >= - (signed)filterSize ; --y) {
-        buffer[y] = buffer[y + 1] ;
-      }
-    } else {
-      for ( ; y >= - (signed)filterSize ; --y) {
-        buffer[y] = buffer[y + 1] + *imagei ;
-      }
-    }
-
-    /* compute the filter forward */
-    for (y = - (signed)filterSize ;
-         y < (signed)imageHeight - (signed)filterSize ; ++y) {
-      buffer[y] = buffer[y] - buffer[y + filterSize] ;
-    }
-    if (! zeropad) {
-      for (y = (signed)imageHeight - (signed)filterSize ;
-           y < (signed)imageHeight ;
-           ++y) {
-        buffer[y] = buffer[y] - buffer[imageHeight - 1]  *
-        ((signed)imageHeight - (signed)filterSize - y) ;
-      }
-    }
-
-    /* integrate forward the column */
-    for (y = - (signed)filterSize + 1 ;
-         y < (signed)imageHeight ; ++y) {
-      buffer[y] += buffer[y - 1] ;
-    }
-
-    /* compute the filter backward */
-    {
-      vl_size stride = transp ? 1 : destStride ;
-      dest += dheight * stride ;
-      for (y = step * (dheight - 1) ; y >= 0 ; y -= step) {
-        dest -= stride ;
-        *dest = scale * (buffer[y] - buffer[y - (signed)filterSize]) ;
-      }
-      dest += transp ? destStride : 1 ;
-    }
-    x += 1 ;
-  } /* next x */
-  vl_free (buffer - filterSize) ;
-}
-
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                               Gaussian Smoothing */
-/* ---------------------------------------------------------------- */
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-/** @fn vl_imsmooth_d(double*,vl_size,double const*,vl_size,vl_size,vl_size,double,double)
- ** @brief Smooth an image with a Gaussian filter
- ** @param smoothed
- ** @param smoothedStride
- ** @param image
- ** @param width
- ** @param height
- ** @param stride
- ** @param sigmax
- ** @param sigmay
- **/
-
-/** @fn vl_imsmooth_f(float*,vl_size,float const*,vl_size,vl_size,vl_size,double,double)
- ** @brief Smooth an image with a Gaussian filter
- ** @see ::vl_imsmooth_d
- **/
-
-static T*
-VL_XCAT(_vl_new_gaussian_fitler_,SFX)(vl_size *size, double sigma)
-{
-  T* filter ;
-  T mass = (T)1.0 ;
-  vl_index i ;
-  vl_size width = vl_ceil_d(sigma * 3.0) ;
-  *size = 2 * width + 1 ;
-
-  assert(size) ;
-
-  filter = vl_malloc((*size) * sizeof(T)) ;
-  filter[width] = 1.0 ;
-  for (i = 1 ; i <= (signed)width ; ++i) {
-    double x = (double)i / sigma ;
-    double g = exp(-0.5 * x * x) ;
-    mass += g + g ;
-    filter[width-i] = g ;
-    filter[width+i] = g ;
-  }
-  for (i = 0 ; i < (signed)(*size) ; ++i) {filter[i] /= mass ;}
-  return filter ;
-}
-
-VL_EXPORT void
-VL_XCAT(vl_imsmooth_, SFX)
-(T * smoothed, vl_size smoothedStride,
- T const *image, vl_size width, vl_size height, vl_size stride,
- double sigmax, double sigmay)
-{
-  T *filterx, *filtery, *buffer ;
-  vl_size sizex, sizey ;
-
-  filterx = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizex,sigmax) ;
-  if (sigmax == sigmay) {
-    filtery = filterx ;
-    sizey = sizex ;
-  } else {
-    filtery = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizey,sigmay) ;
-  }
-  buffer = vl_malloc(width*height*sizeof(T)) ;
-
-  VL_XCAT(vl_imconvcol_v,SFX) (buffer, height,
-                               image, width, height, stride,
-                               filtery,
-                               -((signed)sizey-1)/2, ((signed)sizey-1)/2,
-                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
-
-  VL_XCAT(vl_imconvcol_v,SFX) (smoothed, smoothedStride,
-                               buffer, height, width, height,
-                               filterx,
-                               -((signed)sizex-1)/2, ((signed)sizex-1)/2,
-                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
-
-  vl_free(buffer) ;
-  vl_free(filterx) ;
-  if (sigmax != sigmay) {
-    vl_free(filtery) ;
-  }
-}
-
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                                   Image Gradient */
-/* ---------------------------------------------------------------- */
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-/** @fn vl_imgradient_d(double*,double*,vl_size,vl_size,double*,vl_size,vl_size,vl_size)
- ** @brief Compute image gradient
- ** @param xGradient Pointer to amplitude gradient plane
- ** @param yGradient Pointer to angle gradient plane
- ** @param gradWidthStride Width of the gradient plane including padding
- ** @param gradHeightStride Height of the gradient plane including padding
- ** @param image Pointer to the source image
- ** @param imageWidth Source image width
- ** @param imageHeight Source image height
- ** @param imageStride Width of the image including padding.
- **
- ** This functions computes the amplitudes and angles of input image gradient.
- **
- ** Gradient is computed simple by gradient kernel \f$ (-1 ~ 1) \f$,
- ** \f$ (-1 ~ 1)^T \f$ for border pixels and with sobel filter kernel
- ** \f$ (-0.5 ~ 0 ~ 0.5) \f$, \f$ (-0.5 ~ 0 ~ 0.5)^T \f$ otherwise on the input
- ** image @a image yielding x-gradient \f$ dx \f$, stored in @a xGradient and
- ** y-gradient \f$ dy \f$, stored in @a yGradient, respectively.
- **
- ** This function also allows to process only part of the input image
- ** defining the @a imageStride as original image width and @a width as
- ** width of the sub-image.
- **
- ** Also it allows to easily align the output data by definition
- ** of the @a gradWidthStride and @a gradHeightStride .
- **/
-
-/** @fn vl_imgradient_f(float*,float*,vl_size,vl_size,float*,vl_size,vl_size,vl_size)
- ** @brief Compute image gradient
- ** @see ::vl_imgradient_d
- **/
-
-VL_EXPORT void
-VL_XCAT(vl_imgradient_, SFX)
-(T * xGradient, T * yGradient,
- vl_size gradWidthStride, vl_size gradHeightStride,
- T const * image,
- vl_size imageWidth, vl_size imageHeight,
- vl_size imageStride)
-{
-  /* Shortcuts */
-  vl_index const xo = 1 ;
-  vl_index const yo = imageStride ;
-  vl_size const w = imageWidth;
-  vl_size const h = imageHeight;
-
-  T const *src, *end ;
-  T *pgrad_x, *pgrad_y;
-  vl_size y;
-
-  src  = image ;
-  pgrad_x = xGradient ;
-  pgrad_y = yGradient ;
-
-  /* first pixel of the first row */
-  *pgrad_x = src[+xo] - src[0] ;
-  pgrad_x += gradWidthStride;
-  *pgrad_y = src[+yo] - src[0] ;
-  pgrad_y += gradWidthStride;
-  src++;
-
-  /* middle pixels of the  first row */
-  end = (src - 1) + w - 1 ;
-  while (src < end) {
-    *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
-    pgrad_x += gradWidthStride;
-    *pgrad_y =        src[+yo] - src[0] ;
-    pgrad_y += gradWidthStride;
-    src++;
-  }
-
-  /* last pixel of the first row */
-  *pgrad_x = src[0]   - src[-xo] ;
-  pgrad_x += gradWidthStride;
-  *pgrad_y = src[+yo] - src[0] ;
-  pgrad_y += gradWidthStride;
-  src++;
-
-  xGradient += gradHeightStride;
-  pgrad_x = xGradient;
-  yGradient += gradHeightStride;
-  pgrad_y = yGradient;
-  image += yo;
-  src = image;
-
-  for (y = 1 ; y < h -1 ; ++y) {
-
-    /* first pixel of the middle rows */
-    *pgrad_x =        src[+xo] - src[0] ;
-    pgrad_x += gradWidthStride;
-    *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
-    pgrad_y += gradWidthStride;
-    src++;
-
-    /* middle pixels of the middle rows */
-    end = (src - 1) + w - 1 ;
-    while (src < end) {
-      *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
-      pgrad_x += gradWidthStride;
-      *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
-      pgrad_y += gradWidthStride;
-      src++;
-    }
-
-    /* last pixel of the middle row */
-    *pgrad_x =        src[0]   - src[-xo] ;
-    pgrad_x += gradWidthStride;
-    *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
-    pgrad_y += gradWidthStride;
-    src++;
-
-    xGradient += gradHeightStride;
-    pgrad_x = xGradient;
-    yGradient += gradHeightStride;
-    pgrad_y = yGradient;
-    image += yo;
-    src = image;
-  }
-
-  /* first pixel of the last row */
-  *pgrad_x = src[+xo] - src[0] ;
-  pgrad_x += gradWidthStride;
-  *pgrad_y = src[  0] - src[-yo] ;
-  pgrad_y += gradWidthStride;
-  src++;
-
-  /* middle pixels of the last row */
-  end = (src - 1) + w - 1 ;
-  while (src < end) {
-    *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
-    pgrad_x += gradWidthStride;
-    *pgrad_y =        src[0]   - src[-yo] ;
-    pgrad_y += gradWidthStride;
-    src++;
-  }
-
-  /* last pixel of the last row */
-  *pgrad_x = src[0]   - src[-xo] ;
-  *pgrad_y = src[0]   - src[-yo] ;
-}
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-
-/** @fn vl_imgradient_polar_d(double*,double*,vl_size,vl_size,double const*,vl_size,vl_size,vl_size)
- ** @brief Compute gradient mangitudes and directions of an image.
- ** @param amplitudeGradient Pointer to amplitude gradient plane
- ** @param angleGradient Pointer to angle gradient plane
- ** @param gradWidthStride Width of the gradient plane including padding
- ** @param gradHeightStride Height of the gradient plane including padding
- ** @param image Pointer to the source image
- ** @param imageWidth Source image width
- ** @param imageHeight Source image height
- ** @param imageStride Width of the source image including padding.
- **
- ** This functions computes the amplitudes and angles of input image gradient.
- **
- ** Gradient is computed simple by gradient kernel \f$ (-1 ~ 1) \f$,
- ** \f$ (-1 ~ 1)^T \f$ for border pixels and with sobel filter kernel
- ** \f$ (-0.5 ~ 0 ~ 0.5) \f$, \f$ (-0.5 ~ 0 ~ 0.5)^T \f$ otherwise on
- ** the input image @a image yielding x-gradient \f$ dx \f$, stored in
- ** @a xGradient and y-gradient \f$ dy \f$, stored in @a yGradient,
- ** respectively.
- **
- ** The amplitude of the gradient, stored in plane @a
- ** amplitudeGradient, is then calculated as \f$ \sqrt(dx^2+dy^2) \f$
- ** and the angle of the gradient, stored in @a angleGradient is \f$
- ** atan(\frac{dy}{dx}) \f$ normalised into interval 0 and @f$ 2\pi
- ** @f$.
- **
- ** This function also allows to process only part of the input image
- ** defining the @a imageStride as original image width and @a width
- ** as width of the sub-image.
- **
- ** Also it allows to easily align the output data by definition
- ** of the @a gradWidthStride and @a gradHeightStride .
- **/
-
-/** @fn vl_imgradient_polar_f(float*,float*,vl_size,vl_size,float const*,vl_size,vl_size,vl_size)
- ** @see ::vl_imgradient_polar_d
- **/
-
-#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
-
-VL_EXPORT void
-VL_XCAT(vl_imgradient_polar_, SFX)
-(T * gradientModulus, T * gradientAngle,
- vl_size gradientHorizontalStride, vl_size gradHeightStride,
- T const* image,
- vl_size imageWidth, vl_size imageHeight, vl_size imageStride)
-{
-  /* Shortcuts */
-  vl_index const xo = 1 ;
-  vl_index const yo = imageStride ;
-  vl_size const w = imageWidth;
-  vl_size const h = imageHeight;
-
-  T const *src, *end;
-  T *pgrad_angl, *pgrad_ampl;
-  T gx, gy ;
-  vl_size y;
-
-#define SAVE_BACK                                                    \
-*pgrad_ampl = vl_fast_sqrt_f (gx*gx + gy*gy) ;                       \
-pgrad_ampl += gradientHorizontalStride ;                             \
-*pgrad_angl = vl_mod_2pi_f   (vl_fast_atan2_f (gy, gx) + 2*VL_PI) ;  \
-pgrad_angl += gradientHorizontalStride ;                             \
-++src ;                                                              \
-
-  src  = image ;
-  pgrad_angl = gradientAngle ;
-  pgrad_ampl = gradientModulus ;
-
-  /* first pixel of the first row */
-  gx = src[+xo] - src[0] ;
-  gy = src[+yo] - src[0] ;
-  SAVE_BACK ;
-
-  /* middle pixels of the  first row */
-  end = (src - 1) + w - 1 ;
-  while (src < end) {
-    gx = 0.5 * (src[+xo] - src[-xo]) ;
-    gy =        src[+yo] - src[0] ;
-    SAVE_BACK ;
-  }
-
-  /* last pixel of the first row */
-  gx = src[0]   - src[-xo] ;
-  gy = src[+yo] - src[0] ;
-  SAVE_BACK ;
-
-  gradientModulus += gradHeightStride;
-  pgrad_ampl = gradientModulus;
-  gradientAngle += gradHeightStride;
-  pgrad_angl = gradientAngle;
-  image += imageStride;
-  src = image;
-
-  for (y = 1 ; y < h -1 ; ++y) {
-
-    /* first pixel of the middle rows */
-    gx =        src[+xo] - src[0] ;
-    gy = 0.5 * (src[+yo] - src[-yo]) ;
-    SAVE_BACK ;
-
-    /* middle pixels of the middle rows */
-    end = (src - 1) + w - 1 ;
-    while (src < end) {
-      gx = 0.5 * (src[+xo] - src[-xo]) ;
-      gy = 0.5 * (src[+yo] - src[-yo]) ;
-      SAVE_BACK ;
-    }
-
-    /* last pixel of the middle row */
-    gx =        src[0]   - src[-xo] ;
-    gy = 0.5 * (src[+yo] - src[-yo]) ;
-    SAVE_BACK ;
-
-    gradientModulus += gradHeightStride;
-    pgrad_ampl = gradientModulus;
-    gradientAngle += gradHeightStride;
-    pgrad_angl = gradientAngle;
-    image += imageStride;
-    src = image;
-  }
-
-  /* first pixel of the last row */
-  gx = src[+xo] - src[0] ;
-  gy = src[  0] - src[-yo] ;
-  SAVE_BACK ;
-
-  /* middle pixels of the last row */
-  end = (src - 1) + w - 1 ;
-  while (src < end) {
-    gx = 0.5 * (src[+xo] - src[-xo]) ;
-    gy =        src[0]   - src[-yo] ;
-    SAVE_BACK ;
-  }
-
-  /* last pixel of the last row */
-  gx = src[0]   - src[-xo] ;
-  gy = src[0]   - src[-yo] ;
-  SAVE_BACK ;
-
-}
-/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
-#endif
-
-/* ---------------------------------------------------------------- */
-/*                                                   Integral Image */
-/* ---------------------------------------------------------------- */
-
-/** @fn vl_imintegral_d(double*,vl_size,double const*,vl_size,vl_size,vl_size)
- ** @brief Compute integral image
- **
- ** @param integral integral image.
- ** @param integralStride integral image stride.
- ** @param image source image.
- ** @param imageWidth source image width.
- ** @param imageHeight source image height.
- ** @param imageStride source image stride.
- **
- ** Let @f$ I(x,y), (x,y) \in [0, W-1] \times [0, H-1] @f$. The
- ** function computes the integral image @f$ J(x,y) @f$ of @f$ I(x,g)
- ** @f$:
- **
- ** @f[
- **   J(x,y) = \sum_{x'=0}^{x} \sum_{y'=0}^{y} I(x',y')
- ** @f]
- **
- ** The integral image @f$ J(x,y) @f$ can be used to compute quickly
- ** the integral of of @f$ I(x,y) @f$ in a rectangular region @f$ R =
- ** [x',x'']\times[y',y''] @f$:
- **
- ** @f[
- **  \sum_{(x,y)\in[x',x'']\times[y',y'']} I(x,y) =
- **  (J(x'',y'') - J(x'-1, y'')) - (J(x'',y'-1) - J(x'-1,y'-1)).
- ** @f]
- **
- ** Note that the order of operations is important when the integral image
- ** has an unsigned data type (e.g. ::vl_uint32). The formula
- ** is easily derived as follows:
- **
- ** @f{eqnarray*}
- **   \sum_{(x,y)\in R} I(x,y)
- **   &=& \sum_{x=x'}^{x''} \sum_{y=y'}^{y''} I(x,y)\\
- **   &=& \sum_{x=0}^{x''}  \sum_{y=y'}^{y''} I(x,y)
- **     - \sum_{x=0}^{x'-1} \sum_{y=y'}^{y''} I(x,y)\\
- **   &=& \sum_{x=0}^{x''}  \sum_{y=0}^{y''}  I(x,y)
- **     - \sum_{x=0}^{x''}  \sum_{y=0}^{y'-1} I(x,y)
- **     - \sum_{x=0}^{x'-1} \sum_{y=0}^{y''}  I(x,y)
- **     + \sum_{x=0}^{x'-1} \sum_{y=0}^{y'-1} I(x,y)\\
- **   &=& J(x'',y'') - J(x'-1,y'') - J(x'',y'-1) + J(x'-1,y'-1).
- ** @f}
- **/
-
-/** @fn vl_imintegral_f(float*,vl_size,float const*,vl_size,vl_size,vl_size)
- ** @brief Compute integral image
- ** @see ::vl_imintegral_d.
- **/
-
-/** @fn vl_imintegral_ui32(vl_uint32*,vl_size,vl_uint32 const*,vl_size,vl_size,vl_size)
- ** @brief Compute integral image
- ** @see ::vl_imintegral_d.
- **/
-
-/** @fn vl_imintegral_i32(vl_int32*,vl_size,vl_int32 const*,vl_size,vl_size,vl_size)
- ** @brief Compute integral image
- ** @see ::vl_imintegral_d.
- **/
-
-VL_EXPORT void
-VL_XCAT(vl_imintegral_, SFX)
-(T * integral, vl_size integralStride,
- T const * image,
- vl_size imageWidth, vl_size imageHeight, vl_size imageStride)
-{
-  vl_uindex x, y ;
-  T temp  = 0 ;
-
-  if (imageHeight > 0) {
-    for (x = 0 ; x < imageWidth ; ++ x) {
-      temp += *image++ ;
-      *integral++ = temp ;
-    }
-  }
-
-  for (y = 1 ; y < imageHeight ; ++ y) {
-    T * integralPrev ;
-    integral += integralStride - imageWidth ;
-    image += imageStride - imageWidth ;
-    integralPrev = integral - integralStride ;
-
-    temp = 0 ;
-    for (x = 0 ; x < imageWidth ; ++ x) {
-      temp += *image++ ;
-      *integral++ = *integralPrev++ + temp ;
-    }
-  }
-}
-
-/* endif VL_IMOPV_INSTANTIATING */
-#undef FLT
-#undef VL_IMOPV_INSTANTIATING
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv.h b/opensfm/src/third_party/vlfeat/vl/imopv.h
deleted file mode 100644
index ca127ca3c..000000000
--- a/opensfm/src/third_party/vlfeat/vl/imopv.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/** @file imopv.h
- ** @brief Vectorized image operations
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_IMOPV_H
-#define VL_IMOPV_H
-
-#include "generic.h"
-
-/** @name Image convolution flags
- ** @{ */
-#define VL_PAD_BY_ZERO       (0x0 << 0) /**< @brief Pad with zeroes. */
-#define VL_PAD_BY_CONTINUITY (0x1 << 0) /**< @brief Pad by continuity. */
-#define VL_PAD_MASK          (0x3)      /**< @brief Padding field selector. */
-#define VL_TRANSPOSE         (0x1 << 2) /**< @brief Transpose result. */
-/** @} */
-
-/** @name Image convolution
- ** @{ */
-VL_EXPORT
-void vl_imconvcol_vf (float* dst, vl_size dst_stride,
-                      float const* src,
-                      vl_size src_width, vl_size src_height, vl_size src_stride,
-                      float const* filt, vl_index filt_begin, vl_index filt_end,
-                      int step, unsigned int flags) ;
-
-VL_EXPORT
-void vl_imconvcol_vd (double* dst, vl_size dst_stride,
-                      double const* src,
-                      vl_size src_width, vl_size src_height, vl_size src_stride,
-                      double const* filt, vl_index filt_begin, vl_index filt_end,
-                      int step, unsigned int flags) ;
-
-VL_EXPORT
-void vl_imconvcoltri_f (float * dest, vl_size destStride,
-                        float const * image,
-                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
-                        vl_size filterSize,
-                        vl_size step, int unsigned flags) ;
-
-VL_EXPORT
-void vl_imconvcoltri_d (double * dest, vl_size destStride,
-                        double const * image,
-                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
-                        vl_size filterSize,
-                        vl_size step, int unsigned flags) ;
-/** @} */
-
-/** @name Integral image
- ** @{ */
-VL_EXPORT
-void vl_imintegral_f (float * integral,  vl_size integralStride,
-                      float const * image,
-                      vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
-
-VL_EXPORT
-void vl_imintegral_d (double * integral,  vl_size integralStride,
-                      double const * image,
-                      vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
-
-VL_EXPORT
-void vl_imintegral_i32 (vl_int32 * integral,  vl_size integralStride,
-                        vl_int32 const * image,
-                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
-
-VL_EXPORT
-void vl_imintegral_ui32 (vl_uint32 * integral,  vl_size integralStride,
-                         vl_uint32 const * image,
-                         vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
-/** @} */
-
-/** @name Distance transform */
-/** @{ */
-
-VL_EXPORT void
-vl_image_distance_transform_d (double const * image,
-                               vl_size numColumns,
-                               vl_size numRows,
-                               vl_size columnStride,
-                               vl_size rowStride,
-                               double * distanceTransform,
-                               vl_uindex * indexes,
-                               double coeff,
-                               double offset) ;
-
-VL_EXPORT void
-vl_image_distance_transform_f (float const * image,
-                               vl_size numColumns,
-                               vl_size numRows,
-                               vl_size columnStride,
-                               vl_size rowStride,
-                               float * distanceTransform,
-                               vl_uindex * indexes,
-                               float coeff,
-                               float offset) ;
-
-/** @} */
-
-/* ---------------------------------------------------------------- */
-/** @name Image smoothing */
-/** @{ */
-
-VL_EXPORT void
-vl_imsmooth_f (float *smoothed, vl_size smoothedStride,
-               float const *image, vl_size width, vl_size height, vl_size stride,
-               double sigmax, double sigmay) ;
-
-VL_EXPORT void
-vl_imsmooth_d (double *smoothed, vl_size smoothedStride,
-               double const *image, vl_size width, vl_size height, vl_size stride,
-               double sigmax, double sigmay) ;
-
-/** @} */
-
-/* ---------------------------------------------------------------- */
-/** @name Image gradients */
-/** @{ */
-VL_EXPORT void
-vl_imgradient_polar_f (float* amplitudeGradient, float* angleGradient,
-                       vl_size gradWidthStride, vl_size gradHeightStride,
-                       float const* image,
-                       vl_size imageWidth, vl_size imageHeight,
-                       vl_size imageStride);
-
-VL_EXPORT void
-vl_imgradient_polar_d (double* amplitudeGradient, double* angleGradient,
-                       vl_size gradWidthStride, vl_size gradHeightStride,
-                       double const* image,
-                       vl_size imageWidth, vl_size imageHeight,
-                       vl_size imageStride);
-
-VL_EXPORT void
-vl_imgradient_f (float* xGradient, float* yGradient,
-                 vl_size gradWidthStride, vl_size gradHeightStride,
-                 float const *image,
-                 vl_size imageWidth, vl_size imageHeight, vl_size imageStride);
-
-VL_EXPORT void
-vl_imgradient_d(double* xGradient, double* yGradient,
-                vl_size gradWidthStride, vl_size gradHeightStride,
-                double const *image,
-                vl_size imageWidth, vl_size imageHeight, vl_size imageStride);
-
-VL_EXPORT void
-vl_imgradient_polar_f_callback(float const *sourceImage,
-                               int sourceImageWidth, int sourceImageHeight,
-                               float *dstImage,
-                               int dstWidth, int dstHeight,
-                               int octave, int level,
-                               void *params);
-
-/** @} */
-
-/* VL_IMOPV_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
deleted file mode 100644
index 11df6d858..000000000
--- a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
+++ /dev/null
@@ -1,289 +0,0 @@
-/** @file imopv_sse2.c
- ** @brief Vectorized image operations - SSE2 - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#if ! defined(VL_DISABLE_SSE2) & ! defined(__SSE2__)
-#error "Compiling with SSE2 enabled, but no __SSE2__ defined"
-#endif
-
-#if ! defined(VL_DISABLE_SSE2)
-
-#ifndef VL_IMOPV_SSE2_INSTANTIATING
-
-#include <emmintrin.h>
-
-#include "imopv.h"
-#include "imopv_sse2.h"
-
-#define FLT VL_TYPE_FLOAT
-#define VL_IMOPV_SSE2_INSTANTIATING
-#include "imopv_sse2.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define VL_IMOPV_SSE2_INSTANTIATING
-#include "imopv_sse2.c"
-
-/* ---------------------------------------------------------------- */
-/* VL_IMOPV_SSE2_INSTANTIATING */
-#else
-
-#include "float.h"
-
-/* ---------------------------------------------------------------- */
-void
-VL_XCAT3(_vl_imconvcol_v, SFX, _sse2)
-(T* dst, vl_size dst_stride,
- T const* src,
- vl_size src_width, vl_size src_height, vl_size src_stride,
- T const* filt, vl_index filt_begin, vl_index filt_end,
- int step, unsigned int flags)
-{
-  vl_index x = 0 ;
-  vl_index y ;
-  vl_index dheight = (src_height - 1) / step + 1 ;
-  vl_bool use_simd  = VALIGNED(src_stride) ;
-  vl_bool transp    = flags & VL_TRANSPOSE ;
-  vl_bool zeropad   = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
-  double totcol = 0 ;
-  double simdcol = 0 ;
-
-  /* let filt point to the last sample of the filter */
-  filt += filt_end - filt_begin ;
-
-  while (x < (signed)src_width) {
-    /* Calculate dest[x,y] = sum_p image[x,p] filt[y - p]
-     * where supp(filt) = [filt_begin, filt_end] = [fb,fe].
-     *
-     * CHUNK_A: y - fe <= p < 0
-     *          completes VL_MAX(fe - y, 0) samples
-     * CHUNK_B: VL_MAX(y - fe, 0) <= p < VL_MIN(y - fb, height - 1)
-     *          completes fe - VL_MAX(fb, height - y) + 1 samples
-     * CHUNK_C: completes all samples
-     */
-
-    T const *filti ;
-    vl_index stop ;
-
-    if ((x + VSIZE < (signed)src_width) &
-        VALIGNED(src + x) & use_simd)
-    {
-      /* ----------------------------------------------  Vectorized */
-      for (y = 0 ; y < (signed)src_height ; y += step)  {
-        union {VTYPE v ; T x [VSIZE] ; } acc ;
-        VTYPE v, c ;
-        T const *srci ;
-        acc.v = VSTZ () ;
-        v = VSTZ() ;
-
-        filti = filt ;
-        stop = filt_end - y ;
-        srci = src + x - stop * src_stride ;
-
-        if (stop > 0) {
-          if (zeropad) {
-            v = VSTZ () ;
-          } else {
-            v = * (VTYPE*) (src + x) ;
-          }
-          while (filti > filt - stop) {
-            c = VLD1 (filti--) ;
-            acc.v = VADD (acc.v,  VMUL (v, c)) ;
-            srci += src_stride ;
-          }
-        }
-
-        stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
-        while (filti > filt - stop) {
-          v = * (VTYPE*) srci ;
-          c = VLD1 (filti--) ;
-          acc.v = VADD (acc.v, VMUL (v, c)) ;
-          srci += src_stride ;
-        }
-
-        if (zeropad) v = VSTZ () ;
-
-        stop = filt_end - filt_begin + 1;
-        while (filti > filt - stop) {
-          c = VLD1 (filti--) ;
-          acc.v = VADD (acc.v, VMUL (v, c)) ;
-        }
-
-        if (transp) {
-          *dst = acc.x[0] ; dst += dst_stride ;
-          *dst = acc.x[1] ; dst += dst_stride ;
-#if(VSIZE == 4)
-          *dst = acc.x[2] ; dst += dst_stride ;
-          *dst = acc.x[3] ; dst += dst_stride ;
-#endif
-          dst += 1 * 1 - VSIZE * dst_stride ;
-        } else {
-          *dst = acc.x[0] ; dst += 1 ;
-          *dst = acc.x[1] ; dst += 1 ;
-#if(VSIZE == 4)
-          *dst = acc.x[2] ; dst += 1 ;
-          *dst = acc.x[3] ; dst += 1 ;
-#endif
-          dst += 1 * dst_stride - VSIZE * 1 ;
-        }
-      } /* next y */
-      if (transp) {
-        dst += VSIZE * dst_stride - dheight * 1 ;
-      } else {
-        dst += VSIZE * 1 - dheight * dst_stride ;
-      }
-      x       += VSIZE ;
-      simdcol += VSIZE ;
-      totcol  += VSIZE ;
-    } else {
-      /* -------------------------------------------------  Vanilla */
-      for (y = 0 ; y < (signed)src_height ; y += step) {
-        T acc = 0 ;
-        T v = 0, c ;
-        T const* srci ;
-
-        filti = filt ;
-        stop = filt_end - y ;
-        srci = src + x - stop * src_stride ;
-
-        if (stop > 0) {
-          if (zeropad) {
-            v = 0 ;
-          } else {
-            v = *(src + x) ;
-          }
-          while (filti > filt - stop) {
-            c = *filti-- ;
-            acc += v * c ;
-            srci += src_stride ;
-          }
-        }
-
-        stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
-        while (filti > filt - (signed)stop) {
-          v = *srci ;
-          c = *filti-- ;
-          acc += v * c ;
-          srci += src_stride ;
-        }
-
-        if (zeropad) v = 0 ;
-
-        stop = filt_end - filt_begin + 1 ;
-        while (filti > filt - stop) {
-          c = *filti-- ;
-          acc += v * c ;
-        }
-
-        if (transp) {
-          *dst = acc ; dst += 1 ;
-        } else {
-          *dst = acc ; dst += dst_stride ;
-        }
-      } /* next y */
-      if (transp) {
-        dst += 1 * dst_stride - dheight * 1 ;
-      } else {
-        dst += 1 * 1 - dheight * dst_stride ;
-      }
-      x      += 1 ;
-      totcol += 1 ;
-    } /* next x */
-  }
-}
-
-/* ---------------------------------------------------------------- */
-#if 0
-void
-VL_XCAT(_vl_imconvcoltri_v, SFX, sse2)
-(T* dst, int dst_stride,
- T const* src,
- int src_width, int src_height, int src_stride,
- int filt_size,
- int step, unsigned int flags)
-{
-  int x = 0 ;
-  int y ;
-  int dheight = (src_height - 1) / step + 1 ;
-  vl_bool use_simd  = ((src_stride & ALIGNSTRIDE) == 0) &&
-  (! (flags & VL_NO_SIMD)) ;
-  vl_bool transp = flags & VL_TRANSPOSE ;
-  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
-
-  T * buff = vl_malloc(sizeof(T) * (src_height + filt_size)) ;
-#define fa (1.0 / (double) (filt_size + 1))
-  T scale = fa*fa*fa*fa ;
-  buff += filt_size ;
-
-  while (x < src_width) {
-    T const *srci ;
-
-    use_simd = 0 ;
-    if ((x + VSIZE < src_width) &
-        (((vl_ptrint)(src + x) & ALIGNPTR) == 0) &
-        use_simd)
-    {
-
-    } else {
-      int stridex = transp ? dst_stride : 1 ;
-      int stridey = transp ? 1 : dst_stride ;
-      srci = src + x + src_stride * (src_height - 1) ;
-
-      /* integrate backward the column */
-      buff [src_height - 1] = *srci ;
-      for (y = src_height-2 ; y >=  0 ; --y) {
-        srci -= src_stride ;
-        buff [y] = buff [y+1] + *srci ;
-      }
-      if (zeropad) {
-        for ( ; y >= - filt_size ; --y) {
-          buff [y] = buff [y+1] ;
-        }
-      } else {
-        for ( ; y >= - filt_size ; --y) {
-          buff [y] = buff[y+1] + *srci ;
-        }
-      }
-
-      /* compute the filter forward */
-      for (y = - filt_size ; y < src_height - filt_size ; ++y) {
-        buff [y] = buff [y] - buff [y + filt_size] ;
-      }
-      if (! zeropad) {
-        for (y = src_height - filt_size ; y < src_height ; ++y) {
-          buff [y] = buff [y] - buff [src_height-1]  *
-          (src_height - filt_size - y) ;
-        }
-      }
-
-      /* integrate forward the column */
-      for (y = - filt_size + 1 ; y < src_height ; ++y) {
-        buff [y] += buff [y - 1] ;
-      }
-
-      /* compute the filter backward */
-      for (y = src_height - 1 ; y >= 0 ; --y) {
-        dst [x*stridex + y*stridey]
-        = scale * (buff [y] - buff [y - filt_size]) ;
-      }
-    } /* next y */
-    x += 1 ;
-  }
-  vl_free (buff - filt_size) ;
-}
-#endif
-
-#undef FLT
-#undef VL_IMOPV_SSE2_INSTANTIATING
-#endif
-
-/* ! VL_DISABLE_SSE2 */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
deleted file mode 100644
index 0f8da374e..000000000
--- a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/** @file imopv_sse2.h
- ** @brief Vectorized image operations - SSE2
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_IMOPV_SSE2_H
-#define VL_IMOPV_SSE2_H
-
-#include "generic.h"
-
-#ifndef VL_DISABLE_SSE2
-
-VL_EXPORT
-void _vl_imconvcol_vf_sse2 (float* dst, vl_size dst_stride,
-                            float const* src,
-                            vl_size src_width, vl_size src_height, vl_size src_stride,
-                            float const* filt, vl_index filt_begin, vl_index filt_end,
-                            int step, unsigned int flags) ;
-
-VL_EXPORT
-void _vl_imconvcol_vd_sse2 (double* dst, vl_size dst_stride,
-                            double const* src,
-                            vl_size src_width, vl_size src_height, vl_size src_stride,
-                            double const* filt, vl_index filt_begin, vl_index filt_end,
-                            int step, unsigned int flags) ;
-
-/*
-VL_EXPORT
-void _vl_imconvcoltri_vf_sse2 (float* dst, int dst_stride,
-                               float const* src,
-                               int src_width, int src_height, int src_stride,
-                               int filt_size,
-                               int step, unsigned int flags) ;
-
-VL_EXPORT
-void _vl_imconvcoltri_vd_sse2 (double* dst, int dst_stride,
-                               double const* src,
-                               int src_width, int src_height, int src_stride,
-                               int filt_size,
-                               int step, unsigned int flags) ;
-*/
-
-#endif
-
-/* VL_IMOPV_SSE2_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/kdtree.c b/opensfm/src/third_party/vlfeat/vl/kdtree.c
deleted file mode 100644
index 889cc7dc3..000000000
--- a/opensfm/src/third_party/vlfeat/vl/kdtree.c
+++ /dev/null
@@ -1,1082 +0,0 @@
-/** @file kdtree.c
- ** @brief KD-tree - Definition
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page kdtree KD-trees and forests
-@author Andrea Vedaldi
-@author David Novotny
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref kdtree.h implements a KD-tree object, a data structure that can
-efficiently index moderately dimensional vector spaces. Both
-best-bin-first @cite{beis97shape} and randomized KD-tree forests are
-implemented
-@cite{silpa-anan08optimised},@cite{muja09fast}. Applications include
-fast matching of feature descriptors.
-
-- @ref kdtree-overview
-- @ref kdtree-tech
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kdtree-overview Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-To create a ::VlKDForest object use ::vl_kdforest_new specifying the
-dimensionality of the data and the number of trees in the forest.
-With one tree only, the algorithm is analogous to @cite{beis97shape}
-(best-bin KDTree). Multiple trees correspond to the randomized KDTree
-forest as in @cite{silpa-anan08optimised},@cite{muja09fast}.
-
-To let the KD-tree index some data use ::vl_kdforest_build. Note that
-for efficiency KD-tree does not copy the data but retains a pointer to
-it. Therefore the data must exist (and not change) until the KD-tree
-is deleted. To delete the KD-tree object, use ::vl_kdforest_delete.
-
-To find the N nearest neighbors to a query point first instantiate
-a ::VlKDForestSearcher and then start search using a ::vl_kdforest_query
-with the searcher object as an argument. To set a maximum number of
-comparisons per query and calculate approximate nearest neighbors use
-::vl_kdforest_set_max_num_comparisons.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kdtree-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-::VlKDForest implements the best-bin-first kd-tree of @cite{beis97shape}.
-
-<b>Construction.</b> Given a set of points @f$ x_1,\dots,x_n \in
-\mathbb{R}^d @f$, the algorithm recursively partitions the @e d
-dimensional Euclidean space @f$ \mathbb{R}^d @f$ into (hyper-)
-rectangles.
-
-Partitions are organized into a binary tree with the root
-corresponding to the whole space @f$ \mathbb{R}^d @f$. The algorithm
-refines each partition by dividing it into two halves by thresholding
-along a given dimension. Both the splitting dimension and the
-threshold are determined as a statistic of the data points contained
-in the partition. The splitting dimension is the one which has largest
-sample variance and the splitting threshold is either the sample mean
-or the median. Leaves are atomic partitions and they contain a list of
-zero or more data points (typically one).
-
-<b>Querying.</b> Querying amounts to finding the N data points closer
-to a given query point @f$ x_q \in \mathbb{R}^d @f$. This is done by
-branch-and-bound. A search state is an active partition (initially the
-root) and it is weighed by the lower bound on the distance of any
-point in the partition and the query point. Such a lower bound is
-trivial to compute because partitions are hyper-rectangles.
-
-<b>Querying usage.</b> As said before a user has to create an instance
-::VlKDForestSearcher using ::vl_kdforest_new_searcher in order to be able
-to make queries. When a user wants to delete a KD-Tree all the searchers
-bound to the given KD-Forest are erased automatically. If a user wants to
-delete some of the searchers before the KD-Tree erase, he could do it
-using the vl_kdforest_delete_searcher method.
-**/
-
-#include "kdtree.h"
-#include "generic.h"
-#include "random.h"
-#include "mathop.h"
-#include <stdlib.h>
-
-#if defined(_OPENMP)
-#include <omp.h>
-#endif
-
-#define VL_HEAP_prefix     vl_kdforest_search_heap
-#define VL_HEAP_type       VlKDForestSearchState
-#define VL_HEAP_cmp(v,x,y) (v[x].distanceLowerBound - v[y].distanceLowerBound)
-#include "heap-def.h"
-
-#define VL_HEAP_prefix     vl_kdtree_split_heap
-#define VL_HEAP_type       VlKDTreeSplitDimension
-#define VL_HEAP_cmp(v,x,y) (v[x].variance - v[y].variance)
-#include "heap-def.h"
-
-#define VL_HEAP_prefix     vl_kdforest_neighbor_heap
-#define VL_HEAP_type       VlKDForestNeighbor
-#define VL_HEAP_cmp(v,x,y) (v[y].distance - v[x].distance)
-#include "heap-def.h"
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Allocate a new node from the tree pool
- **/
-
-static vl_uindex
-vl_kdtree_node_new (VlKDTree * tree, vl_uindex parentIndex)
-{
-  VlKDTreeNode * node = NULL ;
-  vl_uindex nodeIndex = tree->numUsedNodes ;
-  tree -> numUsedNodes += 1 ;
-
-  assert (tree->numUsedNodes <= tree->numAllocatedNodes) ;
-
-  node = tree->nodes + nodeIndex ;
-  node -> parent = parentIndex ;
-  node -> lowerChild = 0 ;
-  node -> upperChild = 0 ;
-  node -> splitDimension = 0 ;
-  node -> splitThreshold = 0 ;
-  return nodeIndex ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Compare KDTree index entries for sorting
- **/
-
-VL_INLINE int
-vl_kdtree_compare_index_entries (void const * a,
-                                 void const * b)
-{
-  double delta =
-    ((VlKDTreeDataIndexEntry const*)a) -> value -
-    ((VlKDTreeDataIndexEntry const*)b) -> value ;
-  if (delta < 0) return -1 ;
-  if (delta > 0) return +1 ;
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Build KDTree recursively
- ** @param forest forest to which the tree belongs.
- ** @param tree tree being built.
- ** @param nodeIndex node to process.
- ** @param dataBegin begin of data for this node.
- ** @param dataEnd end of data for this node.
- ** @param depth depth of this node.
- **/
-
-static void
-vl_kdtree_build_recursively
-(VlKDForest * forest,
- VlKDTree * tree, vl_uindex nodeIndex,
- vl_uindex dataBegin, vl_uindex dataEnd,
- unsigned int depth)
-{
-  vl_uindex d, i, medianIndex, splitIndex ;
-  VlKDTreeNode * node = tree->nodes + nodeIndex ;
-  VlKDTreeSplitDimension * splitDimension ;
-
-  /* base case: there is only one data point */
-  if (dataEnd - dataBegin <= 1) {
-    if (tree->depth < depth) tree->depth = depth ;
-    node->lowerChild = - dataBegin - 1;
-    node->upperChild = - dataEnd - 1 ;
-    return ;
-  }
-
-  /* compute the dimension with largest variance > 0 */
-  forest->splitHeapNumNodes = 0 ;
-  for (d = 0 ; d < forest->dimension ; ++ d) {
-    double mean = 0 ; /* unnormalized */
-    double secondMoment = 0 ;
-    double variance = 0 ;
-    vl_size numSamples = VL_KDTREE_VARIANCE_EST_NUM_SAMPLES;
-    vl_bool useAllData = VL_FALSE;
-
-    if(dataEnd - dataBegin <= VL_KDTREE_VARIANCE_EST_NUM_SAMPLES) {
-      useAllData = VL_TRUE;
-      numSamples = dataEnd - dataBegin;
-    }
-
-    for (i = 0; i < numSamples ; ++ i) {
-      vl_uint32 sampleIndex;
-      vl_index di;
-      double datum ;
-
-      if(useAllData == VL_TRUE) {
-        sampleIndex = (vl_uint32)i;
-      } else {
-        sampleIndex = (vl_rand_uint32(forest->rand) % VL_KDTREE_VARIANCE_EST_NUM_SAMPLES);
-      }
-      sampleIndex += dataBegin;
-
-      di = tree->dataIndex[sampleIndex].index ;
-
-      switch(forest->dataType) {
-        case VL_TYPE_FLOAT: datum = ((float const*)forest->data)
-          [di * forest->dimension + d] ;
-          break ;
-        case VL_TYPE_DOUBLE: datum = ((double const*)forest->data)
-          [di * forest->dimension + d] ;
-          break ;
-        default:
-          abort() ;
-      }
-      mean += datum ;
-      secondMoment += datum * datum ;
-    }
-
-    mean /= numSamples ;
-    secondMoment /= numSamples ;
-    variance = secondMoment - mean * mean ;
-
-    if (variance <= 0) continue ;
-
-    /* keep splitHeapSize most varying dimensions */
-    if (forest->splitHeapNumNodes < forest->splitHeapSize) {
-      VlKDTreeSplitDimension * splitDimension
-        = forest->splitHeapArray + forest->splitHeapNumNodes ;
-      splitDimension->dimension = (unsigned int)d ;
-      splitDimension->mean = mean ;
-      splitDimension->variance = variance ;
-      vl_kdtree_split_heap_push (forest->splitHeapArray, &forest->splitHeapNumNodes) ;
-    } else {
-      VlKDTreeSplitDimension * splitDimension = forest->splitHeapArray + 0 ;
-      if (splitDimension->variance < variance) {
-        splitDimension->dimension = (unsigned int)d ;
-        splitDimension->mean = mean ;
-        splitDimension->variance = variance ;
-        vl_kdtree_split_heap_update (forest->splitHeapArray, forest->splitHeapNumNodes, 0) ;
-      }
-    }
-  }
-
-  /* additional base case: the maximum variance is equal to 0 (overlapping points) */
-  if (forest->splitHeapNumNodes == 0) {
-    node->lowerChild = - dataBegin - 1 ;
-    node->upperChild = - dataEnd - 1 ;
-    return ;
-  }
-
-  /* toss a dice to decide the splitting dimension (variance > 0) */
-  splitDimension = forest->splitHeapArray
-  + (vl_rand_uint32(forest->rand) % VL_MIN(forest->splitHeapSize, forest->splitHeapNumNodes)) ;
-
-  node->splitDimension = splitDimension->dimension ;
-
-  /* sort data along largest variance dimension */
-  for (i = dataBegin ; i < dataEnd ; ++ i) {
-    vl_index di = tree->dataIndex[i].index ;
-    double datum ;
-    switch (forest->dataType) {
-      case VL_TYPE_FLOAT: datum = ((float const*)forest->data)
-        [di * forest->dimension + splitDimension->dimension] ;
-        break ;
-      case VL_TYPE_DOUBLE: datum = ((double const*)forest->data)
-        [di * forest->dimension + splitDimension->dimension] ;
-        break ;
-      default:
-        abort() ;
-    }
-    tree->dataIndex [i] .value = datum ;
-  }
-  qsort (tree->dataIndex + dataBegin,
-         dataEnd - dataBegin,
-         sizeof (VlKDTreeDataIndexEntry),
-         vl_kdtree_compare_index_entries) ;
-
-  /* determine split threshold */
-  switch (forest->thresholdingMethod) {
-    case VL_KDTREE_MEAN :
-      node->splitThreshold = splitDimension->mean ;
-      for (splitIndex = dataBegin ;
-           splitIndex < dataEnd && tree->dataIndex[splitIndex].value <= node->splitThreshold ;
-           ++ splitIndex) ;
-      splitIndex -= 1 ;
-      /* If the mean does not provide a proper partition, fall back to
-       * median. This usually happens if all points have the same
-       * value and the zero variance test fails for numerical accuracy
-       * reasons. In this case, also due to numerical accuracy, the
-       * mean value can be smaller, equal, or larger than all
-       * points. */
-      if (dataBegin <= splitIndex && splitIndex + 1 < dataEnd) break ;
-
-    case VL_KDTREE_MEDIAN :
-      medianIndex = (dataBegin + dataEnd - 1) / 2 ;
-      splitIndex = medianIndex ;
-      node -> splitThreshold = tree->dataIndex[medianIndex].value ;
-      break ;
-
-    default:
-      abort() ;
-  }
-
-  /* divide subparts */
-  node->lowerChild = vl_kdtree_node_new (tree, nodeIndex) ;
-  vl_kdtree_build_recursively (forest, tree, node->lowerChild, dataBegin, splitIndex + 1, depth + 1) ;
-
-  node->upperChild = vl_kdtree_node_new (tree, nodeIndex) ;
-  vl_kdtree_build_recursively (forest, tree, node->upperChild, splitIndex + 1, dataEnd, depth + 1) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create new KDForest object
- ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
- ** @param dimension data dimensionality.
- ** @param numTrees number of trees in the forest.
- ** @param distance type of distance norm (::VlDistanceL1 or ::VlDistanceL2).
- ** @return new KDForest.
- **
- ** The data dimension @a dimension and the number of trees @a
- ** numTrees must not be smaller than one.
- **/
-
-VlKDForest *
-vl_kdforest_new (vl_type dataType,
-                 vl_size dimension, vl_size numTrees, VlVectorComparisonType distance)
-{
-  VlKDForest * self = vl_calloc (sizeof(VlKDForest), 1) ;
-
-  assert(dataType == VL_TYPE_FLOAT || dataType == VL_TYPE_DOUBLE) ;
-  assert(dimension >= 1) ;
-  assert(numTrees >= 1) ;
-
-  self -> rand = vl_get_rand () ;
-  self -> dataType = dataType ;
-  self -> numData = 0 ;
-  self -> data = 0 ;
-  self -> dimension = dimension ;
-  self -> numTrees = numTrees ;
-  self -> trees = 0 ;
-  self -> thresholdingMethod = VL_KDTREE_MEDIAN ;
-  self -> splitHeapSize = VL_MIN(numTrees, VL_KDTREE_SPLIT_HEAP_SIZE) ;
-  self -> splitHeapNumNodes = 0 ;
-  self -> distance = distance;
-  self -> maxNumNodes = 0 ;
-  self -> numSearchers = 0 ;
-  self -> headSearcher = 0 ;
-
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT:
-      self -> distanceFunction = (void(*)(void))
-      vl_get_vector_comparison_function_f (distance) ;
-      break;
-    case VL_TYPE_DOUBLE :
-      self -> distanceFunction = (void(*)(void))
-      vl_get_vector_comparison_function_d (distance) ;
-      break ;
-    default :
-      abort() ;
-  }
-
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a KDForest searcher object, used for processing queries
- ** @param kdforest a forest to which the queries should be pointing.
- ** @return KDForest searcher object.
- **
- ** A searcher is an object attached to the forest which must be created
- ** before running the queries. Each query has to be invoked with the
- ** searcher as its argument.
- **
- ** When using a multi-threaded approach a user should at first instantiate
- ** a correct number of searchers - each used in one thread.
- ** Then in each thread a query to the given searcher could be run.
- **
- **/
-
-VlKDForestSearcher *
-vl_kdforest_new_searcher (VlKDForest * kdforest)
-{
-  VlKDForestSearcher * self = vl_calloc(sizeof(VlKDForestSearcher), 1);
-  if(kdforest->numSearchers == 0) {
-    kdforest->headSearcher = self;
-    self->previous = NULL;
-    self->next = NULL;
-  } else {
-    VlKDForestSearcher * lastSearcher = kdforest->headSearcher;
-    while (1) {
-      if(lastSearcher->next) {
-        lastSearcher = lastSearcher->next;
-      } else {
-        lastSearcher->next = self;
-        self->previous = lastSearcher;
-        self->next = NULL;
-        break;
-      }
-    }
-  }
-
-  kdforest->numSearchers++;
-
-  self->forest = kdforest;
-  self->searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * kdforest->maxNumNodes) ;
-  self->searchIdBook = vl_calloc (sizeof(vl_uindex), kdforest->numData) ;
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Delete object
- ** @param self object.
- **/
-
-void
-vl_kdforestsearcher_delete (VlKDForestSearcher * self)
-{
-  if (self->previous && self->next) {
-    self->previous->next = self->next;
-    self->next->previous = self->previous;
-  } else if (self->previous && !self->next) {
-    self->previous->next = NULL;
-  } else if (!self->previous && self->next) {
-    self->next->previous = NULL;
-    self->forest->headSearcher = self->next;
-  } else {
-    self->forest->headSearcher = NULL;
-  }
-  self->forest->numSearchers -- ;
-  vl_free(self->searchHeapArray) ;
-  vl_free(self->searchIdBook) ;
-  vl_free(self) ;
-}
-
-VlKDForestSearcher *
-vl_kdforest_get_searcher (VlKDForest const * self, vl_uindex pos)
-{
-  VlKDForestSearcher * lastSearcher = self->headSearcher ;
-  vl_uindex i ;
-
-  for(i = 0; (i < pos) & (lastSearcher != NULL) ; ++i) {
-    lastSearcher = lastSearcher->next ;
-  }
-  return lastSearcher ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Delete KDForest object
- ** @param self KDForest object to delete
- ** @sa ::vl_kdforest_new
- **/
-
-void
-vl_kdforest_delete (VlKDForest * self)
-{
-  vl_uindex ti ;
-  VlKDForestSearcher * searcher ;
-
-  while ((searcher = vl_kdforest_get_searcher(self, 0))) {
-    vl_kdforestsearcher_delete(searcher) ;
-  }
-
-  if (self->trees) {
-    for (ti = 0 ; ti < self->numTrees ; ++ ti) {
-      if (self->trees[ti]) {
-        if (self->trees[ti]->nodes) vl_free (self->trees[ti]->nodes) ;
-        if (self->trees[ti]->dataIndex) vl_free (self->trees[ti]->dataIndex) ;
-        vl_free (self->trees[ti]) ;
-      }
-    }
-    vl_free (self->trees) ;
-  }
-  vl_free (self) ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Compute tree bounds recursively
- ** @param tree KDTree object instance.
- ** @param nodeIndex node index to start from.
- ** @param searchBounds 2 x numDimension array of bounds.
- **/
-
-static void
-vl_kdtree_calc_bounds_recursively (VlKDTree * tree,
-                                   vl_uindex nodeIndex, double * searchBounds)
-{
-  VlKDTreeNode * node = tree->nodes + nodeIndex ;
-  vl_uindex i = node->splitDimension ;
-  double t = node->splitThreshold ;
-
-  node->lowerBound = searchBounds [2 * i + 0] ;
-  node->upperBound = searchBounds [2 * i + 1] ;
-
-  //VL_PRINT("%f %f\n",node->lowerBound,node->upperBound);
-
-  if (node->lowerChild > 0) {
-    searchBounds [2 * i + 1] = t ;
-    vl_kdtree_calc_bounds_recursively (tree, node->lowerChild, searchBounds) ;
-    searchBounds [2 * i + 1] = node->upperBound ;
-  }
-  if (node->upperChild > 0) {
-    searchBounds [2 * i + 0] = t ;
-    vl_kdtree_calc_bounds_recursively (tree, node->upperChild, searchBounds) ;
-    searchBounds [2 * i + 0] = node->lowerBound ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Build KDTree from data
- ** @param self KDTree object
- ** @param numData number of data points.
- ** @param data pointer to the data.
- **
- ** The function builds the KDTree by processing the data @a data. For
- ** efficiency, KDTree does not make a copy the data, but retains a
- ** pointer to it. Therefore the data buffer must be valid and
- ** unchanged for the lifespan of the object.
- **
- ** The number of data points @c numData must not be smaller than one.
- **/
-
-void
-vl_kdforest_build (VlKDForest * self, vl_size numData, void const * data)
-{
-  vl_uindex di, ti ;
-  vl_size maxNumNodes ;
-  double * searchBounds;
-
-  assert(data) ;
-  assert(numData >= 1) ;
-
-  /* need to check: if alredy built, clean first */
-  self->data = data ;
-  self->numData = numData ;
-  self->trees = vl_malloc (sizeof(VlKDTree*) * self->numTrees) ;
-  maxNumNodes = 0 ;
-
-  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
-    self->trees[ti] = vl_malloc (sizeof(VlKDTree)) ;
-    self->trees[ti]->dataIndex = vl_malloc (sizeof(VlKDTreeDataIndexEntry) * self->numData) ;
-    for (di = 0 ; di < self->numData ; ++ di) {
-      self->trees[ti]->dataIndex[di].index = di ;
-    }
-    self->trees[ti]->numUsedNodes = 0 ;
-    /* num. nodes of a complete binary tree with numData leaves */
-    self->trees[ti]->numAllocatedNodes = 2 * self->numData - 1 ;
-    self->trees[ti]->nodes = vl_malloc (sizeof(VlKDTreeNode) * self->trees[ti]->numAllocatedNodes) ;
-    self->trees[ti]->depth = 0 ;
-    vl_kdtree_build_recursively (self, self->trees[ti],
-                                 vl_kdtree_node_new(self->trees[ti], 0), 0,
-                                 self->numData, 0) ;
-    maxNumNodes += self->trees[ti]->numUsedNodes ;
-  }
-
-  searchBounds = vl_malloc(sizeof(double) * 2 * self->dimension);
-
-  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
-    double * iter = searchBounds  ;
-    double * end = iter + 2 * self->dimension ;
-    while (iter < end) {
-      *iter++ = - VL_INFINITY_F ;
-      *iter++ = + VL_INFINITY_F ;
-    }
-
-    vl_kdtree_calc_bounds_recursively (self->trees[ti], 0, searchBounds) ;
-  }
-
-  vl_free(searchBounds);
-  self -> maxNumNodes = maxNumNodes;
-}
-
-
-/** ------------------------------------------------------------------
- ** @internal @brief
- **/
-
-vl_uindex
-vl_kdforest_query_recursively (VlKDForestSearcher * searcher,
-                               VlKDTree * tree,
-                               vl_uindex nodeIndex,
-                               VlKDForestNeighbor * neighbors,
-                               vl_size numNeighbors,
-                               vl_size * numAddedNeighbors,
-                               double dist,
-                               void const * query)
-{
-
-  VlKDTreeNode const * node = tree->nodes + nodeIndex ;
-  vl_uindex i = node->splitDimension ;
-  vl_index nextChild, saveChild ;
-  double delta, saveDist ;
-  double x ;
-  double x1 = node->lowerBound ;
-  double x2 = node->splitThreshold ;
-  double x3 = node->upperBound ;
-  VlKDForestSearchState * searchState ;
-
-  searcher->searchNumRecursions ++ ;
-
-  switch (searcher->forest->dataType) {
-    case VL_TYPE_FLOAT :
-      x = ((float const*) query)[i] ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      x = ((double const*) query)[i] ;
-      break ;
-    default :
-      abort() ;
-  }
-
-  /* base case: this is a leaf node */
-  if (node->lowerChild < 0) {
-
-    vl_index begin = - node->lowerChild - 1 ;
-    vl_index end   = - node->upperChild - 1 ;
-    vl_index iter ;
-
-    for (iter = begin ;
-         iter < end &&
-         (searcher->forest->searchMaxNumComparisons == 0 ||
-          searcher->searchNumComparisons < searcher->forest->searchMaxNumComparisons) ;
-         ++ iter) {
-
-      vl_index di = tree->dataIndex [iter].index ;
-
-      /* multiple KDTrees share the database points and we must avoid
-       * adding the same point twice */
-      if (searcher->searchIdBook[di] == searcher->searchId) continue ;
-      searcher->searchIdBook[di] = searcher->searchId ;
-
-      /* compare the query to this point */
-      switch (searcher->forest->dataType) {
-        case VL_TYPE_FLOAT:
-          dist = ((VlFloatVectorComparisonFunction)searcher->forest->distanceFunction)
-                 (searcher->forest->dimension,
-                  ((float const *)query),
-                  ((float const*)searcher->forest->data) + di * searcher->forest->dimension) ;
-          break ;
-        case VL_TYPE_DOUBLE:
-          dist = ((VlDoubleVectorComparisonFunction)searcher->forest->distanceFunction)
-                 (searcher->forest->dimension,
-                  ((double const *)query),
-                  ((double const*)searcher->forest->data) + di * searcher->forest->dimension) ;
-          break ;
-        default:
-          abort() ;
-      }
-      searcher->searchNumComparisons += 1 ;
-
-      /* see if it should be added to the result set */
-      if (*numAddedNeighbors < numNeighbors) {
-        VlKDForestNeighbor * newNeighbor = neighbors + *numAddedNeighbors ;
-        newNeighbor->index = di ;
-        newNeighbor->distance = dist ;
-        vl_kdforest_neighbor_heap_push (neighbors, numAddedNeighbors) ;
-      } else {
-        VlKDForestNeighbor * largestNeighbor = neighbors + 0 ;
-        if (largestNeighbor->distance > dist) {
-          largestNeighbor->index = di ;
-          largestNeighbor->distance = dist ;
-          vl_kdforest_neighbor_heap_update (neighbors, *numAddedNeighbors, 0) ;
-        }
-      }
-    } /* next data point */
-
-
-    return nodeIndex ;
-  }
-
-#if 0
-  assert (x1 <= x2 && x2 <= x3) ;
-  assert (node->lowerChild >= 0) ;
-  assert (node->upperChild >= 0) ;
-#endif
-
-  /*
-   *   x1  x2 x3
-   * x (---|---]
-   *   (--x|---]
-   *   (---|x--]
-   *   (---|---] x
-   */
-
-  delta = x - x2 ;
-  saveDist = dist + delta*delta ;
-
-  if (x <= x2) {
-    nextChild = node->lowerChild ;
-    saveChild = node->upperChild ;
-    if (x <= x1) {
-      delta = x - x1 ;
-      saveDist -= delta*delta ;
-    }
-  } else {
-    nextChild = node->upperChild ;
-    saveChild = node->lowerChild ;
-    if (x > x3) {
-      delta = x - x3 ;
-      saveDist -= delta*delta ;
-    }
-  }
-
-  if (*numAddedNeighbors < numNeighbors || neighbors[0].distance > saveDist) {
-    searchState = searcher->searchHeapArray + searcher->searchHeapNumNodes ;
-    searchState->tree = tree ;
-    searchState->nodeIndex = saveChild ;
-    searchState->distanceLowerBound = saveDist ;
-    vl_kdforest_search_heap_push (searcher->searchHeapArray ,
-                                  &searcher->searchHeapNumNodes) ;
-  }
-
-  return vl_kdforest_query_recursively (searcher,
-                                        tree,
-                                        nextChild,
-                                        neighbors,
-                                        numNeighbors,
-                                        numAddedNeighbors,
-                                        dist,
-                                        query) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Query the forest
- ** @param self object.
- ** @param neighbors list of nearest neighbors found (output).
- ** @param numNeighbors number of nearest neighbors to find.
- ** @param query query point.
- ** @return number of tree leaves visited.
- **
- ** A neighbor is represented by an instance of the structure
- ** ::VlKDForestNeighbor. Each entry contains the index of the
- ** neighbor (this is an index into the KDTree data) and its distance
- ** to the query point. Neighbors are sorted by increasing distance.
- **/
-
-vl_size
-vl_kdforest_query (VlKDForest * self,
-                   VlKDForestNeighbor * neighbors,
-                   vl_size numNeighbors,
-                   void const * query)
-{
-  VlKDForestSearcher * searcher = vl_kdforest_get_searcher(self, 0) ;
-  if (searcher == NULL) {
-    searcher = vl_kdforest_new_searcher(self) ;
-  }
-  return vl_kdforestsearcher_query(searcher,
-                                   neighbors,
-                                   numNeighbors,
-                                   query) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Query the forest
- ** @param self object.
- ** @param neighbors list of nearest neighbors found (output).
- ** @param numNeighbors number of nearest neighbors to find.
- ** @param query query point.
- ** @return number of tree leaves visited.
- **
- ** A neighbor is represented by an instance of the structure
- ** ::VlKDForestNeighbor. Each entry contains the index of the
- ** neighbor (this is an index into the KDTree data) and its distance
- ** to the query point. Neighbors are sorted by increasing distance.
- **/
-
-vl_size
-vl_kdforestsearcher_query (VlKDForestSearcher * self,
-                           VlKDForestNeighbor * neighbors,
-                           vl_size numNeighbors,
-                           void const * query)
-{
-
-  vl_uindex i, ti ;
-  vl_bool exactSearch = self->forest->searchMaxNumComparisons == 0 ;
-
-  VlKDForestSearchState * searchState  ;
-  vl_size numAddedNeighbors = 0 ;
-
-  assert (neighbors) ;
-  assert (numNeighbors > 0) ;
-  assert (query) ;
-
-  /* this number is used to differentiate a query from the next */
-  self -> searchId += 1 ;
-  self -> searchNumRecursions = 0 ;
-
-  self->searchNumComparisons = 0 ;
-  self->searchNumSimplifications = 0 ;
-
-  /* put the root node into the search heap */
-  self->searchHeapNumNodes = 0 ;
-  for (ti = 0 ; ti < self->forest->numTrees ; ++ ti) {
-    searchState = self->searchHeapArray + self->searchHeapNumNodes ;
-    searchState -> tree = self->forest->trees[ti] ;
-    searchState -> nodeIndex = 0 ;
-    searchState -> distanceLowerBound = 0 ;
-
-    vl_kdforest_search_heap_push (self->searchHeapArray, &self->searchHeapNumNodes) ;
-  }
-
-  /* branch and bound */
-  while (exactSearch || self->searchNumComparisons < self->forest->searchMaxNumComparisons)
-  {
-    /* pop the next optimal search node */
-    VlKDForestSearchState * searchState ;
-
-    /* break if search space completed */
-    if (self->searchHeapNumNodes == 0) {
-      break ;
-    }
-    searchState = self->searchHeapArray +
-                  vl_kdforest_search_heap_pop (self->searchHeapArray, &self->searchHeapNumNodes) ;
-    /* break if no better solution may exist */
-    if (numAddedNeighbors == numNeighbors &&
-        neighbors[0].distance < searchState->distanceLowerBound) {
-      self->searchNumSimplifications ++ ;
-      break ;
-    }
-    vl_kdforest_query_recursively (self,
-                                   searchState->tree,
-                                   searchState->nodeIndex,
-                                   neighbors,
-                                   numNeighbors,
-                                   &numAddedNeighbors,
-                                   searchState->distanceLowerBound,
-                                   query) ;
-  }
-
-  /* sort neighbors by increasing distance */
-  for (i = numAddedNeighbors ; i < numNeighbors ; ++ i) {
-    neighbors[i].index = -1 ;
-    neighbors[i].distance = VL_NAN_F ;
-  }
-
-  while (numAddedNeighbors) {
-    vl_kdforest_neighbor_heap_pop (neighbors, &numAddedNeighbors) ;
-  }
-
-  return self->searchNumComparisons ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Run multiple queries
- ** @param self object.
- ** @param indexes assignments of points.
- ** @param numNeighbors number of nearest neighbors to be found for each data point
- ** @param numQueries number of query points.
- ** @param distances distances of query points.
- ** @param queries lisf of vectors to use as queries.
- **
- ** @a indexes and @a distances are @a numNeighbors by @a numQueries
- ** matrices containing the indexes and distances of the nearest neighbours
- ** for each of the @a numQueries queries @a queries.
- **
- ** This function is similar to ::vl_kdforest_query. The main
- ** difference is that the function can use multiple cores to query
- ** large amounts of data.
- **
- ** @sa ::vl_kdforest_query.
- **/
-
-vl_size
-vl_kdforest_query_with_array (VlKDForest * self,
-                              vl_uint32 * indexes,
-                              vl_size numNeighbors,
-                              vl_size numQueries,
-                              void * distances,
-                              void const * queries)
-{
-  vl_size numComparisons = 0;
-  vl_type dataType = vl_kdforest_get_data_type(self) ;
-  vl_size dimension = vl_kdforest_get_data_dimension(self) ;
-
-#ifdef _OPENMP
-#pragma omp parallel default(shared) num_threads(vl_get_max_threads())
-#endif
-  {
-    vl_index qi ;
-    vl_size thisNumComparisons = 0 ;
-    VlKDForestSearcher * searcher ;
-    VlKDForestNeighbor * neighbors ;
-
-#ifdef _OPENMP
-#pragma omp critical
-#endif
-    {
-      searcher = vl_kdforest_new_searcher(self) ;
-      neighbors = vl_calloc (sizeof(VlKDForestNeighbor), numNeighbors) ;
-    }
-
-#ifdef _OPENMP
-#pragma omp for
-#endif
-    for(qi = 0 ; qi < (signed)numQueries; ++ qi) {
-      switch (dataType) {
-        case VL_TYPE_FLOAT: {
-          vl_size ni;
-          thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
-                                                           (float const *) (queries) + qi * dimension) ;
-          for (ni = 0 ; ni < numNeighbors ; ++ni) {
-            indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
-            if (distances){
-              *((float*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
-            }
-          }
-          break ;
-        }
-        case VL_TYPE_DOUBLE: {
-          vl_size ni;
-          thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
-                                                           (double const *) (queries) + qi * dimension) ;
-          for (ni = 0 ; ni < numNeighbors ; ++ni) {
-            indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
-            if (distances){
-              *((double*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
-            }
-          }
-          break ;
-        }
-        default:
-          abort() ;
-      }
-    }
-
-#ifdef _OPENMP
-#pragma omp critical
-#endif
-    {
-      numComparisons += thisNumComparisons ;
-      vl_kdforestsearcher_delete (searcher) ;
-      vl_free (neighbors) ;
-    }
-  }
-  return numComparisons ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the number of nodes of a given tree
- ** @param self KDForest object.
- ** @param treeIndex index of the tree.
- ** @return number of trees.
- **/
-
-vl_size
-vl_kdforest_get_num_nodes_of_tree (VlKDForest const * self, vl_uindex treeIndex)
-{
-  assert (treeIndex < self->numTrees) ;
-  return self->trees[treeIndex]->numUsedNodes ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the detph of a given tree
- ** @param self KDForest object.
- ** @param treeIndex index of the tree.
- ** @return number of trees.
- **/
-
-vl_size
-vl_kdforest_get_depth_of_tree (VlKDForest const * self, vl_uindex treeIndex)
-{
-  assert (treeIndex < self->numTrees) ;
-  return self->trees[treeIndex]->depth ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the number of trees in the forest
- **
- ** @param self KDForest object.
- ** @return number of trees.
- **/
-
-vl_size
-vl_kdforest_get_num_trees (VlKDForest const * self)
-{
-  return self->numTrees ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set the maximum number of comparisons for a search
- **
- ** @param self KDForest object.
- ** @param n maximum number of leaves.
- **
- ** This function sets the maximum number of comparisons for a
- ** nearest neighbor search. Setting it to 0 means unbounded comparisons.
- **
- ** @sa ::vl_kdforest_query, ::vl_kdforest_get_max_num_comparisons.
- **/
-
-void
-vl_kdforest_set_max_num_comparisons (VlKDForest * self, vl_size n)
-{
-  self->searchMaxNumComparisons = n ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the maximum number of comparisons for a search
- **
- ** @param self KDForest object.
- ** @return maximum number of leaves.
- **
- ** @sa ::vl_kdforest_set_max_num_comparisons.
- **/
-
-vl_size
-vl_kdforest_get_max_num_comparisons (VlKDForest * self)
-{
-  return self->searchMaxNumComparisons ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set the thresholding method
- ** @param self KDForest object.
- ** @param method one of ::VlKDTreeThresholdingMethod.
- **
- ** @sa ::vl_kdforest_get_thresholding_method
- **/
-
- void
-vl_kdforest_set_thresholding_method (VlKDForest * self, VlKDTreeThresholdingMethod method)
-{
-  assert(method == VL_KDTREE_MEDIAN || method == VL_KDTREE_MEAN) ;
-  self->thresholdingMethod = method ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the thresholding method
- **
- ** @param self KDForest object.
- ** @return thresholding method.
- **
- ** @sa ::vl_kdforest_set_thresholding_method
- **/
-
- VlKDTreeThresholdingMethod
-vl_kdforest_get_thresholding_method (VlKDForest const * self)
-{
-  return self->thresholdingMethod ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the dimension of the data
- ** @param self KDForest object.
- ** @return dimension of the data.
- **/
-
- vl_size
-vl_kdforest_get_data_dimension (VlKDForest const * self)
-{
-  return self->dimension ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the data type
- ** @param self KDForest object.
- ** @return data type (one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE).
- **/
-
-vl_type
-vl_kdforest_get_data_type (VlKDForest const * self)
-{
-  return self->dataType ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the forest linked to the searcher
- ** @param self object.
- ** @return correspoinding KD-Forest.
- **/
-
-VlKDForest *
-vl_kdforestsearcher_get_forest (VlKDForestSearcher const * self)
-{
-  return self->forest;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/kdtree.h b/opensfm/src/third_party/vlfeat/vl/kdtree.h
deleted file mode 100644
index 8c8f212be..000000000
--- a/opensfm/src/third_party/vlfeat/vl/kdtree.h
+++ /dev/null
@@ -1,185 +0,0 @@
-/** @file kdtree.h
- ** @brief KD-tree (@ref kdtree)
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_KDTREE_H
-#define VL_KDTREE_H
-
-#include "generic.h"
-#include "mathop.h"
-
-#define VL_KDTREE_SPLIT_HEAP_SIZE 5
-#define VL_KDTREE_VARIANCE_EST_NUM_SAMPLES 1024
-
-typedef struct _VlKDTreeNode VlKDTreeNode ;
-typedef struct _VlKDTreeSplitDimension VlKDTreeSplitDimension ;
-typedef struct _VlKDTreeDataIndexEntry VlKDTreeDataIndexEntry ;
-typedef struct _VlKDForestSearchState VlKDForestSearchState ;
-
-struct _VlKDTreeNode
-{
-  vl_uindex parent ;
-  vl_index lowerChild ;
-  vl_index upperChild ;
-  unsigned int splitDimension ;
-  double splitThreshold ;
-  double lowerBound ;
-  double upperBound ;
-} ;
-
-struct _VlKDTreeSplitDimension
-{
-  unsigned int dimension ;
-  double mean ;
-  double variance ;
-} ;
-
-struct _VlKDTreeDataIndexEntry
-{
-  vl_index index ;
-  double value ;
-} ;
-
-/** @brief Thresholding method */
-typedef enum _VlKDTreeThresholdingMethod
-{
-  VL_KDTREE_MEDIAN,
-  VL_KDTREE_MEAN
-} VlKDTreeThresholdingMethod ;
-
-/** @brief Neighbor of a query point */
-typedef struct _VlKDForestNeighbor {
-  double distance ;   /**< distance to the query point */
-  vl_uindex index ;   /**< index of the neighbor in the KDTree data */
-} VlKDForestNeighbor ;
-
-typedef struct _VlKDTree
-{
-  VlKDTreeNode * nodes ;
-  vl_size numUsedNodes ;
-  vl_size numAllocatedNodes ;
-  VlKDTreeDataIndexEntry * dataIndex ;
-  unsigned int depth ;
-} VlKDTree ;
-
-struct _VlKDForestSearchState
-{
-  VlKDTree * tree ;
-  vl_uindex nodeIndex ;
-  double distanceLowerBound ;
-} ;
-
-struct _VlKDForestSearcher;
-
-/** @brief KDForest object */
-typedef struct _VlKDForest
-{
-  vl_size dimension ;
-
-  /* random number generator */
-  VlRand * rand ;
-
-  /* indexed data */
-  vl_type dataType ;
-  void const * data ;
-  vl_size numData ;
-  VlVectorComparisonType distance;
-  void (*distanceFunction)(void) ;
-
-  /* tree structure */
-  VlKDTree ** trees ;
-  vl_size numTrees ;
-
-  /* build */
-  VlKDTreeThresholdingMethod thresholdingMethod ;
-  VlKDTreeSplitDimension splitHeapArray [VL_KDTREE_SPLIT_HEAP_SIZE] ;
-  vl_size splitHeapNumNodes ;
-  vl_size splitHeapSize ;
-  vl_size maxNumNodes;
-
-  /* query */
-  vl_size searchMaxNumComparisons ;
-  vl_size numSearchers;
-  struct _VlKDForestSearcher * headSearcher ;  /* head of the double linked list with searchers */
-
-} VlKDForest ;
-
-/** @brief ::VlKDForest searcher object */
-typedef struct _VlKDForestSearcher
-{
-  /* maintain a linked list of searchers for later disposal*/
-  struct _VlKDForestSearcher * next;
-  struct _VlKDForestSearcher * previous;
-
-  vl_uindex * searchIdBook ;
-  VlKDForestSearchState * searchHeapArray ;
-  VlKDForest * forest;
-
-  vl_size searchNumComparisons;
-  vl_size searchNumRecursions ;
-  vl_size searchNumSimplifications ;
-
-  vl_size searchHeapNumNodes ;
-  vl_uindex searchId ;
-} VlKDForestSearcher ;
-
-/** @name Creating, copying and disposing
- ** @{ */
-VL_EXPORT VlKDForest * vl_kdforest_new (vl_type dataType,
-                                        vl_size dimension, vl_size numTrees, VlVectorComparisonType normType) ;
-VL_EXPORT VlKDForestSearcher * vl_kdforest_new_searcher (VlKDForest * kdforest);
-VL_EXPORT void vl_kdforest_delete (VlKDForest * self) ;
-VL_EXPORT void vl_kdforestsearcher_delete (VlKDForestSearcher * searcher) ;
-/** @} */
-
-/** @name Building and querying
- ** @{ */
-VL_EXPORT void vl_kdforest_build (VlKDForest * self,
-                                  vl_size numData,
-                                  void const * data) ;
-
-VL_EXPORT vl_size vl_kdforest_query (VlKDForest * self,
-                                     VlKDForestNeighbor * neighbors,
-                                     vl_size numNeighbors,
-                                     void const * query) ;
-
-VL_EXPORT vl_size vl_kdforest_query_with_array (VlKDForest * self,
-                                                vl_uint32 * index,
-                                                vl_size numNeighbors,
-                                                vl_size numQueries,
-                                                void * distance,
-                                                void const * queries) ;
-
-VL_EXPORT vl_size vl_kdforestsearcher_query (VlKDForestSearcher * self,
-                                             VlKDForestNeighbor * neighbors,
-                                             vl_size numNeighbors,
-                                             void const * query) ;
-/** @} */
-
-/** @name Retrieving and setting parameters
- ** @{ */
-VL_EXPORT vl_size vl_kdforest_get_depth_of_tree (VlKDForest const * self, vl_uindex treeIndex) ;
-VL_EXPORT vl_size vl_kdforest_get_num_nodes_of_tree (VlKDForest const * self, vl_uindex treeIndex) ;
-VL_EXPORT vl_size vl_kdforest_get_num_trees (VlKDForest const * self) ;
-VL_EXPORT vl_size vl_kdforest_get_data_dimension (VlKDForest const * self) ;
-VL_EXPORT vl_type vl_kdforest_get_data_type (VlKDForest const * self) ;
-VL_EXPORT void vl_kdforest_set_max_num_comparisons (VlKDForest * self, vl_size n) ;
-VL_EXPORT vl_size vl_kdforest_get_max_num_comparisons (VlKDForest * self) ;
-VL_EXPORT void vl_kdforest_set_thresholding_method (VlKDForest * self, VlKDTreeThresholdingMethod method) ;
-VL_EXPORT VlKDTreeThresholdingMethod vl_kdforest_get_thresholding_method (VlKDForest const * self) ;
-VL_EXPORT VlKDForest * vl_kdforest_searcher_get_forest (VlKDForestSearcher const * self) ;
-VL_EXPORT VlKDForestSearcher * vl_kdforest_get_searcher (VlKDForest const * self, vl_uindex pos) ;
-/** @} */
-
-
-/* VL_KDTREE_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/kmeans.c b/opensfm/src/third_party/vlfeat/vl/kmeans.c
deleted file mode 100644
index b7c93088b..000000000
--- a/opensfm/src/third_party/vlfeat/vl/kmeans.c
+++ /dev/null
@@ -1,2101 +0,0 @@
-/** @file kmeans.c
- ** @brief K-means - Declaration
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi and David Novotny.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page kmeans K-means clustering
-@author Andrea Vedaldi
-@author David Novotny
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref kmeans.h implements a number of algorithm for **K-means
-quantization**: Lloyd @cite{lloyd82least}, an accelerated version by
-Elkan @cite{elkan03using}, and a large scale algorithm based on
-Approximate Nearest Neighbors (ANN). All algorithms support @c float
-or @c double data and can use the $l^1$ or the $l^2$ distance for
-clustering. Furthermore, all algorithms can take advantage of multiple
-CPU cores.
-
-Please see @subpage kmeans-fundamentals for a technical description of
-K-means and of the algorithms implemented here.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kmeans-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The goal of K-means is to partition a dataset into $K$
-&ldquo;compact&rdquo; clusters. The following example demonstrates
-using @ref kmeans.h in the C programming language to partition @c
-numData @c float vectors into compute @c numCenters clusters using
-Lloyd's algorithm:
-
-@code
-#include <vl/kmeans.h>
-double energy ;
-double * centers ;
-
-// Use float data and the L2 distance for clustering
-KMeans * kmeans = vl_kmeans_new (VLDistanceL2, VL_TYPE_FLOAT) ;
-
-// Use Lloyd algorithm
-vl_kmeans_set_algorithm (kmeans, VlKMeansLloyd) ;
-
-// Initialize the cluster centers by randomly sampling the data
-vl_kmeans_init_centers_with_rand_data (kmeans, data, dimension, numData, numCenters) ;
-
-// Run at most 100 iterations of cluster refinement using Lloyd algorithm
-vl_kmeans_set_max_num_iterations (kmeans, 100) ;
-vl_kmeans_refine_centers (kmeans, data, numData) ;
-
-// Obtain the energy of the solution
-energy = vl_kmeans_get_energy(kmeans) ;
-
-// Obtain the cluster centers
-centers = vl_kmeans_get_centers(kmeans) ;
-@endcode
-
-Once the centers have been obtained, new data points can be assigned
-to clusters by using the ::vl_kmeans_quantize function:
-
-@code
-vl_uint32 * assignments = vl_malloc(sizeof(vl_uint32) * numData) ;
-float * distances = vl_malloc(sizeof(float) * numData) ;
-vl_kmeans_quantize(kmeans, assignments, distances, data, numData) ;
-@endcode
-
-Alternatively, one can directly assign new pointers to the closest
-centers, without bothering with a ::VlKMeans object.
-
-There are several considerations that may impact the performance of
-KMeans. First, since K-means is usually based local optimization
-algorithm, the **initialization method** is important. The following
-initialization methods are supported:
-
-Method         | Function                                | Description
----------------|-----------------------------------------|-----------------------------------------------
-Random samples | ::vl_kmeans_init_centers_with_rand_data | Random data points
-K-means++      | ::vl_kmeans_init_centers_plus_plus      | Random selection biased towards diversity
-Custom         | ::vl_kmeans_set_centers                 | Choose centers (useful to run quantization only)
-
-See @ref kmeans-init for further details. The initialization methods
-use a randomized selection of the data points; the random number
-generator init is controlled by ::vl_rand_init.
-
-The second important choice is the **optimization algorithm**. The
-following optimization algorithms are supported:
-
-Algorithm   | Symbol           | See               | Description
-------------|------------------|-------------------|-----------------------------------------------
-Lloyd       | ::VlKMeansLloyd  | @ref kmeans-lloyd | Alternate EM-style optimization
-Elkan       | ::VlKMeansElkan  | @ref kmeans-elkan | A speedup using triangular inequalities
-ANN         | ::VlKMeansANN    | @ref kmeans-ann   | A speedup using approximated nearest neighbors
-
-See the relative sections for further details. These algorithm are
-iterative, and stop when either a **maximum number of iterations**
-(::vl_kmeans_set_max_num_iterations) is reached, or when the energy
-changes sufficiently slowly in one iteration (::vl_kmeans_set_min_energy_variation).
-
-
-All the three algorithms support multithreaded computations. The number
-of threads used is usually controlled globally by ::vl_set_num_threads.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page kmeans-fundamentals K-means fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Given $n$ points $\bx_1,\dots,\bx_n \in \real^d$, the goal of K-means
-is find $K$ `centers` $\bc_1,\dots,\bc_m \in \real^d$ and
-`assignments` $q_1,\dots,q_n \in \{1,\dots,K\}$ of the points to the
-centers such that the sum of distances
-
-\[
- E(\bc_1,\dots,\bc_k,q_1,\dots,q_n)
- = \sum_{i=1}^n \|\bx_i - \bc_{q_i} \|_p^p
-\]
-
-is minimized. $K$-means is obtained for the case $p=2$ ($l^2$ norm),
-because in this case the optimal centers are the means of the input
-vectors assigned to them. Here the generalization $p=1$ ($l^1$ norm)
-will also be considered.
-
-Up to normalization, the K-means objective $E$ is also the average
-reconstruction error if the original points are approximated with the
-cluster centers. Thus K-means is used not only to group the input
-points into cluster, but also to `quantize` their values.
-
-K-means is widely used in computer vision, for example in the
-construction of vocabularies of visual features (visual words). In
-these applications the number $n$ of points to cluster and/or the
-number $K$ of clusters is often large. Unfortunately, minimizing the
-objective $E$ is in general a difficult combinatorial problem, so
-locally optimal or approximated solutions are sought instead.
-
-The basic K-means algorithm alternate between re-estimating the
-centers and the assignments (@ref kmeans-lloyd). Combined with a good
-initialization strategy (@ref kmeans-init) and, potentially, by
-re-running the optimization from a number of randomized starting
-states, this algorithm may attain satisfactory solutions in practice.
-
-However, despite its simplicity, Lloyd's algorithm is often too slow.
-A good replacement is Elkan's algorithm (@ref kmeans-elkan), which
-uses the triangular inequality to cut down significantly the cost of
-Lloyd's algorithm. Since this algorithm is otherwise equivalent, it
-should often be preferred.
-
-For very large problems (millions of point to clusters and hundreds,
-thousands, or more clusters to find), even Elkan's algorithm is not
-sufficiently fast. In these cases, one can resort to a variant of
-Lloyd's algorithm that uses an approximated nearest neighbors routine
-(@ref kmeans-ann).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kmeans-init Initialization methods
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-All the $K$-means algorithms considered here find locally optimal
-solutions; as such the way they are initialized is important. @ref
-kmeans.h supports the following initialization algorithms:
-
-@par Random data samples
-
-The simplest initialization method is to sample $K$ points at random
-from the input data and use them as initial values for the cluster
-centers.
-
-@par K-means++
-
-@cite{arthur07k-means} proposes a randomized initialization of the
-centers which improves upon random selection. The first center $\bc_1$
-is selected at random from the data points $\bx_1, \dots, \bx_n $ and
-the distance from this center to all points $\|\bx_i - \bc_1\|_p^p$ is
-computed. Then the second center $\bc_2$ is selected at random from
-the data points with probability proportional to the distance. The
-procedure is repeated to obtain the other centers by using the minimum
-distance to the centers collected so far.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kmeans-lloyd Lloyd's algorithm
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The most common K-means method is Lloyd's algorithm
-@cite{lloyd82least}. This algorithm is based on the observation that,
-while jointly optimizing clusters and assignment is difficult,
-optimizing one given the other is easy. Lloyd's algorithm alternates
-the steps:
-
-1. **Quantization.** Each point $\bx_i$ is reassigned to the center
-   $\bc_{q_j}$ closer to it. This requires finding for each point the
-   closest among $K$ other points, which is potentially slow.
-2. **Center estimation.** Each center $\bc_q$ is updated to minimize
-   its average distances to the points assigned to it. It is easy to
-   show that the best center is the mean or median of the points,
-   respectively if the $l^2$ or $l^1$ norm is considered.
-
-A naive implementation of the assignment step requires $O(dnK)$
-operations, where $d$ is the dimensionality of the data, $n$ the
-number of data points, and $K$ the number of centers. Updating the
-centers is much cheaper: $O(dn)$ operations suffice to compute the $K$
-means and a slightly higher cost is required for the medians. Clearly,
-the bottleneck is the assignment computation, and this is what the
-other K-means algorithm try to improve.
-
-During the iterations, it can happen that a cluster becomes empty. In
-this case, K-means automatically **&ldquo;restarts&rdquo; the
-cluster** center by selecting a training point at random.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kmeans-elkan Elkan's algorithm
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Elkan's algorithm @cite{elkan03using} is a variation of Lloyd
-alternate optimization algorithm (@ref kmeans-lloyd) that uses the
-triangular inequality to avoid many distance calculations when
-assigning points to clusters. While much faster than Lloyd, Elkan's
-method uses storage proportional to the umber of clusters by data
-points, which makes it unpractical for a very large number of
-clusters.
-
-The idea of this algorithm is that, if a center update does not move
-them much, then most of the point-to-center computations can be
-avoided when the point-to-center assignments are recomputed. To detect
-which distances need evaluation, the triangular inequality is used to
-lower and upper bound distances after a center update.
-
-Elkan algorithms uses two key observations. First, one has
-
-\[
-\|\bx_i - \bc_{q_i}\|_p \leq \|\bc - \bc_{q_i}\|_p / 2
-\quad\Rightarrow\quad
-\|\bx_i - \bc_{q_i}\|_p \leq \|\bx_i - \bc\|_p.
-\]
-
-Thus if the distance between $\bx_i$ and its current center
-$\bc_{q_i}$ is less than half the distance of the center $\bc_{q_i}$
-to another center $\bc$, then $\bc$ can be skipped when the new
-assignment for $\bx_i$ is searched. Checking this requires keeping
-track of all the inter-center distances, but centers are typically a
-small fraction of the training data, so overall this can be a
-significant saving. In particular, if this condition is satisfied for
-all the centers $\bc \not= \bc_{q_i}$, the point $\bx_i$ can be
-skipped completely. Furthermore, the condition can be tested also
-based on an upper bound $UB_i$ of $\|\bx_i - \bc_{q_i}\|_p$.
-
-Second, if a center $\bc$ is updated to $\hat{\bc}$, then the new
-distance from $\bx$ to $\hat{\bc}$ is bounded from below and above by
-
-\[
-\|\bx - \bc\|_p - \|bc - \hat\bc\|_p
-\leq
-\|\bx - \hat{\bc}\|_p
-\leq
-\|\bx - \hat{\bc}\|_p + \|\bc + \hat{\bc}\|_p.
-\]
-
-This allows to maintain an upper bound on the distance of $\bx_i$ to
-its current center $\bc_{q_i}$ and a lower bound to any other center
-$\bc$:
-
-@f{align*}
-  UB_i      & \leftarrow UB_i + \|\bc_{q_i} - \hat{\bc}_{q_i} \|_p \\
-  LB_i(\bc) & \leftarrow LB_i(\bc) - \|\bc -\hat \bc\|_p.
-@f}
-
-Thus the K-means algorithm becomes:
-
-1.  **Initialization.** Compute $LB_i(\bc) = \|\bx_i -\hat \bc\|_p$ for
-    all points and centers.  Find the current assignments $q_i$ and
-    bounds $UB_i$ by finding the closest centers to each point: $UB_i =
-    \min_{\bc} LB_i(\bc)$.
-2.  **Center estimation.**
-    1. Recompute all the centers based on the new means; call the updated
-       version $\hat{\bc}$.
-    2. Update all the bounds based on the distance $\|\bc - \hat\bc\|_p$
-       as explained above.
-    3. Set $\bc \leftarrow \hat\bc$ for all the centers and go to the next
-       iteration.
-3.  **Quantization.**
-    1. Skip any point $\bx_i$ such that $UB_i \leq \frac{1}{2} \|\bc_{q_i} - \bc\|_p$
-       for all centers $\bc \not= \bc_{q_i}$.
-    2. For each remaining point $\bx_i$ and center $\bc \not= \bc_{q_i}$:
-       1. Skip $\bc$ if
-          \[
-           UB_i \leq \frac{1}{2} \| \bc_{q_i} - \bc \|
-           \quad\text{or}\quad
-           UB_i \leq LB_i(\bc).
-           \]
-          The first condition reflects the first observation above; the
-          second uses the bounds to decide if $\bc$ can be closer than the
-          current center $\bc_{q_i}$ to the point $\bx_i$. If the center
-          cannot be skipped, continue as follows.
-       3. Skip $\bc$ if the condition above is satisfied after making the
-          upper bound tight:
-          \[
-          UB_i = LB_i(\bc_{q_i}) = \| \bx_i - \bc_{q_i} \|_p.
-          \]
-          Note that the latter calculation can be done only once for $\bx_i$.
-          If the center cannot be skipped still, continue as follows.
-       4. Tighten the lower bound too:
-          \[
-          LB_i(\bc) = \| \bx_i - \bc \|_p.
-          \]
-          At this point both $UB_i$ and $LB_i(\bc)$ are tight. If $LB_i <
-          UB_i$, then the point $\bx_i$ should be reassigned to
-          $\bc$. Update $q_i$ to the index of center $\bc$ and reset $UB_i
-          = LB_i(\bc)$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section kmeans-ann ANN algorithm
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The *Approximate Nearest Neighbor* (ANN) K-means algorithm
-@cite{beis97shape} @cite{silpa-anan08optimised} @cite{muja09fast} is a
-variant of Lloyd's algorithm (@ref kmeans-lloyd) uses a best-bin-first
-randomized KD-tree algorithm to approximately (and quickly) find the
-closest cluster center to each point. The KD-tree implementation is
-based on @ref kdtree.
-
-The algorithm can be summarized as follows:
-
-1. **Quantization.** Each point $\bx_i$ is reassigned to the center
-   $\bc_{q_j}$ closer to it. This starts by indexing the $K$ centers
-   by a KD-tree and then using the latter to quickly find the closest
-   center for every training point. The search is approximated to
-   further improve speed. This opens up the possibility that a data
-   point may receive an assignment that is *worse* than the current
-   one. This is avoided by checking that the new assignment estimated
-   by using ANN is an improvement; otherwise the old assignment is
-   kept.
-2. **Center estimation.** Each center $\bc_q$ is updated to minimize
-   its average distances to the points assigned to it. It is easy to
-   show that the best center is the mean or median of the points,
-   respectively if the $l^2$ or $l^1$ norm is considered.
-
-The key is to trade-off carefully the speedup obtained by using the
-ANN algorithm and the loss in accuracy when retrieving neighbors.  Due
-to the curse of dimensionality, KD-trees become less effective for
-higher dimensional data, so that the search cost, which in the best
-case is logarithmic with this data structure, may become effectively
-linear. This is somehow mitigated by the fact that new a new KD-tree
-is computed at each iteration, reducing the likelihood that points may
-get stuck with sub-optimal assignments.
-
-Experiments with the quantization of 128-dimensional SIFT features
-show that the ANN algorithm may use one quarter of the comparisons of
-Elkan's while retaining a similar solution accuracy.
-
-*/
-
-#include "kmeans.h"
-#include "generic.h"
-#include "mathop.h"
-#include <string.h>
-
-#ifdef _OPENMP
-#include <omp.h>
-#endif
-
-/* ================================================================ */
-#ifndef VL_KMEANS_INSTANTIATING
-
-
-/** ------------------------------------------------------------------
- ** @brief Reset state
- **
- ** The function reset the state of the KMeans object. It deletes
- ** any stored centers, releasing the corresponding memory. This
- ** cancels the effect of seeding or setting the centers, but
- ** does not change the other configuration parameters.
- **/
-
-VL_EXPORT void
-vl_kmeans_reset (VlKMeans * self)
-{
-  self->numCenters = 0 ;
-  self->dimension = 0 ;
-
-  if (self->centers) vl_free(self->centers) ;
-  if (self->centerDistances) vl_free(self->centerDistances) ;
-
-  self->centers = NULL ;
-  self->centerDistances = NULL ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new KMeans object
- ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
- ** @param distance distance.
- ** @return new KMeans object instance.
-**/
-
-VL_EXPORT VlKMeans *
-vl_kmeans_new (vl_type dataType,
-               VlVectorComparisonType distance)
-{
-  VlKMeans * self = vl_calloc(1, sizeof(VlKMeans)) ;
-
-  self->algorithm = VlKMeansLloyd ;
-  self->distance = distance ;
-  self->dataType = dataType ;
-  self->verbosity = 0 ;
-  self->maxNumIterations = 100 ;
-  self->minEnergyVariation = 1e-4 ;
-  self->numRepetitions = 1 ;
-  self->centers = NULL ;
-  self->centerDistances = NULL ;
-  self->numTrees = 3;
-  self->maxNumComparisons = 100;
-
-  vl_kmeans_reset (self) ;
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new KMeans object by copy
- ** @param kmeans KMeans object to copy.
- ** @return new copy.
- **/
-
-VL_EXPORT VlKMeans *
-vl_kmeans_new_copy (VlKMeans const * kmeans)
-{
-  VlKMeans * self = vl_malloc(sizeof(VlKMeans)) ;
-
-  self->algorithm = kmeans->algorithm ;
-  self->distance = kmeans->distance ;
-  self->dataType = kmeans->dataType ;
-
-  self->verbosity = kmeans->verbosity ;
-  self->maxNumIterations = kmeans->maxNumIterations ;
-  self->numRepetitions = kmeans->numRepetitions ;
-
-  self->dimension = kmeans->dimension ;
-  self->numCenters = kmeans->numCenters ;
-  self->centers = NULL ;
-  self->centerDistances = NULL ;
-
-  self->numTrees = kmeans->numTrees;
-  self->maxNumComparisons = kmeans->maxNumComparisons;
-
-  if (kmeans->centers) {
-    vl_size dataSize = vl_get_type_size(self->dataType) * self->dimension * self->numCenters ;
-    self->centers = vl_malloc(dataSize) ;
-    memcpy (self->centers, kmeans->centers, dataSize) ;
-  }
-
-  if (kmeans->centerDistances) {
-    vl_size dataSize = vl_get_type_size(self->dataType) * self->numCenters * self->numCenters ;
-    self->centerDistances = vl_malloc(dataSize) ;
-    memcpy (self->centerDistances, kmeans->centerDistances, dataSize) ;
-  }
-
-  return self ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Deletes a KMeans object
- ** @param self KMeans object instance.
- **
- ** The function deletes the KMeans object instance created
- ** by ::vl_kmeans_new.
- **/
-
-VL_EXPORT void
-vl_kmeans_delete (VlKMeans * self)
-{
-  vl_kmeans_reset (self) ;
-  vl_free (self) ;
-}
-
-/* an helper structure */
-typedef struct _VlKMeansSortWrapper {
-  vl_uint32 * permutation ;
-  void const * data ;
-  vl_size stride ;
-} VlKMeansSortWrapper ;
-
-
-/* ---------------------------------------------------------------- */
-/* Instantiate shuffle algorithm */
-
-#define VL_SHUFFLE_type vl_uindex
-#define VL_SHUFFLE_prefix _vl_kmeans
-#include "shuffle-def.h"
-
-/* #ifdef VL_KMEANS_INSTANTITATING */
-#endif
-
-/* ================================================================ */
-#ifdef VL_KMEANS_INSTANTIATING
-
-/* ---------------------------------------------------------------- */
-/*                                                      Set centers */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_kmeans_set_centers_, SFX)
-(VlKMeans * self,
- TYPE const * centers,
- vl_size dimension,
- vl_size numCenters)
-{
-  self->dimension = dimension ;
-  self->numCenters = numCenters ;
-  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
-  memcpy ((TYPE*)self->centers, centers,
-          sizeof(TYPE) * dimension * numCenters) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                   Random seeding */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_kmeans_init_centers_with_rand_data_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size dimension,
- vl_size numData,
- vl_size numCenters)
-{
-  vl_uindex i, j, k ;
-  VlRand * rand = vl_get_rand () ;
-
-  self->dimension = dimension ;
-  self->numCenters = numCenters ;
-  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
-
-  {
-    vl_uindex * perm = vl_malloc (sizeof(vl_uindex) * numData) ;
-#if (FLT == VL_TYPE_FLOAT)
-    VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-    VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-    TYPE * distances = vl_malloc (sizeof(TYPE) * numCenters) ;
-
-    /* get a random permutation of the data point */
-    for (i = 0 ; i < numData ; ++i) perm[i] = i ;
-    _vl_kmeans_shuffle (perm, numData, rand) ;
-
-    for (k = 0, i = 0 ; k < numCenters ; ++ i) {
-
-      /* compare the next data point to all centers collected so far
-       to detect duplicates (if there are enough left)
-       */
-      if (numCenters - k < numData - i) {
-        vl_bool duplicateDetected = VL_FALSE ;
-        VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(distances,
-            dimension,
-            data + dimension * perm[i], 1,
-            (TYPE*)self->centers, k,
-            distFn) ;
-        for (j = 0 ; j < k ; ++j) {
-          duplicateDetected |= (distances[j] == 0) ;
-        }
-        if (duplicateDetected) continue ;
-      }
-
-      /* ok, it is not a duplicate so we can accept it! */
-      memcpy ((TYPE*)self->centers + dimension * k,
-              data + dimension * perm[i],
-              sizeof(TYPE) * dimension) ;
-      k ++ ;
-    }
-    vl_free(distances) ;
-    vl_free(perm) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 kmeans++ seeding */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_kmeans_init_centers_plus_plus_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size dimension,
- vl_size numData,
- vl_size numCenters)
-{
-  vl_uindex x, c ;
-  VlRand * rand = vl_get_rand () ;
-  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
-  TYPE * minDistances = vl_malloc (sizeof(TYPE) * numData) ;
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-
-  self->dimension = dimension ;
-  self->numCenters = numCenters ;
-  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
-
-  for (x = 0 ; x < numData ; ++x) {
-    minDistances[x] = (TYPE) VL_INFINITY_D ;
-  }
-
-  /* select the first point at random */
-  x = vl_rand_uindex (rand, numData) ;
-  c = 0 ;
-  while (1) {
-    TYPE energy = 0 ;
-    TYPE acc = 0 ;
-    TYPE thresh = (TYPE) vl_rand_real1 (rand) ;
-
-    memcpy ((TYPE*)self->centers + c * dimension,
-            data + x * dimension,
-            sizeof(TYPE) * dimension) ;
-
-    c ++ ;
-    if (c == numCenters) break ;
-
-    VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)
-    (distances,
-     dimension,
-     (TYPE*)self->centers + (c - 1) * dimension, 1,
-     data, numData,
-     distFn) ;
-
-    for (x = 0 ; x < numData ; ++x) {
-      minDistances[x] = VL_MIN(minDistances[x], distances[x]) ;
-      energy += minDistances[x] ;
-    }
-
-    for (x = 0 ; x < numData - 1 ; ++x) {
-      acc += minDistances[x] ;
-      if (acc >= thresh * energy) break ;
-    }
-  }
-
-  vl_free(distances) ;
-  vl_free(minDistances) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                     Quantization */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_kmeans_quantize_, SFX)
-(VlKMeans * self,
- vl_uint32 * assignments,
- TYPE * distances,
- TYPE const * data,
- vl_size numData)
-{
-  vl_index i ;
-
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-
-#ifdef _OPENMP
-#pragma omp parallel \
-            shared(self, distances, assignments, numData, distFn, data) \
-            num_threads(vl_get_max_threads())
-#endif
-  {
-    /* vl_malloc cannot be used here if mapped to MATLAB malloc */
-    TYPE * distanceToCenters = malloc(sizeof(TYPE) * self->numCenters) ;
-
-#ifdef _OPENMP
-#pragma omp for
-#endif
-    for (i = 0 ; i < (signed)numData ; ++i) {
-      vl_uindex k ;
-      TYPE bestDistance = (TYPE) VL_INFINITY_D ;
-      VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(distanceToCenters,
-                                                            self->dimension,
-                                                            data + self->dimension * i, 1,
-                                                            (TYPE*)self->centers, self->numCenters,
-                                                            distFn) ;
-      for (k = 0 ; k < self->numCenters ; ++k) {
-        if (distanceToCenters[k] < bestDistance) {
-          bestDistance = distanceToCenters[k] ;
-          assignments[i] = (vl_uint32)k ;
-        }
-      }
-      if (distances) distances[i] = bestDistance ;
-    }
-
-    free(distanceToCenters) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 ANN quantization */
-/* ---------------------------------------------------------------- */
-
-static void
-VL_XCAT(_vl_kmeans_quantize_ann_, SFX)
-(VlKMeans * self,
- vl_uint32 * assignments,
- TYPE * distances,
- TYPE const * data,
- vl_size numData,
- vl_bool update)
-{
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-
-  VlKDForest * forest = vl_kdforest_new(self->dataType,self->dimension,self->numTrees, self->distance) ;
-  vl_kdforest_set_max_num_comparisons(forest,self->maxNumComparisons);
-  vl_kdforest_set_thresholding_method(forest,VL_KDTREE_MEDIAN);
-  vl_kdforest_build(forest,self->numCenters,self->centers);
-
-#ifdef _OPENMP
-#pragma omp parallel default(none) \
-  num_threads(vl_get_max_threads()) \
-  shared(self, forest, update, assignments, distances, data, numData, distFn)
-#endif
-  {
-    VlKDForestNeighbor neighbor ;
-    VlKDForestSearcher * searcher ;
-    vl_index x;
-
-#ifdef _OPENMP
-#pragma omp critical
-#endif
-    searcher = vl_kdforest_new_searcher (forest) ;
-
-#ifdef _OPENMP
-#pragma omp for
-#endif
-    for(x = 0 ; x < (signed)numData ; ++x) {
-      vl_kdforestsearcher_query (searcher, &neighbor, 1, (TYPE const *) (data + x*self->dimension));
-
-      if (distances) {
-        if(!update) {
-          distances[x] = (TYPE) neighbor.distance;
-          assignments[x] = (vl_uint32) neighbor.index ;
-        } else {
-          TYPE prevDist = (TYPE) distFn(self->dimension,
-                                        data + self->dimension * x,
-                                        (TYPE*)self->centers + self->dimension *assignments[x]);
-          if (prevDist > (TYPE) neighbor.distance) {
-            distances[x] = (TYPE) neighbor.distance ;
-            assignments[x] = (vl_uint32) neighbor.index ;
-          } else {
-            distances[x] = prevDist ;
-          }
-        }
-      } else {
-        assignments[x] = (vl_uint32) neighbor.index ;
-      }
-    } /* end for */
-  } /* end of parallel region */
-
-  vl_kdforest_delete(forest);
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 Helper functions */
-/* ---------------------------------------------------------------- */
-
-/* The sorting routine is used to find increasing permutation of each
- * data dimension. This is used to quickly find the median for l1
- * distance clustering. */
-
-VL_INLINE TYPE
-VL_XCAT3(_vl_kmeans_, SFX, _qsort_cmp)
-(VlKMeansSortWrapper * array, vl_uindex indexA, vl_uindex indexB)
-{
-  return
-    ((TYPE*)array->data) [array->permutation[indexA] * array->stride]
-    -
-    ((TYPE*)array->data) [array->permutation[indexB] * array->stride] ;
-}
-
-VL_INLINE void
-VL_XCAT3(_vl_kmeans_, SFX, _qsort_swap)
-(VlKMeansSortWrapper * array, vl_uindex indexA, vl_uindex indexB)
-{
-  vl_uint32 tmp = array->permutation[indexA] ;
-  array->permutation[indexA] = array->permutation[indexB] ;
-  array->permutation[indexB] = tmp ;
-}
-
-#define VL_QSORT_prefix  VL_XCAT3(_vl_kmeans_, SFX, _qsort)
-#define VL_QSORT_array   VlKMeansSortWrapper*
-#define VL_QSORT_cmp     VL_XCAT3(_vl_kmeans_, SFX, _qsort_cmp)
-#define VL_QSORT_swap    VL_XCAT3(_vl_kmeans_, SFX, _qsort_swap)
-#include "qsort-def.h"
-
-static void
-VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)
-(VlKMeans * self, vl_uint32 * permutations, TYPE const * data, vl_size numData)
-{
-  vl_uindex d, x ;
-
-  for (d = 0 ; d < self->dimension ; ++d) {
-    VlKMeansSortWrapper array ;
-    array.permutation = permutations + d * numData ;
-    array.data = data + d ;
-    array.stride = self->dimension ;
-    for (x = 0 ; x < numData ; ++x) {
-      array.permutation[x] = (vl_uint32)x ;
-    }
-    VL_XCAT3(_vl_kmeans_, SFX, _qsort_sort)(&array, numData) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 Lloyd refinement */
-/* ---------------------------------------------------------------- */
-
-static double
-VL_XCAT(_vl_kmeans_refine_centers_lloyd_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size numData)
-{
-  vl_size c, d, x, iteration ;
-  double previousEnergy = VL_INFINITY_D ;
-  double initialEnergy = VL_INFINITY_D ;
-  double energy ;
-  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
-
-  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
-  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
-  vl_uint32 * permutations = NULL ;
-  vl_size * numSeenSoFar = NULL ;
-  VlRand * rand = vl_get_rand () ;
-  vl_size totNumRestartedCenters = 0 ;
-  vl_size numRestartedCenters = 0 ;
-
-  if (self->distance == VlDistanceL1) {
-    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
-    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
-    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
-  }
-
-  for (energy = VL_INFINITY_D,
-       iteration = 0;
-       1 ;
-       ++ iteration) {
-
-    /* assign data to cluters */
-    VL_XCAT(_vl_kmeans_quantize_, SFX)(self, assignments, distances, data, numData) ;
-
-    /* compute energy */
-    energy = 0 ;
-    for (x = 0 ; x < numData ; ++x) energy += distances[x] ;
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: Lloyd iter %d: energy = %g\n", iteration,
-                energy) ;
-    }
-
-    /* check termination conditions */
-    if (iteration >= self->maxNumIterations) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: Lloyd terminating because maximum number of iterations reached\n") ;
-      }
-      break ;
-    }
-    if (energy == previousEnergy) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: Lloyd terminating because the algorithm fully converged\n") ;
-      }
-      break ;
-    }
-    
-    if (iteration == 0) {
-      initialEnergy = energy ;
-    } else {
-      double eps = (previousEnergy - energy) / (initialEnergy - energy) ;
-      if (eps < self->minEnergyVariation) {
-        if (self->verbosity) {
-          VL_PRINTF("kmeans: ANN terminating because the energy relative variation was less than %f\n", self->minEnergyVariation) ;
-        }
-        break ;
-      }
-    }
-    
-    /* begin next iteration */
-    previousEnergy = energy ;
-
-    /* update clusters */
-    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
-    for (x = 0 ; x < numData ; ++x) {
-      clusterMasses[assignments[x]] ++ ;
-    }
-
-    numRestartedCenters = 0 ;
-    switch (self->distance) {
-      case VlDistanceL2:
-        memset(self->centers, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
-        for (x = 0 ; x < numData ; ++x) {
-          TYPE * cpt = (TYPE*)self->centers + assignments[x] * self->dimension ;
-          TYPE const * xpt = data + x * self->dimension ;
-          for (d = 0 ; d < self->dimension ; ++d) {
-            cpt[d] += xpt[d] ;
-          }
-        }
-        for (c = 0 ; c < self->numCenters ; ++c) {
-          TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
-          if (clusterMasses[c] > 0) {
-            TYPE mass = clusterMasses[c] ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] /= mass ;
-            }
-          } else {
-            vl_uindex x = vl_rand_uindex(rand, numData) ;
-            numRestartedCenters ++ ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] = data[x * self->dimension + d] ;
-            }
-          }
-        }
-        break ;
-      case VlDistanceL1:
-        for (d = 0 ; d < self->dimension ; ++d) {
-          vl_uint32 * perm = permutations + d * numData ;
-          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
-          for (x = 0; x < numData ; ++x) {
-            c = assignments[perm[x]] ;
-            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
-              ((TYPE*)self->centers) [d + c * self->dimension] =
-                data [d + perm[x] * self->dimension] ;
-            }
-            numSeenSoFar[c] ++ ;
-          }
-          /* restart the centers as required  */
-          for (c = 0 ; c < self->numCenters ; ++c) {
-            if (clusterMasses[c] == 0) {
-              TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
-              vl_uindex x = vl_rand_uindex(rand, numData) ;
-              numRestartedCenters ++ ;
-              for (d = 0 ; d < self->dimension ; ++d) {
-                cpt[d] = data[x * self->dimension + d] ;
-              }
-            }
-          }
-        }
-        break ;
-      default:
-        abort();
-    } /* done compute centers */
-
-    totNumRestartedCenters += numRestartedCenters ;
-    if (self->verbosity && numRestartedCenters) {
-      VL_PRINTF("kmeans: Lloyd iter %d: restarted %d centers\n", iteration,
-                numRestartedCenters) ;
-    }
-  } /* next Lloyd iteration */
-
-  if (permutations) {
-    vl_free(permutations) ;
-  }
-  if (numSeenSoFar) {
-    vl_free(numSeenSoFar) ;
-  }
-  vl_free(distances) ;
-  vl_free(assignments) ;
-  vl_free(clusterMasses) ;
-  return energy ;
-}
-
-static double
-VL_XCAT(_vl_kmeans_update_center_distances_, SFX)
-(VlKMeans * self)
-{
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-
-  if (! self->centerDistances) {
-    self->centerDistances = vl_malloc (sizeof(TYPE) *
-                                       self->numCenters *
-                                       self->numCenters) ;
-  }
-  VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(self->centerDistances,
-      self->dimension,
-      self->centers, self->numCenters,
-      NULL, 0,
-      distFn) ;
-  return self->numCenters * (self->numCenters - 1) / 2 ;
-}
-
-static double
-VL_XCAT(_vl_kmeans_refine_centers_ann_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size numData)
-{
-  vl_size c, d, x, iteration ;
-  double initialEnergy = VL_INFINITY_D ;
-  double previousEnergy = VL_INFINITY_D ;
-  double energy ;
-
-  vl_uint32 * permutations = NULL ;
-  vl_size * numSeenSoFar = NULL ;
-  VlRand * rand = vl_get_rand () ;
-  vl_size totNumRestartedCenters = 0 ;
-  vl_size numRestartedCenters = 0 ;
-
-  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
-  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
-  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
-
-  if (self->distance == VlDistanceL1) {
-    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
-    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
-    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
-  }
-
-  for (energy = VL_INFINITY_D,
-       iteration = 0;
-       1 ;
-       ++ iteration) {
-
-    /* assign data to cluters */
-    VL_XCAT(_vl_kmeans_quantize_ann_, SFX)(self, assignments, distances, data, numData, iteration > 0) ;
-
-    /* compute energy */
-    energy = 0 ;
-    for (x = 0 ; x < numData ; ++x) energy += distances[x] ;
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: ANN iter %d: energy = %g\n", iteration,
-                energy) ;
-    }
-
-    /* check termination conditions */
-    if (iteration >= self->maxNumIterations) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: ANN terminating because the maximum number of iterations has been reached\n") ;
-      }
-      break ;
-    }
-    if (energy == previousEnergy) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: ANN terminating because the algorithm fully converged\n") ;
-      }
-      break ;
-    }
-    
-    if (iteration == 0) {
-      initialEnergy = energy ;
-    } else {
-      double eps = (previousEnergy - energy) / (initialEnergy - energy) ;
-      if (eps < self->minEnergyVariation) {
-        if (self->verbosity) {
-          VL_PRINTF("kmeans: ANN terminating because the energy relative variation was less than %f\n", self->minEnergyVariation) ;
-        }
-        break ;
-      }
-    }
-
-    /* begin next iteration */
-    previousEnergy = energy ;
-
-    /* update clusters */
-    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
-    for (x = 0 ; x < numData ; ++x) {
-      clusterMasses[assignments[x]] ++ ;
-    }
-
-    numRestartedCenters = 0 ;
-    switch (self->distance) {
-      case VlDistanceL2:
-        memset(self->centers, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
-        for (x = 0 ; x < numData ; ++x) {
-          TYPE * cpt = (TYPE*)self->centers + assignments[x] * self->dimension ;
-          TYPE const * xpt = data + x * self->dimension ;
-          for (d = 0 ; d < self->dimension ; ++d) {
-            cpt[d] += xpt[d] ;
-          }
-        }
-        for (c = 0 ; c < self->numCenters ; ++c) {
-          TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
-          if (clusterMasses[c] > 0) {
-            TYPE mass = clusterMasses[c] ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] /= mass ;
-            }
-          } else {
-            vl_uindex x = vl_rand_uindex(rand, numData) ;
-            numRestartedCenters ++ ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] = data[x * self->dimension + d] ;
-            }
-          }
-        }
-        break ;
-      case VlDistanceL1:
-        for (d = 0 ; d < self->dimension ; ++d) {
-          vl_uint32 * perm = permutations + d * numData ;
-          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
-          for (x = 0; x < numData ; ++x) {
-            c = assignments[perm[x]] ;
-            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
-              ((TYPE*)self->centers) [d + c * self->dimension] =
-                data [d + perm[x] * self->dimension] ;
-            }
-            numSeenSoFar[c] ++ ;
-          }
-          /* restart the centers as required  */
-          for (c = 0 ; c < self->numCenters ; ++c) {
-            if (clusterMasses[c] == 0) {
-              TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
-              vl_uindex x = vl_rand_uindex(rand, numData) ;
-              numRestartedCenters ++ ;
-              for (d = 0 ; d < self->dimension ; ++d) {
-                cpt[d] = data[x * self->dimension + d] ;
-              }
-            }
-          }
-        }
-        break ;
-      default:
-        VL_PRINT("bad distance set: %d\n",self->distance);
-        abort();
-    } /* done compute centers */
-
-    totNumRestartedCenters += numRestartedCenters ;
-    if (self->verbosity && numRestartedCenters) {
-      VL_PRINTF("kmeans: ANN iter %d: restarted %d centers\n", iteration,
-                numRestartedCenters) ;
-    }
-  }
-
-  if (permutations) {
-    vl_free(permutations) ;
-  }
-  if (numSeenSoFar) {
-    vl_free(numSeenSoFar) ;
-  }
-
-  vl_free(distances) ;
-  vl_free(assignments) ;
-  vl_free(clusterMasses) ;
-  return energy ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                 Elkan refinement */
-/* ---------------------------------------------------------------- */
-
-static double
-VL_XCAT(_vl_kmeans_refine_centers_elkan_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size numData)
-{
-  vl_size d, iteration ;
-  vl_index x ;
-  vl_uint32 c, j ;
-  vl_bool allDone ;
-  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
-  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
-  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
-  VlRand * rand = vl_get_rand () ;
-
-#if (FLT == VL_TYPE_FLOAT)
-  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
-#else
-  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
-#endif
-
-  TYPE * nextCenterDistances = vl_malloc (sizeof(TYPE) * self->numCenters) ;
-  TYPE * pointToClosestCenterUB = vl_malloc (sizeof(TYPE) * numData) ;
-  vl_bool * pointToClosestCenterUBIsStrict = vl_malloc (sizeof(vl_bool) * numData) ;
-  TYPE * pointToCenterLB = vl_malloc (sizeof(TYPE) * numData * self->numCenters) ;
-  TYPE * newCenters = vl_malloc(sizeof(TYPE) * self->dimension * self->numCenters) ;
-  TYPE * centerToNewCenterDistances = vl_malloc (sizeof(TYPE) * self->numCenters) ;
-
-  vl_uint32 * permutations = NULL ;
-  vl_size * numSeenSoFar = NULL ;
-
-  double energy ;
-
-  vl_size totDistanceComputationsToInit = 0 ;
-  vl_size totDistanceComputationsToRefreshUB = 0 ;
-  vl_size totDistanceComputationsToRefreshLB = 0 ;
-  vl_size totDistanceComputationsToRefreshCenterDistances = 0 ;
-  vl_size totDistanceComputationsToNewCenters = 0 ;
-  vl_size totDistanceComputationsToFinalize = 0 ;
-  vl_size totNumRestartedCenters = 0 ;
-
-  if (self->distance == VlDistanceL1) {
-    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
-    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
-    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
-  }
-
-  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-  /*                          Initialization                        */
-  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-  /* An iteration is: get_new_centers + reassign + get_energy.
-   This counts as iteration 0, where get_new_centers is assumed
-   to be performed before calling the train function by
-   the initialization function */
-
-  /* update distances between centers */
-  totDistanceComputationsToInit +=
-  VL_XCAT(_vl_kmeans_update_center_distances_, SFX)(self) ;
-
-  /* assigmen points to the initial centers and initialize bounds */
-  memset(pointToCenterLB, 0, sizeof(TYPE) * self->numCenters *  numData) ;
-  for (x = 0 ; x < (signed)numData ; ++x) {
-    TYPE distance ;
-
-    /* do the first center */
-    assignments[x] = 0 ;
-    distance = distFn(self->dimension,
-                      data + x * self->dimension,
-                      (TYPE*)self->centers + 0) ;
-    pointToClosestCenterUB[x] = distance ;
-    pointToClosestCenterUBIsStrict[x] = VL_TRUE ;
-    pointToCenterLB[0 + x * self->numCenters] = distance ;
-    totDistanceComputationsToInit += 1 ;
-
-    /* do other centers */
-    for (c = 1 ; c < self->numCenters ; ++c) {
-
-      /* Can skip if the center assigned so far is twice as close
-       as its distance to the center under consideration */
-
-      if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
-          pointToClosestCenterUB[x] <=
-          ((TYPE*)self->centerDistances)
-          [c + assignments[x] * self->numCenters]) {
-        continue ;
-      }
-
-      distance = distFn(self->dimension,
-                        data + x * self->dimension,
-                        (TYPE*)self->centers + c * self->dimension) ;
-      pointToCenterLB[c + x * self->numCenters] = distance ;
-      totDistanceComputationsToInit += 1 ;
-      if (distance < pointToClosestCenterUB[x]) {
-        pointToClosestCenterUB[x] = distance ;
-        assignments[x] = c ;
-      }
-    }
-  }
-
-  /* compute UB on energy */
-  energy = 0 ;
-  for (x = 0 ; x < (signed)numData ; ++x) {
-    energy += pointToClosestCenterUB[x] ;
-  }
-
-  if (self->verbosity) {
-    VL_PRINTF("kmeans: Elkan iter 0: energy = %g, dist. calc. = %d\n",
-              energy, totDistanceComputationsToInit) ;
-  }
-
-  /* #define SANITY*/
-#ifdef SANITY
-  {
-    int xx ;
-    int cc ;
-    TYPE tol = 1e-5 ;
-    VL_PRINTF("inconsistencies after initial assignments:\n");
-    for (xx = 0 ; xx < numData ; ++xx) {
-      for (cc = 0 ; cc < self->numCenters ; ++cc) {
-        TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
-        TYPE b = distFn(self->dimension,
-                        data + self->dimension * xx,
-                        (TYPE*)self->centers + self->dimension * cc) ;
-        if (cc == assignments[xx]) {
-          TYPE z = pointToClosestCenterUB[xx] ;
-          if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
-                                 cc, xx, z, b) ;
-        }
-        if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f\n",
-                               cc, xx, a, b) ;
-      }
-    }
-  }
-#endif
-
-  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-  /*                          Iterations                            */
-  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-  for (iteration = 1 ; 1; ++iteration) {
-
-    vl_size numDistanceComputationsToRefreshUB = 0 ;
-    vl_size numDistanceComputationsToRefreshLB = 0 ;
-    vl_size numDistanceComputationsToRefreshCenterDistances = 0 ;
-    vl_size numDistanceComputationsToNewCenters = 0 ;
-    vl_size numRestartedCenters = 0 ;
-
-    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-    /*                         Compute new centers                  */
-    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
-    for (x = 0 ; x < (signed)numData ; ++x) {
-      clusterMasses[assignments[x]] ++ ;
-    }
-
-    switch (self->distance) {
-      case VlDistanceL2:
-        memset(newCenters, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
-        for (x = 0 ; x < (signed)numData ; ++x) {
-          TYPE * cpt = newCenters + assignments[x] * self->dimension ;
-          TYPE const * xpt = data + x * self->dimension ;
-          for (d = 0 ; d < self->dimension ; ++d) {
-            cpt[d] += xpt[d] ;
-          }
-        }
-        for (c = 0 ; c < self->numCenters ; ++c) {
-          TYPE * cpt = newCenters + c * self->dimension ;
-          if (clusterMasses[c] > 0) {
-            TYPE mass = clusterMasses[c] ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] /= mass ;
-            }
-          } else {
-            /* restart the center */
-            vl_uindex x = vl_rand_uindex(rand, numData) ;
-            numRestartedCenters ++ ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] = data[x * self->dimension + d] ;
-            }
-          }
-        }
-        break ;
-      case VlDistanceL1:
-        for (d = 0 ; d < self->dimension ; ++d) {
-          vl_uint32 * perm = permutations + d * numData ;
-          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
-          for (x = 0; x < (signed)numData ; ++x) {
-            c = assignments[perm[x]] ;
-            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
-              newCenters [d + c * self->dimension] =
-              data [d + perm[x] * self->dimension] ;
-            }
-            numSeenSoFar[c] ++ ;
-          }
-        }
-        /* restart the centers as required  */
-        for (c = 0 ; c < self->numCenters ; ++c) {
-          if (clusterMasses[c] == 0) {
-            TYPE * cpt = newCenters + c * self->dimension ;
-            vl_uindex x = vl_rand_uindex(rand, numData) ;
-            numRestartedCenters ++ ;
-            for (d = 0 ; d < self->dimension ; ++d) {
-              cpt[d] = data[x * self->dimension + d] ;
-            }
-          }
-        }
-        break ;
-      default:
-        abort();
-    } /* done compute centers */
-
-    /* compute the distance from the old centers to the new centers */
-    for (c = 0 ; c < self->numCenters ; ++c) {
-      TYPE distance = distFn(self->dimension,
-                             newCenters + c * self->dimension,
-                             (TYPE*)self->centers + c * self->dimension) ;
-      centerToNewCenterDistances[c] = distance ;
-      numDistanceComputationsToNewCenters += 1 ;
-    }
-
-    /* make the new centers current */
-    {
-      TYPE * tmp = self->centers ;
-      self->centers = newCenters ;
-      newCenters = tmp ;
-    }
-
-    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-    /*                Reassign points to a centers                  */
-    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-    /*
-     Update distances between centers.
-     */
-    numDistanceComputationsToRefreshCenterDistances
-    += VL_XCAT(_vl_kmeans_update_center_distances_, SFX)(self) ;
-
-    for (c = 0 ; c < self->numCenters ; ++c) {
-      nextCenterDistances[c] = (TYPE) VL_INFINITY_D ;
-      for (j = 0 ; j < self->numCenters ; ++j) {
-        if (j == c) continue ;
-        nextCenterDistances[c] = VL_MIN(nextCenterDistances[c],
-                                        ((TYPE*)self->centerDistances)
-                                        [j + c * self->numCenters]) ;
-      }
-    }
-
-    /*
-     Update upper bounds on point-to-closest-center distances
-     based on the center variation.
-     */
-    for (x = 0 ; x < (signed)numData ; ++x) {
-      TYPE a = pointToClosestCenterUB[x] ;
-      TYPE b = centerToNewCenterDistances[assignments[x]] ;
-      if (self->distance == VlDistanceL1) {
-        pointToClosestCenterUB[x] = a + b ;
-      } else {
-#if (FLT == VL_TYPE_FLOAT)
-        TYPE sqrtab =  sqrtf (a * b) ;
-#else
-        TYPE sqrtab =  sqrt (a * b) ;
-#endif
-        pointToClosestCenterUB[x] = a + b + 2.0 * sqrtab ;
-      }
-      pointToClosestCenterUBIsStrict[x] = VL_FALSE ;
-    }
-
-    /*
-     Update lower bounds on point-to-center distances
-     based on the center variation.
-     */
-
-#if defined(_OPENMP)
-#pragma omp parallel for default(shared) private(x,c) num_threads(vl_get_max_threads())
-#endif
-    for (x = 0 ; x < (signed)numData ; ++x) {
-      for (c = 0 ; c < self->numCenters ; ++c) {
-        TYPE a = pointToCenterLB[c + x * self->numCenters] ;
-        TYPE b = centerToNewCenterDistances[c] ;
-        if (a < b) {
-          pointToCenterLB[c + x * self->numCenters] = 0 ;
-        } else {
-          if (self->distance == VlDistanceL1) {
-            pointToCenterLB[c + x * self->numCenters]  = a - b ;
-          } else {
-#if (FLT == VL_TYPE_FLOAT)
-            TYPE sqrtab =  sqrtf (a * b) ;
-#else
-            TYPE sqrtab =  sqrt (a * b) ;
-#endif
-            pointToCenterLB[c + x * self->numCenters]  = a + b - 2.0 * sqrtab ;
-          }
-        }
-      }
-    }
-
-#ifdef SANITY
-    {
-      int xx ;
-      int cc ;
-      TYPE tol = 1e-5 ;
-      VL_PRINTF("inconsistencies before assignments:\n");
-      for (xx = 0 ; xx < numData ; ++xx) {
-        for (cc = 0 ; cc < self->numCenters ; ++cc) {
-          TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
-          TYPE b = distFn(self->dimension,
-                          data + self->dimension * xx,
-                          (TYPE*)self->centers + self->dimension * cc) ;
-          if (cc == assignments[xx]) {
-            TYPE z = pointToClosestCenterUB[xx] ;
-            if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
-                                   cc, xx, z, b) ;
-          }
-          if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f (assign = %d)\n",
-                                 cc, xx, a, b, assignments[xx]) ;
-        }
-      }
-    }
-#endif
-
-    /*
-     Scan the data and do the reassignments. Use the bounds to
-     skip as many point-to-center distance calculations as possible.
-     */
-    allDone = VL_TRUE ;
-
-#if defined(_OPENMP)
-#pragma omp parallel for \
-            default(none) \
-            shared(self,numData, \
-              pointToClosestCenterUB,pointToCenterLB, \
-              nextCenterDistances,pointToClosestCenterUBIsStrict, \
-              assignments,data,distFn,allDone) \
-            private(c,x) \
-            reduction(+:numDistanceComputationsToRefreshUB,numDistanceComputationsToRefreshLB) \
-            num_threads(vl_get_max_threads())
-#endif
-    for (x = 0 ; x < (signed)numData ; ++ x) {
-      /*
-       A point x sticks with its current center assignmets[x]
-       the UB to d(x, c[assigmnets[x]]) is not larger than half
-       the distance of c[assigments[x]] to any other center c.
-       */
-      if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
-          pointToClosestCenterUB[x] <= nextCenterDistances[assignments[x]]) {
-        continue ;
-      }
-
-      for (c = 0 ; c < self->numCenters ; ++c) {
-        vl_uint32 cx = assignments[x] ;
-        TYPE distance ;
-
-        /* The point is not reassigned to a given center c
-         if either:
-
-         0 - c is already the assigned center
-         1 - The UB of d(x, c[assignments[x]]) is smaller than half
-         the distance of c[assigments[x]] to c, OR
-         2 - The UB of d(x, c[assignmets[x]]) is smaller than the
-         LB of the distance of x to c.
-         */
-        if (cx == c) {
-          continue ;
-        }
-        if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
-            pointToClosestCenterUB[x] <= ((TYPE*)self->centerDistances)
-            [c + cx * self->numCenters]) {
-          continue ;
-        }
-        if (pointToClosestCenterUB[x] <= pointToCenterLB
-            [c + x * self->numCenters]) {
-          continue ;
-        }
-
-        /* If the UB is loose, try recomputing it and test again */
-        if (! pointToClosestCenterUBIsStrict[x]) {
-          distance = distFn(self->dimension,
-                            data + self->dimension * x,
-                            (TYPE*)self->centers + self->dimension * cx) ;
-          pointToClosestCenterUB[x] = distance ;
-          pointToClosestCenterUBIsStrict[x] = VL_TRUE ;
-          pointToCenterLB[cx + x * self->numCenters] = distance ;
-          numDistanceComputationsToRefreshUB += 1 ;
-
-          if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
-              pointToClosestCenterUB[x] <= ((TYPE*)self->centerDistances)
-              [c + cx * self->numCenters]) {
-            continue ;
-          }
-          if (pointToClosestCenterUB[x] <= pointToCenterLB
-              [c + x * self->numCenters]) {
-            continue ;
-          }
-        }
-
-        /*
-         Now the UB is strict (equal to d(x, assignments[x])), but
-         we still could not exclude that x should be reassigned to
-         c. We therefore compute the distance, update the LB,
-         and check if a reassigmnet must be made
-         */
-        distance = distFn(self->dimension,
-                          data + x * self->dimension,
-                          (TYPE*)self->centers + c *  self->dimension) ;
-        numDistanceComputationsToRefreshLB += 1 ;
-        pointToCenterLB[c + x * self->numCenters] = distance ;
-
-        if (distance < pointToClosestCenterUB[x]) {
-          assignments[x] = c ;
-          pointToClosestCenterUB[x] = distance ;
-          allDone = VL_FALSE ;
-          /* the UB strict flag is already set here */
-        }
-
-      } /* assign center */
-    } /* next data point */
-
-
-    totDistanceComputationsToRefreshUB
-    += numDistanceComputationsToRefreshUB ;
-
-    totDistanceComputationsToRefreshLB
-    += numDistanceComputationsToRefreshLB ;
-
-    totDistanceComputationsToRefreshCenterDistances
-    += numDistanceComputationsToRefreshCenterDistances ;
-
-    totDistanceComputationsToNewCenters
-    += numDistanceComputationsToNewCenters ;
-
-    totNumRestartedCenters
-    += numRestartedCenters ;
-
-#ifdef SANITY
-    {
-      int xx ;
-      int cc ;
-      TYPE tol = 1e-5 ;
-      VL_PRINTF("inconsistencies after assignments:\n");
-      for (xx = 0 ; xx < numData ; ++xx) {
-        for (cc = 0 ; cc < self->numCenters ; ++cc) {
-          TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
-          TYPE b = distFn(self->dimension,
-                          data + self->dimension * xx,
-                          (TYPE*)self->centers + self->dimension * cc) ;
-          if (cc == assignments[xx]) {
-            TYPE z = pointToClosestCenterUB[xx] ;
-            if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
-                                   cc, xx, z, b) ;
-          }
-          if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f (assign = %d)\n",
-                                 cc, xx, a, b, assignments[xx]) ;
-        }
-      }
-    }
-#endif
-
-    /* compute UB on energy */
-    energy = 0 ;
-    for (x = 0 ; x < (signed)numData ; ++x) {
-      energy += pointToClosestCenterUB[x] ;
-    }
-
-    if (self->verbosity) {
-      vl_size numDistanceComputations =
-      numDistanceComputationsToRefreshUB +
-      numDistanceComputationsToRefreshLB +
-      numDistanceComputationsToRefreshCenterDistances +
-      numDistanceComputationsToNewCenters ;
-      VL_PRINTF("kmeans: Elkan iter %d: energy <= %g, dist. calc. = %d\n",
-                iteration,
-                energy,
-                numDistanceComputations) ;
-      if (numRestartedCenters) {
-        VL_PRINTF("kmeans: Elkan iter %d: restarted %d centers\n",
-                  iteration,
-                  energy,
-                  numRestartedCenters) ;
-      }
-      if (self->verbosity > 1) {
-        VL_PRINTF("kmeans: Elkan iter %d: total dist. calc. per type: "
-                  "UB: %.1f%% (%d), LB: %.1f%% (%d), "
-                  "intra_center: %.1f%% (%d), "
-                  "new_center: %.1f%% (%d)\n",
-                  iteration,
-                  100.0 * numDistanceComputationsToRefreshUB / numDistanceComputations,
-                  numDistanceComputationsToRefreshUB,
-                  100.0 *numDistanceComputationsToRefreshLB / numDistanceComputations,
-                  numDistanceComputationsToRefreshLB,
-                  100.0 * numDistanceComputationsToRefreshCenterDistances / numDistanceComputations,
-                  numDistanceComputationsToRefreshCenterDistances,
-                  100.0 * numDistanceComputationsToNewCenters / numDistanceComputations,
-                  numDistanceComputationsToNewCenters) ;
-      }
-    }
-
-    /* check termination conditions */
-    if (iteration >= self->maxNumIterations) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: Elkan terminating because maximum number of iterations reached\n") ;
-      }
-      break ;
-    }
-    if (allDone) {
-      if (self->verbosity) {
-        VL_PRINTF("kmeans: Elkan terminating because the algorithm fully converged\n") ;
-      }
-      break ;
-    }
-
-  } /* next Elkan iteration */
-
-  /* compute true energy */
-  energy = 0 ;
-  for (x = 0 ; x < (signed)numData ; ++ x) {
-    vl_uindex cx = assignments [x] ;
-    energy += distFn(self->dimension,
-                     data + self->dimension * x,
-                     (TYPE*)self->centers + self->dimension * cx) ;
-    totDistanceComputationsToFinalize += 1 ;
-  }
-
-  {
-    vl_size totDistanceComputations =
-    totDistanceComputationsToInit +
-    totDistanceComputationsToRefreshUB +
-    totDistanceComputationsToRefreshLB +
-    totDistanceComputationsToRefreshCenterDistances +
-    totDistanceComputationsToNewCenters +
-    totDistanceComputationsToFinalize ;
-
-    double saving = (double)totDistanceComputations
-    / (iteration * self->numCenters * numData) ;
-
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: Elkan: total dist. calc.: %d (%.2f %% of Lloyd)\n",
-                totDistanceComputations, saving * 100.0) ;
-      if (totNumRestartedCenters) {
-        VL_PRINTF("kmeans: Elkan: there have been %d restarts\n",
-                  totNumRestartedCenters) ;
-      }
-    }
-
-    if (self->verbosity > 1) {
-      VL_PRINTF("kmeans: Elkan: total dist. calc. per type: "
-                "init: %.1f%% (%d), UB: %.1f%% (%d), LB: %.1f%% (%d), "
-                "intra_center: %.1f%% (%d), "
-                "new_center: %.1f%% (%d), "
-                "finalize: %.1f%% (%d)\n",
-                100.0 * totDistanceComputationsToInit / totDistanceComputations,
-                totDistanceComputationsToInit,
-                100.0 * totDistanceComputationsToRefreshUB / totDistanceComputations,
-                totDistanceComputationsToRefreshUB,
-                100.0 *totDistanceComputationsToRefreshLB / totDistanceComputations,
-                totDistanceComputationsToRefreshLB,
-                100.0 * totDistanceComputationsToRefreshCenterDistances / totDistanceComputations,
-                totDistanceComputationsToRefreshCenterDistances,
-                100.0 * totDistanceComputationsToNewCenters / totDistanceComputations,
-                totDistanceComputationsToNewCenters,
-                100.0 * totDistanceComputationsToFinalize / totDistanceComputations,
-                totDistanceComputationsToFinalize) ;
-    }
-  }
-
-  if (permutations) {
-    vl_free(permutations) ;
-  }
-  if (numSeenSoFar) {
-    vl_free(numSeenSoFar) ;
-  }
-
-  vl_free(distances) ;
-  vl_free(assignments) ;
-  vl_free(clusterMasses) ;
-
-  vl_free(nextCenterDistances) ;
-  vl_free(pointToClosestCenterUB) ;
-  vl_free(pointToClosestCenterUBIsStrict) ;
-  vl_free(pointToCenterLB) ;
-  vl_free(newCenters) ;
-  vl_free(centerToNewCenterDistances) ;
-
-  return energy ;
-}
-
-/* ---------------------------------------------------------------- */
-static double
-VL_XCAT(_vl_kmeans_refine_centers_, SFX)
-(VlKMeans * self,
- TYPE const * data,
- vl_size numData)
-{
-  switch (self->algorithm) {
-    case VlKMeansLloyd:
-      return
-        VL_XCAT(_vl_kmeans_refine_centers_lloyd_, SFX)(self, data, numData) ;
-      break ;
-    case VlKMeansElkan:
-      return
-        VL_XCAT(_vl_kmeans_refine_centers_elkan_, SFX)(self, data, numData) ;
-      break ;
-    case VlKMeansANN:
-      return
-        VL_XCAT(_vl_kmeans_refine_centers_ann_, SFX)(self, data, numData) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/* VL_KMEANS_INSTANTIATING */
-#else
-
-#ifndef __DOXYGEN__
-#define FLT VL_TYPE_FLOAT
-#define TYPE float
-#define SFX f
-#define VL_KMEANS_INSTANTIATING
-#include "kmeans.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define TYPE double
-#define SFX d
-#define VL_KMEANS_INSTANTIATING
-#include "kmeans.c"
-#endif
-
-/* VL_KMEANS_INSTANTIATING */
-#endif
-
-/* ================================================================ */
-#ifndef VL_KMEANS_INSTANTIATING
-
-/** ------------------------------------------------------------------
- ** @brief Set centers
- ** @param self KMeans object.
- ** @param centers centers to copy.
- ** @param dimension data dimension.
- ** @param numCenters number of centers.
- **/
-
-VL_EXPORT void
-vl_kmeans_set_centers
-(VlKMeans * self,
- void const * centers,
- vl_size dimension,
- vl_size numCenters)
-{
-  vl_kmeans_reset (self) ;
-
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_kmeans_set_centers_f
-      (self, (float const *)centers, dimension, numCenters) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_kmeans_set_centers_d
-      (self, (double const *)centers, dimension, numCenters) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief init centers by randomly sampling data
- ** @param self KMeans object.
- ** @param data data to sample from.
- ** @param dimension data dimension.
- ** @param numData nmber of data points.
- ** @param numCenters number of centers.
- **
- ** The function inits the KMeans centers by randomly sampling
- ** the data @a data.
- **/
-
-VL_EXPORT void
-vl_kmeans_init_centers_with_rand_data
-(VlKMeans * self,
- void const * data,
- vl_size dimension,
- vl_size numData,
- vl_size numCenters)
-{
-  vl_kmeans_reset (self) ;
-
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_kmeans_init_centers_with_rand_data_f
-      (self, (float const *)data, dimension, numData, numCenters) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_kmeans_init_centers_with_rand_data_d
-      (self, (double const *)data, dimension, numData, numCenters) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Seed centers by the KMeans++ algorithm
- ** @param self KMeans object.
- ** @param data data to sample from.
- ** @param dimension data dimension.
- ** @param numData nmber of data points.
- ** @param numCenters number of centers.
- **/
-
-VL_EXPORT void
-vl_kmeans_init_centers_plus_plus
-(VlKMeans * self,
- void const * data,
- vl_size dimension,
- vl_size numData,
- vl_size numCenters)
-{
-  vl_kmeans_reset (self) ;
-
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_kmeans_init_centers_plus_plus_f
-      (self, (float const *)data, dimension, numData, numCenters) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_kmeans_init_centers_plus_plus_d
-      (self, (double const *)data, dimension, numData, numCenters) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Quantize data
- ** @param self KMeans object.
- ** @param assignments data to closest center assignments (output).
- ** @param distances data to closest center distance (output).
- ** @param data data to quantize.
- ** @param numData number of data points to quantize.
- **/
-
-VL_EXPORT void
-vl_kmeans_quantize
-(VlKMeans * self,
- vl_uint32 * assignments,
- void * distances,
- void const * data,
- vl_size numData)
-{
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_kmeans_quantize_f
-      (self, assignments, distances, (float const *)data, numData) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_kmeans_quantize_d
-      (self, assignments, distances, (double const *)data, numData) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Quantize data using approximate nearest neighbours (ANN).
- ** @param self KMeans object.
- ** @param assignments data to centers assignments (output).
- ** @param distances data to closes center distance (output)
- ** @param data data to quantize.
- ** @param numData number of data points.
- ** @param update choose wether to update current assignments.
- **
- ** The function uses an ANN procedure to compute the approximate
- ** nearest neighbours of the input data point.
- **
- ** Setting @a update to ::VL_TRUE will cause the algorithm
- ** to *update existing assignments*. This means that each
- ** element of @a assignments and @a distances is updated ony if the
- ** ANN procedure can find a better assignment of the existing one.
- **/
-
-VL_EXPORT void
-vl_kmeans_quantize_ann
-(VlKMeans * self,
- vl_uint32 * assignments,
- void * distances,
- void const * data,
- vl_size numData,
- vl_bool update)
-{
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      _vl_kmeans_quantize_ann_f
-      (self, assignments, distances, (float const *)data, numData, update) ;
-      break ;
-    case VL_TYPE_DOUBLE :
-      _vl_kmeans_quantize_ann_d
-      (self, assignments, distances, (double const *)data, numData, update) ;
-      break ;
-    default:
-      abort() ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Refine center locations.
- ** @param self KMeans object.
- ** @param data data to quantize.
- ** @param numData number of data points.
- ** @return K-means energy at the end of optimization.
- **
- ** The function calls the underlying K-means quantization algorithm
- ** (@ref VlKMeansAlgorithm) to quantize the specified data @a data.
- ** The function assumes that the cluster centers have already
- ** been assigned by using one of the seeding functions, or by
- ** setting them.
- **/
-
-VL_EXPORT double
-vl_kmeans_refine_centers
-(VlKMeans * self,
- void const * data,
- vl_size numData)
-{
-  assert (self->centers) ;
-
-  switch (self->dataType) {
-    case VL_TYPE_FLOAT :
-      return
-        _vl_kmeans_refine_centers_f
-        (self, (float const *)data, numData) ;
-    case VL_TYPE_DOUBLE :
-      return
-        _vl_kmeans_refine_centers_d
-        (self, (double const *)data, numData) ;
-    default:
-      abort() ;
-  }
-}
-
-
-/** ------------------------------------------------------------------
- ** @brief Cluster data.
- ** @param self KMeans object.
- ** @param data data to quantize.
- ** @param dimension data dimension.
- ** @param numData number of data points.
- ** @param numCenters number of clusters.
- ** @return K-means energy at the end of optimization.
- **
- ** The function initializes the centers by using the initialization
- ** algorithm set by ::vl_kmeans_set_initialization and refines them
- ** by the quantization algorithm set by ::vl_kmeans_set_algorithm.
- ** The process is repeated one or more times (see
- ** ::vl_kmeans_set_num_repetitions) and the resutl with smaller
- ** energy is retained.
- **/
-
-VL_EXPORT double
-vl_kmeans_cluster (VlKMeans * self,
-                   void const * data,
-                   vl_size dimension,
-                   vl_size numData,
-                   vl_size numCenters)
-{
-  vl_uindex repetition ;
-  double bestEnergy = VL_INFINITY_D ;
-  void * bestCenters = NULL ;
-
-  for (repetition = 0 ; repetition < self->numRepetitions ; ++ repetition) {
-    double energy ;
-    double timeRef ;
-
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: repetition %d of %d\n", repetition + 1, self->numRepetitions) ;
-    }
-
-    timeRef = vl_get_cpu_time() ;
-    switch (self->initialization) {
-      case VlKMeansRandomSelection :
-        vl_kmeans_init_centers_with_rand_data (self,
-                                               data, dimension, numData,
-                                               numCenters) ;
-        break ;
-      case VlKMeansPlusPlus :
-        vl_kmeans_init_centers_plus_plus (self,
-                                          data, dimension, numData,
-                                          numCenters) ;
-        break ;
-      default:
-        abort() ;
-    }
-
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: K-means initialized in %.2f s\n",
-                vl_get_cpu_time() - timeRef) ;
-    }
-
-    timeRef = vl_get_cpu_time () ;
-    energy = vl_kmeans_refine_centers (self, data, numData) ;
-    if (self->verbosity) {
-      VL_PRINTF("kmeans: K-means terminated in %.2f s with energy %g\n",
-                vl_get_cpu_time() - timeRef, energy) ;
-    }
-
-    /* copy centers to output if current solution is optimal */
-    /* check repetition == 0 as well in case energy = NaN, which */
-    /* can happen if the data contain NaNs */
-    if (energy < bestEnergy || repetition == 0) {
-      void * temp ;
-      bestEnergy = energy ;
-
-      if (bestCenters == NULL) {
-        bestCenters = vl_malloc(vl_get_type_size(self->dataType) *
-                                self->dimension *
-                                self->numCenters) ;
-      }
-
-      /* swap buffers */
-      temp = bestCenters ;
-      bestCenters = self->centers ;
-      self->centers = temp ;
-    } /* better energy */
-  } /* next repetition */
-
-  vl_free (self->centers) ;
-  self->centers = bestCenters ;
-  return bestEnergy ;
-}
-
-/* VL_KMEANS_INSTANTIATING */
-#endif
-
-#undef SFX
-#undef TYPE
-#undef FLT
-#undef VL_KMEANS_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/kmeans.h b/opensfm/src/third_party/vlfeat/vl/kmeans.h
deleted file mode 100644
index a3cd17631..000000000
--- a/opensfm/src/third_party/vlfeat/vl/kmeans.h
+++ /dev/null
@@ -1,435 +0,0 @@
-/** @file kmeans.h
- ** @brief K-means (@ref kmeans)
- ** @author Andrea Vedaldi
- ** @author David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi and David Novotny.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_KMEANS_H
-#define VL_KMEANS_H
-
-#include "generic.h"
-#include "random.h"
-#include "mathop.h"
-#include "kdtree.h"
-
-/* ---------------------------------------------------------------- */
-
-/** @brief K-means algorithms */
-
-typedef enum _VlKMeansAlgorithm {
-  VlKMeansLloyd,       /**< Lloyd algorithm */
-  VlKMeansElkan,       /**< Elkan algorithm */
-  VlKMeansANN          /**< Approximate nearest neighbors */
-} VlKMeansAlgorithm ;
-
-/** @brief K-means initialization algorithms */
-
-typedef enum _VlKMeansInitialization {
-  VlKMeansRandomSelection,  /**< Randomized selection */
-  VlKMeansPlusPlus          /**< Plus plus raondomized selection */
-} VlKMeansInitialization ;
-
-/** ------------------------------------------------------------------
- ** @brief K-means quantizer
- **/
-
-typedef struct _VlKMeans
-{
-
-  vl_type dataType ;                      /**< Data type. */
-  vl_size dimension ;                     /**< Data dimensionality. */
-  vl_size numCenters ;                    /**< Number of centers. */
-  vl_size numTrees ;                      /**< Number of trees in forest when using ANN-kmeans. */
-  vl_size maxNumComparisons ;             /**< Maximum number of comparisons when using ANN-kmeans. */
-
-  VlKMeansInitialization initialization ; /**< Initalization algorithm. */
-  VlKMeansAlgorithm algorithm ;           /**< Clustring algorithm. */
-  VlVectorComparisonType distance ;       /**< Distance. */
-  vl_size maxNumIterations ;              /**< Maximum number of refinement iterations. */
-  double minEnergyVariation ;             /**< Minimum energy variation. */
-  vl_size numRepetitions ;                /**< Number of clustering repetitions. */
-  int verbosity ;                         /**< Verbosity level. */
-
-  void * centers ;                        /**< Centers */
-  void * centerDistances ;                /**< Centers inter-distances. */
-
-  double energy ;                         /**< Current solution energy. */
-  VlFloatVectorComparisonFunction floatVectorComparisonFn ;
-  VlDoubleVectorComparisonFunction doubleVectorComparisonFn ;
-} VlKMeans ;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT VlKMeans * vl_kmeans_new (vl_type dataType, VlVectorComparisonType distance) ;
-VL_EXPORT VlKMeans * vl_kmeans_new_copy (VlKMeans const * kmeans) ;
-VL_EXPORT void vl_kmeans_delete (VlKMeans * self) ;
-/** @} */
-
-/** @name Basic data processing
- ** @{
- **/
-VL_EXPORT void vl_kmeans_reset (VlKMeans * self) ;
-
-VL_EXPORT double vl_kmeans_cluster (VlKMeans * self,
-                                    void const * data,
-                                    vl_size dimension,
-                                    vl_size numData,
-                                    vl_size numCenters) ;
-
-VL_EXPORT void vl_kmeans_quantize (VlKMeans * self,
-                                   vl_uint32 * assignments,
-                                   void * distances,
-                                   void const * data,
-                                   vl_size numData) ;
-
-VL_EXPORT void vl_kmeans_quantize_ANN (VlKMeans * self,
-                                   vl_uint32 * assignments,
-                                   void * distances,
-                                   void const * data,
-                                   vl_size numData,
-                                   vl_size iteration );
-/** @} */
-
-/** @name Advanced data processing
- ** @{
- **/
-VL_EXPORT void vl_kmeans_set_centers (VlKMeans * self,
-                                      void const * centers,
-                                      vl_size dimension,
-                                      vl_size numCenters) ;
-
-VL_EXPORT void vl_kmeans_init_centers_with_rand_data
-                  (VlKMeans * self,
-                   void const * data,
-                   vl_size dimensions,
-                   vl_size numData,
-                   vl_size numCenters) ;
-
-VL_EXPORT void vl_kmeans_init_centers_plus_plus
-                  (VlKMeans * self,
-                   void const * data,
-                   vl_size dimensions,
-                   vl_size numData,
-                   vl_size numCenters) ;
-
-VL_EXPORT double vl_kmeans_refine_centers (VlKMeans * self,
-                                           void const * data,
-                                           vl_size numData) ;
-
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{
- **/
-VL_INLINE vl_type vl_kmeans_get_data_type (VlKMeans const * self) ;
-VL_INLINE VlVectorComparisonType vl_kmeans_get_distance (VlKMeans const * self) ;
-
-VL_INLINE VlKMeansAlgorithm vl_kmeans_get_algorithm (VlKMeans const * self) ;
-VL_INLINE VlKMeansInitialization vl_kmeans_get_initialization (VlKMeans const * self) ;
-VL_INLINE vl_size vl_kmeans_get_num_repetitions (VlKMeans const * self) ;
-
-VL_INLINE vl_size vl_kmeans_get_dimension (VlKMeans const * self) ;
-VL_INLINE vl_size vl_kmeans_get_num_centers (VlKMeans const * self) ;
-
-VL_INLINE int vl_kmeans_get_verbosity (VlKMeans const * self) ;
-VL_INLINE vl_size vl_kmeans_get_max_num_iterations (VlKMeans const * self) ;
-VL_INLINE double vl_kmeans_get_min_energy_variation (VlKMeans const * self) ;
-VL_INLINE vl_size vl_kmeans_get_max_num_comparisons (VlKMeans const * self) ;
-VL_INLINE vl_size vl_kmeans_get_num_trees (VlKMeans const * self) ;
-VL_INLINE double vl_kmeans_get_energy (VlKMeans const * self) ;
-VL_INLINE void const * vl_kmeans_get_centers (VlKMeans const * self) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_INLINE void vl_kmeans_set_algorithm (VlKMeans * self, VlKMeansAlgorithm algorithm) ;
-VL_INLINE void vl_kmeans_set_initialization (VlKMeans * self, VlKMeansInitialization initialization) ;
-VL_INLINE void vl_kmeans_set_num_repetitions (VlKMeans * self, vl_size numRepetitions) ;
-VL_INLINE void vl_kmeans_set_max_num_iterations (VlKMeans * self, vl_size maxNumIterations) ;
-VL_INLINE void vl_kmeans_set_min_energy_variation (VlKMeans * self, double minEnergyVariation) ;
-VL_INLINE void vl_kmeans_set_verbosity (VlKMeans * self, int verbosity) ;
-VL_INLINE void vl_kmeans_set_max_num_comparisons (VlKMeans * self, vl_size maxNumComparisons) ;
-VL_INLINE void vl_kmeans_set_num_trees (VlKMeans * self, vl_size numTrees) ;
-/** @} */
-
-/** ------------------------------------------------------------------
- ** @brief Get data type
- ** @param self KMeans object instance.
- ** @return data type.
- **/
-
-VL_INLINE vl_type
-vl_kmeans_get_data_type (VlKMeans const * self)
-{
-  return self->dataType ;
-}
-
-/** @brief Get data dimension
- ** @param self KMeans object instance.
- ** @return data dimension.
- **/
-
-VL_INLINE vl_size
-vl_kmeans_get_dimension (VlKMeans const * self)
-{
-  return self->dimension ;
-}
-
-/** @brief Get data type
- ** @param self KMeans object instance.
- ** @return data type.
- **/
-
-VL_INLINE VlVectorComparisonType
-vl_kmeans_get_distance (VlKMeans const * self)
-{
-  return self->distance ;
-}
-
-/** @brief Get the number of centers (K)
- ** @param self KMeans object instance.
- ** @return number of centers.
- **/
-
-VL_INLINE vl_size
-vl_kmeans_get_num_centers (VlKMeans const * self)
-{
-  return self->numCenters ;
-}
-
-/** @brief Get the number energy of the current fit
- ** @param self KMeans object instance.
- ** @return energy.
- **/
-
-VL_INLINE double
-vl_kmeans_get_energy (VlKMeans const * self)
-{
-  return self->energy ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get verbosity level
- ** @param self KMeans object instance.
- ** @return verbosity level.
- **/
-
-VL_INLINE int
-vl_kmeans_get_verbosity (VlKMeans const * self)
-{
-  return self->verbosity ;
-}
-
-/** @brief Set verbosity level
- ** @param self KMeans object instance.
- ** @param verbosity verbosity level.
- **/
-
-VL_INLINE void
-vl_kmeans_set_verbosity (VlKMeans * self, int verbosity)
-{
-  self->verbosity = verbosity ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get centers
- ** @param self KMeans object instance.
- ** @return cluster centers.
- **/
-
-VL_INLINE void const *
-vl_kmeans_get_centers (VlKMeans const * self)
-{
-  return self->centers ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get maximum number of iterations
- ** @param self KMeans object instance.
- ** @return maximum number of iterations.
- **/
-
-VL_INLINE vl_size
-vl_kmeans_get_max_num_iterations (VlKMeans const * self)
-{
-  return self->maxNumIterations ;
-}
-
-/** @brief Set maximum number of iterations
- ** @param self KMeans filter.
- ** @param maxNumIterations maximum number of iterations.
- **/
-
-VL_INLINE void
-vl_kmeans_set_max_num_iterations (VlKMeans * self, vl_size maxNumIterations)
-{
-  self->maxNumIterations = maxNumIterations ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get maximum number of repetitions.
- ** @param self KMeans object instance.
- ** @return current number of repretitions for quantization.
- **/
-
-VL_INLINE vl_size
-vl_kmeans_get_num_repetitions (VlKMeans const * self)
-{
-  return self->numRepetitions ;
-}
-
-/** @brief Set maximum number of repetitions
- ** @param self KMeans object instance.
- ** @param numRepetitions maximum number of repetitions.
- ** The number of repetitions cannot be smaller than 1.
- **/
-
-VL_INLINE void
-vl_kmeans_set_num_repetitions (VlKMeans * self,
-                               vl_size numRepetitions)
-{
-  assert (numRepetitions >= 1) ;
-  self->numRepetitions = numRepetitions ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the minimum relative energy variation for convergence.
- ** @param self KMeans object instance.
- ** @return minimum energy variation.
- **/
-
-VL_INLINE double
-vl_kmeans_get_min_energy_variation (VlKMeans const * self)
-{
-  return self->minEnergyVariation ;
-}
-
-/** @brief Set the maximum relative energy variation for convergence.
- ** @param self KMeans object instance.
- ** @param minEnergyVariation maximum number of repetitions.
- ** The variation cannot be negative.
- **
- ** The relative energy variation is calculated after the $t$-th update
- ** to the parameters as:
- **
- ** \[ \epsilon_t =  \frac{E_{t-1} - E_t}{E_0 - E_t} \]
- **
- ** Note that this quantitiy is non-negative since $E_{t+1} \leq E_t$.
- ** Hence, $\epsilon_t$ is the improvement to the energy made in the last
- ** iteration compared to the total improvement so far. The algorithm
- ** stops if this value is less or equal than @a minEnergyVariation.
- **
- ** This test is applied only to the LLoyd and ANN algorithms.
- **/
-
-VL_INLINE void
-vl_kmeans_set_min_energy_variation (VlKMeans * self,
-                                    double minEnergyVariation)
-{
-  assert (minEnergyVariation >= 0) ;
-  self->minEnergyVariation = minEnergyVariation ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get K-means algorithm
- ** @param self KMeans object.
- ** @return algorithm.
- **/
-
-VL_INLINE VlKMeansAlgorithm
-vl_kmeans_get_algorithm (VlKMeans const * self)
-{
-  return self->algorithm ;
-}
-
-/** @brief Set K-means algorithm
- ** @param self KMeans object.
- ** @param algorithm K-means algorithm.
- **/
-
-VL_INLINE void
-vl_kmeans_set_algorithm (VlKMeans * self, VlKMeansAlgorithm algorithm)
-{
-  self->algorithm = algorithm ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get K-means initialization algorithm
- ** @param self KMeans object.
- ** @return algorithm.
- **/
-
-VL_INLINE VlKMeansInitialization
-vl_kmeans_get_initialization (VlKMeans const * self)
-{
-  return self->initialization ;
-}
-
-/** @brief Set K-means initialization algorithm
- ** @param self KMeans object.
- ** @param initialization initialization.
- **/
-
-VL_INLINE void
-vl_kmeans_set_initialization (VlKMeans * self,
-                              VlKMeansInitialization initialization)
-{
-  self->initialization = initialization ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the maximum number of comparisons in the KD-forest ANN algorithm.
- ** @param self KMeans object instance.
- ** @return maximum number of comparisons.
- **/
-
-VL_INLINE vl_size
-vl_kmeans_get_max_num_comparisons (VlKMeans const * self)
-{
-  return self->maxNumComparisons ;
-}
-
-/** @brief Set maximum number of comparisons in ANN-KD-Tree.
- ** @param self KMeans filter.
- ** @param maxNumComparisons maximum number of comparisons.
- **/
-
-VL_INLINE void
-vl_kmeans_set_max_num_comparisons (VlKMeans * self,
-                              vl_size maxNumComparisons)
-{
-    self->maxNumComparisons = maxNumComparisons;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set the number of trees in the KD-forest ANN algorithm
- ** @param self KMeans object instance.
- ** @param numTrees number of trees to use.
- **/
-
-VL_INLINE void
-vl_kmeans_set_num_trees (VlKMeans * self, vl_size numTrees)
-{
-    self->numTrees = numTrees;
-}
-
-VL_INLINE vl_size
-vl_kmeans_get_num_trees (VlKMeans const * self)
-{
-    return self->numTrees;
-}
-
-
-/* VL_IKMEANS_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/lbp.c b/opensfm/src/third_party/vlfeat/vl/lbp.c
deleted file mode 100644
index 6cea7ccd9..000000000
--- a/opensfm/src/third_party/vlfeat/vl/lbp.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/** @file lbp.c
- ** @brief Local Binary Patterns (LBP) - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 Andrea Vedaldi.
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page lbp Local Binary Patterns (LBP) descriptor
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref lbp.h implements the Local Binary Pattern (LBP) feature
-descriptor.  The LBP descriptor @cite{ojala10multiresolution} is a
-histogram of quantized LBPs pooled in a local image neighborhood. @ref
-lbp-starting demonstrates how to use the C API to compute the LBP
-descriptors of an image. For further details refer to:
-
-- @subpage lbp-fundamentals - LBP definition and parameters.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section lbp-starting Getting started with LBP
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-To compute the LBP descriptor of an image, start by creating a ::VlLbp
-object instance by specifying the type of LBP quantization. Given the
-configure LBP object, then call ::vl_lbp_process to process a
-grayscale image and obtain the corresponding LBP descriptors. This
-function expects as input a buffer large enough to contain the
-computed features. If the image has size @c width x @c height, there
-are exactly @c floor(width/cellSize) x @c floor(height/cellSize)
-cells, each of which has a histogram of LBPs of size @c dimension (as
-returned by ::vl_lbp_get_dimension). Thus the required buffer has size
-@c floor(width/cellSize) x @c floor(height/cellSize) x @c dimension.
-
-::VlLbp supports computing transposed LPBs as well. A transposed LBP
-is the LBP obtained by transposing the input image (regarded as a
-matrix). This functionality can be useful to compute the features when
-the input image is stored in column major format (e.g. MATLAB) rather
-than row major.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page lbp-fundamentals Local Binary Patterns fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A *Locally Binary Pattern* (LBP) is a local descriptor that captures
-the appearance of an image in a small neighborhood around a pixel.  An
-LBP is a string of bits, with one bit for each of the pixels in the
-neighborhood. Each bit is turned on or off depending on whether the
-intensity of the corresponding pixel is greater than the intensity of
-the central pixel. LBP are seldom used directly, however. Instead, the
-binary string thus produced are further quantized (@ref
-lbp-quantization) and pooled in local histograms (@ref
-lbp-histograms).
-
-While many variants are possible, ::VlLbp implements only the case of
-3 &times; 3 pixel neighborhoods (this setting was found to be optimal
-in several applications). In particular, the LBP centered on pixel
-$(x,y)$ is a string of eight bits. Each bit is equal to one if the
-corresponding pixel is brighter than the central one. Pixels are
-scanned starting from the one to the right in anti-clockwise order.
-For example the first bit is one if, and only if, $I(x+1,y) >
-I(x,y)$, and the second bit is one if, and only if, $I(x+1,y-1) >
-I(x,y)$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section lbp-quantization Quantized LBP
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-For a 3 &times; 3 neighborhood, an LBP is a string of eight bits and
-so there are 256 possible LBPs. These are usually too many for a
-reliable statistics (histogram) to be computed. Therefore the 256
-patterns are further quantized into a smaller number of patterns
-according to one of the following rules:
-
-- <b>Uniform</b> (::VlLbpUniform) There is one quantized pattern for
-  each LBP that has exactly a transitions from 0 to 1 and one from 1
-  to 0 when scanned in anti-clockwise order, plus one quantized
-  pattern comprising the two uniform LBPs, and one quantized pattern
-  comprising all the other LBPs. This yields a total of 58 quantized
-  patterns.
-
-  @image html lbp.png "LBP quantized patterns."
-
-The number of quantized LBPs, which depends on the quantization type,
-can be obtained by ::vl_lbp_get_dimension.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section lbp-histograms Histograms of LBPs
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The quantized LBP patterns are further grouped into local
-histograms. The image is divided into a number of cells of a
-prescribed size (as specified by the parameter @c cellSize passed to
-::vl_lbp_process as described in @ref lbp-starting). Then the
-quantized LBPs are aggregated into histogram by using bilinear
-interpolation along the two spatial dimensions (similar to HOG and
-SIFT).
-**/
-
-#include "lbp.h"
-#include "mathop.h"
-#include "string.h"
-
-/* ---------------------------------------------------------------- */
-/*                                           Initialization helpers */
-/* ---------------------------------------------------------------- */
-
-/*
- This function creates the LBP quantization table for the uniform LBP
- patterns. The purpose of this lookup table is to map a 8-bit LBP
- strings to one of 58 uniform pattern codes.
-
- Pixels in the 8-neighbourhoods are read in counterclockwise order
- starting from the east direction, as follows:
-
- NW(5)  N(6) NE(7)
- W(4)         E(0)  -> b0 b1 b2 b3 b4 b5 b6 b7
- SW(3)  S(2) SE(1)
-
- There are 256 such strings, indexing the lookup table. The table
- contains the corresponding code, effectively quantizing the 256
- patterns into 58. There is one bin for constant patterns (all zeros
- or ones), 8*7 for the uniform ones, and one for all other.
-
- A uniform pattern is a circular sequence of bit b0b1...b7 such that
- there is exactly one switch from 0 to 1 and one from 1 to 0.  These
- uniform patterns are enumerated as follows. The slowest varying index
- i (0...7) points to the first bit that is on and the slowest varying
- index j (1...7) to the length of the run of bits equal to one,
- resulting in the sequence:
-
- 0:  1000 0000
- 1:  1100 0000
- ...
- 7:  1111 1110
- 8:  0100 0000
- 9:  0110 0000
- ...
- 56: 1111 1101
-
- The function also accounts for when the image is stored in transposed
- format. The sampling function is unchanged, so that the first bit to
- be read is not the one to the east, but the one to the south, and
- overall the following sequence is read:
-
- NW(5)  W(4) SW(3)
- N(6)         S(2)  -> b2 b1 b0 b7 b6 b5 b4 b3
- NE(7)  E(0) SE(1)
-
- In enumerating the uniform patterns, the index j is unchanged as it
- encodes the runlenght. On the contrary, the index i changes to
- account for the transposition and for the fact that the beginning and
- ending of the run are swapped. With modular arithmetic, the i must be
- transformed as
-
- ip = - i + 2 - (j - 1)
- */
-
-static void
-_vl_lbp_init_uniform(VlLbp * self)
-{
-  int i, j ;
-
-  /* overall number of quantized LBPs */
-  self->dimension = 58 ;
-
-  /* all but selected patterns map to bin 57 (the first bin has index 0) */
-  for (i = 0 ; i < 256 ; ++i) {
-    self->mapping[i] = 57 ;
-  }
-
-  /* the uniform (all zeros or ones) patterns map to bin 56 */
-  self->mapping[0x00] = 56 ;
-  self->mapping[0xff] = 56 ;
-
-  /* 56 uniform patterns */
-  for (i = 0 ; i < 8 ; ++i) {
-    for (j = 1 ; j <= 7 ; ++j) {
-      int ip ;
-      int unsigned string ;
-      if (self->transposed) {
-        ip = (- i + 2 - (j - 1) + 16) % 8 ;
-      } else {
-        ip = i ;
-      }
-
-      /* string starting with j ones */
-      string = (1 << j) - 1 ;
-      string <<= ip ;
-      string = (string | (string >> 8)) & 0xff ;
-
-      self->mapping[string] = i * 7 + (j-1) ;
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Create a new LBP object
- ** @param type type of LBP features.
- ** @param transposed if @c true, then transpose each LBP pattern.
- ** @return new VlLbp object instance.
- **/
-
-VlLbp *
-vl_lbp_new(VlLbpMappingType type, vl_bool transposed)
-{
-  VlLbp * self = vl_malloc(sizeof(VlLbp)) ;
-  if (self == NULL) {
-    vl_set_last_error(VL_ERR_ALLOC, NULL) ;
-    return NULL ;
-  }
-  self->transposed = transposed ;
-  switch (type) {
-    case VlLbpUniform: _vl_lbp_init_uniform(self) ; break ;
-    default: exit(1) ;
-  }
-  return self ;
-}
-
-/** @brief Delete VlLbp object
- ** @param self object to delete.
- **/
-
-void
-vl_lbp_delete(VlLbp * self) {
-  vl_free(self) ;
-}
-
-/** @brief Get the dimension of the LBP histograms
- ** @return dimension of the LBP histograms.
- ** The dimension depends on the type of quantization used.
- ** @see ::vl_lbp_new().
- **/
-
-VL_EXPORT vl_size vl_lbp_get_dimension(VlLbp * self)
-{
-  return self->dimension ;
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Extract LBP features
- ** @param self LBP object.
- ** @param features buffer to write the features to.
- ** @param image image.
- ** @param width image width.
- ** @param height image height.
- ** @param cellSize size of the LBP cells.
- **
- ** @a features is a  @c numColumns x @c numRows x @c dimension where
- ** @c dimension is the dimension of a LBP feature obtained from ::vl_lbp_get_dimension,
- ** @c numColumns is equal to @c floor(width / cellSize), and similarly
- ** for @c numRows.
- **/
-
-VL_EXPORT void
-vl_lbp_process (VlLbp * self,
-                float * features,
-                float * image, vl_size width, vl_size height,
-                vl_size cellSize)
-{
-  vl_size cwidth = width / cellSize;
-  vl_size cheight = height / cellSize ;
-  vl_size cstride = cwidth * cheight ;
-  vl_size cdimension = vl_lbp_get_dimension(self) ;
-  vl_index x,y,cx,cy,k,bin ;
-
-#define at(u,v) (*(image + width * (v) + (u)))
-#define to(u,v,w) (*(features + cstride * (w) + cwidth * (v) + (u)))
-
-  /* clear the output buffer */
-  memset(features, 0, sizeof(float)*cdimension*cstride) ;
-
-  /* accumulate pixel-level measurements into cells */
-  for (y = 1 ; y < (signed)height - 1 ; ++y) {
-    float wy1 = (y + 0.5f) / (float)cellSize - 0.5f ;
-    int cy1 = (int) vl_floor_f(wy1) ;
-    int cy2 = cy1 + 1 ;
-    float wy2 = wy1 - (float)cy1 ;
-    wy1 = 1.0f - wy2 ;
-    if (cy1 >= (signed)cheight) continue ;
-
-    for (x = 1 ; x < (signed)width - 1; ++x) {
-      float wx1 = (x + 0.5f) / (float)cellSize - 0.5f ;
-      int cx1 = (int) vl_floor_f(wx1) ;
-      int cx2 = cx1 + 1 ;
-      float wx2 = wx1 - (float)cx1 ;
-      wx1 = 1.0f - wx2 ;
-      if (cx1 >= (signed)cwidth) continue ;
-
-      {
-        int unsigned bitString = 0 ;
-        float center = at(x,y) ;
-        if(at(x+1,y+0) > center) bitString |= 0x1 << 0; /*  E */
-        if(at(x+1,y+1) > center) bitString |= 0x1 << 1; /* SE */
-        if(at(x+0,y+1) > center) bitString |= 0x1 << 2; /* S  */
-        if(at(x-1,y+1) > center) bitString |= 0x1 << 3; /* SW */
-        if(at(x-1,y+0) > center) bitString |= 0x1 << 4; /*  W */
-        if(at(x-1,y-1) > center) bitString |= 0x1 << 5; /* NW */
-        if(at(x+0,y-1) > center) bitString |= 0x1 << 6; /* N  */
-        if(at(x+1,y-1) > center) bitString |= 0x1 << 7; /* NE */
-        bin = self->mapping[bitString] ;
-      }
-
-      if ((cx1 >= 0) & (cy1 >=0)) {
-        to(cx1,cy1,bin) += wx1 * wy1;
-      }
-      if ((cx2 < (signed)cwidth)  & (cy1 >=0)) {
-        to(cx2,cy1,bin) += wx2 * wy1 ;
-      }
-      if ((cx1 >= 0) & (cy2 < (signed)cheight)) {
-        to(cx1,cy2,bin) += wx1 * wy2 ;
-      }
-      if ((cx2 < (signed)cwidth) & (cy2 < (signed)cheight)) {
-        to(cx2,cy2,bin) += wx2 * wy2 ;
-      }
-    } /* x */
-  } /* y */
-
-  /* normalize cells */
-  for (cy = 0 ; cy < (signed)cheight ; ++cy) {
-    for (cx = 0 ; cx < (signed)cwidth ; ++ cx) {
-      float norm = 0 ;
-      for (k = 0 ; k < (signed)cdimension ; ++k) {
-        norm += features[k * cstride] ;
-      }
-      norm = sqrtf(norm) + 1e-10f; ;
-      for (k = 0 ; k < (signed)cdimension ; ++k) {
-        features[k * cstride] = sqrtf(features[k * cstride]) / norm  ;
-      }
-      features += 1 ;
-    }
-  } /* next cell to normalize */
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/lbp.h b/opensfm/src/third_party/vlfeat/vl/lbp.h
deleted file mode 100644
index d33715b5e..000000000
--- a/opensfm/src/third_party/vlfeat/vl/lbp.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/** @file lbp.h
- ** @brief Local Binary Patterns (LBP) descriptor (@ref lbp)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_LBP_H
-#define VL_LBP_H
-
-#include "generic.h"
-
-/** @brief Type of quantization for the LBP descriptors
- ** @see @ref lbp-quantization
- **/
-typedef enum _VlLbpMappingType
-{
-  VlLbpUniform     /**< Uniform local binary patterns. */
-} VlLbpMappingType ;
-
-/** @brief Local Binary Pattern extractor */
-typedef struct VlLbp_
-{
-  vl_size dimension ;
-  vl_uint8 mapping [256] ;
-  vl_bool transposed ;
-} VlLbp ;
-
-VL_EXPORT VlLbp * vl_lbp_new(VlLbpMappingType type, vl_bool transposed) ;
-VL_EXPORT void vl_lbp_delete(VlLbp * self) ;
-VL_EXPORT void vl_lbp_process(VlLbp * self,
-                              float * features,
-                              float * image, vl_size width, vl_size height,
-                              vl_size cellSize) ;
-VL_EXPORT vl_size vl_lbp_get_dimension(VlLbp * self) ;
-
-/* VL_LBP_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/liop.c b/opensfm/src/third_party/vlfeat/vl/liop.c
deleted file mode 100644
index ae788ec9d..000000000
--- a/opensfm/src/third_party/vlfeat/vl/liop.c
+++ /dev/null
@@ -1,641 +0,0 @@
-/** @file liop.c
- ** @brief Local Intensity Order Pattern (LIOP) descriptor - Definition
- ** @author Hana Sarbortova
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 Hana Sarbortova and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page liop Local Intensity Order Pattern (LIOP) descriptor
-@author Hana Sarbortova
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref liop.h implements *Local Intensity Order Pattern descriptor*
-(LIOP) of @cite{wang11local}. LIOP is a local image descriptor,
-similarly to the @ref sift "SIFT descriptor".
-
-@ref liop-starting demonstrates how to use the C API to compute the
-LIOP descriptor of a patch. For further details refer to:
-
-- @subpage liop-fundamentals - LIOP definition and parameters.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section liop-starting Getting started with LIOP
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The following code fragment demonstrates how tow to use @ref liop.h in
-a C program in order to compute the LIOP descriptor of an image patch.
-
-@code
-#include <vl/liop.h>
-
-// Create a new object instance (these numbers corresponds to parameter
-// values proposed by authors of the paper, except for 41)
-vl_size sideLength = 41 ;
-VlLiopDesc * liop = vl_liopdesc_new_basic (sideLength);
-
-// allocate the descriptor array
-vl_size dimension = vl_liopdesc_get_dimension(liop) ;
-float * desc = vl_malloc(sizeof(float) * dimension) ;
-
-// compute descriptor from a patch (an array of length sideLegnth *
-// sideLength)
-vl_liopdesc_process(liop, desc, patch) ;
-
-// delete the object
-vl_liopdesc_delete(liop) ;
-@endcode
-
-The image patch must be of odd side length and in single
-precision. There are several parameters affecting the LIOP
-descriptor. An example is the @ref liop-weighing "threshold" used to
-discard low-contrast oder pattern in the computation of the
-statistics. This is changed by using ::vl_liopdesc_set_intensity_threshold.
-**/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page liop-fundamentals LIOP fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The *Local Invariant Order Pattern* (LIOP) descriptor
-@cite{wang11local} is a local image descriptor based on the concept of
-*local order pattern*. An order pattern is simply the order obtained
-by sorting selected image samples by increasing intensity. Consider in
-particular a pixel $\bx$ and $n$ neighbors
-$\bx_1,\bx_2,\dots,\bx_n$. The local order pattern at $\bx$ is the
-permutation $\sigma$ that sorts the neighbours by increasing intensity
-$I(\bx_{\sigma(1)}) \leq I(\bx_{\sigma(2)}) \leq \dots \leq
-I(\bx_{\sigma(2)})$.
-
-An advantage of order patterns is that they are invariant to monotonic
-changes of the image intensity. However, an order pattern describes
-only a small portion of a patch and is not very distinctive. LIOP
-assembles local order patterns computed at all image locations to
-obtain a descriptor that at the same time distinctive and invariant to
-monotonic intensity changes as well as image rotations.
-
-In order to make order patterns rotation invariant, the neighborhood
-of samples around $\bx$ is taken in a rotation-covariant manner. In
-particular, the points $\bx_1,\dots,\bx_n$ are sampled anticlockwise
-on a circle of radius $r$ around $\bx$, as shown in the following
-figure:
-
-@image html liop.png "LIOP descriptor layout: square input patch (shaded area), circular measurement region (white area), local neighborhood of a point (blue)."
-
-Since the sample points do not necessarily have integer coordinates,
-$I(\bx_i)$ is computed using bilinear interpolation.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section liop-spatial-binning Intensity rank spatial binning
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Once local order patterns are computed for all pixels $\bx$ in the
-image, they can be pooled into a histogram to form an image
-descriptor. Pooling discards spatial information resulting in a
-warp-invariant statistics. In practice, there are two restriction on
-which pixels can be used for this purpose:
-
-- A margin of $r$ pixels from the image boundary must be maintained so
-  that neighborhoods fall within the image boundaries.
-- Rotation invariance requires the pooling regions to be rotation
-  co-variant.  A way to do so is to make the shape of the pooling
-  region rotation invariant.
-
-For this reason, the histogram pooling region is restricted to the
-circular region shown with a light color in the figure above.
-
-In order to increase distinctiveness of the descriptor, LIOP pools
-multiple histograms from a number of regions $R_1,\dots,R_m$ (spatial
-pooling). These regions are selected in an illumination-invariant and
-rotation-covariant manner by looking at level sets:
-\[
-R_t = \{\bx :\tau_{t} \leq I(\bx) < \tau_{t+1} \}.
-\]
-In order to be invariant to monotonic changes of the intensity, the
-thresholds $\tau_t$ are selected so that all regions contain the same
-number of pixels. This can be done efficiently by sorting pixels by
-increasing intensity and then partitioning the resulting list into $m$
-equal parts (when $m$ does not divide the number of pixels exactly,
-the remaining pixels are incorporated into the last partition).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section liop-weighing Weighted pooling
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In order to compute a histogram of order pattern occurrences, one
-needs to map permutations to histogram bins. This is obtained by
-sorting permutation in lexycogrpahical order. For example, for $n=4$
-neighbors one has the following $n!=24$ permutations:
-
-Permutation   | Lexycographical rank
---------------|----------------------
-1 2 3 4       | 1
-1 2 4 3       | 2
-1 3 2 4       | 3
-1 3 4 2       | 4
-...           | ...
-4 3 1 2       | 23
-4 3 2 1       | 24
-
-In the following, $q(\bx) \in [1, n!]$ will denote the index of the
-local order pattern $\sigma$ centered at pixel $\bx$.
-
-The local order patterns $q(\bx)$ in a region $R_t$ are then pooled to
-form a histogram of size $!n$. In this process, patterns are weighted
-based on their stability. The latter is assumed to be proportional to
-the number of pairs of pixels in the neighborhood that have a
-sufficiently large intensity difference:
-
-@f[
-w(\bx) = \sum_{i=1}^n \sum_{j=1}^n [ |I(\bx_{i}) - I(\bx_{j})| >  \Theta) ]
-@f]
-
-where $[\cdot]$ is the indicator function.
-
-In VLFeat LIOP implementation, the threshold $\Theta$ is either set as
-an absolute value, or as a faction of the difference between the
-maximum and minimum intensity in the image (restricted to the pixels
-in the light area in the figure above).
-
-Overall, LIOP consists of $m$ histograms of size $n!$ obtained as
-
-\[
-  h_{qt} = \sum_{\bx : q(\bx) = q \ \wedge\  \bx \in R_t} w(\bx).
-\]
-
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section liop-normalization Normalization
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-After computing the weighted counts $h_{qt}$, the LIOP descriptor is
-obtained by stacking the values $\{h_{qt}\}$ into a vector
-$\mathbf{h}$ and then normalising it:
-
-\[
-  \Phi = \frac{\mathbf{h}}{\|\mathbf{h}\|_2}
-\]
-
-The dimensionality is therefore $m n!$, where $m$ is the @c
-numSpatialBins number of spatial bins and $n$ is the @c numNeighbours
-number of neighbours (see ::vl_liopdesc_new). By default, this
-descriptor is stored in @c single format. It can be stored as a
-sequence of bytes by premultiplying the values by the constant 255 and
-then rounding:
-
-\[
- \operatorname{round}\left[ 255\, \times \Phi\right].
-\]
-
-*/
-
-#include "liop.h"
-#include "mathop.h"
-#include "imopv.h"
-#include <string.h>
-
-#define DEFAULT_INTENSITY_THRESHOLD -(5.0/255)
-#define DEFAULT_RADIUS 6.0
-#define DEFAULT_NUM_SPATIAL_BINS 6
-#define DEFAULT_NUM_NEIGHBOURS 4
-
-/* ---------------------------------------------------------------- */
-/*                                                 Helper functions */
-/* ---------------------------------------------------------------- */
-
-static
-vl_int factorial(vl_int num)
-{
-  vl_int result = 1;
-  while(num > 1){
-    result = num*result;
-    num--;
-  }
-  return result ;
-}
-
-/** @internal @brief Compute permutation index.
- ** @param permutation array containing all values from 0 to (size - 1) (input/output).
- ** @param size size of the permutation array.
- ** @return permutation index.
- **
- ** Compute the position of @a permutation in the lexycographcial
- ** sorting of permutations of the given @a size.
- **
- ** For example, in the lexicographical ordering, permutations of four elements
- ** are listed as [1 2 3 4], [1 2 4 3], [1 3 2 4], [1 3 4 2], [1 4 2 3],
- ** [1 4 3 2], [2 1 3 4], ..., [4 3 2 1].
- **
- ** The index can be computed as follows. First pick the first digit
- ** perm[1]. This is either 1,2,...,n. For each
- ** choice of the first digits, there are (n-1)! other permutations, separated
- ** therefore by (n-1)! elements in lexicographical order.
- **
- ** Process then the second digit perm[2]. This can be though as finding
- ** the lexycotraphical index of perm[2], ..., perm[n], a permutation of
- ** n-1 elements. This can be explicitly obtained by taking out 1 from
- ** all elements perm[i] > perm[1]. */
-
-VL_INLINE vl_index get_permutation_index(vl_uindex *permutation, vl_size size){
-  vl_index index = 0 ;
-  vl_index i ;
-  vl_index j ;
-
-  for (i = 0 ; i < (signed)size ; ++i) {
-    index = index * ((signed)size - i) + permutation[i] ;
-    for (j = i + 1 ; j < (signed)size ; ++j) {
-      if (permutation[j] > permutation[i]) { permutation[j] -- ; }
-    }
-  }
-  return index ;
-}
-
-/* instantiate two quick sort algorithms */
-VL_INLINE float patch_cmp (VlLiopDesc * liop, vl_index i, vl_index j)
-{
-  vl_index ii = liop->patchPermutation[i] ;
-  vl_index jj = liop->patchPermutation[j] ;
-  return liop->patchIntensities[ii] - liop->patchIntensities[jj] ;
-}
-
-VL_INLINE void patch_swap (VlLiopDesc * liop, vl_index i, vl_index j)
-{
-  vl_index tmp = liop->patchPermutation[i] ;
-  liop->patchPermutation[i] = liop->patchPermutation[j] ;
-  liop->patchPermutation[j] = tmp ;
-}
-
-#define VL_QSORT_prefix patch
-#define VL_QSORT_array VlLiopDesc*
-#define VL_QSORT_cmp patch_cmp
-#define VL_QSORT_swap patch_swap
-#include "qsort-def.h"
-
-VL_INLINE float neigh_cmp (VlLiopDesc * liop, vl_index i, vl_index j)
-{
-  vl_index ii = liop->neighPermutation[i] ;
-  vl_index jj = liop->neighPermutation[j] ;
-  return liop->neighIntensities[ii] - liop->neighIntensities[jj] ;
-}
-
-VL_INLINE void neigh_swap (VlLiopDesc * liop, vl_index i, vl_index j)
-{
-  vl_index tmp = liop->neighPermutation[i] ;
-  liop->neighPermutation[i] = liop->neighPermutation[j] ;
-  liop->neighPermutation[j] = tmp ;
-}
-
-#define VL_QSORT_prefix neigh
-#define VL_QSORT_array VlLiopDesc*
-#define VL_QSORT_cmp neigh_cmp
-#define VL_QSORT_swap neigh_swap
-#include "qsort-def.h"
-
-/* ---------------------------------------------------------------- */
-/*                                            Construct and destroy */
-/* ---------------------------------------------------------------- */
-
-/** @brief Create a new LIOP object instance.
- ** @param numNeighbours number of neighbours.
- ** @param numSpatialBins number of bins.
- ** @param radius radius of the cirucal sample neighbourhoods.
- ** @param sideLength width of the input image patch (the patch is square).
- ** @return new object instance.
- **
- ** The value of @a radius should be at least less than half the @a
- ** sideLength of the patch.
- **/
-
-VlLiopDesc *
-vl_liopdesc_new (vl_int numNeighbours, vl_int numSpatialBins,
-                 float radius, vl_size sideLength)
-{
-  vl_index i, t ;
-  VlLiopDesc * self = vl_calloc(sizeof(VlLiopDesc), 1);
-
-  assert(radius <= sideLength/2) ;
-
-  self->numNeighbours = numNeighbours ;
-  self->numSpatialBins = numSpatialBins ;
-  self->neighRadius = radius ;
-  self->intensityThreshold = DEFAULT_INTENSITY_THRESHOLD ;
-
-  self->dimension = factorial(numNeighbours) * numSpatialBins ;
-
-  /*
-   Precompute a list of pixels within a circular patch inside
-   the square image. Leave a suitable marging for sampling around
-   these pixels.
-   */
-
-  self->patchSize = 0 ;
-  self->patchPixels = vl_malloc(sizeof(vl_uindex)*sideLength*sideLength) ;
-  self->patchSideLength = sideLength ;
-
-  {
-    vl_index x, y ;
-    vl_index center = (sideLength - 1) / 2 ;
-    double t = center - radius + 0.6 ;
-    vl_index t2 = (vl_index) (t * t) ;
-    for (y = 0 ; y < (signed)sideLength ; ++y) {
-      for (x = 0 ; x < (signed)sideLength ; ++x) {
-        vl_index dx = x - center ;
-        vl_index dy = y - center ;
-        if (x == 0 && y == 0) continue ;
-        if (dx*dx + dy*dy <= t2) {
-          self->patchPixels[self->patchSize++] = x + y * sideLength ;
-        }
-      }
-    }
-  }
-
-  self->patchIntensities = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
-  self->patchPermutation = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
-
-  /*
-   Precompute the samples in the circular neighbourhood of each
-   measurement point.
-   */
-
-  self->neighPermutation = vl_malloc(sizeof(vl_uindex) * self->numNeighbours) ;
-  self->neighIntensities = vl_malloc(sizeof(float) * self->numNeighbours) ;
-  self->neighSamplesX = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
-  self->neighSamplesY = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
-
-  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
-    vl_index pixel ;
-    double x, y ;
-    double dangle = 2*VL_PI / (double)self->numNeighbours ;
-    double angle0 ;
-    vl_index center = (sideLength - 1) / 2 ;
-
-    pixel = self->patchPixels[i] ;
-    x = (pixel % (signed)self->patchSideLength) - center ;
-    y = (pixel / (signed)self->patchSideLength) - center ;
-
-    angle0 = atan2(y,x) ;
-
-    for (t = 0 ; t < (signed)self->numNeighbours ; ++t) {
-      double x1 = x + radius * cos(angle0 + dangle * t) + center ;
-      double y1 = y + radius * sin(angle0 + dangle * t) + center ;
-      self->neighSamplesX[t + (signed)self->numNeighbours * i] = x1 ;
-      self->neighSamplesY[t + (signed)self->numNeighbours * i] = y1 ;
-    }
-  }
-  return self ;
-}
-
-/** @brief Create a new object with default parameters
- ** @param sideLength size of the patches to be processed.
- ** @return new object.
- **
- ** @see ::vl_liopdesc_new. */
-
-VlLiopDesc * vl_liopdesc_new_basic (vl_size sideLength)
-{
-  return vl_liopdesc_new(DEFAULT_NUM_NEIGHBOURS,
-                         DEFAULT_NUM_SPATIAL_BINS,
-                         DEFAULT_RADIUS,
-                         sideLength) ;
-}
-
-/** @brief Delete object instance.
- ** @param self object instance. */
-
-void
-vl_liopdesc_delete (VlLiopDesc * self)
-{
-  vl_free (self->patchPixels) ;
-  vl_free (self->patchIntensities) ;
-  vl_free (self->patchPermutation) ;
-  vl_free (self->neighPermutation) ;
-  vl_free (self->neighIntensities) ;
-  vl_free (self->neighSamplesX) ;
-  vl_free (self->neighSamplesY) ;
-  vl_free (self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                          Compute LIOP descriptor */
-/* ---------------------------------------------------------------- */
-
-/** @brief Compute liop descriptor for a patch
- ** @param self object instance
- ** @param desc descriptor to be computed (output).
- ** @param patch patch to process
- **
- ** Use ::vl_liopdesc_get_dimension to get the size of the descriptor
- ** @a desc. */
-
-void
-vl_liopdesc_process (VlLiopDesc * self, float * desc, float const * patch)
-{
-  vl_index i,t ;
-  vl_index offset,numPermutations ;
-  vl_index spatialBinArea, spatialBinEnd, spatialBinIndex ;
-  float threshold ;
-
-  memset(desc, 0, sizeof(float) * self->dimension) ;
-
-  /*
-   * Sort pixels in the patch by increasing intensity.
-   */
-
-  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
-    vl_index pixel = self->patchPixels[i] ;
-    self->patchIntensities[i] = patch[pixel] ;
-    self->patchPermutation[i] = i ;
-  }
-  patch_sort(self, self->patchSize) ;
-
-  /*
-   * Tune the threshold if needed.
-   */
-
-  if (self->intensityThreshold < 0) {
-    i = self->patchPermutation[0] ;
-    t = self->patchPermutation[self->patchSize-1] ;
-    threshold = - self->intensityThreshold
-    * (self->patchIntensities[t] - self->patchIntensities[i]);
-  } else {
-    threshold = self->intensityThreshold ;
-  }
-
-  /*
-   * Process pixels in order of increasing intenisity, dividing them into
-   * spatial bins on the fly.
-   */
-
-  numPermutations = factorial(self->numNeighbours) ;
-  spatialBinArea = self->patchSize / self->numSpatialBins ;
-  spatialBinEnd = spatialBinArea ;
-  spatialBinIndex = 0 ;
-  offset = 0 ;
-
-  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
-    vl_index permIndex ;
-    double *sx, *sy ;
-
-    /* advance to the next spatial bin if needed */
-    if (i >= (signed)spatialBinEnd && spatialBinIndex < (signed)self->numSpatialBins - 1) {
-      spatialBinEnd += spatialBinArea ;
-      spatialBinIndex ++ ;
-      offset += numPermutations ;
-    }
-
-    /* get intensities of neighbours of the current patch element and sort them */
-    sx = self->neighSamplesX + self->numNeighbours * self->patchPermutation[i] ;
-    sy = self->neighSamplesY + self->numNeighbours * self->patchPermutation[i] ;
-    for (t = 0 ; t < self->numNeighbours ; ++t) {
-      double x = *sx++ ;
-      double y = *sy++ ;
-
-      /* bilinear interpolation */
-      vl_index ix = vl_floor_d(x) ;
-      vl_index iy = vl_floor_d(y) ;
-
-      double wx = x - ix ;
-      double wy = y - iy ;
-
-      double a = 0, b = 0, c = 0, d = 0 ;
-
-      int L = (int) self->patchSideLength ;
-
-      if (ix >= 0   && iy >= 0  ) { a = patch[ix   + iy * L] ; }
-      if (ix <  L-1 && iy >= 0  ) { b = patch[ix+1 + iy * L] ; }
-      if (ix >= 0   && iy <  L-1) { c = patch[ix   + (iy+1) * L] ; }
-      if (ix <  L-1 && iy <  L-1) { d = patch[ix+1 + (iy+1) * L] ; }
-
-      self->neighPermutation[t] = t;
-      self->neighIntensities[t] = (1 - wy) * (a + (b - a) * wx) + wy * (c + (d - c) * wx) ;
-    }
-    neigh_sort (self, self->numNeighbours) ;
-
-    /* get permutation index */
-    permIndex = get_permutation_index(self->neighPermutation, self->numNeighbours);
-
-    /*
-     * Compute weight according to difference in intensity values and
-     * accumulate.
-     */
-    {
-      int k, t ;
-      float weight = 0 ;
-      for(k = 0; k < self->numNeighbours ; ++k) {
-        for(t = k + 1; t < self->numNeighbours; ++t){
-          double a = self->neighIntensities[k] ;
-          double b = self->neighIntensities[t] ;
-          weight += (a > b + threshold || b > a + threshold) ;
-        }
-      }
-      desc[permIndex + offset] += weight ;
-    }
-  }
-
-  /* normalization */
-  {
-    float norm = 0;
-    for(i = 0; i < (signed)self->dimension; i++) {
-      norm += desc[i]*desc[i];
-    }
-    norm = VL_MAX(sqrt(norm), 1e-12) ;
-    for(i = 0; i < (signed)self->dimension; i++){
-      desc[i] /= norm ;
-    }
-  }
-}
-
-
-/* ---------------------------------------------------------------- */
-/*                                              Getters and setters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get the dimension of a LIOP descriptor.
- ** @param self object.
- ** @return dimension. */
-
-vl_size
-vl_liopdesc_get_dimension (VlLiopDesc const * self)
-{
-  return self->dimension ;
-}
-
-
-/** @brief Get the number of neighbours.
- ** @param self object.
- ** @return number of neighbours.
- **/
-
-vl_size
-vl_liopdesc_get_num_neighbours (VlLiopDesc const * self)
-{
-  assert(self) ;
-  return self->numNeighbours ;
-}
-
-/** @brief Get the intensity threshold
- ** @param self object.
- ** @return intensity threshold.
- ** @see liop-weighing
- **/
-
-float
-vl_liopdesc_get_intensity_threshold (VlLiopDesc const * self)
-{
-  assert(self) ;
-  return self->intensityThreshold ;
-}
-
-/** @brief Set the intensity threshold
- ** @param self object.
- ** @param x intensity threshold.
- **
- ** If non-negative, the threshold as is is used when comparing
- ** intensities. If negative, the absolute value of the specified
- ** number is multipled by the maximum intensity difference inside a
- ** patch to obtain the threshold.
- **
- ** @see liop-weighing
- **/
-
-void
-vl_liopdesc_set_intensity_threshold (VlLiopDesc * self, float x)
-{
-  assert(self) ;
-  self->intensityThreshold = x ;
-}
-
-/** @brief Get the neighbourhood radius.
- ** @param self object.
- ** @return neighbourhood radius.
- **/
-
-double
-vl_liopdesc_get_neighbourhood_radius (VlLiopDesc const * self)
-{
-  assert(self) ;
-  return self->neighRadius ;
-}
-
-/** @brief Get the number of spatial bins.
- ** @param self object.
- ** @return number of spatial bins.
- **/
-
-vl_size
-vl_liopdesc_get_num_spatial_bins (VlLiopDesc const * self)
-{
-  assert(self) ;
-  return self->numSpatialBins ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/liop.h b/opensfm/src/third_party/vlfeat/vl/liop.h
deleted file mode 100644
index d96de915d..000000000
--- a/opensfm/src/third_party/vlfeat/vl/liop.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/** @file liop.h
- ** @brief Local Intensity Order Pattern (LIOP) descriptor (@ref liop)
- ** @author Hana Sarbortova
- ** @author Andrea Vedaldi
- ** @see @ref liop
- **/
-
-/*
-Copyright (C) 2013 Hana Sarbortova and Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_LIOP_H
-#define VL_LIOP_H
-
-#include "generic.h"
-
-/** @brief LIOP descriptor extractor object */
-typedef struct _VlLiopDesc
-{
-  vl_int numNeighbours; /**< Number of neighbours. */
-  vl_int numSpatialBins; /**< Number of bins. */
-  float intensityThreshold; /**< Weight threshold. */
-  vl_size dimension; /**< LIOP descriptor size. */
-
-  /* Pixels in the circular patch */
-  vl_size patchSideLength ;
-  vl_size patchSize ; /* only circular neighbourhood */
-  vl_uindex * patchPixels ;
-  float * patchIntensities ;
-  vl_uindex * patchPermutation ;
-
-  /* Neighbourhoods of each pixel (samples in a circle) */
-  float neighRadius; /**< Point to neighbour radius (distance). */
-
-  float * neighIntensities ;
-  vl_uindex * neighPermutation ;
-  double * neighSamplesX ;
-  double * neighSamplesY ;
-
-} VlLiopDesc ;
-
-/** @name Construct and destroy
- ** @{ */
-VL_EXPORT
-VlLiopDesc * vl_liopdesc_new (vl_int numNeighbours,
-                              vl_int numSpatialBins,
-                              float radius,
-                              vl_size sideLength) ;
-
-VL_EXPORT
-VlLiopDesc * vl_liopdesc_new_basic (vl_size sideLength) ;
-
-VL_EXPORT
-void vl_liopdesc_delete (VlLiopDesc * self) ;
-/** @} */
-
-/**  @name Get data and parameters
- **  @{ */
-VL_EXPORT vl_size vl_liopdesc_get_dimension (VlLiopDesc const * self) ;
-VL_EXPORT vl_size vl_liopdesc_get_num_neighbours (VlLiopDesc const * self) ;
-VL_EXPORT float vl_liopdesc_get_intensity_threshold (VlLiopDesc const * self) ;
-VL_EXPORT vl_size vl_liopdesc_get_num_spatial_bins (VlLiopDesc const * self) ;
-VL_EXPORT double vl_liopdesc_get_neighbourhood_radius (VlLiopDesc const * self) ;
-VL_EXPORT void vl_liopdesc_set_intensity_threshold (VlLiopDesc * self, float x) ;
-/** @} */
-
-/**  @name Compute LIOP descriptor
- **  @{ */
-VL_EXPORT
-void vl_liopdesc_process (VlLiopDesc * liop, float * desc, float const * patch) ;
-/** @} */
-
-/* VL_LIOP_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop.c b/opensfm/src/third_party/vlfeat/vl/mathop.c
deleted file mode 100644
index d2a292697..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop.c
+++ /dev/null
@@ -1,1032 +0,0 @@
-/** @file mathop.c
- ** @brief Math operations - Definition
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2014 Andrea Vedaldi.
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@page mathop Mathematical operations
-@author Andrea Vedaldi
-@author Brian Fulkerson
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-VLFeat include several low-level routines to speedup common
-mathematical operations used throughout the library. Most are
-collected in the @ref mathop.h module.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section mathop-usage-vector-comparison Comparing vectors
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-@ref mathop.h includes a number of functions to quickly compute
-distances or similarity of pairs of vector. Applications include
-clustering and evaluation of SVM-like classifiers.
-
-Use ::vl_get_vector_comparison_function_f or
-::vl_get_vector_comparison_function_d obtain an approprite function
-to comprare vectors of floats or doubles, respectively.  Such
-functions are usually optimized (for instance, on X86 platforms they
-use the SSE vector extension) and are several times faster than a
-naive implementation.  ::vl_eval_vector_comparison_on_all_pairs_f and
-::vl_eval_vector_comparison_on_all_pairs_d can be used to evaluate
-the comparison function on all pairs of one or two sequences of
-vectors.
-
-Let @f$ \mathbf{x} = (x_1,\dots,x_d) @f$ and @f$ \mathbf{y} =
-(y_1,\dots,y_d) @f$ be two vectors.  The following comparison
-functions are supported:
-
-<table>
-<tr>
-<td>@f$ l^1 @f$</td>
-<td>::VlDistanceL1</td>
-<td>@f$ \sum_{i=1}^d |x_i - y_i| @f$</td>
-<td>l1 distance (squared intersection metric)</td>
-</tr>
-<tr>
-<td>@f$ l^2 @f$</td>
-<td>::VlDistanceL2</td>
-<td>@f$\sum_{i=1}^d (x_i - y_i)^2@f$</td>
-<td>Squared Euclidean disance</td>
-</tr>
-<tr>
-<td>@f$ \chi^2 @f$</td>
-<td>::VlDistanceChi2</td>
-<td>@f$\sum_{i=1}^d \frac{(x_i - y_i)^2}{x_i + y_i}@f$</td>
-<td>Squared chi-square distance</td>
-</tr>
-<tr>
-<td>-</td>
-<td>::VlDistanceHellinger</td>
-<td>@f$\sum_{i=1}^d (\sqrt{x_i} - \sqrt{y_i})^2@f$</td>
-<td>Squared Hellinger's distance</td>
-</tr>
-<tr>
-<td>-</td>
-<td>::VlDistanceJS</td>
-<td>@f$
-\sum_{i=1}^d
-\left(
-  x_i \log\frac{2x_i}{x_i+y_i}
-+ y_i \log\frac{2y_i}{x_i+y_i}
-\right)
-@f$
-</td>
-<td>Squared Jensen-Shannon distance</td>
-</tr>
-<tr>
-<td>@f$ l^1 @f$</td>
-<td>::VlKernelL1</td>
-<td>@f$ \sum_{i=1}^d \min\{ x_i, y_i \} @f$</td>
-<td>intersection kernel</td>
-</tr>
-<tr>
-<td>@f$ l^2 @f$</td>
-<td>::VlKernelL2</td>
-<td>@f$\sum_{i=1}^d x_iy_i @f$</td>
-<td>linear kernel</td>
-</tr>
-<tr>
-<td>@f$ \chi^2 @f$</td>
-<td>::VlKernelChi2</td>
-<td>@f$\sum_{i=1}^d 2 \frac{x_iy_i}{x_i + y_i}@f$</td>
-<td>chi-square kernel</td>
-</tr>
-<tr>
-<td>-</td>
-<td>::VlKernelHellinger</td>
-<td>@f$\sum_{i=1}^d 2 \sqrt{x_i y_i}@f$</td>
-<td>Hellinger's kernel (Bhattacharya coefficient)</td>
-</tr>
-<tr>
-<td>-</td>
-<td>::VlKernelJS</td>
-<td>@f$
-\sum_{i=1}^d
-\left(
-  \frac{x_i}{2} \log_2\frac{x_i+y_i}{x_i}
-+ \frac{y_i}{2} \log_2\frac{x_i+y_i}{y_i}
-\right)
-@f$
-</td>
-<td>Jensen-Shannon kernel</td>
-</tr>
-</table>
-
-@remark The definitions have been choosen so that corresponding kernels and
-distances are related by the equation:
-@f[
- d^2(\mathbf{x},\mathbf{y})
- =
- k(\mathbf{x},\mathbf{x})
- +k(\mathbf{y},\mathbf{y})
- -k(\mathbf{x},\mathbf{y})
- -k(\mathbf{y},\mathbf{x})
-@f]
-This means that each of these distances can be interpreted as a
-squared distance or metric in the corresponding reproducing kernel
-Hilbert space. Notice in particular that the @f$ l^1 @f$ or Manhattan
-distance is also a <em>squared</em> distance in this sense.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section mathop-integer-ops Fast basic functions operations
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-In certain algorithm it is useful to quickly compute integer
-approximation of certain mathematical operations. Presently, VLFeat
-includes and implementations of:
-
-- Fast single precision atan2: ::vl_fast_sqrt_f.
-- Fast inverse square root: ::vl_fast_resqrt_f, ::vl_fast_resqrt_d.
-- Fast square root: ::vl_fast_sqrt_f, ::vl_fast_sqrt_d.
-- Fast integer square root: ::vl_fast_sqrt_ui16, ::vl_fast_sqrt_ui32,
-  ::vl_fast_sqrt_ui64 (see also @subpage mathop-sqrti).
-**/
-
-/** @fn vl_get_vector_comparison_function_f(VlVectorComparisonType)
- **
- ** @brief Get vector comparison function from comparison type
- ** @param type vector comparison type.
- ** @return comparison function.
- **/
-
-/** @fn vl_get_vector_comparison_function_d(VlVectorComparisonType)
- ** @brief Get vector comparison function from comparison type
- ** @sa vl_get_vector_comparison_function_f
- **/
-
-/** @fn vl_eval_vector_comparison_on_all_pairs_f(float*,vl_size,
- **     float const*,vl_size,float const*,vl_size,VlFloatVectorComparisonFunction)
- **
- ** @brief Evaluate vector comparison function on all vector pairs
- ** @param result comparison matrix (output).
- ** @param dimension number of vector components (rows of @a X and @a Y).
- ** @param X data matrix X.
- ** @param Y data matrix Y.
- ** @param numDataX number of vectors in @a X (columns of @a X)
- ** @param numDataY number of vectros in @a Y (columns of @a Y)
- ** @param function vector comparison function.
- **
- ** The function evaluates @a function on all pairs of columns
- ** from matrices @a X and @a Y, filling a @a numDataX by @a numDataY
- ** matrix.
- **
- ** If @a Y is a null pointer the function compares all columns from
- ** @a X with themselves.
- **/
-
-/** @fn vl_eval_vector_comparison_on_all_pairs_d(double*,vl_size,
- **     double const*,vl_size,double const*,vl_size,VlDoubleVectorComparisonFunction)
- ** @brief Evaluate vector comparison function on all vector pairs
- ** @sa vl_eval_vector_comparison_on_all_pairs_f
- **/
-
-/**
-@page mathop-sqrti Fast integer square root algorithm
-@tableofcontents
-
-This section describes the fast integer square root algorithm used by
-vl_fast_sqrt_ui8, ::vl_fast_sqrt_ui16, ::vl_fast_sqrt_ui32,
-::vl_fast_sqrt_ui64.
-
-Given a non-negative integer $x \in \mathbb{Z}_+$, the goal of this
-algorithm is to quickly compute the integer approximation of the
-square root of an integer number:
-
-\[
-y = \max_{\bar y\in\mathbb{Z}} \bar y, \qquad \text{such that}\  \bar y^2 \leq x.
-\]
-
-Consider determining the k-th bit of $y$. To this end, decompose $y$
-in three parts:
-
-\[
-y = y_{k+1} + q 2^k + r,
-\qquad \text{where}\   y_{k+1} \geq 2^{k+1}, r < 2^k,
-\]
-
-and $q\in\{0,1\}$ is the bit to be determined. Here $y_{k+1}$ is a part
-of the result $y$ that has already been determined, while the bit $q$
-and the remainder $r$ are still unknown. Recall that the goal is to
-find the largest $y^2$ such that $y^2 \leq x$. Expanding $y^2$ this
-condition becomes
-
-\[
-q (2^{2k} + 2 y_{k+1} 2^k) + r(r + 2q 2^k + 2 y_{k+1}) \leq x - y_{k+1}^2.
-\]
-
-We can now determine if $q=1$ or $q=0$ based on the value of the
-residual $x - y_{k+1}^2$. Specifically, $q=1$ requires that:
-
-\[
-\boxed{
-2^{2k} + 2a2^k \leq x - y_{k+1}^2.
-}
-\]
-
-On the other hand, if this equation is satisfied, then setting $r=0$
-shows that there exists at least one $y$ such that $q=1$ and $y^2 \leq
-x$. In particular, greedily choosing $q=1$ in $x=y_{k+1} + 2^k q + r$ is
-optimal because $2^k > r$. This yields the algorithm:
-
-1. Note that if $x$ is stored in $n$ bits and $n$ is even, then the
-   integer square root $y$ does not require more than $m = n / 2$ bit
-   to be stored. Thus the first bit to be determined is $k \leftarrow
-   m - 1 = n/2 - 1$ and $y_{n/2}=0$.
-2. The algorithm stores and updates $y_k/2^{k}$ and $x - y_{k}^2$ for
-   convenience.
-3. During iteration $k$, $y_k$ is determined. On entering the
-   iteration, the first step is to compute $y_{k+1}/2^k = 2
-   y_{k+1}/2^{k+1}$.
-4. Then the bound $t = (2^{2k} + 2 y_{k+1})2^k = 2^{2k}(1 + 2
-   y_{k+1}/2^k)$.
-5. If $t \geq x - y_{k+1}$, the $k$-th bit of $y_k$ is set to
-   one. This means applying the update $\hat y_{k}/2^k \leftarrow
-   y_{k+1}/2^k + 1$. This also requires computing $x - y_{k}^2
-   \leftarrow x - y_{k+1}^2 - t$.
-6. Decrement $k \leftarrow k -1$ and, if $k\geq 0$, continue from 3.
-
-**/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_MATHOP_INSTANTIATING
-
-#include "mathop.h"
-#include "mathop_sse2.h"
- #include "mathop_avx.h"
-#include <math.h>
-
-#undef FLT
-#define FLT VL_TYPE_FLOAT
-#define VL_MATHOP_INSTANTIATING
-#include "mathop.c"
-
-#undef FLT
-#define FLT VL_TYPE_DOUBLE
-#define VL_MATHOP_INSTANTIATING
-#include "mathop.c"
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifdef VL_MATHOP_INSTANTIATING
-#include "float.h"
-
-#undef COMPARISONFUNCTION_TYPE
-#undef COMPARISONFUNCTION3_TYPE
-#if (FLT == VL_TYPE_FLOAT)
-#  define COMPARISONFUNCTION_TYPE VlFloatVectorComparisonFunction
-#  define COMPARISONFUNCTION3_TYPE VlFloatVector3ComparisonFunction
-#else
-#  define COMPARISONFUNCTION_TYPE VlDoubleVectorComparisonFunction
-#  define COMPARISONFUNCTION3_TYPE VlDoubleVector3ComparisonFunction
-#endif
-
-/* ---------------------------------------------------------------- */
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T d = *X++ - *Y++ ;
-    acc += d * d ;
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l1_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T d = *X++ - *Y++ ;
-    acc += VL_MAX(d, -d) ;
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_chi2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    T denom = (a + b) ;
-    T numer = delta * delta ;
-    if (denom) {
-      T ratio = numer / denom ;
-      acc += ratio ;
-    }
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_hellinger_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-#if (FLT == VL_TYPE_FLOAT)
-    acc += a + b - 2.0 * sqrtf (a*b) ;
-#else
-    acc += a + b - 2.0 * sqrt (a*b) ;
-#endif
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_js_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T x = *X++ ;
-    T y = *Y++ ;
-    if (x) acc += x - x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
-    if (y) acc += y - y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    acc += a * b ;
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l1_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
-    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
-    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
-  }
-  return acc / ((T)2) ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_chi2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T denom = (a + b) ;
-    if (denom) {
-      T numer = 2 * a * b ;
-      T ratio = numer / denom ;
-      acc += ratio ;
-    }
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_hellinger_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-#if (FLT == VL_TYPE_FLOAT)
-    acc += sqrtf (a*b) ;
-#else
-    acc += sqrt (a*b) ;
-#endif
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_js_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T x = *X++ ;
-    T y = *Y++ ;
-    if (x) acc += x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
-    if (y) acc += y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
-  }
-  return (T)0.5 * acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_mahalanobis_sq_, SFX)
-(vl_size dimension, T const * X, T const * MU, T const * S)
-{
-  T const * X_end = X + dimension ;
-  T acc = 0.0 ;
-  while (X < X_end) {
-    T d = *X++ - *MU++ ;
-    acc += d * d * (*S++) ;
-  }
-  return acc ;
-}
-
-/* ---------------------------------------------------------------- */
-
-VL_EXPORT COMPARISONFUNCTION_TYPE
-VL_XCAT(vl_get_vector_comparison_function_, SFX)(VlVectorComparisonType type)
-{
-  COMPARISONFUNCTION_TYPE function = 0 ;
-  switch (type) {
-    case VlDistanceL2        : function = VL_XCAT(_vl_distance_l2_,             SFX) ; break ;
-    case VlDistanceL1        : function = VL_XCAT(_vl_distance_l1_,             SFX) ; break ;
-    case VlDistanceChi2      : function = VL_XCAT(_vl_distance_chi2_,           SFX) ; break ;
-    case VlDistanceHellinger : function = VL_XCAT(_vl_distance_hellinger_,      SFX) ; break ;
-    case VlDistanceJS        : function = VL_XCAT(_vl_distance_js_,             SFX) ; break ;
-    case VlKernelL2          : function = VL_XCAT(_vl_kernel_l2_,               SFX) ; break ;
-    case VlKernelL1          : function = VL_XCAT(_vl_kernel_l1_,               SFX) ; break ;
-    case VlKernelChi2        : function = VL_XCAT(_vl_kernel_chi2_,             SFX) ; break ;
-    case VlKernelHellinger   : function = VL_XCAT(_vl_kernel_hellinger_,        SFX) ; break ;
-    case VlKernelJS          : function = VL_XCAT(_vl_kernel_js_,               SFX) ; break ;
-    default: abort() ;
-  }
-
-#ifndef VL_DISABLE_SSE2
-  /* if a SSE2 implementation is available, use it */
-  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
-    switch (type) {
-      case VlDistanceL2    : function = VL_XCAT(_vl_distance_l2_sse2_,             SFX) ; break ;
-      case VlDistanceL1    : function = VL_XCAT(_vl_distance_l1_sse2_,             SFX) ; break ;
-      case VlDistanceChi2  : function = VL_XCAT(_vl_distance_chi2_sse2_,           SFX) ; break ;
-      case VlKernelL2      : function = VL_XCAT(_vl_kernel_l2_sse2_,               SFX) ; break ;
-      case VlKernelL1      : function = VL_XCAT(_vl_kernel_l1_sse2_,               SFX) ; break ;
-      case VlKernelChi2    : function = VL_XCAT(_vl_kernel_chi2_sse2_,             SFX) ; break ;
-      default: break ;
-    }
-  }
-#endif
-
-#ifndef VL_DISABLE_AVX
-  /* if an AVX implementation is available, use it */
-  if (vl_cpu_has_avx() && vl_get_simd_enabled()) {
-    switch (type) {
-      case VlDistanceL2    : function = VL_XCAT(_vl_distance_l2_avx_,             SFX) ; break ;
-      default: break ;
-    }
-  }
-#endif
-
-  return function ;
-}
-
-/* ---------------------------------------------------------------- */
-
-VL_EXPORT COMPARISONFUNCTION3_TYPE
-VL_XCAT(vl_get_vector_3_comparison_function_, SFX)(VlVectorComparisonType type)
-{
-  COMPARISONFUNCTION3_TYPE function = 0 ;
-  switch (type) {
-    case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_, SFX) ; break ;
-    default: abort() ;
-  }
-
-#ifndef VL_DISABLE_SSE2
-  /* if a SSE2 implementation is available, use it */
-  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
-    switch (type) {
-      case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX) ; break ;
-      default: break ;
-    }
-  }
-#endif
-
-#ifndef VL_DISABLE_AVX
-  /* if an AVX implementation is available, use it */
-  if (vl_cpu_has_avx() && vl_get_simd_enabled()) {
-    switch (type) {
-      case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX) ; break ;
-      default: break ;
-    }
-  }
-#endif
-
-  return function ;
-}
-
-/* ---------------------------------------------------------------- */
-
-VL_EXPORT void
-VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)
-(T * result, vl_size dimension,
- T const * X, vl_size numDataX,
- T const * Y, vl_size numDataY,
- COMPARISONFUNCTION_TYPE function)
-{
-  vl_uindex xi ;
-  vl_uindex yi ;
-
-  if (dimension == 0) return ;
-  if (numDataX == 0) return ;
-  assert (X) ;
-
-  if (Y) {
-    if (numDataY == 0) return ;
-    for (yi = 0 ; yi < numDataY ; ++ yi) {
-      for (xi = 0 ; xi < numDataX ; ++ xi) {
-        *result++ = (*function)(dimension, X, Y) ;
-        X += dimension ;
-      }
-      X -= dimension * numDataX ;
-      Y += dimension ;
-    }
-  } else {
-    T * resultTransp = result ;
-    Y = X ;
-    for (yi = 0 ; yi < numDataX ; ++ yi) {
-      for (xi = 0 ; xi <= yi ; ++ xi) {
-        T z = (*function)(dimension, X, Y) ;
-        X += dimension ;
-        *result       = z ;
-        *resultTransp = z ;
-        result        += 1 ;
-        resultTransp  += numDataX ;
-      }
-      X -= dimension * (yi + 1) ;
-      Y += dimension ;
-      result       += numDataX - (yi + 1) ;
-      resultTransp += 1        - (yi + 1) * numDataX ;
-    }
-  }
-}
-
-/* VL_MATHOP_INSTANTIATING */
-#endif
-
-
-/* ---------------------------------------------------------------- */
-/*                                               Numerical analysis */
-/* ---------------------------------------------------------------- */
-
-#ifndef VL_MATHOP_INSTANTIATING
-
-/** @brief SVD of a 2x2 real matrix
- ** @param S 2x2 real diagonal matrix of the singular values (out).
- ** @param U first 2x2 real orthonormal matrix (out).
- ** @param V second 2x2 real orthonormal matrix (out).
- ** @param M 2x2 matrix.
- **
- ** The function comptues the SVD decomposition of the 2x2
- ** real matrix @f$ M @f$:
- ** @f[
- **    M = U \operatorname S V^\top
- ** @f]
- ** where @f$ U @f$ and @f$ V @f$ are real orthonormal matrices
- ** and @f$ S @f$ is the diagonal matrix of the singular values
- ** in decreasing order.
- **
- ** @par Algorithm
- **
- ** The fist step is to find rotation matrices @f$ U_1 @f$ and
- ** @f$ V_1 @f$ such taht
- ** @f[
- **     M = U_1 R V_1^\top, \quad
- **     U_1 = \begin{barray} c_{u1} & - s_{u1} \\ s_{u1} & c_{u1} \end{barray}, \quad
- **     V_1 = \begin{barray} c_{v1} & - s_{v1} \\ s_{v1} & c_{v1} \end{barray}, \quad
- **     R = \begin{barray} f & g \\ 0 & h \end{barray}.
- ** @f]
- ** Gives a 2x2 triangular matrix. The second step is to call
- ** ::vl_lapack_dlasv2 on the matrix @f$ R @f$ obtaining
- ** @f[
- **   M = U_1 (U_2 S V_2^\top) V_2.
- ** @f]
- **/
-
-void
-vl_svd2 (double* S, double *U, double *V, double const *M)
-{
-  double m11 = M[0] ;
-  double m21 = M[1] ;
-  double m12 = M[2] ;
-  double m22 = M[3] ;
-  double cu1 = m11 ;
-  double su1 = m21 ;
-  double norm = sqrt(cu1*cu1 + su1*su1) ;
-  double cu2, su2, cv2, sv2 ;
-  double f, g, h ;
-  double smin, smax ;
-  cu1 /= norm ;
-  su1 /= norm ;
-
-  f = cu1 * m11 + su1 * m21 ;
-  g = cu1 * m12 + su1 * m22 ;
-  h = - su1 * m12 + cu1 * m22 ;
-
-  vl_lapack_dlasv2 (&smin, &smax,
-                    &sv2, &cv2,
-                    &su2, &cu2,
-                    f, g, h) ;
-
-  assert(S) ;
-  S[0] = smax ;
-  S[1] = 0 ;
-  S[2] = 0 ;
-  S[3] = smin ;
-
-  if (U) {
-    U[0] = cu2*cu1 - su2*su1 ;
-    U[1] = su2*cu1 + cu2*su1 ;
-    U[2] = - cu2*su1 - su2*cu1 ;
-    U[3] = - su2*su1 + cu2*cu1 ;
-  }
-  if (V) {
-    V[0] = cv2 ;
-    V[1] = sv2 ;
-    V[2] = - sv2 ;
-    V[3] = cv2 ;
-  }
-}
-
-/** @brief SVD of a 2x2 upper triangular matrix (LAPACK @c dlasv2 equivalent)
- ** @param smin smallest (in modulus) singular value (out).
- ** @param smax largest (in modulus) singuarl value (out).
- ** @param sv second component of the right singular vector of @c smax (out).
- ** @param cv first component of the right singular vector of @c smax (out).
- ** @param su second component of the left singular vector of @c smax (out).
- ** @param cu first component of the left singular vector of @c smax (out).
- ** @param f first entry of the upper triangular matrix.
- ** @param g second entry of the upper triangular matrix.
- ** @param h third entry of the upper triangular matrix.
- **
- ** @f[
- **  \begin{bmatrix} f & g \\ 0 & h \end{bmatrix}
- **  =
- **  \begin{bmatrix} cv & - sv \\ sv & cv \end{bmatrix}
- **  \begon{bmatrix} smax & 0 \\ 0 & smin \end{bmatrix}
- **  \begin{bmatrix} cv & - sv \\ sv & cv \end{bmatrix}
- ** @f]
- **
- ** Z.Bai and J.Demmel,
- ** "Computing the Generalized Singular Value Decomposition",
- ** SIAM J. Sci. Comput., Vol. 14, No. 6, pp. 1464-1486, November 1993
- **/
-
-#define isign(i) ((i)<0 ? (-1) : (+1))  /* integer sign function */
-#define sign(x) ((x)<0.0 ? (-1) : (+1)) /* double sign function */
-
-void
-vl_lapack_dlasv2 (double *smin,
-                  double *smax,
-                  double *sv,
-                  double *cv,
-                  double *su,
-                  double *cu,
-                  double f,
-                  double g,
-                  double h)
-{
-  double svt, cvt, sut, cut; /* temporary sv, cv, su, and cu */
-  double ft = f, gt = g, ht = h; /* temporary f, g, h */
-  double fa = fabs(f), ga = fabs(g), ha = fabs(h); /* |f|, |g|, and |h| */
-  int pmax = 1 ; /* pointer to max abs entry */
-  int swap = 0 ; /* is swapped */
-  int glarge = 0 ; /* is g very large */
-  int tsign ; /* tmp sign */
-  double fmh ; /* |f| -|h| */
-  double d ; /* (|f| -|h|)/|f| */
-  double dd ; /* d*d */
-  double q ; /* g/f */
-  double qq ; /* q*q */
-  double s ; /* (|f| + |h|)/|f| */
-  double ss ; /* s*s */
-  double spq ; /* sqrt(ss + qq) */
-  double dpq ; /* sqrt(dd + qq) */
-  double a ; /* (spq + dpq)/2 */
-  double tmp ; /* temporaries */
-  double tt;
-
-  /* make fa >= ha */
-  if (fa < ha) {
-    pmax = 3 ;
-    tmp =ft ; ft = ht ; ht = tmp ; /* swap ft and ht */
-    tmp =fa ; fa = ha ; ha = tmp ; /* swap fa and ha */
-    swap = 1 ;
-  }
-
-  if (ga == 0.0) { /* diagonal */
-    *smin = ha ;
-    *smax = fa ;
-    /* identity matrix */
-    cut = 1.0 ; sut = 0.0 ;
-    cvt = 1.0 ; svt = 0.0 ;
-  }
-  else { /* not diagonal */
-    if (ga > fa) { /* g is the largest entry */
-      pmax = 2 ;
-      if ((fa / ga) < VL_EPSILON_D) { /* g is very large */
-        glarge = 1 ;
-        *smax = ga ; /* 1 ulp */
-        if (ha > 1.0) {
-          *smin = fa / (ga / ha) ; /* 2 ulps */
-        } else {
-          *smin = (fa / ga) * ha ; /* 2 ulps */
-        }
-        cut = 1.0 ; sut = ht / gt ;
-        cvt = 1.0 ; svt = ft / gt ;
-      }
-    }
-
-    if (glarge == 0) { /* normal case */
-      fmh = fa - ha ; /* 1ulp */
-      if (fmh == fa) {  /* cope with infinite f or h */
-        d = 1.0 ;
-      } else {
-        d = fmh / fa ; /* note 0<=d<=1.0, 2 ulps */
-      }
-      q = gt / ft ; /* note |q|<1/EPS, 1 ulp */
-      s = 2.0 - d ; /* note s>=1.0, 3 ulps */
-      dd = d*d ;
-      qq = q*q ;
-      ss = s*s ;
-      spq = sqrt(ss + qq) ; /* note 1<=spq<=1+1/EPS, 5 ulps */
-      if (d == 0.0) {
-        dpq = fabs(q) ; /* 0 ulp */
-      } else {
-        dpq = sqrt(dd + qq) ; /* note 0<=dpq<=1+1/EPS, 3.5 ulps */
-      }
-      a = 0.5 * (spq + dpq) ; /* note 1<=a<=1 + |q|, 6 ulps */
-      *smin = ha / a; /* 7 ulps */
-      *smax = fa * a; /* 7 ulps */
-      if (qq==0.0) { /* qq underflow */
-        if (d==0.0) {
-          tmp = sign(ft)*2*sign(gt); /* 0ulp */
-        }
-        else {
-          tmp = gt/(sign(ft)*fmh) + q/s; /* 6 ulps */
-        }
-      } else {
-        tmp = (q/(spq + s) + q/(dpq + d))*(1.0 + a);  /* 17 ulps */
-      }
-      /* if qq */
-      tt = sqrt(tmp*tmp + 4.0) ; /* 18.5 ulps */
-      cvt = 2.0 / tt ; /* 19.5 ulps */
-      svt = tmp / tt ; /* 36.5 ulps */
-      cut = (cvt + svt*q) / a ; /* 46.5 ulps */
-      sut = (ht / ft) * svt / a ; /* 45.5 ulps */
-    } /* if g not large */
-  } /* if ga */
-  if (swap == 1) {
-    *cu = svt ; *su = cvt ;
-    *cv = sut ; *sv = cut ;
-  } else {
-    *cu = cut ; *su = sut ;
-    *cv = cvt ; *sv = svt ;
-  }
-  /* correct the signs of smax and smin */
-  if (pmax==1) { tsign = sign(*cv) * sign(*cu) * sign(f) ; }
-  if (pmax==2) { tsign = sign(*sv) * sign(*cu) * sign(g) ; }
-  if (pmax==3) { tsign = sign(*sv) * sign(*su) * sign(h) ; }
-  *smax = isign(tsign) * (*smax);
-  *smin = isign(tsign * sign(f) * sign(h)) * (*smin) ;
-}
-
-
-/** @brief Solve a 3x3 linear system
- ** @param x result.
- ** @param A system matrix.
- ** @param b coefficients.
- **
- ** The function computes a solution to @f$ Ax =b @f$ for a 3x3
- ** matrix.
- **/
-
-VL_EXPORT int
-vl_solve_linear_system_3 (double * x, double const * A, double const *b)
-{
-  int err ;
-  double M[3*4] ;
-  M[0] = A[0] ;
-  M[1] = A[1] ;
-  M[2] = A[2] ;
-  M[3] = A[3] ;
-  M[4] = A[4] ;
-  M[5] = A[5] ;
-  M[6] = A[6] ;
-  M[7] = A[7] ;
-  M[8] = A[8] ;
-  M[9] = b[0] ;
-  M[10] = b[1] ;
-  M[11] = b[2] ;
-  err = vl_gaussian_elimination(M,3,4) ;
-  x[0] = M[9] ;
-  x[1] = M[10] ;
-  x[2] = M[11] ;
-  return err ;
-}
-
-/** @brief Solve a 2x2 linear system
- ** @param x result.
- ** @param A system matrix.
- ** @param b coefficients.
- **
- ** The function computes a solution to @f$ Ax =b @f$ for a 2x2
- ** matrix.
- **/
-
-VL_EXPORT int
-vl_solve_linear_system_2 (double * x, double const * A, double const *b)
-{
-  int err ;
-  double M[2*3] ;
-  M[0] = A[0] ;
-  M[1] = A[1] ;
-  M[2] = A[2] ;
-  M[3] = A[3] ;
-  M[4] = b[0];
-  M[5] = b[1] ;
-  err = vl_gaussian_elimination(M,2,3) ;
-  x[0] = M[4] ;
-  x[1] = M[5] ;
-  return err ;
-}
-
-/** @brief Gaussian elimination
- ** @param M matrix.
- ** @param numRows number of rows of @c M.
- ** @param numColumns number of columns of @c M.
- **
- ** The function runs Gaussian elimination with pivoting
- ** on the matrix @a M in place.
- ** @c numRows must be not larger than @c numColumns.
- **
- ** Let @f$ M = [A, b] @f$ to obtain the solution to the linear
- ** system @f$ Ax=b @f$ (as the last column of @c M after
- ** elimination).
- **
- ** Let @f$ M = [A, I] @f$ to compute the inverse of @c A in
- ** a similar manner.
- **/
-
-VL_EXPORT vl_bool
-vl_gaussian_elimination (double * A, vl_size numRows, vl_size numColumns)
-{
-  vl_index i, j, ii, jj ;
-  assert(A) ;
-  assert(numRows <= numColumns) ;
-
-#define Aat(i,j) A[(i) + (j)*numRows]
-
-  /* Gauss elimination */
-  for(j = 0 ; j < (signed)numRows ; ++j) {
-    double maxa = 0 ;
-    double maxabsa = 0 ;
-    vl_index maxi = -1 ;
-    double tmp ;
-
-#if 0
-    {
-      vl_index iii, jjj ;
-      for (iii = 0 ; iii < 2 ; ++iii) {
-        for (jjj = 0 ; jjj < 3 ; ++jjj) {
-          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
-
-        }
-        VL_PRINTF("\n") ;
-      }
-      VL_PRINTF("\n") ;
-    }
-#endif
-
-    /* look for the maximally stable pivot */
-    for (i = j ; i < (signed)numRows ; ++i) {
-      double a = Aat(i,j) ;
-      double absa = vl_abs_d (a) ;
-      if (absa > maxabsa) {
-        maxa = a ;
-        maxabsa = absa ;
-        maxi = i ;
-      }
-    }
-    i = maxi ;
-
-    /* if singular give up */
-    if (maxabsa < 1e-10) return VL_ERR_OVERFLOW ;
-
-    /* swap j-th row with i-th row and normalize j-th row */
-    for(jj = j ; jj < (signed)numColumns ; ++jj) {
-      tmp = Aat(i,jj) ; Aat(i,jj) = Aat(j,jj) ; Aat(j,jj) = tmp ;
-      Aat(j,jj) /= maxa ;
-    }
-
-#if 0
-    {
-      vl_index iii, jjj ;
-      VL_PRINTF("after swap %d %d\n", j, i);
-      for (iii = 0 ; iii < 2 ; ++iii) {
-        for (jjj = 0 ; jjj < 3 ; ++jjj) {
-          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
-
-        }
-        VL_PRINTF("\n") ;
-      }
-      VL_PRINTF("\n") ;
-    }
-#endif
-
-    /* elimination */
-    for (ii = j+1 ; ii < (signed)numRows ; ++ii) {
-      double x = Aat(ii,j) ;
-      for (jj = j ; jj < (signed)numColumns ; ++jj) {
-        Aat(ii,jj) -= x * Aat(j,jj) ;
-      }
-    }
-
-#if 0
-    {
-      VL_PRINTF("after elimination\n");
-
-      vl_index iii, jjj ;
-      for (iii = 0 ; iii < 2 ; ++iii) {
-        for (jjj = 0 ; jjj < 3 ; ++jjj) {
-          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
-
-        }
-        VL_PRINTF("\n") ;
-      }
-      VL_PRINTF("\n") ;
-    }
-#endif
-
-  }
-
-  /* backward substitution */
-  for (i = numRows - 1 ; i > 0 ; --i) {
-    /* substitute in all rows above */
-    for (ii = i - 1 ; ii >= 0 ; --ii) {
-      double x = Aat(ii,i) ;
-      /* j = numRows */
-      for (j = numRows ; j < (signed)numColumns ; ++j) {
-        Aat(ii,j) -= x * Aat(i,j) ;
-      }
-    }
-  }
-
-#if 0
-  {
-    VL_PRINTF("after substitution\n");
-
-    vl_index iii, jjj ;
-    for (iii = 0 ; iii < 2 ; ++iii) {
-      for (jjj = 0 ; jjj < 3 ; ++jjj) {
-        VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
-
-      }
-      VL_PRINTF("\n") ;
-    }
-    VL_PRINTF("\n") ;
-  }
-#endif
-
-
-  return VL_ERR_OK ;
-}
-
-/* VL_MATHOP_INSTANTIATING */
-#endif
-
-#undef VL_MATHOP_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop.h b/opensfm/src/third_party/vlfeat/vl/mathop.h
deleted file mode 100644
index 6a1df8058..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop.h
+++ /dev/null
@@ -1,719 +0,0 @@
-/** @file mathop.h
- ** @brief Math operations (@ref mathop)
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_MATHOP_H
-#define VL_MATHOP_H
-
-#include "generic.h"
-#include <math.h>
-#include <float.h>
-
-/** @brief Euler constant*/
-#define VL_E 2.718281828459045
-
-/** @brief Logarithm of 2 (math constant)*/
-#define VL_LOG_OF_2 0.693147180559945
-
-/** @brief Pi (math constant) */
-#define VL_PI 3.141592653589793
-
-/** @brief IEEE single precision epsilon (math constant)
- **
- ** <code>1.0F + VL_EPSILON_F</code> is the smallest representable
- ** single precision number greater than @c 1.0F. Numerically,
- ** ::VL_EPSILON_F is equal to @f$ 2^{-23} @f$.
- **
- **/
-#define VL_EPSILON_F 1.19209290E-07F
-
-/** @brief IEEE double precision epsilon (math constant)
- **
- ** <code>1.0 + VL_EPSILON_D</code> is the smallest representable
- ** double precision number greater than @c 1.0. Numerically,
- ** ::VL_EPSILON_D is equal to @f$ 2^{-52} @f$.
- **/
-#define VL_EPSILON_D 2.220446049250313e-16
-
-/*
-   For the code below: An ANSI C compiler takes the two expressions,
-   LONG_VAR and CHAR_VAR, and implicitly casts them to the type of the
-   first member of the union. Refer to K&R Second Edition Page 148,
-   last paragraph.
-*/
-
-/** @internal @brief IEEE single precision quiet NaN constant */
-static union { vl_uint32 raw ; float value ; }
-  const vl_nan_f =
-    { 0x7FC00000UL } ;
-
-/** @internal @brief IEEE single precision infinity constant */
-static union { vl_uint32 raw ; float value ; }
-  const vl_infinity_f =
-    { 0x7F800000UL } ;
-
-/** @internal @brief IEEE double precision quiet NaN constant */
-static union { vl_uint64 raw ; double value ; }
-  const vl_nan_d =
-#ifdef VL_COMPILER_MSC
-    { 0x7FF8000000000000ui64 } ;
-#else
-    { 0x7FF8000000000000ULL } ;
-#endif
-
-/** @internal @brief IEEE double precision infinity constant */
-static union { vl_uint64 raw ; double value ; }
-  const vl_infinity_d =
-#ifdef VL_COMPILER_MSC
-    { 0x7FF0000000000000ui64 } ;
-#else
-    { 0x7FF0000000000000ULL } ;
-#endif
-
-/** @brief IEEE single precision NaN (not signaling) */
-#define VL_NAN_F (vl_nan_f.value)
-
-/** @brief IEEE single precision positive infinity (not signaling) */
-#define VL_INFINITY_F (vl_infinity_f.value)
-
-/** @brief IEEE double precision NaN (not signaling) */
-#define VL_NAN_D (vl_nan_d.value)
-
-/** @brief IEEE double precision positive infinity (not signaling) */
-#define VL_INFINITY_D (vl_infinity_d.value)
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Fast <code>mod(x, 2 * VL_PI)</code>
- **
- ** @param x input value.
- ** @return <code>mod(x, 2 * VL_PI)</code>
- **
- ** The function is optimized for small absolute values of @a x.
- **
- ** The result is guaranteed to be not smaller than 0. However, due to
- ** finite numerical precision and rounding errors, the result can be
- ** equal to 2 * VL_PI (for instance, if @c x is a very small negative
- ** number).
- **/
-
-VL_INLINE float
-vl_mod_2pi_f (float x)
-{
-  while (x > (float)(2 * VL_PI)) x -= (float) (2 * VL_PI) ;
-  while (x < 0.0F) x += (float) (2 * VL_PI);
-  return x ;
-}
-
-/** @brief Fast <code>mod(x, 2 * VL_PI)</code>
- ** @see vl_mod_2pi_f
- **/
-
-VL_INLINE double
-vl_mod_2pi_d (double x)
-{
-  while (x > 2.0 * VL_PI) x -= 2 * VL_PI ;
-  while (x < 0.0) x += 2 * VL_PI ;
-  return x ;
-}
-
-/** @brief Floor and convert to integer
- ** @param x argument.
- ** @return Similar to @c (int) floor(x)
- **/
-
-VL_INLINE long int
-vl_floor_f (float x)
-{
-  long int xi = (long int) x ;
-  if (x >= 0 || (float) xi == x) return xi ;
-  else return xi - 1 ;
-}
-
-/** @brief Floor and convert to integer
- ** @see vl_floor_f
- **/
-
-VL_INLINE long int
-vl_floor_d (double x)
-{
-  long int xi = (long int) x ;
-  if (x >= 0 || (double) xi == x) return xi ;
-  else return xi - 1 ;
-}
-
-/** @brief Ceil and convert to integer
- ** @param x argument.
- ** @return @c lceilf(x)
- **/
-
-VL_INLINE long int
-vl_ceil_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return (long int) __builtin_ceilf(x) ;
-#else
-  return (long int) ceilf(x) ;
-#endif
-}
-
-/** @brief Ceil and convert to integer
- ** @see vl_ceil_f
- **/
-
-VL_INLINE long int
-vl_ceil_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_ceil(x) ;
-#else
-  return (long int) ceil(x) ;
-#endif
-}
-
-/** @brief Round
- ** @param x argument.
- ** @return @c lroundf(x)
- ** This function is either the same or similar to C99 @c lroundf().
- **/
-
-VL_INLINE long int
-vl_round_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_lroundf(x) ;
-#elif VL_COMPILER_MSC
-  if (x >= 0.0F) {
-    return vl_floor_f(x + 0.5F) ;
-  } else {
-    return vl_ceil_f(x - 0.5F) ;
-  }
-#else
-  return lroundf(x) ;
-#endif
-}
-
-/** @brief Round
- ** @param x argument.
- ** @return @c lround(x)
- ** This function is either the same or similar to C99 @c lround().
- **/
-
-VL_INLINE long int
-vl_round_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_lround(x) ;
-#elif VL_COMPILER_MSC
-  if (x >= 0.0) {
-    return vl_floor_d(x + 0.5) ;
-  } else {
-    return vl_ceil_d(x - 0.5) ;
-  }
-#else
-  return lround(x) ;
-#endif
-}
-
-/** @brief Fast @c abs(x)
- ** @param x argument.
- ** @return @c abs(x)
- **/
-
-VL_INLINE float
-vl_abs_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_fabsf (x) ;
-#else
-  return fabsf(x) ;
-#endif
-}
-
-/** @brief Fast @c abs(x)
- ** @sa vl_abs_f
- **/
-
-VL_INLINE double
-vl_abs_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_fabs (x) ;
-#else
-  return fabs(x) ;
-#endif
-}
-
-/** @brief Base-2 logaritghm
- ** @param x argument.
- ** @return @c log(x).
- **/
-
-VL_INLINE double
-vl_log2_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_log2(x) ;
-#elif VL_COMPILER_MSC
-  return log(x) / 0.693147180559945 ;
-#else
-  return log2(x) ;
-#endif
-}
-
-/** @copydoc vl_log2_d */
-VL_INLINE float
-vl_log2_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_log2f (x) ;
-#elif VL_COMPILER_MSC
-  return logf(x) / 0.6931472F ;
-#else
-  return log2(x) ;
-#endif
-}
-
-/** @brief Square root.
- ** @param x argument.
- ** @return @c sqrt(x).
- **/
-
-VL_INLINE double
-vl_sqrt_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_sqrt(x) ;
-#else
-  return sqrt(x) ;
-#endif
-}
-
-/** @copydoc vl_sqrt_d */
-VL_INLINE float
-vl_sqrt_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_sqrtf(x) ;
-#else
-  return sqrtf(x) ;
-#endif
-}
-
-
-/** @brief Check whether a floating point value is NaN
- ** @param x argument.
- ** @return true if @a x is NaN.
- **/
-VL_INLINE vl_bool
-vl_is_nan_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_isnan (x) ;
-#elif VL_COMPILER_MSC
-  return _isnan(x) ;
-#else
-  return isnan(x) ;
-#endif
-}
-
-/** @copydoc vl_is_nan_f */
-VL_INLINE vl_bool
-vl_is_nan_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_isnan (x) ;
-#elif VL_COMPILER_MSC
-  return _isnan(x) ;
-#else
-  return isnan(x) ;
-#endif
-}
-
-/** @brief Check whether a floating point value is infinity
- ** @param x argument.
- ** @return true if @a x is infinity.
- **/
-VL_INLINE vl_bool
-vl_is_inf_f (float x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_isinf (x) ;
-#elif VL_COMPILER_MSC
-  return ! _finite(x) ;
-#else
-  return isinf(x) ;
-#endif
-}
-
-/** @copydoc vl_is_inf_f */
-VL_INLINE vl_bool
-vl_is_inf_d (double x)
-{
-#ifdef VL_COMPILER_GNUC
-  return __builtin_isinf (x) ;
-#elif VL_COMPILER_MSC
-  return ! _finite(x) ;
-#else
-  return isinf(x) ;
-#endif
-}
-
-/** ------------------------------------------------------------------
- ** @brief Fast @c atan2 approximation
- ** @param y argument.
- ** @param x argument.
- **
- ** The function computes a relatively rough but fast approximation of
- ** @c atan2(y,x).
- **
- ** @par Algorithm
- **
- ** The algorithm approximates the function @f$ f(r)=atan((1-r)/(1+r))
- ** @f$, @f$ r \in [-1,1] @f$ with a third order polynomial @f$
- ** f(r)=c_0 + c_1 r + c_2 r^2 + c_3 r^3 @f$.  To fit the polynomial
- ** we impose the constraints
- **
- ** @f{eqnarray*}
- ** f(+1) &=& c_0 + c_1 + c_2 + c_3  = atan(0)       = 0,\\
- ** f(-1) &=& c_0 - c_1 + c_2 - c_3  = atan(\infty)  = \pi/2,\\
- ** f(0)  &=& c_0                    = atan(1)       = \pi/4.
- ** @f}
- **
- ** The last degree of freedom is fixed by minimizing the @f$
- ** l^{\infty} @f$ error, which yields
- **
- ** @f[
- ** c_0=\pi/4, \quad
- ** c_1=-0.9675, \quad
- ** c_2=0, \quad
- ** c_3=0.1821,
- ** @f]
- **
- ** with maximum error of 0.0061 radians at 0.35 degrees.
- **
- ** @return Approximation of @c atan2(y,x).
- **/
-
-VL_INLINE float
-vl_fast_atan2_f (float y, float x)
-{
-  float angle, r ;
-  float const c3 = 0.1821F ;
-  float const c1 = 0.9675F ;
-  float abs_y    = vl_abs_f (y) + VL_EPSILON_F ;
-
-  if (x >= 0) {
-    r = (x - abs_y) / (x + abs_y) ;
-    angle = (float) (VL_PI / 4) ;
-  } else {
-    r = (x + abs_y) / (abs_y - x) ;
-    angle = (float) (3 * VL_PI / 4) ;
-  }
-  angle += (c3*r*r - c1) * r ;
-  return (y < 0) ? - angle : angle ;
-}
-
-/** @brief Fast @c atan2 approximation
- ** @sa vl_fast_atan2_f
- **/
-
-VL_INLINE double
-vl_fast_atan2_d (double y, double x)
-{
-  double angle, r ;
-  double const c3 = 0.1821 ;
-  double const c1 = 0.9675 ;
-  double abs_y = vl_abs_d (y) + VL_EPSILON_D ;
-
-  if (x >= 0) {
-    r = (x - abs_y) / (x + abs_y) ;
-    angle = VL_PI / 4 ;
-  } else {
-    r = (x + abs_y) / (abs_y - x) ;
-    angle = 3 * VL_PI / 4 ;
-  }
-  angle += (c3*r*r - c1) * r ;
-  return (y < 0) ? - angle : angle ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Fast @c resqrt approximation
- ** @param x argument.
- ** @return approximation of @c resqrt(x).
- **
- ** The function quickly computes an approximation of @f$ x^{-1/2}
- ** @f$.
- **
- ** @par Algorithm
- **
- ** The goal is to compute @f$ y = x^{-1/2} @f$, which we do by
- ** finding the solution of @f$ 0 = f(y) = y^{-2} - x @f$ by two Newton
- ** steps. Each Newton iteration is given by
- **
- ** @f[
- **   y \leftarrow
- **   y - \frac{f(y)}{\frac{df(y)}{dy}} =
- **   y + \frac{1}{2} (y-xy^3) =
- **   \frac{y}{2} \left( 3 - xy^2 \right)
- ** @f]
- **
- ** which yields a simple polynomial update rule.
- **
- ** The clever bit (attributed to either J. Carmack or G. Tarolli) is
- ** the way an initial guess @f$ y \approx x^{-1/2} @f$ is chosen.
- **
- ** @see <a href="http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf">Inverse Sqare Root</a>.
- **
- **/
-
-VL_INLINE float
-vl_fast_resqrt_f (float x)
-{
-  /* 32-bit version */
-  union {
-    float x ;
-    vl_int32  i ;
-  } u ;
-
-  float xhalf = (float) 0.5 * x ;
-
-  /* convert floating point value in RAW integer */
-  u.x = x ;
-
-  /* gives initial guess y0 */
-  u.i = 0x5f3759df - (u.i >> 1);
-  /*u.i = 0xdf59375f - (u.i>>1);*/
-
-  /* two Newton steps */
-  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
-  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
-  return u.x ;
-}
-
-/** @brief Fast @c resqrt approximation
- ** @sa vl_fast_resqrt_d
- **/
-
-VL_INLINE double
-vl_fast_resqrt_d (double x)
-{
-  /* 64-bit version */
-  union {
-    double x ;
-    vl_int64  i ;
-  } u ;
-
-  double xhalf = (double) 0.5 * x ;
-
-  /* convert floating point value in RAW integer */
-  u.x = x ;
-
-  /* gives initial guess y0 */
-#ifdef VL_COMPILER_MSC
-  u.i = 0x5fe6ec85e7de30dai64 - (u.i >> 1) ;
-#else
-  u.i = 0x5fe6ec85e7de30daLL - (u.i >> 1) ;
-#endif
-
-  /* two Newton steps */
-  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
-  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
-  return u.x ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Fast @c sqrt approximation
- ** @param x argument.
- ** @return approximation of @c sqrt(x).
- **
- ** The function uses ::vl_fast_resqrt_f
- ** (or ::vl_fast_resqrt_d) to compute <code>x *
- ** vl_fast_resqrt_f(x)</code>.
- **/
-
-VL_INLINE float
-vl_fast_sqrt_f (float x)
-{
-  return (x < 1e-8) ? 0 : x * vl_fast_resqrt_f (x) ;
-}
-
-/** @brief Fast @c sqrt approximation
- ** @copydoc vl_fast_sqrt_f
- **/
-
-VL_INLINE double
-vl_fast_sqrt_d (float x)
-{
-  return (x < 1e-8) ? 0 : x * vl_fast_resqrt_d (x) ;
-}
-
-/** @brief Fast integer @c sqrt approximation
- ** @param x non-negative integer.
- ** @return largest integer $y$ such that $y^2 \leq x$.
- ** @sa @ref mathop-sqrti "Algorithm"
- **/
-VL_INLINE vl_uint64 vl_fast_sqrt_ui64 (vl_uint64 x) ;
-
-/** @brief Fast @c sqrt approximation
- ** @copydoc vl_fast_sqrt_ui64 */
-VL_INLINE vl_uint32 vl_fast_sqrt_ui32 (vl_uint32 x) ;
-
-/** @brief Fast @c sqrt approximation
- ** @copydoc vl_fast_sqrt_ui64 */
-VL_INLINE vl_uint16 vl_fast_sqrt_ui16 (vl_uint16 x) ;
-
-/** @brief Fast @c sqrt approximation
- ** @copydoc vl_fast_sqrt_ui64 */
-VL_INLINE vl_uint8  vl_fast_sqrt_ui8  (vl_uint8  x) ;
-
-#define VL_FAST_SQRT_UI(T,SFX)                                       \
-VL_INLINE T                                                          \
-vl_fast_sqrt_ ## SFX (T x)                                           \
-{                                                                    \
-  T y = 0 ;                                                          \
-  T tmp = 0 ;                                                        \
-  int twice_k ;                                                      \
-  for (twice_k = 8 * sizeof(T) - 2 ;                                 \
-       twice_k >= 0 ; twice_k -= 2) {                                \
-    y <<= 1 ; /* y = 2 * y */                                        \
-    tmp = (2*y + 1) << twice_k ;                                     \
-    if (x >= tmp) {                                                  \
-      x -= tmp ;                                                     \
-      y += 1 ;                                                       \
-    }                                                                \
-  }                                                                  \
-  return y ;                                                         \
-}
-
-VL_FAST_SQRT_UI(vl_uint64,ui64)
-VL_FAST_SQRT_UI(vl_uint32,ui32)
-VL_FAST_SQRT_UI(vl_uint16,ui16)
-VL_FAST_SQRT_UI(vl_uint8,ui8)
-
-/* ---------------------------------------------------------------- */
-/*                                Vector distances and similarities */
-/* ---------------------------------------------------------------- */
-
-/** @typedef VlFloatVectorComparisonFunction
- ** @brief Pointer to a function to compare vectors of floats
- **/
-typedef float (*VlFloatVectorComparisonFunction)(vl_size dimension, float const * X, float const * Y) ;
-
-/** @typedef VlDoubleVectorComparisonFunction
- ** @brief Pointer to a function to compare vectors of doubles
- **/
-typedef double (*VlDoubleVectorComparisonFunction)(vl_size dimension, double const * X, double const * Y) ;
-
-/** @typedef VlFloatVector3ComparisonFunction
- ** @brief Pointer to a function to compare 3 vectors of doubles
- **/
-typedef float (*VlFloatVector3ComparisonFunction)(vl_size dimension, float const * X, float const * Y, float const * Z) ;
-
-/** @typedef VlDoubleVector3ComparisonFunction
- ** @brief Pointer to a function to compare 3 vectors of doubles
- **/
-typedef double (*VlDoubleVector3ComparisonFunction)(vl_size dimension, double const * X, double const * Y, double const * Z) ;
-
-/** @brief Vector comparison types */
-enum _VlVectorComparisonType {
-  VlDistanceL1,        /**< l1 distance (squared intersection metric) */
-  VlDistanceL2,        /**< squared l2 distance */
-  VlDistanceChi2,      /**< squared Chi2 distance */
-  VlDistanceHellinger, /**< squared Hellinger's distance */
-  VlDistanceJS,        /**< squared Jensen-Shannon distance */
-  VlDistanceMahalanobis,     /**< squared mahalanobis distance */
-  VlKernelL1,          /**< intersection kernel */
-  VlKernelL2,          /**< l2 kernel */
-  VlKernelChi2,        /**< Chi2 kernel */
-  VlKernelHellinger,   /**< Hellinger's kernel */
-  VlKernelJS           /**< Jensen-Shannon kernel */
-} ;
-
-/** @brief Vector comparison types */
-typedef enum _VlVectorComparisonType VlVectorComparisonType ;
-
-/** @brief Get the symbolic name of a vector comparison type
- ** @param type vector comparison type.
- ** @return data symbolic name.
- **/
-
-VL_INLINE char const *
-vl_get_vector_comparison_type_name (int type)
-{
-  switch (type) {
-    case VlDistanceL1   : return "l1" ;
-    case VlDistanceL2   : return "l2" ;
-    case VlDistanceChi2 : return "chi2" ;
-    case VlDistanceMahalanobis  : return "mahalanobis" ;
-    case VlKernelL1     : return "kl1" ;
-    case VlKernelL2     : return "kl2" ;
-    case VlKernelChi2   : return "kchi2" ;
-    default: return NULL ;
-  }
-}
-
-VL_EXPORT VlFloatVectorComparisonFunction
-vl_get_vector_comparison_function_f (VlVectorComparisonType type) ;
-
-VL_EXPORT VlDoubleVectorComparisonFunction
-vl_get_vector_comparison_function_d (VlVectorComparisonType type) ;
-
-VL_EXPORT VlFloatVector3ComparisonFunction
-vl_get_vector_3_comparison_function_f (VlVectorComparisonType type) ;
-
-VL_EXPORT VlDoubleVector3ComparisonFunction
-vl_get_vector_3_comparison_function_d (VlVectorComparisonType type) ;
-
-
-VL_EXPORT void
-vl_eval_vector_comparison_on_all_pairs_f (float * result, vl_size dimension,
-                                          float const * X, vl_size numDataX,
-                                          float const * Y, vl_size numDataY,
-                                          VlFloatVectorComparisonFunction function) ;
-
-VL_EXPORT void
-vl_eval_vector_comparison_on_all_pairs_d (double * result, vl_size dimension,
-                                          double const * X, vl_size numDataX,
-                                          double const * Y, vl_size numDataY,
-                                          VlDoubleVectorComparisonFunction function) ;
-
-/* ---------------------------------------------------------------- */
-/*                                               Numerical analysis */
-/* ---------------------------------------------------------------- */
-
-VL_EXPORT void
-vl_svd2 (double* S, double *U, double *V, double const *M) ;
-
-VL_EXPORT void
-vl_lapack_dlasv2 (double *smin,
-                  double *smax,
-                  double *sv,
-                  double *cv,
-                  double *su,
-                  double *cu,
-                  double f,
-                  double g,
-                  double h) ;
-
-
-VL_EXPORT int
-vl_solve_linear_system_3 (double * x, double const * A, double const *b) ;
-
-VL_EXPORT int
-vl_solve_linear_system_2 (double * x, double const * A, double const *b) ;
-
-VL_EXPORT int
-vl_gaussian_elimination (double * A, vl_size numRows, vl_size numColumns) ;
-
-/* VL_MATHOP_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_avx.c b/opensfm/src/third_party/vlfeat/vl/mathop_avx.c
deleted file mode 100644
index 03dba22d8..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop_avx.c
+++ /dev/null
@@ -1,275 +0,0 @@
-/** @file mathop_avx.c
- ** @brief mathop for AVX - Definition
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/* ---------------------------------------------------------------- */
-#if ! defined(VL_MATHOP_AVX_INSTANTIATING)
-
-#include "mathop_avx.h"
-
-#undef FLT
-#define FLT VL_TYPE_DOUBLE
-#define VL_MATHOP_AVX_INSTANTIATING
-#include "mathop_avx.c"
-
-#undef FLT
-#define FLT VL_TYPE_FLOAT
-#define VL_MATHOP_AVX_INSTANTIATING
-#include "mathop_avx.c"
-
-/* ---------------------------------------------------------------- */
-/* VL_MATHOP_AVX_INSTANTIATING */
-#else
-#ifndef VL_DISABLE_AVX
-
-#ifndef __AVX__
-#error Compiling AVX functions but AVX does not seem to be supported by the compiler.
-#endif
-
-#include <immintrin.h>
-#include "generic.h"
-#include "mathop.h"
-#include "float.h"
-
-VL_INLINE T
-VL_XCAT(_vl_vhsum_avx_, SFX)(VTYPEavx x)
-{
-  T acc ;
-#if (VSIZEavx == 8)
-  {
-    //VTYPEavx hsum = _mm256_hadd_ps(x, x);
-    //hsum = _mm256_add_ps(hsum, _mm256_permute2f128_ps(hsum, hsum, 0x1));
-    //_mm_store_ss(&acc, _mm_hadd_ps( _mm256_castps256_ps128(hsum), _mm256_castps256_ps128(hsum) ) );
-    VTYPEavx hsum = VHADD2avx(x, x);
-    hsum = VADDavx(hsum, VPERMavx(hsum, hsum, 0x1));
-    VST1(&acc, VHADDavx( VCSTavx(hsum), VCSTavx(hsum) ) );
-  }
-#else
-  {
-    //VTYPEavx hsum = _mm256_add_pd(x, _mm256_permute2f128_pd(x, x, 0x1));
-    VTYPEavx hsum = VADDavx(x, VPERMavx(x, x, 0x1));
-
-    //_mm_store_sd(&acc, _mm_hadd_pd( _mm256_castpd256_pd128(hsum), _mm256_castpd256_pd128(hsum) ) );
-    VST1(&acc, VHADDavx( VCSTavx(hsum), VCSTavx(hsum) ) );
-  }
-#endif
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l2_avx_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZEavx + 1 ;
-  T acc ;
-  VTYPEavx vacc = VSTZavx() ;
-  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPEavx a = *(VTYPEavx*)X ;
-      VTYPEavx b = *(VTYPEavx*)Y ;
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      vacc = VADDavx(vacc, delta2) ;
-      X += VSIZEavx ;
-      Y += VSIZEavx ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPEavx a = VLDUavx(X) ;
-      VTYPEavx b = VLDUavx(Y) ;
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      vacc = VADDavx(vacc, delta2) ;
-      X += VSIZEavx ;
-      Y += VSIZEavx ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_avx_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    acc += delta * delta ;
-  }
-
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX)
-(vl_size dimension, T const * X, T const * MU, T const * S)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZEavx + 1 ;
-  T acc ;
-  VTYPEavx vacc = VSTZavx() ;
-  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(MU) & VALIGNEDavx(S);
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPEavx a = *(VTYPEavx*)X ;
-      VTYPEavx b = *(VTYPEavx*)MU ;
-      VTYPEavx c = *(VTYPEavx*)S ;
-
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      VTYPEavx delta2div = VMULavx(delta2,c);
-
-      vacc = VADDavx(vacc, delta2div) ;
-
-      X  += VSIZEavx ;
-      MU += VSIZEavx ;
-      S  += VSIZEavx ;
-    }
-  } else {
-    while (X < X_vec_end) {
-
-      VTYPEavx a = VLDUavx(X) ;
-      VTYPEavx b = VLDUavx(MU) ;
-      VTYPEavx c = VLDUavx(S) ;
-
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      VTYPEavx delta2div = VMULavx(delta2,c);
-
-      vacc = VADDavx(vacc, delta2div) ;
-
-      X  += VSIZEavx ;
-      MU += VSIZEavx ;
-      S  += VSIZEavx ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_avx_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *MU++ ;
-    T c = *S++ ;
-    T delta = a - b ;
-    acc += (delta * delta) * c;
-  }
-
-  return acc ;
-}
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_mean_avx_, SFX)
-(vl_size dimension, T * MU, T const * X, T const  W)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZEavx + 1 ;
-
-  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(MU);
-  VTYPEavx w = VLD1avx (&W) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPEavx a = *(VTYPEavx*)X ;
-      VTYPEavx mu = *(VTYPEavx*)MU ;
-
-      VTYPEavx aw = VMULavx(a, w) ;
-      VTYPEavx meanStore = VADDavx(aw, mu);
-
-      *(VTYPEavx *)MU = meanStore;
-
-      X += VSIZEavx ;
-      MU += VSIZEavx ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPEavx a  = VLDUavx(X) ;
-      VTYPEavx mu = VLDUavx(MU) ;
-
-      VTYPEavx aw = VMULavx(a, w) ;
-      VTYPEavx meanStore = VADDavx(aw, mu);
-
-      VST2Uavx(MU,meanStore);
-
-      X += VSIZEavx ;
-      MU += VSIZEavx ;
-    }
-  }
-
-  while (X < X_end) {
-    T a = *X++ ;
-    *MU += a * W ;
-    MU++;
-  }
-}
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_sigma_avx_, SFX)
-(vl_size dimension, T * S, T const * X, T const * Y, T const W)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZEavx + 1 ;
-
-  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) & VALIGNEDavx(S);
-
-  VTYPEavx w = VLD1avx (&W) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPEavx a = *(VTYPEavx*)X ;
-      VTYPEavx b = *(VTYPEavx*)Y ;
-      VTYPEavx s = *(VTYPEavx*)S ;
-
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      VTYPEavx delta2w = VMULavx(delta2, w) ;
-      VTYPEavx sigmaStore = VADDavx(s,delta2w);
-
-      *(VTYPEavx *)S = sigmaStore;
-
-      X += VSIZEavx ;
-      Y += VSIZEavx ;
-      S += VSIZEavx ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPEavx a = VLDUavx(X) ;
-      VTYPEavx b = VLDUavx(Y) ;
-      VTYPEavx s = VLDUavx(S) ;
-
-      VTYPEavx delta = VSUBavx(a, b) ;
-      VTYPEavx delta2 = VMULavx(delta, delta) ;
-      VTYPEavx delta2w = VMULavx(delta2, w) ;
-      VTYPEavx sigmaStore = VADDavx(s,delta2w);
-
-      VST2Uavx(S,sigmaStore);
-
-      X += VSIZEavx ;
-      Y += VSIZEavx ;
-      S += VSIZEavx ;
-    }
-  }
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    *S += ((delta * delta)*W) ;
-    S++;
-  }
-}
-
-/* VL_DISABLE_AVX */
-#endif
-#undef VL_MATHOP_AVX_INSTANTIATING
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_avx.h b/opensfm/src/third_party/vlfeat/vl/mathop_avx.h
deleted file mode 100644
index 2acebf0fd..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop_avx.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/** @file mathop_avx.h
- ** @brief mathop for avx
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_MATHOP_AVX_H_INSTANTIATING
-
-#ifndef VL_MATHOP_AVX_H
-#define VL_MATHOP_AVX_H
-
-#undef FLT
-#define FLT VL_TYPE_DOUBLE
-#define VL_MATHOP_AVX_H_INSTANTIATING
-#include "mathop_avx.h"
-
-#undef FLT
-#define FLT VL_TYPE_FLOAT
-#define VL_MATHOP_AVX_H_INSTANTIATING
-#include "mathop_avx.h"
-
-/* VL_MATHOP_AVX_H */
-#endif
-
-/* ---------------------------------------------------------------- */
-/* VL_MATHOP_AVX_H_INSTANTIATING */
-#else
-
-#ifndef VL_DISABLE_AVX
-#include "generic.h"
-#include "float.h"
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX)
-(vl_size dimension, T const * X, T const * MU, T const * S);
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l2_avx_, SFX)
-(vl_size dimension, T const * X, T const * Y);
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_sigma_avx_, SFX)
-(vl_size dimension, T * S, T const * X, T const * Y, T const W);
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_mean_avx_, SFX)
-(vl_size dimension, T * MU, T const * X, T const W);
-
-/* ! VL_DISABLE_AVX */
-#endif
-
-#undef VL_MATHOP_AVX_H_INSTANTIATING
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
deleted file mode 100644
index dd98a5bea..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
+++ /dev/null
@@ -1,564 +0,0 @@
-/** @file mathop_sse2.c
- ** @brief mathop for SSE2 - Definition
- ** @author Andrea Vedaldi, David Novotny
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_MATHOP_SSE2_INSTANTIATING
-
-#include "mathop_sse2.h"
-
-#undef FLT
-#define FLT VL_TYPE_DOUBLE
-#define VL_MATHOP_SSE2_INSTANTIATING
-#include "mathop_sse2.c"
-
-#undef FLT
-#define FLT VL_TYPE_FLOAT
-#define VL_MATHOP_SSE2_INSTANTIATING
-#include "mathop_sse2.c"
-
-/* ---------------------------------------------------------------- */
-/* VL_MATHOP_SSE2_INSTANTIATING */
-#else
-#ifndef VL_DISABLE_SSE2
-
-#ifndef __SSE2__
-#error Compiling SSE2 functions but SSE2 does not to be supported by the compiler.
-#endif
-
-#include <emmintrin.h>
-#include "mathop.h"
-#include "generic.h"
-#include "float.h"
-
-VL_INLINE T
-VL_XCAT(_vl_vhsum_sse2_, SFX)(VTYPE x)
-{
-  T acc ;
-#if (VSIZE == 4)
-  {
-    VTYPE sum ;
-    VTYPE shuffle ;
-    /* shuffle = [1 0 3 2] */
-    /* sum     = [3+1 2+0 1+3 0+2] */
-    /* shuffle = [2+0 3+1 0+2 1+3] */
-    /* vacc    = [3+1+2+0 3+1+2+0 1+3+0+2 0+2+1+3] */
-    shuffle = VSHU (x, x, _MM_SHUFFLE(1, 0, 3, 2)) ;
-    sum     = VADD (x, shuffle) ;
-    shuffle = VSHU (sum, sum, _MM_SHUFFLE(2, 3, 0, 1)) ;
-    x       = VADD (sum, shuffle) ;
-  }
-#else
-  {
-    VTYPE shuffle ;
-    /* acc     = [1   0  ] */
-    /* shuffle = [0   1  ] */
-    /* sum     = [1+0 0+1] */
-    shuffle = VSHU (x, x, _MM_SHUFFLE2(0, 1)) ;
-    x       = VADD (x, shuffle) ;
-  }
-#endif
-  VST1(&acc, x);
-  return acc ;
-}
-
-
-
-VL_EXPORT T
-VL_XCAT(_vl_dot_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE d = VMUL(a, b) ;
-      vacc = VADD(vacc, d) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE d = VMUL(a, b) ;
-      vacc = VADD(vacc, d) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    acc += a * b ;
-  }
-
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      vacc = VADD(vacc, delta2) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      vacc = VADD(vacc, delta2) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    acc += delta * delta ;
-  }
-
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX)
-(vl_size dimension, T const * X, T const * MU, T const * S)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(MU) & VALIGNED(S);
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)MU ;
-      VTYPE c = *(VTYPE*)S ;
-
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      VTYPE delta2div = VMUL(delta2,c);
-
-      vacc = VADD(vacc, delta2div) ;
-
-      X  += VSIZE ;
-      MU += VSIZE ;
-      S  += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(MU) ;
-      VTYPE c = VLDU(S) ;
-
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      VTYPE delta2div = VMUL(delta2,c);
-
-      vacc = VADD(vacc, delta2div) ;
-
-      X  += VSIZE ;
-      MU += VSIZE ;
-      S  += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *MU++ ;
-    T c = *S++ ;
-    T delta = a - b ;
-    acc += (delta * delta) * c;
-  }
-
-  return acc ;
-}
-
-
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l1_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X + dimension - VSIZE ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ; /* sign bit */
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE delta = VSUB(a, b) ;
-      vacc = VADD(vacc, VANDN(vminus, delta)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE delta = VSUB(a, b) ;
-      vacc = VADD(vacc, VANDN(vminus, delta)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    acc += VL_MAX(delta, - delta) ;
-  }
-
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_chi2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X + dimension - VSIZE ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE denom = VADD(a, b) ;
-      VTYPE numer = VMUL(delta, delta) ;
-      VTYPE ratio = VDIV(numer, denom) ;
-      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
-      vacc = VADD(vacc, ratio) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE denom = VADD(a, b) ;
-      VTYPE numer = VMUL(delta, delta) ;
-      VTYPE ratio = VDIV(numer, denom) ;
-      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
-      vacc = VADD(vacc, ratio) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    T denom = a + b ;
-    T numer = delta * delta ;
-    if (denom) {
-      T ratio = numer / denom ;
-      acc += ratio ;
-    }
-  }
-  return acc ;
-}
-
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      vacc = VADD(vacc, VMUL(a,b)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      vacc = VADD(vacc, VMUL(a,b)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    acc += a * b ;
-  }
-  return acc ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l1_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE a_ = VANDN(vminus, a) ;
-      VTYPE b_ = VANDN(vminus, b) ;
-      VTYPE sum = VADD(a_,b_) ;
-      VTYPE diff = VSUB(a, b) ;
-      VTYPE diff_ = VANDN(vminus, diff) ;
-      vacc = VADD(vacc, VSUB(sum, diff_)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE a_ = VANDN(vminus, a) ;
-      VTYPE b_ = VANDN(vminus, b) ;
-      VTYPE sum = VADD(a_,b_) ;
-      VTYPE diff = VSUB(a, b) ;
-      VTYPE diff_ = VANDN(vminus, diff) ;
-      vacc = VADD(vacc, VSUB(sum, diff_)) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
-    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
-    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
-  }
-
-  return acc / ((T)2) ;
-}
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_chi2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X + dimension - VSIZE ;
-  T acc ;
-  VTYPE vacc = VSTZ() ;
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE denom = VADD(a, b) ;
-      VTYPE numer = VMUL(a,b) ;
-      VTYPE ratio = VDIV(numer, denom) ;
-      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
-      vacc = VADD(vacc, ratio) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE denom = VADD(a, b) ;
-      VTYPE numer = VMUL(a,b) ;
-      VTYPE ratio = VDIV(numer, denom) ;
-      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
-      vacc = VADD(vacc, ratio) ;
-      X += VSIZE ;
-      Y += VSIZE ;
-    }
-  }
-
-  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T denom = a + b ;
-    if (denom) {
-      T ratio = a * b / denom ;
-      acc += ratio ;
-    }
-  }
-  return ((T)2) * acc ;
-}
-//
-VL_EXPORT void
-VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
-(vl_size dimension, T * S, T const * X, T const * Y, T const W)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) & VALIGNED(S);
-
-  VTYPE w = VLD1 (&W) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE b = *(VTYPE*)Y ;
-      VTYPE s = *(VTYPE*)S ;
-
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      VTYPE delta2w = VMUL(delta2, w) ;
-      VTYPE sigmaStore = VADD(s,delta2w);
-
-      *(VTYPE *)S = sigmaStore;
-
-      X += VSIZE ;
-      Y += VSIZE ;
-      S += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a = VLDU(X) ;
-      VTYPE b = VLDU(Y) ;
-      VTYPE s = VLDU(S) ;
-
-      VTYPE delta = VSUB(a, b) ;
-      VTYPE delta2 = VMUL(delta, delta) ;
-      VTYPE delta2w = VMUL(delta2, w) ;
-      VTYPE sigmaStore = VADD(s,delta2w);
-
-      VST2U(S,sigmaStore);
-
-      X += VSIZE ;
-      Y += VSIZE ;
-      S += VSIZE ;
-    }
-  }
-
-
-  while (X < X_end) {
-    T a = *X++ ;
-    T b = *Y++ ;
-    T delta = a - b ;
-    *S += ((delta * delta)*W) ;
-    S++;
-  }
-}
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_mean_sse2_, SFX)
-(vl_size dimension, T * MU, T const * X, T const W)
-{
-  T const * X_end = X + dimension ;
-  T const * X_vec_end = X_end - VSIZE + 1 ;
-
-  vl_bool dataAligned = VALIGNED(X) & VALIGNED(MU);
-  VTYPE w = VLD1 (&W) ;
-
-  if (dataAligned) {
-    while (X < X_vec_end) {
-      VTYPE a = *(VTYPE*)X ;
-      VTYPE mu = *(VTYPE*)MU ;
-
-      VTYPE aw = VMUL(a, w) ;
-      VTYPE meanStore = VADD(aw, mu);
-
-      *(VTYPE *)MU = meanStore;
-
-      X += VSIZE ;
-      MU += VSIZE ;
-    }
-  } else {
-    while (X < X_vec_end) {
-      VTYPE a  = VLDU(X) ;
-      VTYPE mu = VLDU(MU) ;
-
-      VTYPE aw = VMUL(a, w) ;
-      VTYPE meanStore = VADD(aw, mu);
-
-      VST2U(MU,meanStore);
-
-      X += VSIZE ;
-      MU += VSIZE ;
-    }
-  }
-
-  while (X < X_end) {
-    T a = *X++ ;
-    *MU += a * W ;
-    MU++;
-  }
-}
-
-/* VL_DISABLE_SSE2 */
-#endif
-#undef VL_MATHOP_SSE2_INSTANTIATING
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
deleted file mode 100644
index 553cea12f..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/** @file mathop_sse2.h
- ** @brief mathop for sse2
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_MATHOP_SSE2_H_INSTANTIATING
-
-#ifndef VL_MATHOP_SSE2_H
-#define VL_MATHOP_SSE2_H
-
-#undef FLT
-#define FLT VL_TYPE_DOUBLE
-#define VL_MATHOP_SSE2_H_INSTANTIATING
-#include "mathop_sse2.h"
-
-#undef FLT
-#define FLT VL_TYPE_FLOAT
-#define VL_MATHOP_SSE2_H_INSTANTIATING
-#include "mathop_sse2.h"
-
-/* VL_MATHOP_SSE2_H */
-#endif
-
-/* ---------------------------------------------------------------- */
-/* VL_MATHOP_SSE2_H_INSTANTIATING */
-#else
-
-#ifndef VL_DISABLE_SSE2
-
-#include "generic.h"
-#include "float.h"
-
-VL_EXPORT T
-VL_XCAT(_vl_dot_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_l1_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_chi2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_l1_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_kernel_chi2_sse2_, SFX)
-(vl_size dimension, T const * X, T const * Y) ;
-
-VL_EXPORT T
-VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX)
-(vl_size dimension, T const * X, T const * MU, T const * S);
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
-(vl_size dimension, T * S, T const * X, T const * Y, T const W);
-
-VL_EXPORT void
-VL_XCAT(_vl_weighted_mean_sse2_, SFX)
-(vl_size dimension, T * MU, T const * X, T const W);
-
-/* ! VL_DISABLE_SSE2 */
-#endif
-#undef VL_MATHOP_SSE2_INSTANTIATING
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mser.c b/opensfm/src/third_party/vlfeat/vl/mser.c
deleted file mode 100644
index e6e879e50..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mser.c
+++ /dev/null
@@ -1,1001 +0,0 @@
-/** @file mser.c
- ** @brief MSER - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page mser Maximally Stable Extremal Regions (MSER)
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref mser.h implements the *Maximally Stable Extremal Regions* (MSER)
-local feature detector of @cite{matas03robust}. This detector extracts
-as features the the connected components of the level sets of the
-input intensity image. Among all such regions, the ones that are
-locally maximally stable are selected. MSERs are affine co-variant, as
-well as largely co-variant to generic diffeomorphic transformations.
-
-See @ref mser-starting for an introduction on how to use the detector
-from the C API. For further details refer to:
-
-- @subpage mser-fundamentals - MSER definition and parameters.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section mser-starting Getting started with the MSER detector
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Running the MSER filter usually involves the following steps:
-
-- Initialize the MSER filter by ::vl_mser_new(). The
-  filter can be reused for images of the same size.
-- Compute the MSERs by ::vl_mser_process().
-- Optionally fit ellipsoids to the MSERs by  ::vl_mser_ell_fit().
-- Retrieve the results by ::vl_mser_get_regions() (and optionally ::vl_mser_get_ell()).
-- Optionally retrieve filter statistics by ::vl_mser_get_stats().
-- Delete the MSER filter by ::vl_mser_delete().
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page mser-fundamentals MSER fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The *extermal regions* of an image are the connected components of the
-level sets $S_l = \{ x : I(x) \leq l \}, l \in \real$ of the image
-$I(x)$. Consider a discretization of the intensity levels $l$
-consisting of $M$ samples $\mathcal{L}=\{0,\dots,M-1\}$. The extremal
-regions $R_l \subset S_l$ of the level sets $S_l, l \in \mathcal{L}$
-can be arranged in a tree, where a region $R_l$ is a children of a
-region $R_{l+1}$ if $R_l \subset R_{l+1}$. The following figures shows
-a 1D example where the regions are denoted by dark thick lines:
-
-@image html mser-tree.png "Connected components of the image level sets arranged in a tree."
-
-Note that, depending on the image, regions at different levels can be
-identical as sets:
-
-@image html mser-er-step.png "Connected components when the image contains step changes."
-
-A *stable extremal region* is an extremal region that does not change
-much as the index $l$ is varied. Here we use a criterion which is
-similar but not identical to the original paper. This definition is
-somewhat simpler both to understand and code.
-
-Let $B(R_l)=(R_l,R_{l+1},\dots,R_{l+\Delta})$ be the branch of the
-tree $R_l \subset R_{l+1} \subset \dots \subset R_{l + \Delta}$
-rooted at $R_l$. We associate to the branch the (in)stability score
-
-@f[
-  v(R_l) = \frac{|R_{l+\Delta} - R_l|}{|R_l|}.
-@f]
-
-This score is a relative measure of how much $R_l$ changes as the
-index is increased from $l$ to $l+\Delta$, as illustrated in the
-following figure.
-
-@image html mser-er.png "Stability is measured by looking at how much a region changes with the intensity level."
-
-The score is low if the regions along the branch have similar area
-(and thus similar shape). We aim to select maximally stable
-branches; then a maximally stable region is just a representative
-region selected from a maximally stable branch (for simplicity we
-select $R_l$, but one could choose for example
-$R_{l+\Delta/2}$).
-
-Roughly speaking, a branch is maximally stable if it is a local
-minimum of the (in)stability score. More accurately, we start by
-assuming that all branches are maximally stable. Then we consider
-each branch $B(R_{l})$ and its parent branch
-$B(R_{l+1}):R_{l+1}\supset R_l$ (notice that, due to the
-discrete nature of the calculations, they might be geometrically
-identical) and we mark as unstable the less stable one, i.e.:
-
-  - if $v(R_l)<v(R_{l+1})$, mark $R_{l+1}$ as unstable;
-  - if $v(R_l)>v(R_{l+1})$, mark $R_{l}$ as unstable;
-  - otherwise, do nothing.
-
-This criterion selects among nearby regions the ones that are more
-stable. We optionally refine the selection by running (starting
-from the bigger and going to the smaller regions) the following
-tests:
-
-- $a_- \leq |R_{l}|/|R_{\infty}| \leq a_+$: exclude MSERs too
-  small or too big ($|R_{\infty}|$ is the area of the image).
-
-- $v(R_{l}) < v_+$: exclude MSERs too unstable.
-
-- For any MSER $R_l$, find the parent MSER $R_{l'}$ and check
-  if
-  $|R_{l'} - R_l|/|R_l'| < d_+$: remove duplicated MSERs.
-
- <table>
- <tr>
-  <td>parameter</td>
-  <td>alt. name</td>
-  <td>standard value</td>
-  <td>set by</td>
- </tr>
- <tr>
-   <td>$\Delta$</td>
-   <td>@c delta</td>
-   <td>5</td>
-   <td>::vl_mser_set_delta()</td>
- </tr>
- <tr>
-   <td>$a_+$</td>
-   <td>@c max_area</td>
-   <td>0.75</td>
-   <td>::vl_mser_set_max_area()</td>
- </tr>
- <tr>
-   <td>$a_-$</td>
-   <td>@c min_area</td>
-   <td>3.0/$|R_\infty|$</td>
-   <td>::vl_mser_set_min_area()</td>
- </tr>
- <tr>
-   <td>$v_+$</td>
-   <td>@c max_var</td>
-   <td>0.25</td>
-   <td>::vl_mser_set_max_variation()</td>
- </tr>
- <tr>
-   <td>$d_+$</td>
-   <td>@c min_diversity</td>
-   <td>0.2</td>
-   <td>::vl_mser_set_min_diversity()</td>
- </tr>
-</table>
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section mser-vol Volumetric images
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The code supports images of arbitrary dimension. For instance, it
-is possible to find the MSER regions of volumetric images or time
-sequences. See ::vl_mser_new() for further details
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section mser-ell Ellipsoids
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Usually extremal regions are returned as a set of ellipsoids
-fitted to the actual regions (which have arbitrary shape). The fit
-is done by calculating the mean and variance of the pixels
-composing the region:
-@f[
-\mu_l = \frac{1}{|R_l|}\sum_{x\in R_l}x,
-\qquad
-\Sigma_l = \frac{1}{|R_l|}\sum_{x\in R_l} (x-\mu_l)^\top(x-\mu_l)
-@f]
-Ellipsoids are fitted by ::vl_mser_ell_fit().  Notice that for a
-<em>n</em> dimensional image, the mean has <em>n</em> components
-and the variance has <em>n(n+1)/2</em> independent components. The
-total number of components is obtained by ::vl_mser_get_ell_dof()
-and the total number of fitted ellipsoids by
-::vl_mser_get_ell_num(). A matrix with an ellipsoid per column is
-returned by ::vl_mser_get_ell(). The column is the stacking of the
-mean and of the independent components of the variance, in the
-order <em>(1,1),(1,2),..,(1,n), (2,2),(2,3)...</em>. In the
-calculations, the pixel coordinate $x=(x_1,...,x_n)$ use the
-standard index order and ranges.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section mser-algo Algorithm
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The algorithm is quite efficient. While some details may be
-tricky, the overall idea is easy to grasp.
-
-- Pixels are sorted by increasing intensity.
-- Pixels are added to a forest by increasing intensity. The forest has the
-  following properties:
-  - All the descendent of a certain pixels are subset of an extremal region.
-  - All the extremal regions are the descendants of some pixels.
-- Extremal regions are extracted from the region tree and the extremal regions tree is
-  calculated.
-- Stable regions are marked.
-- Duplicates and other bad regions are removed.
-
-@remark The extremal region tree which is calculated is a subset
-of the actual extremal region tree. In particular, it does not
-contain redundant entries extremal regions that coincide as
-sets. So, for example, in the calculated extremal region tree, the
-parent $R_q$ of an extremal region $R_{l}$ may or may
-<em>not</em> correspond to $R_{l+1}$, depending whether
-$q\leq l+1$ or not. These subtleties are important when
-calculating the stability tests.
-
-**/
-
-#include "mser.h"
-#include<stdlib.h>
-#include<string.h>
-#include<assert.h>
-
-/** -------------------------------------------------------------------
- ** @brief Advance N-dimensional subscript
- **
- ** The function increments by one the subscript @a subs indexing an
- ** array the @a ndims dimensions @a dims.
- **
- ** @param ndims number of dimensions.
- ** @param dims dimensions.
- ** @param subs subscript to advance.
- **/
-
-VL_INLINE void
-adv(int ndims, int const *dims, int *subs)
-{
-  int d = 0 ;
-  while(d < ndims) {
-    if( ++subs[d]  < dims[d] ) return ;
-    subs[d++] = 0 ;
-  }
-}
-
-/** -------------------------------------------------------------------
- ** @brief Climb the region forest to reach aa root
- **
- ** The function climbs the regions forest @a r starting from the node
- ** @a idx to the corresponding root.
- **
- ** To speed-up the operation, the function uses the
- ** VlMserReg::shortcut field to quickly jump to the root. After the
- ** root is reached, all the used shortcut are updated.
- **
- ** @param r regions' forest.
- ** @param idx stating node.
- ** @return index of the reached root.
- **/
-
-VL_INLINE vl_uint
-climb (VlMserReg* r, vl_uint idx)
-{
-
-  vl_uint prev_idx = idx ;
-  vl_uint next_idx ;
-  vl_uint root_idx ;
-
-  /* move towards root to find it */
-  while (1) {
-
-    /* next jump to the root */
-    next_idx = r [idx] .shortcut ;
-
-    /* recycle shortcut to remember how we came here */
-    r [idx] .shortcut = prev_idx ;
-
-    /* stop if the root is found */
-    if( next_idx == idx ) break ;
-
-    /* next guy */
-    prev_idx = idx ;
-    idx      = next_idx ;
-  }
-
-  root_idx = idx ;
-
-  /* move backward to update shortcuts */
-  while (1) {
-
-    /* get previously visited one */
-    prev_idx = r [idx] .shortcut ;
-
-    /* update shortcut to point to the new root */
-    r [idx] .shortcut = root_idx ;
-
-    /* stop if the first visited node is reached */
-    if( prev_idx == idx ) break ;
-
-    /* next guy */
-    idx = prev_idx ;
-  }
-
-  return root_idx ;
-}
-
-/** -------------------------------------------------------------------
- ** @brief Create a new MSER filter
- **
- ** Initializes a new MSER filter for images of the specified
- ** dimensions. Images are @a ndims -dimensional arrays of dimensions
- ** @a dims.
- **
- ** @param ndims number of dimensions.
- ** @param dims  dimensions.
- **/
-VL_EXPORT
-VlMserFilt*
-vl_mser_new (int ndims, int const* dims)
-{
-  VlMserFilt* f ;
-  int *strides, k ;
-
-  f = vl_calloc (sizeof(VlMserFilt), 1) ;
-
-  f-> ndims   = ndims ;
-  f-> dims    = vl_malloc (sizeof(int) * ndims) ;
-  f-> subs    = vl_malloc (sizeof(int) * ndims) ;
-  f-> dsubs   = vl_malloc (sizeof(int) * ndims) ;
-  f-> strides = vl_malloc (sizeof(int) * ndims) ;
-
-  /* shortcuts */
-  strides = f-> strides ;
-
-  /* copy dims to f->dims */
-  for(k = 0 ; k < ndims ; ++k) {
-    f-> dims [k] = dims [k] ;
-  }
-
-  /* compute strides to move into the N-dimensional image array */
-  strides [0] = 1 ;
-  for(k = 1 ; k < ndims ; ++k) {
-    strides [k] = strides [k-1] * dims [k-1] ;
-  }
-
-  /* total number of pixels */
-  f-> nel = strides [ndims-1] * dims [ndims-1] ;
-
-  /* dof of ellipsoids */
-  f-> dof = ndims * (ndims + 1) / 2 + ndims ;
-
-  /* more buffers */
-  f-> perm   = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
-  f-> joins  = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
-  f-> r      = vl_malloc (sizeof(VlMserReg) * f-> nel) ;
-
-  f-> er     = 0 ;
-  f-> rer    = 0 ;
-  f-> mer    = 0 ;
-  f-> rmer   = 0 ;
-  f-> ell    = 0 ;
-  f-> rell   = 0 ;
-
-  /* other parameters */
-  f-> delta         = 5 ;
-  f-> max_area      = 0.75 ;
-  f-> min_area      = 3.0 / f-> nel ;
-  f-> max_variation = 0.25 ;
-  f-> min_diversity = 0.2 ;
-
-  return f ;
-}
-
-/** -------------------------------------------------------------------
- ** @brief Delete MSER filter
- **
- ** The function releases the MSER filter @a f and all its resources.
- **
- ** @param f MSER filter to be deleted.
- **/
-VL_EXPORT
-void
-vl_mser_delete (VlMserFilt* f)
-{
-  if(f) {
-    if(f-> acc   )  vl_free( f-> acc    ) ;
-    if(f-> ell   )  vl_free( f-> ell    ) ;
-
-    if(f-> er    )  vl_free( f-> er     ) ;
-    if(f-> r     )  vl_free( f-> r      ) ;
-    if(f-> joins )  vl_free( f-> joins  ) ;
-    if(f-> perm  )  vl_free( f-> perm   ) ;
-
-    if(f-> strides) vl_free( f-> strides) ;
-    if(f-> dsubs  ) vl_free( f-> dsubs  ) ;
-    if(f-> subs   ) vl_free( f-> subs   ) ;
-    if(f-> dims   ) vl_free( f-> dims   ) ;
-
-    if(f-> mer    ) vl_free( f-> mer    ) ;
-    vl_free (f) ;
-  }
-}
-
-
-/** -------------------------------------------------------------------
- ** @brief Process image
- **
- ** The functions calculates the Maximally Stable Extremal Regions
- ** (MSERs) of image @a im using the MSER filter @a f.
- **
- ** The filter @a f must have been initialized to be compatible with
- ** the dimensions of @a im.
- **
- ** @param f MSER filter.
- ** @param im image data.
- **/
-VL_EXPORT
-void
-vl_mser_process (VlMserFilt* f, vl_mser_pix const* im)
-{
-  /* shortcuts */
-  vl_uint        nel     = f-> nel  ;
-  vl_uint       *perm    = f-> perm ;
-  vl_uint       *joins   = f-> joins ;
-  int            ndims   = f-> ndims ;
-  int           *dims    = f-> dims ;
-  int           *subs    = f-> subs ;
-  int           *dsubs   = f-> dsubs ;
-  int           *strides = f-> strides ;
-  VlMserReg     *r       = f-> r ;
-  VlMserExtrReg *er      = f-> er ;
-  vl_uint       *mer     = f-> mer ;
-  int            delta   = f-> delta ;
-
-  int njoins = 0 ;
-  int ner    = 0 ;
-  int nmer   = 0 ;
-  int nbig   = 0 ;
-  int nsmall = 0 ;
-  int nbad   = 0 ;
-  int ndup   = 0 ;
-
-  int i, j, k ;
-
-  /* delete any previosuly computed ellipsoid */
-  f-> nell = 0 ;
-
-  /* -----------------------------------------------------------------
-   *                                          Sort pixels by intensity
-   * -------------------------------------------------------------- */
-
-  {
-    vl_uint buckets [ VL_MSER_PIX_MAXVAL ] ;
-
-    /* clear buckets */
-    memset (buckets, 0, sizeof(vl_uint) * VL_MSER_PIX_MAXVAL ) ;
-
-    /* compute bucket size (how many pixels for each intensity
-       value) */
-    for(i = 0 ; i < (int) nel ; ++i) {
-      vl_mser_pix v = im [i] ;
-      ++ buckets [v] ;
-    }
-
-    /* cumulatively add bucket sizes */
-    for(i = 1 ; i < VL_MSER_PIX_MAXVAL ; ++i) {
-      buckets [i] += buckets [i-1] ;
-    }
-
-    /* empty buckets computing pixel ordering */
-    for(i = nel ; i >= 1 ; ) {
-      vl_mser_pix v = im [ --i ] ;
-      vl_uint j = -- buckets [v] ;
-      perm [j] = i ;
-    }
-  }
-
-  /* initialize the forest with all void nodes */
-  for(i = 0 ; i < (int) nel ; ++i) {
-    r [i] .parent = VL_MSER_VOID_NODE ;
-  }
-
-  /* -----------------------------------------------------------------
-   *                        Compute regions and count extremal regions
-   * -------------------------------------------------------------- */
-  /*
-     In the following:
-
-     idx    : index of the current pixel
-     val    : intensity of the current pixel
-     r_idx  : index of the root of the current pixel
-     n_idx  : index of the neighbors of the current pixel
-     nr_idx : index of the root of the neighbor of the current pixel
-
-  */
-
-  /* process each pixel by increasing intensity */
-  for(i = 0 ; i < (int) nel ; ++i) {
-
-    /* pop next node xi */
-    vl_uint     idx = perm [i] ;
-    vl_mser_pix val = im [idx] ;
-    vl_uint     r_idx ;
-
-    /* add the pixel to the forest as a root for now */
-    r [idx] .parent   = idx ;
-    r [idx] .shortcut = idx ;
-    r [idx] .area     = 1 ;
-    r [idx] .height   = 1 ;
-
-    r_idx = idx ;
-
-    /* convert the index IDX into the subscript SUBS; also initialize
-       DSUBS to (-1,-1,...,-1) */
-    {
-      vl_uint temp = idx ;
-      for(k = ndims - 1 ; k >= 0 ; --k) {
-        dsubs [k] = -1 ;
-        subs  [k] = temp / strides [k] ;
-        temp      = temp % strides [k] ;
-      }
-    }
-
-    /* examine the neighbors of the current pixel */
-    while (1) {
-      vl_uint n_idx = 0 ;
-      vl_bool good = 1 ;
-
-      /*
-         Compute the neighbor subscript as NSUBS+SUB, the
-         corresponding neighbor index NINDEX and check that the
-         neighbor is within the image domain.
-      */
-      for(k = 0 ; k < ndims && good ; ++k) {
-        int temp  = dsubs [k] + subs [k] ;
-        good     &= (0 <= temp) && (temp < dims [k]) ;
-        n_idx    += temp * strides [k] ;
-      }
-
-      /*
-         The neighbor should be processed if the following conditions
-         are met:
-
-         1. The neighbor is within image boundaries.
-
-         2. The neighbor is indeed different from the current node
-            (the opposite happens when DSUB=(0,0,...,0)).
-
-         3. The neighbor is already in the forest, meaning that it has
-            already been processed.
-      */
-      if (good &&
-          n_idx != idx &&
-          r [n_idx] .parent != VL_MSER_VOID_NODE ) {
-
-        vl_mser_pix nr_val = 0 ;
-        vl_uint     nr_idx = 0 ;
-        int         hgt   = r [ r_idx] .height ;
-        int         n_hgt = r [nr_idx] .height ;
-
-        /*
-          Now we join the two subtrees rooted at
-
-           R_IDX = ROOT(  IDX)
-          NR_IDX = ROOT(N_IDX).
-
-          Note that R_IDX = ROOT(IDX) might change as we process more
-          neighbors, so we need keep updating it.
-        */
-
-         r_idx = climb(r,   idx) ;
-        nr_idx = climb(r, n_idx) ;
-
-        /*
-          At this point we have three possibilities:
-
-          (A) ROOT(IDX) == ROOT(NR_IDX). In this case the two trees
-              have already been joined and we do not do anything.
-
-          (B) I(ROOT(IDX)) == I(ROOT(NR_IDX)). In this case the pixel
-              IDX is extending an extremal region with the same
-              intensity value. Since ROOT(NR_IDX) will NOT be an
-              extremal region of the full image, ROOT(IDX) can be
-              safely added as children of ROOT(NR_IDX) if this
-              reduces the height according to the union rank
-              heuristic.
-
-          (C) I(ROOT(IDX)) > I(ROOT(NR_IDX)). In this case the pixel
-              IDX is starting a new extremal region. Thus ROOT(NR_IDX)
-              WILL be an extremal region of the final image and the
-              only possibility is to add ROOT(NR_IDX) as children of
-              ROOT(IDX), which becomes parent.
-        */
-
-        if( r_idx != nr_idx ) { /* skip if (A) */
-
-          nr_val = im [nr_idx] ;
-
-          if( nr_val == val && hgt < n_hgt ) {
-
-            /* ROOT(IDX) becomes the child */
-            r [r_idx]  .parent   = nr_idx ;
-            r [r_idx]  .shortcut = nr_idx ;
-            r [nr_idx] .area    += r [r_idx] .area ;
-            r [nr_idx] .height   = VL_MAX(n_hgt, hgt+1) ;
-
-            joins [njoins++] = r_idx ;
-
-          } else {
-
-            /* cases ROOT(IDX) becomes the parent */
-            r [nr_idx] .parent   = r_idx ;
-            r [nr_idx] .shortcut = r_idx ;
-            r [r_idx]  .area    += r [nr_idx] .area ;
-            r [r_idx]  .height   = VL_MAX(hgt, n_hgt + 1) ;
-
-            joins [njoins++] = nr_idx ;
-
-            /* count if extremal */
-            if (nr_val != val) ++ ner ;
-
-          } /* check b vs c */
-        } /* check a vs b or c */
-      } /* neighbor done */
-
-      /* move to next neighbor */
-      k = 0 ;
-      while(++ dsubs [k] > 1) {
-        dsubs [k++] = -1 ;
-        if(k == ndims) goto done_all_neighbors ;
-      }
-    } /* next neighbor */
-  done_all_neighbors : ;
-  } /* next pixel */
-
-  /* the last root is extremal too */
-  ++ ner ;
-
-  /* save back */
-  f-> njoins = njoins ;
-
-  f-> stats. num_extremal = ner ;
-
-  /* -----------------------------------------------------------------
-   *                                          Extract extremal regions
-   * -------------------------------------------------------------- */
-
-  /*
-     Extremal regions are extracted and stored into the array ER.  The
-     structure R is also updated so that .SHORTCUT indexes the
-     corresponding extremal region if any (otherwise it is set to
-     VOID).
-  */
-
-  /* make room */
-  if (f-> rer < ner) {
-    if (er) vl_free (er) ;
-    f->er  = er = vl_malloc (sizeof(VlMserExtrReg) * ner) ;
-    f->rer = ner ;
-  } ;
-
-  /* save back */
-  f-> nmer = ner ;
-
-  /* count again */
-  ner = 0 ;
-
-  /* scan all regions Xi */
-  for(i = 0 ; i < (int) nel ; ++i) {
-
-    /* pop next node xi */
-    vl_uint     idx = perm [i] ;
-
-    vl_mser_pix val   = im [idx] ;
-    vl_uint     p_idx = r  [idx] .parent ;
-    vl_mser_pix p_val = im [p_idx] ;
-
-    /* is extremal ? */
-    vl_bool is_extr = (p_val > val) || idx == p_idx ;
-
-    if( is_extr ) {
-
-      /* if so, add it */
-      er [ner] .index      = idx ;
-      er [ner] .parent     = ner ;
-      er [ner] .value      = im [idx] ;
-      er [ner] .area       = r  [idx] .area ;
-
-      /* link this region to this extremal region */
-      r [idx] .shortcut = ner ;
-
-      /* increase count */
-      ++ ner ;
-    } else {
-      /* link this region to void */
-      r [idx] .shortcut =   VL_MSER_VOID_NODE ;
-    }
-  }
-
-  /* -----------------------------------------------------------------
-   *                                   Link extremal regions in a tree
-   * -------------------------------------------------------------- */
-
-  for(i = 0 ; i < ner ; ++i) {
-
-    vl_uint idx = er [i] .index ;
-
-    do {
-      idx = r[idx] .parent ;
-    } while (r[idx] .shortcut == VL_MSER_VOID_NODE) ;
-
-    er[i] .parent   = r[idx] .shortcut ;
-    er[i] .shortcut = i ;
-  }
-
-  /* -----------------------------------------------------------------
-   *                            Compute variability of +DELTA branches
-   * -------------------------------------------------------------- */
-  /* For each extremal region Xi of value VAL we look for the biggest
-   * parent that has value not greater than VAL+DELTA. This is dubbed
-   * `top parent'. */
-
-  for(i = 0 ; i < ner ; ++i) {
-
-    /* Xj is the current region the region and Xj are the parents */
-    int     top_val = er [i] .value + delta ;
-    int     top     = er [i] .shortcut ;
-
-    /* examine all parents */
-    while (1) {
-      int next     = er [top]  .parent ;
-      int next_val = er [next] .value ;
-
-      /* Break if:
-       * - there is no node above the top or
-       * - the next node is above the top value.
-       */
-      if (next == top || next_val > top_val) break ;
-
-      /* so next could be the top */
-      top = next ;
-    }
-
-    /* calculate branch variation */
-    {
-      int area     = er [i  ] .area ;
-      int area_top = er [top] .area ;
-      er [i] .variation  = (float) (area_top - area) / area ;
-      er [i] .max_stable = 1 ;
-    }
-
-    /* Optimization: since extremal regions are processed by
-     * increasing intensity, all next extremal regions being processed
-     * have value at least equal to the one of Xi. If any of them has
-     * parent the parent of Xi (this comprises the parent itself), we
-     * can safely skip most intermediate node along the branch and
-     * skip directly to the top to start our search. */
-    {
-      int parent = er [i] .parent ;
-      int curr   = er [parent] .shortcut ;
-      er [parent] .shortcut =  VL_MAX (top, curr) ;
-    }
-  }
-
-  /* -----------------------------------------------------------------
-   *                                  Select maximally stable branches
-   * -------------------------------------------------------------- */
-
-  nmer = ner ;
-  for(i = 0 ; i < ner ; ++i) {
-    vl_uint    parent = er [i     ] .parent ;
-    vl_mser_pix   val = er [i     ] .value ;
-    float     var = er [i     ] .variation ;
-    vl_mser_pix p_val = er [parent] .value ;
-    float   p_var = er [parent] .variation ;
-    vl_uint     loser ;
-
-    /*
-       Notice that R_parent = R_{l+1} only if p_val = val + 1. If not,
-       this and the parent region coincide and there is nothing to do.
-    */
-    if(p_val > val + 1) continue ;
-
-    /* decide which one to keep and put that in loser */
-    if(var < p_var) loser = parent ; else loser = i ;
-
-    /* make loser NON maximally stable */
-    if(er [loser] .max_stable) {
-      -- nmer ;
-      er [loser] .max_stable = 0 ;
-    }
-  }
-
-  f-> stats. num_unstable = ner - nmer ;
-
-  /* -----------------------------------------------------------------
-   *                                                 Further filtering
-   * -------------------------------------------------------------- */
-  /* It is critical for correct duplicate detection to remove regions
-   * from the bottom (smallest one first).                          */
-  {
-    float max_area = (float) f-> max_area * nel ;
-    float min_area = (float) f-> min_area * nel ;
-    float max_var  = (float) f-> max_variation ;
-    float min_div  = (float) f-> min_diversity ;
-
-    /* scan all extremal regions (intensity value order) */
-    for(i = ner-1 ; i >= 0L  ; --i) {
-
-      /* process only maximally stable extremal regions */
-      if (! er [i] .max_stable) continue ;
-
-      if (er [i] .variation >= max_var ) { ++ nbad ;   goto remove ; }
-      if (er [i] .area      >  max_area) { ++ nbig ;   goto remove ; }
-      if (er [i] .area      <  min_area) { ++ nsmall ; goto remove ; }
-
-      /*
-       * Remove duplicates
-       */
-      if (min_div < 1.0) {
-        vl_uint   parent = er [i] .parent ;
-        int       area, p_area ;
-        float div ;
-
-        /* check all but the root mser */
-        if((int) parent != i) {
-
-          /* search for the maximally stable parent region */
-          while(! er [parent] .max_stable) {
-            vl_uint next = er [parent] .parent ;
-            if(next == parent) break ;
-            parent = next ;
-          }
-
-          /* Compare with the parent region; if the current and parent
-           * regions are too similar, keep only the parent. */
-          area    = er [i]      .area ;
-          p_area  = er [parent] .area ;
-          div     = (float) (p_area - area) / (float) p_area ;
-
-          if (div < min_div) { ++ ndup ; goto remove ; }
-        } /* remove dups end */
-
-      }
-      continue ;
-    remove :
-      er [i] .max_stable = 0 ;
-      -- nmer ;
-    } /* check next region */
-
-    f-> stats .num_abs_unstable = nbad ;
-    f-> stats .num_too_big      = nbig ;
-    f-> stats .num_too_small    = nsmall ;
-    f-> stats .num_duplicates   = ndup ;
-  }
-  /* -----------------------------------------------------------------
-   *                                                   Save the result
-   * -------------------------------------------------------------- */
-
-  /* make room */
-  if (f-> rmer < nmer) {
-    if (mer) vl_free (mer) ;
-    f->mer  = mer = vl_malloc( sizeof(vl_uint) * nmer) ;
-    f->rmer = nmer ;
-  }
-
-  /* save back */
-  f-> nmer = nmer ;
-
-  j = 0 ;
-  for (i = 0 ; i < ner ; ++i) {
-    if (er [i] .max_stable) mer [j++] = er [i] .index ;
-  }
-}
-
-/** -------------------------------------------------------------------
- ** @brief Fit ellipsoids
- **
- ** @param f MSER filter.
- **
- ** @sa @ref mser-ell
- **/
-
-VL_EXPORT
-void
-vl_mser_ell_fit (VlMserFilt* f)
-{
-  /* shortcuts */
-  int                nel = f-> nel ;
-  int                dof = f-> dof ;
-  int              *dims = f-> dims ;
-  int              ndims = f-> ndims ;
-  int              *subs = f-> subs ;
-  int             njoins = f-> njoins ;
-  vl_uint         *joins = f-> joins ;
-  VlMserReg           *r = f-> r ;
-  vl_uint           *mer = f-> mer ;
-  int               nmer = f-> nmer ;
-  vl_mser_acc       *acc = f-> acc ;
-  vl_mser_acc       *ell = f-> ell ;
-
-  int d, index, i, j ;
-
-  /* already fit ? */
-  if (f->nell == f->nmer) return ;
-
-  /* make room */
-  if (f->rell < f->nmer) {
-    if (f->ell) vl_free (f->ell) ;
-    f->ell  = vl_malloc (sizeof(float) * f->nmer * f->dof) ;
-    f->rell = f-> nmer ;
-  }
-
-  if (f->acc == 0) {
-    f->acc = vl_malloc (sizeof(float) * f->nel) ;
-  }
-
-  acc = f-> acc ;
-  ell = f-> ell ;
-
-  /* -----------------------------------------------------------------
-   *                                                 Integrate moments
-   * -------------------------------------------------------------- */
-
-  /* for each dof */
-  for(d = 0 ; d < f->dof ; ++d) {
-
-    /* start from the upper-left pixel (0,0,...,0) */
-    memset (subs, 0, sizeof(int) * ndims) ;
-
-    /* step 1: fill acc pretending that each region has only one pixel */
-    if(d < ndims) {
-      /* 1-order ................................................... */
-
-      for(index = 0 ; index < nel ; ++ index) {
-        acc [index] = subs [d] ;
-        adv(ndims, dims, subs) ;
-      }
-    }
-    else {
-      /* 2-order ................................................... */
-
-      /* map the dof d to a second order moment E[x_i x_j] */
-      i = d - ndims ;
-      j = 0 ;
-      while(i > j) {
-        i -= j + 1 ;
-        j ++ ;
-      }
-      /* initialize acc with  x_i * x_j */
-      for(index = 0 ; index < nel ; ++ index){
-        acc [index] = subs [i] * subs [j] ;
-        adv(ndims, dims, subs) ;
-      }
-    }
-
-    /* step 2: integrate */
-    for(i = 0 ; i < njoins ; ++i) {
-      vl_uint index  = joins [i] ;
-      vl_uint parent = r [index] .parent ;
-      acc [parent] += acc [index] ;
-    }
-
-    /* step 3: save back to ellpises */
-    for(i = 0 ; i < nmer ; ++i) {
-      vl_uint idx = mer [i] ;
-      ell [d + dof*i] = acc [idx] ;
-    }
-
-  }  /* next dof */
-
-  /* -----------------------------------------------------------------
-   *                                           Compute central moments
-   * -------------------------------------------------------------- */
-
-  for(index = 0 ; index < nmer ; ++index) {
-    float  *pt  = ell + index * dof ;
-    vl_uint    idx  = mer [index] ;
-    float  area = r [idx] .area ;
-
-    for(d = 0 ; d < dof ; ++d) {
-
-      pt [d] /= area ;
-
-      if(d >= ndims) {
-        /* remove squared mean from moment to get variance */
-        i = d - ndims ;
-        j = 0 ;
-        while(i > j) {
-          i -= j + 1 ;
-          j ++ ;
-        }
-        pt [d] -= pt [i] * pt [j] ;
-      }
-
-    }
-  }
-
-  /* save back */
-  f-> nell = nmer ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/mser.h b/opensfm/src/third_party/vlfeat/vl/mser.h
deleted file mode 100644
index bd63cedb1..000000000
--- a/opensfm/src/third_party/vlfeat/vl/mser.h
+++ /dev/null
@@ -1,424 +0,0 @@
-/** @file mser.h
- ** @brief MSER (@ref mser)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_MSER
-#define VL_MSER
-
-#include "generic.h"
-
-/** @brief MSER image data type
- **
- ** This is the data type of the image pixels. It has to be an
- ** integer.
- **/
-typedef vl_uint8 vl_mser_pix ;
-
-/** @brief Maximum value
- **
- ** Maximum value of the integer type ::vl_mser_pix.
- **/
-#define VL_MSER_PIX_MAXVAL 256
-
-/** @brief MSER Filter
- **
- ** The MSER filter computes the Maximally Stable Extremal Regions of
- ** an image.
- **
- ** @sa @ref mser
- **/
-typedef struct _VlMserFilt VlMserFilt ;
-
-/** @brief MSER filter statistics */
-typedef struct _VlMserStats VlMserStats ;
-
-/** @brief MSER filter statistics definition */
-struct _VlMserStats
-{
-  int num_extremal ;      /**< number of extremal regions                                */
-  int num_unstable ;      /**< number of unstable extremal regions                       */
-  int num_abs_unstable ;  /**< number of regions that failed the absolute stability test */
-  int num_too_big ;       /**< number of regions that failed the maximum size test       */
-  int num_too_small ;     /**< number of regions that failed the minimum size test       */
-  int num_duplicates ;    /**< number of regions that failed the duplicate test          */
-} ;
-
-/** @name Construction and Destruction
- ** @{
- **/
-VL_EXPORT VlMserFilt*      vl_mser_new     (int ndims, int const* dims) ;
-VL_EXPORT void             vl_mser_delete  (VlMserFilt *f) ;
-/** @} */
-
-/** @name Processing
- ** @{
- **/
-VL_EXPORT void             vl_mser_process (VlMserFilt *f,
-                                            vl_mser_pix const *im) ;
-VL_EXPORT void             vl_mser_ell_fit (VlMserFilt *f) ;
-/** @} */
-
-/** @name Retrieving data
- ** @{
- **/
-VL_INLINE vl_uint          vl_mser_get_regions_num  (VlMserFilt const *f) ;
-VL_INLINE vl_uint const*   vl_mser_get_regions      (VlMserFilt const *f) ;
-VL_INLINE float const*     vl_mser_get_ell          (VlMserFilt const *f) ;
-VL_INLINE vl_uint          vl_mser_get_ell_num      (VlMserFilt const *f) ;
-VL_INLINE vl_uint          vl_mser_get_ell_dof      (VlMserFilt const *f) ;
-VL_INLINE VlMserStats const*  vl_mser_get_stats     (VlMserFilt const *f) ;
-/** @} */
-
-/** @name Retrieving parameters
- ** @{
- **/
-VL_INLINE vl_mser_pix  vl_mser_get_delta          (VlMserFilt const *f) ;
-VL_INLINE double       vl_mser_get_min_area       (VlMserFilt const *f) ;
-VL_INLINE double       vl_mser_get_max_area       (VlMserFilt const *f) ;
-VL_INLINE double       vl_mser_get_max_variation  (VlMserFilt const *f) ;
-VL_INLINE double       vl_mser_get_min_diversity  (VlMserFilt const *f) ;
-/** @} */
-
-/** @name Setting parameters
- ** @{
- **/
-VL_INLINE void  vl_mser_set_delta           (VlMserFilt *f, vl_mser_pix x) ;
-VL_INLINE void  vl_mser_set_min_area        (VlMserFilt *f, double      x) ;
-VL_INLINE void  vl_mser_set_max_area        (VlMserFilt *f, double      x) ;
-VL_INLINE void  vl_mser_set_max_variation   (VlMserFilt *f, double      x) ;
-VL_INLINE void  vl_mser_set_min_diversity   (VlMserFilt *f, double      x) ;
-/** @} */
-
-/* ====================================================================
- *                                                   INLINE DEFINITIONS
- * ================================================================== */
-
-/** @internal
- ** @brief MSER accumulator data type
- **
- ** This is a large integer type. It should be large enough to contain
- ** a number equal to the area (volume) of the image by the image
- ** width by the image height (for instance, if the image is a square
- ** of side 256, the maximum value is 256 x 256 x 256).
- **/
-typedef float vl_mser_acc ;
-
-/** @internal @brief Basic region flag: null region */
-#ifdef VL_COMPILER_MSC
-#define VL_MSER_VOID_NODE ((1ui64<<32) - 1)
-#else
-#define VL_MSER_VOID_NODE ((1ULL<<32) - 1)
-#endif
-
-/* ----------------------------------------------------------------- */
-/** @internal
- ** @brief MSER: basic region (declaration)
- **
- ** Extremal regions and maximally stable extremal regions are
- ** instances of image regions.
- **
- ** There is an image region for each pixel of the image. Each region
- ** is represented by an instance of this structure.  Regions are
- ** stored into an array in pixel order.
- **
- ** Regions are arranged into a forest. VlMserReg::parent points to
- ** the parent node, or to the node itself if the node is a root.
- ** VlMserReg::parent is the index of the node in the node array
- ** (which therefore is also the index of the corresponding
- ** pixel). VlMserReg::height is the distance of the fartest leaf. If
- ** the node itself is a leaf, then VlMserReg::height is zero.
- **
- ** VlMserReg::area is the area of the image region corresponding to
- ** this node.
- **
- ** VlMserReg::region is the extremal region identifier. Not all
- ** regions are extremal regions however; if the region is NOT
- ** extremal, this field is set to ....
- **/
-struct _VlMserReg
-{
-  vl_uint parent ;   /**< points to the parent region.            */
-  vl_uint shortcut ; /**< points to a region closer to a root.    */
-  vl_uint height ;   /**< region height in the forest.            */
-  vl_uint area ;     /**< area of the region.                     */
-} ;
-
-/** @internal @brief MSER: basic region */
-typedef struct _VlMserReg VlMserReg ;
-
-/* ----------------------------------------------------------------- */
-/** @internal
- ** @brief MSER: extremal region (declaration)
- **
- ** Extremal regions (ER) are extracted from the region forest. Each
- ** region is represented by an instance of this structure. The
- ** structures are stored into an array, in arbitrary order.
- **
- ** ER are arranged into a tree. @a parent points to the parent ER, or
- ** to itself if the ER is the root.
- **
- ** An instance of the structure represents the extremal region of the
- ** level set of intensity VlMserExtrReg::value and containing the
- ** pixel VlMserExtReg::index.
- **
- ** VlMserExtrReg::area is the area of the extremal region and
- ** VlMserExtrReg::area_top is the area of the extremal region
- ** containing this region in the level set of intensity
- ** VlMserExtrReg::area + @c delta.
- **
- ** VlMserExtrReg::variation is the relative area variation @c
- ** (area_top-area)/area.
- **
- ** VlMserExtrReg::max_stable is a flag signaling whether this extremal
- ** region is also maximally stable.
- **/
-struct _VlMserExtrReg
-{
-  int          parent ;     /**< index of the parent region                   */
-  int          index ;      /**< index of pivot pixel                         */
-  vl_mser_pix  value ;      /**< value of pivot pixel                         */
-  vl_uint      shortcut ;   /**< shortcut used when building a tree           */
-  vl_uint      area ;       /**< area of the region                           */
-  float        variation ;  /**< rel. area variation                          */
-  vl_uint      max_stable ; /**< max stable number (=0 if not maxstable)      */
-} ;
-
-/** @internal
- ** @brief MSER: extremal region */
-typedef struct _VlMserExtrReg VlMserExtrReg ;
-
-/* ----------------------------------------------------------------- */
-/** @internal
- ** @brief MSER filter
- ** @see @ref mser
- **/
-struct _VlMserFilt
-{
-
-  /** @name Image data and meta data @internal */
-  /*@{*/
-  int                ndims ;   /**< number of dimensions                    */
-  int               *dims ;    /**< dimensions                              */
-  int                nel ;     /**< number of image elements (pixels)       */
-  int               *subs ;    /**< N-dimensional subscript                 */
-  int               *dsubs ;   /**< another subscript                       */
-  int               *strides ; /**< strides to move in image data           */
-  /*@}*/
-
-  vl_uint           *perm ;    /**< pixel ordering                          */
-  vl_uint           *joins ;   /**< sequence of join ops                    */
-  int                njoins ;  /**< number of join ops                      */
-
-  /** @name Regions */
-  /*@{*/
-  VlMserReg         *r ;       /**< basic regions                           */
-  VlMserExtrReg     *er ;      /**< extremal tree                           */
-  vl_uint           *mer ;     /**< maximally stable extremal regions       */
-  int                ner ;     /**< number of extremal regions              */
-  int                nmer ;    /**< number of maximally stable extr. reg.   */
-  int                rer ;     /**< size of er buffer                       */
-  int                rmer ;    /**< size of mer buffer                      */
-  /*@}*/
-
-  /** @name Ellipsoids fitting */
-  /*@{*/
-  float             *acc ;     /**< moment accumulator.                    */
-  float             *ell ;     /**< ellipsoids list.                       */
-  int                rell ;    /**< size of ell buffer                     */
-  int                nell ;    /**< number of ellipsoids extracted         */
-  int                dof ;     /**< number of dof of ellipsoids.           */
-
-  /*@}*/
-
-  /** @name Configuration */
-  /*@{*/
-  vl_bool   verbose ;          /**< be verbose                             */
-  int       delta ;            /**< delta filter parameter                 */
-  double    max_area ;         /**< badness test parameter                 */
-  double    min_area ;         /**< badness test parameter                 */
-  double    max_variation ;    /**< badness test parameter                 */
-  double    min_diversity ;    /**< minimum diversity                      */
-  /*@}*/
-
-  VlMserStats stats ;          /** run statistic                           */
-} ;
-
-/* ----------------------------------------------------------------- */
-/** @brief Get delta
- ** @param f MSER filter.
- ** @return value of @c delta.
- **/
-VL_INLINE vl_mser_pix
-vl_mser_get_delta (VlMserFilt const *f)
-{
-  return f-> delta ;
-}
-
-/** @brief Set delta
- ** @param f MSER filter.
- ** @param x value of @c delta.
- **/
-VL_INLINE void
-vl_mser_set_delta (VlMserFilt *f, vl_mser_pix x)
-{
-  f-> delta = x ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get minimum diversity
- ** @param  f MSER filter.
- ** @return value of @c minimum diversity.
- **/
-VL_INLINE double
-vl_mser_get_min_diversity (VlMserFilt const *f)
-{
-  return f-> min_diversity ;
-}
-
-/** @brief Set minimum diversity
- ** @param f MSER filter.
- ** @param x value of @c minimum diversity.
- **/
-VL_INLINE void
-vl_mser_set_min_diversity (VlMserFilt *f, double x)
-{
-  f-> min_diversity = x ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get statistics
- ** @param f MSER filter.
- ** @return statistics.
- **/
-VL_INLINE VlMserStats const*
-vl_mser_get_stats (VlMserFilt const *f)
-{
-  return & f-> stats ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get maximum region area
- ** @param f MSER filter.
- ** @return maximum region area.
- **/
-VL_INLINE double
-vl_mser_get_max_area (VlMserFilt const *f)
-{
-  return f-> max_area ;
-}
-
-/** @brief Set maximum region area
- ** @param f MSER filter.
- ** @param x maximum region area.
- **/
-VL_INLINE void
-vl_mser_set_max_area (VlMserFilt *f, double x)
-{
-  f-> max_area = x ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get minimum region area
- ** @param f MSER filter.
- ** @return minimum region area.
- **/
-VL_INLINE double
-vl_mser_get_min_area (VlMserFilt const *f)
-{
-  return f-> min_area ;
-}
-
-/** @brief Set minimum region area
- ** @param f MSER filter.
- ** @param x minimum region area.
- **/
-VL_INLINE void
-vl_mser_set_min_area (VlMserFilt *f, double x)
-{
-  f-> min_area = x ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get maximum region variation
- ** @param f MSER filter.
- ** @return maximum region variation.
- **/
-VL_INLINE double
-vl_mser_get_max_variation (VlMserFilt const *f)
-{
-  return f-> max_variation ;
-}
-
-/** @brief Set maximum region variation
- ** @param f MSER filter.
- ** @param x maximum region variation.
- **/
-VL_INLINE void
-vl_mser_set_max_variation (VlMserFilt *f, double x)
-{
-  f-> max_variation = x ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get maximally stable extremal regions
- ** @param f MSER filter.
- ** @return array of MSER pivots.
- **/
-VL_INLINE vl_uint const *
-vl_mser_get_regions (VlMserFilt const* f)
-{
-  return f-> mer ;
-}
-
-/** @brief Get number of maximally stable extremal regions
- ** @param f MSER filter.
- ** @return number of MSERs.
- **/
-VL_INLINE vl_uint
-vl_mser_get_regions_num (VlMserFilt const* f)
-{
-  return f-> nmer ;
-}
-
-/* ----------------------------------------------------------------- */
-/** @brief Get ellipsoids
- ** @param f MSER filter.
- ** @return ellipsoids.
- **/
-VL_INLINE float const *
-vl_mser_get_ell (VlMserFilt const* f)
-{
-  return f-> ell ;
-}
-
-/** @brief Get number of degrees of freedom of ellipsoids
- ** @param f MSER filter.
- ** @return number of degrees of freedom.
- **/
-VL_INLINE vl_uint
-vl_mser_get_ell_dof (VlMserFilt const* f)
-{
-  return f-> dof ;
-}
-
-/** @brief Get number of ellipsoids
- ** @param f MSER filter.
- ** @return number of ellipsoids
- **/
-VL_INLINE vl_uint
-vl_mser_get_ell_num (VlMserFilt const* f)
-{
-  return f-> nell ;
-}
-
-/* VL_MSER */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/pgm.c b/opensfm/src/third_party/vlfeat/vl/pgm.c
deleted file mode 100644
index 81a3e3daf..000000000
--- a/opensfm/src/third_party/vlfeat/vl/pgm.c
+++ /dev/null
@@ -1,542 +0,0 @@
-/** @file pgm.c
- ** @brief Portable graymap format (PGM) parser - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file pgm.h
-
-This module implements basic input and ouptut of images in PGM
-format.
-
-Extracting an image encoded in PGM format from an imput
-file stream involves the following steps:
-
-- use ::vl_pgm_extract_head to extract the image meta data
-  (size and bit depth);
-- allocate a buffer to store the image data;
-- use ::vl_pgm_extract_data to extract the image data to the allocated
-  buffer.
-
-Writing an image in PGM format to an ouptut file stream
-can be done by using ::vl_pgm_insert.
-
-To quickly read/write a PGM image from/to a given file, use
-::vl_pgm_read_new() and ::vl_pgm_write(). To to the same from a
-buffer in floating point format use ::vl_pgm_read_new_f() and
-::vl_pgm_write_f().
-
-**/
-
-#include "pgm.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/** ------------------------------------------------------------------
- ** @internal @brief Remove all characters to the next new-line.
- ** @param f file to strip.
- ** @return number of characters removed.
- **/
-
-static int
-remove_line(FILE* f)
-{
-  int count = 0 ;
-  int c ;
-
-  while (1) {
-    c = fgetc(f) ;
-    ++ count ;
-
-    switch(c) {
-    case '\n' :
-      goto quit_remove_line ;
-
-    case EOF :
-      -- count ;
-      goto quit_remove_line ;
-    }
-  }
- quit_remove_line :
-  return count ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Remove white-spaces and comments.
- ** @param f file to strip.
- ** @return number of characters removed.
- **/
-
-static int
-remove_blanks(FILE* f)
-{
-  int count = 0 ;
-  int c ;
-
-  while (1) {
-    c = fgetc(f) ;
-
-    switch(c) {
-
-    case '\t' : case '\n' :
-    case '\r' : case ' '  :
-      ++ count ;
-      break ;
-
-    case '#' :
-      count += 1 + remove_line(f) ;
-      break ;
-
-    case EOF :
-      goto quit_remove_blanks ;
-
-    default:
-      ungetc(c, f) ;
-      goto quit_remove_blanks ;
-    }
-  }
- quit_remove_blanks:
-  return count ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get PGM image number of pixels.
- ** @param im PGM image descriptor.
- ** @return number of pixels of the image.
- **
- ** The functions returns the number of pixels of the PGM image @a im.
- **
- ** To calculate the image data size in bytes, this value must be
- ** multiplied by the number of byte per pixels (see
- ** ::vl_pgm_get_bpp()).
- **/
-
-VL_EXPORT vl_size
-vl_pgm_get_npixels (VlPgmImage const *im)
-{
-  return im->width * im->height ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get PGM image bytes per pixel.
- ** @param im PGM image descriptor.
- ** @return number of bytes per pixel.
- **
- ** The function returns the number of bytes for each pixel of the
- ** PGM image @a im.
- **/
-
-VL_EXPORT vl_size
-vl_pgm_get_bpp (VlPgmImage const *im)
-{
-  return (im->max_value >= 256) + 1 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Extract PGM header from stream.
- ** @param f  input file.
- ** @param im image structure to fill.
- ** @return error code.
- **
- ** The function extracts from the file @a f the meta-data section of
- ** an image encoded in PGM format. The function fills the structure
- ** ::VlPgmImage accordingly.
- **
- ** The error may be either ::VL_ERR_PGM_INV_HEAD or ::VL_ERR_PGM_INV_META
- ** depending whether the error occurred in decoding the header or
- ** meta section of the PGM file.
- **/
-
-VL_EXPORT int
-vl_pgm_extract_head (FILE* f, VlPgmImage *im)
-{
-  char magic [2] ;
-  int c ;
-  int is_raw ;
-  int width ;
-  int height ;
-  int max_value ;
-  size_t sz ;
-  vl_bool good ;
-
-  /* -----------------------------------------------------------------
-   *                                                check magic number
-   * -------------------------------------------------------------- */
-  sz = fread(magic, 1, 2, f) ;
-
-  if (sz < 2) {
-    return vl_set_last_error(VL_ERR_PGM_INV_HEAD, "Invalid PGM header") ;
-  }
-
-  good = magic [0] == 'P' ;
-
-  switch (magic [1]) {
-  case '2' : /* ASCII format */
-    is_raw = 0 ;
-    break ;
-
-  case '5' : /* RAW format */
-    is_raw = 1 ;
-    break ;
-
-  default :
-    good = 0 ;
-    break ;
-  }
-
-  if( ! good ) {
-    return vl_set_last_error(VL_ERR_PGM_INV_HEAD, "Invalid PGM header") ;
-  }
-
-  /* -----------------------------------------------------------------
-   *                                    parse width, height, max_value
-   * -------------------------------------------------------------- */
-  good = 1 ;
-
-  c = remove_blanks(f) ;
-  good &= c > 0 ;
-
-  c = fscanf(f, "%d", &width) ;
-  good &= c == 1 ;
-
-  c = remove_blanks(f) ;
-  good &= c > 0 ;
-
-  c = fscanf(f, "%d", &height) ;
-  good &= c == 1 ;
-
-  c = remove_blanks(f) ;
-  good &= c > 0 ;
-
-  c = fscanf(f, "%d", &max_value) ;
-  good &= c == 1 ;
-
-  /* must end with a single blank */
-  c = fgetc(f) ;
-  good &=
-    c == '\n' ||
-    c == '\t' ||
-    c == ' '  ||
-    c == '\r' ;
-
-  if(! good) {
-    return vl_set_last_error(VL_ERR_PGM_INV_META, "Invalid PGM meta information");
-  }
-
-  if(! max_value >= 65536) {
-    return vl_set_last_error(VL_ERR_PGM_INV_META, "Invalid PGM meta information");
-  }
-
-  /* exit */
-  im-> width     = width ;
-  im-> height    = height ;
-  im-> max_value = max_value ;
-  im-> is_raw    = is_raw ;
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Extract PGM data from stream.
- ** @param f input file.
- ** @param im PGM image descriptor.
- ** @param data data buffer to fill.
- ** @return error code.
- **
- ** The function extracts from the file @a f the data section of an
- ** image encoded in PGM format. The function fills the buffer @a data
- ** according. The buffer @a data should be ::vl_pgm_get_npixels() by
- ** ::vl_pgm_get_bpp() bytes large.
- **/
-
-VL_EXPORT
-int
-vl_pgm_extract_data (FILE* f, VlPgmImage const *im, void *data)
-{
-  vl_size bpp = vl_pgm_get_bpp(im) ;
-  vl_size data_size = vl_pgm_get_npixels(im) ;
-  vl_bool good = 1 ;
-  size_t c ;
-
-  /* -----------------------------------------------------------------
-   *                                                         read data
-   * -------------------------------------------------------------- */
-
-  /*
-     In RAW mode we read directly an array of bytes or shorts.  In
-     the latter case, however, we must take care of the
-     endianess. PGM files are sorted in big-endian format. If our
-     architecture is little endian, we must do a conversion.
-  */
-  if (im->is_raw) {
-
-    c = fread( data,
-               bpp,
-               data_size,
-               f ) ;
-    good = (c == data_size) ;
-
-    /* adjust endianess */
-#if defined(VL_ARCH_LITTLE_ENDIAN)
-    if (bpp == 2) {
-      vl_uindex i ;
-      vl_uint8 *pt = (vl_uint8*) data ;
-      for(i = 0 ; i < 2 * data_size ; i += 2) {
-        vl_uint8 tmp = pt [i] ;
-        pt [i]   = pt [i+1] ;
-        pt [i+1] = tmp ;
-      }
-    }
-#endif
-  }
-  /*
-     In ASCII mode we read a sequence of decimal numbers separated
-     by whitespaces.
-  */
-  else {
-    vl_uindex i ;
-    int unsigned v ;
-    for(good = 1, i = 0 ;
-        i < data_size && good ;
-        ++i) {
-      c = fscanf(f, " %ud", &v) ;
-      if (bpp == 1) {
-        * ((vl_uint8* )  data + i) = (vl_uint8)  v ;
-      } else {
-        * ((vl_uint16*)  data + i) = (vl_uint16) v ;
-      }
-      good &= c == 1 ;
-    }
-  }
-
-  if(! good ) {
-    return vl_set_last_error(VL_ERR_PGM_INV_DATA, "Invalid PGM data") ;
-  }
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Insert a PGM image into a stream.
- ** @param f output file.
- ** @param im   PGM image meta-data.
- ** @param data image data.
- ** @return error code.
- **/
-
-VL_EXPORT
-int
-vl_pgm_insert(FILE* f, VlPgmImage const *im, void const *data)
-{
-  vl_size bpp = vl_pgm_get_bpp (im) ;
-  vl_size data_size = vl_pgm_get_npixels (im) ;
-  size_t c ;
-
-  /* write preamble */
-  fprintf(f,
-          "P5\n%d\n%d\n%d\n",
-          (signed)im->width,
-          (signed)im->height,
-          (signed)im->max_value) ;
-
-  /* take care of endianness */
-#if defined(VL_ARCH_LITTLE_ENDIAN)
-  if (bpp == 2) {
-    vl_uindex i ;
-    vl_uint8* temp = vl_malloc (2 * data_size) ;
-    memcpy(temp, data, 2 * data_size) ;
-    for(i = 0 ; i < 2 * data_size ; i += 2) {
-      vl_uint8 tmp = temp [i] ;
-      temp [i]   = temp [i+1] ;
-      temp [i+1] = tmp ;
-    }
-    c = fwrite(temp, 2, data_size, f) ;
-    vl_free (temp) ;
-  }
-  else {
-#endif
-    c = fwrite(data, bpp, data_size, f) ;
-#if defined(VL_ARCH_LITTLE_ENDIAN)
-  }
-#endif
-
-  if(c != data_size) {
-    return vl_set_last_error(VL_ERR_PGM_IO, "Error writing PGM data") ;
-  }
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Read a PGM file.
- ** @param name file name.
- ** @param im a pointer to the PGM image structure to fill.
- ** @param data a pointer to the pointer to the allocated buffer.
- ** @return error code.
- **
- ** The function reads a PGM image from file @a name and initializes
- ** the structure @a im and the buffer @a data accordingly.
- **
- ** The ownership of the buffer @a data is transfered to the caller.
- ** @a data should be freed by means of ::vl_free().
- **
- ** @bug Only PGM files with 1 BPP are supported.
- **/
-
-VL_EXPORT
-int vl_pgm_read_new (char const *name, VlPgmImage *im, vl_uint8** data)
-{
-  int err = 0 ;
-  FILE *f = fopen (name, "rb") ;
-
-  if (! f) {
-    return vl_set_last_error(VL_ERR_PGM_IO, "Error opening PGM file `%s' for reading", name) ;
-  }
-
-  err = vl_pgm_extract_head(f, im) ;
-  if (err) {
-    fclose (f) ;
-    return err ;
-  }
-
-  if (vl_pgm_get_bpp(im) > 1) {
-    return vl_set_last_error(VL_ERR_BAD_ARG, "PGM with BPP > 1 not supported") ;
-  }
-
-  *data = vl_malloc (vl_pgm_get_npixels(im) * sizeof(vl_uint8)) ;
-  err = vl_pgm_extract_data(f, im, *data) ;
-
-  if (err) {
-    vl_free (data) ;
-    fclose (f) ;
-  }
-
-  fclose (f) ;
-  return err ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Read floats from a PGM file.
- ** @param name file name.
- ** @param im a pointer to the PGM image structure to fill.
- ** @param data a pointer to the pointer to the allocated buffer.
- ** @return error code.
- **
- ** The function reads a PGM image from file @a name and initializes
- ** the structure @a im and the buffer @a data accordingly. The buffer
- ** @a data is an array of floats in the range [0, 1].
- **
- ** The ownership of the buffer @a data is transfered to the caller.
- ** @a data should be freed by means of ::vl_free().
- **
- ** @bug Only PGM files with 1 BPP are supported.
- **/
-
-VL_EXPORT
-int vl_pgm_read_new_f (char const *name,  VlPgmImage *im, float** data)
-{
-  int err = 0 ;
-  size_t npixels ;
-  vl_uint8 *idata ;
-
-  err = vl_pgm_read_new (name, im, &idata) ;
-  if (err) {
-    return err ;
-  }
-
-  npixels = vl_pgm_get_npixels(im) ;
-  *data = vl_malloc (sizeof(float) * npixels) ;
-  {
-    size_t k ;
-    float scale = 1.0f / (float)im->max_value ;
-    for (k = 0 ; k < npixels ; ++ k) (*data)[k] = scale * idata[k] ;
-  }
-
-  vl_free (idata) ;
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Write bytes to a PGM file.
- ** @param name file name.
- ** @param data data to write.
- ** @param width width of the image.
- ** @param height height of the image.
- ** @return error code.
- **
- ** The function dumps the image @a data to the PGM file of the specified
- ** name. This is an helper function simplifying the usage of
- ** vl_pgm_insert().
- **/
-
-VL_EXPORT
-int vl_pgm_write (char const *name, vl_uint8 const* data, int width, int height)
-{
-  int err = 0 ;
-  VlPgmImage pgm ;
-  FILE *f = fopen (name, "wb") ;
-
-  if (! f) {
-    return vl_set_last_error(VL_ERR_PGM_IO,
-             "Error opening PGM file '%s' for writing", name) ;
-  }
-
-  pgm.width = width ;
-  pgm.height = height ;
-  pgm.is_raw = 1 ;
-  pgm.max_value = 255 ;
-
-  err = vl_pgm_insert (f, &pgm, data) ;
-  fclose (f) ;
-
-  return err ;
-}
-
-/** -------------------------------------------------------------------
- ** @brief Write floats to PGM file
- ** @param name file name.
- ** @param data data to write.
- ** @param width width of the image.
- ** @param height height of the image.
- ** @return error code.
- **
- ** The function dumps the image @a data to the PGM file of the
- ** specified name. The data is re-scaled to fit in the range 0-255.
- ** This is an helper function simplifying the usage of
- ** vl_pgm_insert().
- **/
-
-VL_EXPORT
-int vl_pgm_write_f (char const *name, float const* data, int width, int height)
-{
-  int err = 0 ;
-  int k ;
-  float min = + VL_INFINITY_F ;
-  float max = - VL_INFINITY_F ;
-  float scale ;
-
-  vl_uint8 * buffer = vl_malloc (sizeof(float) * width * height) ;
-
-  for (k = 0 ; k < width * height ; ++k) {
-    min = VL_MIN(min, data [k]) ;
-    max = VL_MAX(max, data [k]) ;
-  }
-
-  scale = 255 / (max - min + VL_EPSILON_F) ;
-
-  for (k = 0 ; k < width * height ; ++k) {
-    buffer [k] = (vl_uint8) ((data [k] - min) * scale) ;
-  }
-
-  err = vl_pgm_write (name, buffer, width, height) ;
-
-  vl_free (buffer) ;
-  return err ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/pgm.h b/opensfm/src/third_party/vlfeat/vl/pgm.h
deleted file mode 100644
index 80b0ef0f1..000000000
--- a/opensfm/src/third_party/vlfeat/vl/pgm.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/** @file pgm.h
- ** @brief Portable graymap format (PGM) parser
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_PGM_H
-#define VL_PGM_H
-
-#include "generic.h"
-#include "mathop.h"
-#include <stdio.h>
-
-/** @name PGM parser error codes
- ** @{ */
-#define VL_ERR_PGM_INV_HEAD  101 /**< Invalid PGM header section. */
-#define VL_ERR_PGM_INV_META  102 /**< Invalid PGM meta section. */
-#define VL_ERR_PGM_INV_DATA  103 /**< Invalid PGM data section.*/
-#define VL_ERR_PGM_IO        104 /**< Generic I/O error. */
-/** @} */
-
-/** @brief PGM image meta data
- **
- ** A PGM image is a 2-D array of pixels of width #width and height
- ** #height. Each pixel is an integer one or two bytes wide, depending
- ** whether #max_value is smaller than 256.
- **/
-
-typedef struct _VlPgmImage
-{
-  vl_size width ;      /**< image width.                     */
-  vl_size height ;     /**< image height.                    */
-  vl_size max_value ;  /**< pixel maximum value (<= 2^16-1). */
-  vl_bool is_raw ;     /**< is RAW format?                   */
-} VlPgmImage ;
-
-/** @name Core operations
- ** @{ */
-VL_EXPORT int vl_pgm_extract_head (FILE *f, VlPgmImage *im) ;
-VL_EXPORT int vl_pgm_extract_data (FILE *f, VlPgmImage const *im, void *data) ;
-VL_EXPORT int vl_pgm_insert (FILE *f,
-                             VlPgmImage const *im,
-                             void const*data ) ;
-VL_EXPORT vl_size vl_pgm_get_npixels (VlPgmImage const *im) ;
-VL_EXPORT vl_size vl_pgm_get_bpp (VlPgmImage const *im) ;
-/** @} */
-
-/** @name Helper functions
- ** @{ */
-VL_EXPORT int vl_pgm_write (char const *name,
-                            vl_uint8 const *data,
-                            int width, int height) ;
-VL_EXPORT int vl_pgm_write_f (char const *name,
-                              float const *data,
-                              int width, int height) ;
-VL_EXPORT int vl_pgm_read_new (char const *name,
-                               VlPgmImage *im,
-                               vl_uint8 **data) ;
-VL_EXPORT int vl_pgm_read_new_f (char const *name,
-                                 VlPgmImage *im,
-                                 float **data) ;
-
-/** @} */
-
-/* VL_PGM_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/qsort-def.h b/opensfm/src/third_party/vlfeat/vl/qsort-def.h
deleted file mode 100644
index 63b61c837..000000000
--- a/opensfm/src/third_party/vlfeat/vl/qsort-def.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/** @file   qsort-def.h
- ** @brief  QSort preprocessor metaprogram
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file qsort-def.h
-
-@section qsort-def-overview Overview
-
-@ref qsort-def.h is a metaprogram to define specialized instances
-of the quick-sort algorithm.
-
-@section qsort-def-usage Usage
-
-@ref qsort-def.h is used to define a specialization of the
-::VL_QSORT_sort function that operates
-on a given type of array. For instance the code
-
-@code
-#define VL_QSORT_type float
-#define VL_QSORT_prefix my_qsort
-#include <vl/qsort-def.h>
-@endcode
-
-defines a function @c my_qsort_sort that operates on an array of floats.
-
-@todo large array compatibility.
-**/
-
-#include "host.h"
-#include <assert.h>
-
-#ifndef VL_QSORT_prefix
-#error "VL_QSORT_prefix must be defined"
-#endif
-
-#ifndef VL_QSORT_array
-#ifndef VL_QSORT_type
-#error "VL_QSORT_type must be defined if VL_QSORT_array is not"
-#endif
-#define VL_QSORT_array VL_QSORT_type*
-#define VL_QSORT_array_const VL_QSORT_type const*
-#endif
-
-#ifdef __DOXYGEN__
-#define VL_QSORT_prefix  QSortPrefix       /**< Prefix of the qsort functions */
-#define VL_QSORT_type    QSortType         /**< Data type of the qsort elements */
-#define VL_QSORT_array   QSortType*        /**< Data type of the qsort container */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_QSORT_cmp) || defined(__DOXYGEN__)
-#define VL_QSORT_cmp VL_XCAT(VL_QSORT_prefix, _cmp)
-
-/** @brief Compare two array elements
- ** @param array qsort array.
- ** @param indexA index of the first element @c A to compare.
- ** @param indexB index of the second element @c B to comapre.
- ** @return a negative number if @c A<B, 0 if @c A==B, and
- ** a positive number if if @c A>B.
- **/
-
-VL_INLINE VL_QSORT_type
-VL_QSORT_cmp
-(VL_QSORT_array_const array,
- vl_uindex indexA,
- vl_uindex indexB)
-{
-  return array[indexA] - array[indexB] ;
-}
-
-/* VL_QSORT_cmp */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_QSORT_swap) || defined(__DOXYGEN__)
-#define VL_QSORT_swap VL_XCAT(VL_QSORT_prefix, _swap)
-
-/** @brief Swap two array elements
- ** @param array qsort array.
- ** @param indexA index of the first element to swap.
- ** @param indexB index of the second element to swap.
- **
- ** The function swaps the two elements @a a and @ b. The function
- ** uses a temporary element of type ::VL_QSORT_type
- ** and the copy operator @c =.
- **/
-
-VL_INLINE void
-VL_QSORT_swap
-(VL_QSORT_array array,
- vl_uindex indexA,
- vl_uindex indexB)
-{
-  VL_QSORT_type t = array [indexA] ;
-  array [indexA] = array [indexB] ;
-  array [indexB] = t ;
-}
-
-/* VL_QSORT_swap */
-#endif
-
-/* ---------------------------------------------------------------- */
-#if ! defined(VL_QSORT_sort_recursive) || defined(__DOXYGEN__)
-#define VL_QSORT_sort_recursive VL_XCAT(VL_QSORT_prefix, _sort_recursive)
-
-/** @brief Sort portion of an array using quicksort
- ** @param array (in/out) pointer to the array.
- ** @param begin first element of the array portion.
- ** @param end last element of the array portion.
- **
- ** The function sorts the array using quick-sort. Note that
- ** @c begin must be not larger than @c end.
- **/
-
-VL_INLINE void
-VL_QSORT_sort_recursive
-(VL_QSORT_array array, vl_uindex begin, vl_uindex end)
-{
-  vl_uindex pivot = (end + begin) / 2 ;
-  vl_uindex lowPart, i ;
-
-  assert (begin <= end) ;
-
-  /* swap pivot with last */
-  VL_QSORT_swap (array, pivot, end) ;
-  pivot = end ;
-
-  /*
-   Now scan from left to right, moving all element smaller
-   or equal than the pivot to the low part
-   array[0], array[1], ..., array[lowPart - 1].
-   */
-  lowPart = begin ;
-  for (i = begin; i < end ; ++i) { /* one less */
-    if (VL_QSORT_cmp (array, i, pivot) <= 0) {
-      /* array[i] must be moved into the low part */
-      VL_QSORT_swap (array, lowPart, i) ;
-      lowPart ++ ;
-    }
-  }
-
-  /* the pivot should also go into the low part */
-  VL_QSORT_swap (array, lowPart, pivot) ;
-  pivot = lowPart ;
-
-  /* do recursion */
-  if (pivot > begin) {
-    /* note that pivot-1 stays non-negative */
-    VL_QSORT_sort_recursive (array, begin, pivot - 1) ;
-  }
-  if (pivot < end) {
-    VL_QSORT_sort_recursive (array, pivot + 1, end) ;
-  }
-}
-
-/* VL_QSORT_sort_recursive */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_QSORT_sort) || defined(__DOXYGEN__)
-#define VL_QSORT_sort VL_XCAT(VL_QSORT_prefix, _sort)
-
-/** @brief Sort array using quicksort
- ** @param array (in/out) pointer to the array.
- ** @param size size of the array.
- **
- ** The function sorts the array using quick-sort.
- **/
-
-VL_INLINE void
-VL_QSORT_sort
-(VL_QSORT_array array, vl_size size)
-{
-  assert (size >= 1) ;
-  VL_QSORT_sort_recursive (array, 0, size - 1) ;
-}
-
-/* VL_QSORT_qsort */
-#endif
-
-#undef VL_QSORT_prefix
-#undef VL_QSORT_swap
-#undef VL_QSORT_sort
-#undef VL_QSORT_sort_recursive
-#undef VL_QSORT_type
-#undef VL_QSORT_array
-#undef VL_QSORT_cmp
-
diff --git a/opensfm/src/third_party/vlfeat/vl/quickshift.c b/opensfm/src/third_party/vlfeat/vl/quickshift.c
deleted file mode 100644
index 802dbf25c..000000000
--- a/opensfm/src/third_party/vlfeat/vl/quickshift.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/** @file quickshift.c
- ** @brief Quick shift - Definition
- ** @author Brian Fulkerson
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page quickshift Quick shift image segmentation
-@author Brian Fulkerson
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref quickshift.h implements an image segmentation algorithm based on
-the quick shift clustering algorithm @cite{vedaldi08quick}.
-
-- @ref quickshift-intro
-- @ref quickshift-usage
-- @ref quickshift-tech
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section quickshift-intro Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Quick shift @cite{vedaldi08quick} is a fast mode seeking algorithm,
-similar to mean shift. The algorithm segments an RGB image (or any
-image with more than one channel) by identifying clusters of pixels in
-the joint spatial and color dimensions. Segments are local
-(superpixels) and can be used as a basis for further processing.
-
-Given an image, the algorithm calculates a forest of pixels whose
-branches are labeled with a distance value
-(::vl_quickshift_get_parents, ::vl_quickshift_get_dists). This
-specifies a hierarchical segmentation of the image, with segments
-corresponding to subtrees. Useful superpixels can be identified by
-cutting the branches whose distance label is above a given threshold
-(the threshold can be either fixed by hand, or determined by cross
-validation).
-
-Parameter influencing the algorithm are:
-
-- <b>Kernel size.</b> The pixel density and its modes are estimated by
-using a Parzen window estimator with a Gaussian kernel of the
-specified size (::vl_quickshift_set_kernel_size). The larger the size,
-the larger the neighborhoods of pixels considered.
-- <b>Maximum distance.</b> This (::vl_quickshift_set_max_dist) is the
-maximum distance between two pixels that the algorithm considers when
-building the forest. In principle, it can be infinity (so that a tree
-is returned), but in practice it is much faster to consider only
-relatively small distances (the maximum distance can be set to a small
-multiple of the kernel size).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section quickshift-usage Usage
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-- Create a new quick shift object (::vl_quickshift_new). The object
-  can be reused for multiple images of the same size.
-- Configure quick shift by setting the kernel size
-  (::vl_quickshift_set_kernel_size) and the maximum gap
-  (::vl_quickshift_set_max_dist). The latter is in principle not
-  necessary, but useful to speedup processing.
-- Process an image (::vl_quickshift_process).
-- Retrieve the parents (::vl_quickshift_get_parents) and the distances
-  (::vl_quickshift_get_dists). These can be used to segment
-  the image in superpixels.
-- Delete the quick shift object (::vl_quickshift_delete).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section quickshift-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-For each pixel <em>(x,y)</em>, quick shift regards @f$ (x,y,I(x,y))
-@f$ as a sample from a <em>d + 2</em> dimensional vector space. It
-then calculates the Parzen density estimate (with a Gaussian kernel of
-standard deviation @f$ \sigma @f$)
-
-@f[
-E(x,y) = P(x,y,I(x,y)) = \sum_{x'y'}
-\frac{1}{(2\pi\sigma)^{d+2}}
-\exp
-\left(
--\frac{1}{2\sigma^2}
-\left[
-\begin{array}{c}
-x - x' \\
-y - y' \\
-I(x,y) - I(x',y') \\
-\end{array}
-\right]
-\right)
-@f]
-
-Then quick shift construct a tree connecting each image pixel to its
-nearest neighbor which has greater density value. Formally, write @f$
-(x',y') >_P (x,y) @f$ if, and only if,
-
-@f[
-  P(x',y',I(x',y')) > P(x,y,I(x,y))}.
-@f]
-
-Each pixel <em>(x, y)</em> is connected to the closest higher density
-pixel <em>parent(x, y)</em> that achieves the minimum distance in
-
-@f[
- \mathrm{dist}(x,y) =
- \mathrm{min}_{(x',y') > P(x,y)}
-\left(
-(x - x')^2 +
-(y - y')^2 +
-\| I(x,y) - I(x',y') \|_2^2
-\right).
-@f]
-
-**/
-
-#include "quickshift.h"
-#include "mathop.h"
-#include <string.h>
-#include <math.h>
-#include <stdio.h>
-
-/** -----------------------------------------------------------------
- ** @internal
- ** @brief Computes the accumulated channel L2 distance between
- **        i,j + the distance between i,j
- **
- ** @param I    input image buffer
- ** @param N1   size of the first dimension of the image
- ** @param N2   size of the second dimension of the image
- ** @param K    number of channels
- ** @param i1   first dimension index of the first pixel to compare
- ** @param i2   second dimension of the first pixel
- ** @param j1   index of the second pixel to compare
- ** @param j2   second dimension of the second pixel
- **
- ** Takes the L2 distance between the values in I at pixel i and j,
- ** accumulating along K channels and adding in the distance
- ** between i,j in the image.
- **
- ** @return the distance as described above
- **/
-
-VL_INLINE
-vl_qs_type
-vl_quickshift_distance(vl_qs_type const * I,
-         int N1, int N2, int K,
-         int i1, int i2,
-         int j1, int j2)
-{
-  vl_qs_type dist = 0 ;
-  int d1 = j1 - i1 ;
-  int d2 = j2 - i2 ;
-  int k ;
-  dist += d1*d1 + d2*d2 ;
-  /* For k = 0...K-1, d+= L2 distance between I(i1,i2,k) and
-   * I(j1,j2,k) */
-  for (k = 0 ; k < K ; ++k) {
-    vl_qs_type d =
-      I [i1 + N1 * i2 + (N1*N2) * k] -
-      I [j1 + N1 * j2 + (N1*N2) * k] ;
-    dist += d*d ;
-  }
-  return dist ;
-}
-
-/** -----------------------------------------------------------------
- ** @internal
- ** @brief Computes the accumulated channel inner product between i,j + the
- **        distance between i,j
- **
- ** @param I    input image buffer
- ** @param N1   size of the first dimension of the image
- ** @param N2   size of the second dimension of the image
- ** @param K    number of channels
- ** @param i1   first dimension index of the first pixel to compare
- ** @param i2   second dimension of the first pixel
- ** @param j1   index of the second pixel to compare
- ** @param j2   second dimension of the second pixel
- **
- ** Takes the channel-wise inner product between the values in I at
- ** pixel i and j, accumulating along K channels and adding in the
- ** inner product between i,j in the image.
- **
- ** @return the inner product as described above
- **/
-
-VL_INLINE
-vl_qs_type
-vl_quickshift_inner(vl_qs_type const * I,
-      int N1, int N2, int K,
-      int i1, int i2,
-      int j1, int j2)
-{
-  vl_qs_type ker = 0 ;
-  int k ;
-  ker += i1*j1 + i2*j2 ;
-  for (k = 0 ; k < K ; ++k) {
-    ker +=
-      I [i1 + N1 * i2 + (N1*N2) * k] *
-      I [j1 + N1 * j2 + (N1*N2) * k] ;
-  }
-  return ker ;
-}
-
-/** -----------------------------------------------------------------
- ** @brief Create a quick shift object
- ** @param image the image.
- ** @param height the height (number of rows) of the image.
- ** @param width the width (number of columns) of the image.
- ** @param channels the number of channels of the image.
- ** @return new quick shift object.
- **
- ** The @c image is an array of ::vl_qs_type values with three
- ** dimensions (respectively @c widht, @c height, and @c
- ** channels). Typically, a color (e.g, RGB) image has three
- ** channels. The linear index of a pixel is computed with:
- ** @c channels * @c width* @c height + @c row + @c height * @c col.
- **/
-
-VL_EXPORT
-VlQS *
-vl_quickshift_new(vl_qs_type const * image, int height, int width,
-                       int channels)
-{
-  VlQS * q = vl_malloc(sizeof(VlQS));
-
-  q->image    = (vl_qs_type *)image;
-  q->height   = height;
-  q->width    = width;
-  q->channels = channels;
-
-  q->medoid   = VL_FALSE;
-  q->tau      = VL_MAX(height,width)/50;
-  q->sigma    = VL_MAX(2, q->tau/3);
-
-  q->dists    = vl_calloc(height*width, sizeof(vl_qs_type));
-  q->parents  = vl_calloc(height*width, sizeof(int));
-  q->density  = vl_calloc(height*width, sizeof(vl_qs_type)) ;
-
-  return q;
-}
-
-/** -----------------------------------------------------------------
- ** @brief Create a quick shift objet
- ** @param q quick shift object.
- **/
-
-VL_EXPORT
-void vl_quickshift_process(VlQS * q)
-{
-  vl_qs_type const *I = q->image;
-  int        *parents = q->parents;
-  vl_qs_type *E = q->density;
-  vl_qs_type *dists = q->dists;
-  vl_qs_type *M = 0, *n = 0 ;
-  vl_qs_type sigma = q->sigma ;
-  vl_qs_type tau = q->tau;
-  vl_qs_type tau2 = tau*tau;
-
-  int K = q->channels, d;
-  int N1 = q->height, N2 = q->width;
-  int i1,i2, j1,j2, R, tR;
-
-  d = 2 + K ; /* Total dimensions include spatial component (x,y) */
-
-  if (q->medoid) { /* n and M are only used in mediod shift */
-    M = (vl_qs_type *) vl_calloc(N1*N2*d, sizeof(vl_qs_type)) ;
-    n = (vl_qs_type *) vl_calloc(N1*N2,   sizeof(vl_qs_type)) ;
-  }
-
-  R = (int) ceil (3 * sigma) ;
-  tR = (int) ceil (tau) ;
-
-  /* -----------------------------------------------------------------
-   *                                                                 n
-   * -------------------------------------------------------------- */
-
-  /* If we are doing medoid shift, initialize n to the inner product of the
-   * image with itself
-   */
-  if (n) {
-    for (i2 = 0 ; i2 < N2 ; ++ i2) {
-      for (i1 = 0 ; i1 < N1 ; ++ i1) {
-        n [i1 + N1 * i2] = vl_quickshift_inner(I,N1,N2,K,
-                                               i1,i2,
-                                               i1,i2) ;
-      }
-    }
-  }
-
-  /* -----------------------------------------------------------------
-   *                                                 E = - [oN'*F]', M
-   * -------------------------------------------------------------- */
-
-  /*
-     D_ij = d(x_i,x_j)
-     E_ij = exp(- .5 * D_ij / sigma^2) ;
-     F_ij = - E_ij
-     E_i  = sum_j E_ij
-     M_di = sum_j X_j F_ij
-
-     E is the parzen window estimate of the density
-     0 = dissimilar to everything, windowsize = identical
-  */
-
-  for (i2 = 0 ; i2 < N2 ; ++ i2) {
-    for (i1 = 0 ; i1 < N1 ; ++ i1) {
-
-      int j1min = VL_MAX(i1 - R, 0   ) ;
-      int j1max = VL_MIN(i1 + R, N1-1) ;
-      int j2min = VL_MAX(i2 - R, 0   ) ;
-      int j2max = VL_MIN(i2 + R, N2-1) ;
-
-      /* For each pixel in the window compute the distance between it and the
-       * source pixel */
-      for (j2 = j2min ; j2 <= j2max ; ++ j2) {
-        for (j1 = j1min ; j1 <= j1max ; ++ j1) {
-          vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
-          /* Make distance a similarity */
-          vl_qs_type Fij = - exp(- Dij / (2*sigma*sigma)) ;
-
-          /* E is E_i above */
-          E [i1 + N1 * i2] -= Fij ;
-
-          if (M) {
-            /* Accumulate votes for the median */
-            int k ;
-            M [i1 + N1*i2 + (N1*N2) * 0] += j1 * Fij ;
-            M [i1 + N1*i2 + (N1*N2) * 1] += j2 * Fij ;
-            for (k = 0 ; k < K ; ++k) {
-              M [i1 + N1*i2 + (N1*N2) * (k+2)] +=
-                I [j1 + N1*j2 + (N1*N2) * k] * Fij ;
-            }
-          }
-
-        } /* j1 */
-      } /* j2 */
-
-    }  /* i1 */
-  } /* i2 */
-
-  /* -----------------------------------------------------------------
-   *                                               Find best neighbors
-   * -------------------------------------------------------------- */
-
-  if (q->medoid) {
-
-    /*
-       Qij = - nj Ei - 2 sum_k Gjk Mik
-       n is I.^2
-    */
-
-    /* medoid shift */
-    for (i2 = 0 ; i2 < N2 ; ++i2) {
-      for (i1 = 0 ; i1 < N1 ; ++i1) {
-
-        vl_qs_type sc_best = 0  ;
-        /* j1/j2 best are the best indicies for each i */
-        vl_qs_type j1_best = i1 ;
-        vl_qs_type j2_best = i2 ;
-
-        int j1min = VL_MAX(i1 - R, 0   ) ;
-        int j1max = VL_MIN(i1 + R, N1-1) ;
-        int j2min = VL_MAX(i2 - R, 0   ) ;
-        int j2max = VL_MIN(i2 + R, N2-1) ;
-
-        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
-          for (j1 = j1min ; j1 <= j1max ; ++ j1) {
-
-            vl_qs_type Qij = - n [j1 + j2 * N1] * E [i1 + i2 * N1] ;
-            int k ;
-
-            Qij -= 2 * j1 * M [i1 + i2 * N1 + (N1*N2) * 0] ;
-            Qij -= 2 * j2 * M [i1 + i2 * N1 + (N1*N2) * 1] ;
-            for (k = 0 ; k < K ; ++k) {
-              Qij -= 2 *
-                I [j1 + j2 * N1 + (N1*N2) * k] *
-                M [i1 + i2 * N1 + (N1*N2) * (k + 2)] ;
-            }
-
-            if (Qij > sc_best) {
-              sc_best = Qij ;
-              j1_best = j1 ;
-              j2_best = j2 ;
-            }
-          }
-        }
-
-        /* parents_i is the linear index of j which is the best pair
-         * dists_i is the score of the best match
-         */
-        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
-        dists[i1 + N1 * i2] = sc_best ;
-      }
-    }
-
-  } else {
-
-    /* Quickshift assigns each i to the closest j which has an increase in the
-     * density (E). If there is no j s.t. Ej > Ei, then dists_i == inf (a root
-     * node in one of the trees of merges).
-     */
-    for (i2 = 0 ; i2 < N2 ; ++i2) {
-      for (i1 = 0 ; i1 < N1 ; ++i1) {
-
-        vl_qs_type E0 = E [i1 + N1 * i2] ;
-        vl_qs_type d_best = VL_QS_INF ;
-        vl_qs_type j1_best = i1   ;
-        vl_qs_type j2_best = i2   ;
-
-        int j1min = VL_MAX(i1 - tR, 0   ) ;
-        int j1max = VL_MIN(i1 + tR, N1-1) ;
-        int j2min = VL_MAX(i2 - tR, 0   ) ;
-        int j2max = VL_MIN(i2 + tR, N2-1) ;
-
-        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
-          for (j1 = j1min ; j1 <= j1max ; ++ j1) {
-            if (E [j1 + N1 * j2] > E0) {
-              vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
-              if (Dij <= tau2 && Dij < d_best) {
-                d_best = Dij ;
-                j1_best = j1 ;
-                j2_best = j2 ;
-              }
-            }
-          }
-        }
-
-        /* parents is the index of the best pair */
-        /* dists_i is the minimal distance, inf implies no Ej > Ei within
-         * distance tau from the point */
-        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
-        dists[i1 + N1 * i2] = sqrt(d_best) ;
-      }
-    }
-  }
-
-  if (M) vl_free(M) ;
-  if (n) vl_free(n) ;
-}
-
-/** -----------------------------------------------------------------
- ** @brief Delete quick shift object
- ** @param q quick shift object.
- **/
-
-void vl_quickshift_delete(VlQS * q)
-{
-  if (q) {
-    if (q->parents) vl_free(q->parents);
-    if (q->dists)   vl_free(q->dists);
-    if (q->density) vl_free(q->density);
-
-    vl_free(q);
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/quickshift.h b/opensfm/src/third_party/vlfeat/vl/quickshift.h
deleted file mode 100644
index d7bec8bf6..000000000
--- a/opensfm/src/third_party/vlfeat/vl/quickshift.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/** @file quickshift.h
- ** @brief Quick shift (@ref quickshift)
- ** @author Andrea Vedaldi
- ** @author Brian Fulkerson
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_QUICKSHIFT_H
-#define VL_QUICKSHIFT_H
-
-#include "generic.h"
-#include "mathop.h"
-
-/** @brief quick shift datatype */
-typedef double vl_qs_type ;
-
-/** @brief quick shift infinity constant */
-#define VL_QS_INF VL_INFINITY_D /* Change to _F for float math */
-
-/** ------------------------------------------------------------------
- ** @brief quick shift results
- **
- ** This implements quick shift mode seeking.
- **/
-
-typedef struct _VlQS
-{
-  vl_qs_type *image ;   /**< height x width x channels feature image */
-  int height;           /**< height of the image */
-  int width;            /**< width of the image */
-  int channels;         /**< number of channels in the image */
-
-  vl_bool medoid;
-  vl_qs_type sigma;
-  vl_qs_type tau;
-
-  int *parents ;
-  vl_qs_type *dists ;
-  vl_qs_type *density ;
-} VlQS ;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT
-VlQS*  vl_quickshift_new (vl_qs_type const * im, int height, int width,
-                          int channels);
-
-VL_EXPORT
-void   vl_quickshift_delete (VlQS *q) ;
-/** @} */
-
-/** @name Process data
- ** @{
- **/
-
-VL_EXPORT
-void   vl_quickshift_process (VlQS *q) ;
-
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{
- **/
-VL_INLINE vl_qs_type    vl_quickshift_get_max_dist      (VlQS const *q) ;
-VL_INLINE vl_qs_type    vl_quickshift_get_kernel_size    (VlQS const *q) ;
-VL_INLINE vl_bool       vl_quickshift_get_medoid   (VlQS const *q) ;
-
-VL_INLINE int *        vl_quickshift_get_parents  (VlQS const *q) ;
-VL_INLINE vl_qs_type * vl_quickshift_get_dists    (VlQS const *q) ;
-VL_INLINE vl_qs_type * vl_quickshift_get_density  (VlQS const *q) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_INLINE void vl_quickshift_set_max_dist    (VlQS *f, vl_qs_type tau) ;
-VL_INLINE void vl_quickshift_set_kernel_size  (VlQS *f, vl_qs_type sigma) ;
-VL_INLINE void vl_quickshift_set_medoid (VlQS *f, vl_bool medoid) ;
-/** @} */
-
-/* -------------------------------------------------------------------
- *                                     Inline functions implementation
- * ---------------------------------------------------------------- */
-
-/** ------------------------------------------------------------------
- ** @brief Get tau.
- ** @param q quick shift object.
- ** @return the maximum distance in the feature space between nodes in the
- **         quick shift tree.
- **/
-
-VL_INLINE vl_qs_type
-vl_quickshift_get_max_dist (VlQS const *q)
-{
-  return q->tau ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get sigma.
- ** @param q quick shift object.
- ** @return the standard deviation of the kernel used in the Parzen density
- **         estimate.
- **/
-
-VL_INLINE vl_qs_type
-vl_quickshift_get_kernel_size (VlQS const *q)
-{
-  return q->sigma ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get medoid.
- ** @param q quick Shift object.
- ** @return @c true if medoid shift is used instead of quick shift.
- **/
-
-VL_INLINE vl_bool
-vl_quickshift_get_medoid (VlQS const *q)
-{
-  return q->medoid ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get parents.
- ** @param q quick shift object.
- ** @return a @c height x @c width matrix where each element contains the
- **         linear index of its parent node. The node is a root if its
- **         value is its own linear index.
- **/
-
-VL_INLINE int *
-vl_quickshift_get_parents (VlQS const *q)
-{
-  return q->parents ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get dists.
- ** @param q quick shift object.
- ** @return for each pixel, the distance in feature space to the pixel
- **         that is its parent in the quick shift tree. The distance is
- **         set to 'inf' if the pixel is a root node.
- **/
-
-VL_INLINE vl_qs_type *
-vl_quickshift_get_dists (VlQS const *q)
-{
-  return q->dists ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get density.
- ** @param q quick shift object.
- ** @return the estimate of the density at each pixel.
- **/
-
-VL_INLINE vl_qs_type *
-vl_quickshift_get_density (VlQS const *q)
-{
-  return q->density ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set sigma
- ** @param q quick shift object.
- ** @param sigma standard deviation of the kernel used in the Parzen density
- **        estimate.
- **/
-
-VL_INLINE void
-vl_quickshift_set_kernel_size (VlQS *q, vl_qs_type sigma)
-{
-  q -> sigma = sigma ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set max distance
- ** @param q quick shift object.
- ** @param tau the maximum distance in the feature space between nodes in the
- **            quick shift tree.
- **/
-
-VL_INLINE void
-vl_quickshift_set_max_dist (VlQS *q, vl_qs_type tau)
-{
-  q -> tau = tau ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set medoid
- ** @param q quick shift object.
- ** @param medoid @c true to use kernelized medoid shift, @c false (default) uses
- **        quick shift.
- **/
-
-VL_INLINE void
-vl_quickshift_set_medoid (VlQS *q, vl_bool medoid)
-{
-  q -> medoid = medoid ;
-}
-
-
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/random.c b/opensfm/src/third_party/vlfeat/vl/random.c
deleted file mode 100644
index 107ee1fb7..000000000
--- a/opensfm/src/third_party/vlfeat/vl/random.c
+++ /dev/null
@@ -1,266 +0,0 @@
-/** @file random.c
- ** @brief Random number generator - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ------------------------------------------------------------- -->
-@page random Random number generator
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-The module @ref random.h implements random number generation in
-VLFeat.  The generator is based on the popular Mersenne Twister
-algorithm @cite{matsumoto98mersenne} (which is the same as MATLAB
-random generator from MATLAB version 7.4 onwards).
-
-<!-- ------------------------------------------------------------- -->
-@section random-starting Getting started
-<!-- ------------------------------------------------------------- -->
-
-In VLFeat, a random number generator is implemented by an object of
-type ::VlRand. The simplest way to obtain such an object is to get the
-default random generator by
-
-@code
-VlRand * rand = vl_get_rand() ;
-vl_int32 signedRandomInteger = vl_rand_int31(rand) ;
-@code
-
-Note that there is one such generator per thread (see
-::vl_get_rand). If more control is desired, a new ::VlRand object can
-be easily created.  The object is lightweight, designed to be
-allocated on the stack:
-
-@code
-VlRand rand ;
-vl_rand_init (&rand) ;
-@endcode
-
-The generator can be seeded by ::vl_rand_seed and ::vl_rand_seed_by_array.
-For instance:
-
-@code
-vl_rand_seed (&rand, clock()) ;
-@endcode
-
-The generator can be used to obtain random quantities of
-various types:
-
-- ::vl_rand_int31, ::vl_rand_uint32 for 32-bit random integers;
-- ::vl_rand_real1 for a double in [0,1];
-- ::vl_rand_real2 for a double in [0,1);
-- ::vl_rand_real3 for a double in (0,1);
-- ::vl_rand_res53 for a double in [0,1) with high resolution.
-
-There is no need to explicitly destroy a ::VlRand instance.
-
-**/
-
-#include "random.h"
-
-/*
-A C-program for MT19937, with initialization improved 2002/1/26.
-Coded by Takuji Nishimura and Makoto Matsumoto.
-
-Before using, initialize the state by using init_genrand(seed)
-or init_by_array(init_key, keySize).
-
-Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-2. 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.
-
-3. The names of its contributors may not be used to endorse or promote
-products derived from this software without specific prior written
-permission.
-
-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.
-
-
-Any feedback is very welcome.
-http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
-email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
-*/
-
-#include <stdio.h>
-#include <string.h>
-
-/* Period parameters */
-#define N 624
-#define M 397
-#define MATRIX_A VL_UINT32_C(0x9908b0df)   /* constant vector a */
-#define UPPER_MASK VL_UINT32_C(0x80000000) /* most asignificant w-r bits */
-#define LOWER_MASK VL_UINT32_C(0x7fffffff) /* least significant r bits */
-
-/* initializes mt[N] with a seed */
-
-/** @brief Initialise random number generator
- ** @param self number generator.
- **/
-
-void
-vl_rand_init (VlRand * self)
-{
-  memset (self->mt, 0, sizeof(self->mt[0]) * N) ;
-  self->mti = N + 1 ;
-}
-
-/** @brief Seed the state of the random number generator
- ** @param self random number generator.
- ** @param s seed.
- **/
-
-void
-vl_rand_seed (VlRand * self, vl_uint32 s)
-{
-#define mti self->mti
-#define mt self->mt
-  mt[0]= s & VL_UINT32_C(0xffffffff);
-  for (mti=1; mti<N; mti++) {
-    mt[mti] =
-      (VL_UINT32_C(1812433253) * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
-    /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
-    /* In the previous versions, MSBs of the seed affect   */
-    /* only MSBs of the array mt[].                        */
-    /* 2002/01/09 modified by Makoto Matsumoto             */
-    mt[mti] &= VL_UINT32_C(0xffffffff);
-    /* for >32 bit machines */
-  }
-#undef mti
-#undef mt
-}
-
-/** @brief Seed the state of the random number generator by an array
- ** @param self     random number generator.
- ** @param key      array of numbers.
- ** @param keySize  length of the array.
- **/
-
-void
-vl_rand_seed_by_array (VlRand * self, vl_uint32 const key [], vl_size keySize)
-{
-#define mti self->mti
-#define mt self->mt
-  int i, j, k;
-  vl_rand_seed (self, VL_UINT32_C(19650218));
-  i=1; j=0;
-  k = (N > keySize ? N : (int)keySize);
-  for (; k; k--) {
-    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1664525)))
-      + key[j] + j; /* non linear */
-    mt[i] &= VL_UINT32_C(0xffffffff); /* for WORDSIZE > 32 machines */
-    i++; j++;
-    if (i>=N) { mt[0] = mt[N-1]; i=1; }
-    if (j>=(signed)keySize) j=0;
-  }
-  for (k=N-1; k; k--) {
-    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1566083941)))
-      - i; /* non linear */
-    mt[i] &= VL_UINT32_C(0xffffffff) ; /* for WORDSIZE > 32 machines */
-    i++;
-    if (i>=N) { mt[0] = mt[N-1]; i=1; }
-  }
-
-  mt[0] = VL_UINT32_C(0x80000000); /* MSB is 1; assuring non-zero initial array */
-#undef mti
-#undef mt
-}
-
-/** @brief Randomly permute and array of indexes.
- ** @param self random number generator.
- ** @param array array of indexes.
- ** @param size number of element in the array.
- **
- ** The function uses *Algorithm P*, also known as *Knuth shuffle*.
- **/
-
-void
-vl_rand_permute_indexes (VlRand *self, vl_index *array, vl_size size)
-{
-  vl_index i, j, tmp;
-  for (i = size - 1 ; i > 0; i--) {
-    /* Pick a random index j in the range 0, i + 1 and swap it with i */
-    j = (vl_int) vl_rand_uindex (self, i + 1) ;
-    tmp = array[i] ; array[i] = array[j] ; array[j] = tmp ;
-  }
-}
-
-
-/** @brief Generate a random UINT32
- ** @param self random number generator.
- ** @return a random number in [0, 0xffffffff].
- **/
-
-vl_uint32
-vl_rand_uint32 (VlRand * self)
-{
-  vl_uint32 y;
-  static vl_uint32 mag01[2]={VL_UINT32_C(0x0), MATRIX_A};
-  /* mag01[x] = x * MATRIX_A  for x=0,1 */
-
-#define mti self->mti
-#define mt self->mt
-
-  if (mti >= N) { /* generate N words at one time */
-    int kk;
-
-    if (mti == N+1)   /* if init_genrand() has not been called, */
-      vl_rand_seed (self, VL_UINT32_C(5489)); /* a default initial seed is used */
-
-    for (kk=0;kk<N-M;kk++) {
-      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
-      mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
-    }
-    for (;kk<N-1;kk++) {
-      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
-      mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
-    }
-    y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
-    mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
-
-    mti = 0;
-  }
-
-  y = mt[mti++];
-
-  /* Tempering */
-  y ^= (y >> 11);
-  y ^= (y << 7) & VL_UINT32_C(0x9d2c5680);
-  y ^= (y << 15) & VL_UINT32_C(0xefc60000);
-  y ^= (y >> 18);
-
-  return (vl_uint32)y;
-
-#undef mti
-#undef mt
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/random.h b/opensfm/src/third_party/vlfeat/vl/random.h
deleted file mode 100644
index f464fc47b..000000000
--- a/opensfm/src/third_party/vlfeat/vl/random.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/** @file random.h
- ** @brief Random number generator (@ref random)
- ** @author Andrea Vedaldi
- ** @see @ref random
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_RANDOM_H
-#define VL_RANDOM_H
-
-#include "host.h"
-
-/** @brief Random numbber generator state */
-typedef struct _VlRand {
-  vl_uint32 mt [624] ;
-  vl_uint32 mti ;
-} VlRand ;
-
-/** @name Setting and reading the state
- **
- ** @{ */
-VL_EXPORT void vl_rand_init (VlRand * self) ;
-VL_EXPORT void vl_rand_seed (VlRand * self, vl_uint32 s) ;
-VL_EXPORT void vl_rand_seed_by_array (VlRand * self,
-                                      vl_uint32 const key [],
-                                      vl_size keySize) ;
-/** @} */
-
-/** @name Generate random numbers
- **
- ** @{ */
-VL_INLINE vl_uint64 vl_rand_uint64 (VlRand * self) ;
-VL_INLINE vl_int64  vl_rand_int63  (VlRand * self) ;
-VL_EXPORT vl_uint32 vl_rand_uint32 (VlRand * self) ;
-VL_INLINE vl_int32  vl_rand_int31  (VlRand * self) ;
-VL_INLINE double    vl_rand_real1  (VlRand * self) ;
-VL_INLINE double    vl_rand_real2  (VlRand * self) ;
-VL_INLINE double    vl_rand_real3  (VlRand * self) ;
-VL_INLINE double    vl_rand_res53  (VlRand * self) ;
-VL_INLINE vl_uindex vl_rand_uindex (VlRand * self, vl_uindex range) ;
-/** @} */
-
-VL_EXPORT void vl_rand_permute_indexes (VlRand * self, vl_index* array, vl_size size) ;
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Generate a random index in a given range
- ** @param self random number generator.
- ** @param range range.
- ** @return an index sampled uniformly at random in the interval [0, @c range - 1]
- **
- ** @remark Currently, this function uses a simple algorithm that
- ** may yield slightly biased samples if @c range is not a power of
- ** two.
- **/
-
-VL_INLINE vl_uindex
-vl_rand_uindex (VlRand * self, vl_uindex range)
-{
-  if (range <= 0xffffffff) {
-    /* 32-bit version */
-    return (vl_rand_uint32 (self) % (vl_uint32)range) ;
-  } else {
-    /* 64-bit version */
-    return (vl_rand_uint64 (self) % range) ;
-  }
-}
-
-/** @brief Generate a random UINT64
- ** @param self random number generator.
- ** @return a random number in [0, 0xffffffffffffffff].
- **/
-
-VL_INLINE vl_uint64
-vl_rand_uint64 (VlRand * self)
-{
-  vl_uint64 a = vl_rand_uint32 (self) ;
-  vl_uint64 b = vl_rand_uint32 (self) ;
-  return (a << 32) | b ;
-}
-
-/** @brief Generate a random INT63
- ** @param self random number generator.
- ** @return a random number in [0, 0x7fffffffffffffff].
- **/
-
-VL_INLINE vl_int64
-vl_rand_int63 (VlRand * self)
-{
-  return (vl_int64)(vl_rand_uint64 (self) >> 1) ;
-}
-
-/** @brief Generate a random INT31
- ** @param self random number generator.
- ** @return a random number in [0, 0x7fffffff].
- **/
-
-VL_INLINE vl_int32
-vl_rand_int31 (VlRand * self)
-{
-  return (vl_int32)(vl_rand_uint32 (self) >> 1) ;
-}
-
-/** @brief Generate a random number in [0,1]
- ** @param self random number generator.
- ** @return a random number.
- **/
-
-VL_INLINE double
-vl_rand_real1 (VlRand * self)
-{
-  return vl_rand_uint32(self)*(1.0/4294967295.0);
-  /* divided by 2^32-1 */
-}
-
-/** @brief Generate a random number in [0,1)
- ** @param self random number generator.
- ** @return a random number.
- **/
-
-VL_INLINE double
-vl_rand_real2 (VlRand * self)
-{
-  return vl_rand_uint32(self)*(1.0/4294967296.0);
-  /* divided by 2^32 */
-}
-
-/** @brief Generate a random number in (0,1)
- ** @param self random number generator.
- ** @return a random number.
- **/
-
-VL_INLINE double
-vl_rand_real3 (VlRand * self)
-{
-  return (((double)vl_rand_uint32(self)) + 0.5)*(1.0/4294967296.0);
-  /* divided by 2^32 */
-}
-
-/** @brief Generate a random number in [0,1) with 53-bit resolution
- ** @param self random number generator.
- ** @return a random number.
- **/
-
-VL_INLINE double
-vl_rand_res53 (VlRand * self)
-{
-  vl_uint32
-  a = vl_rand_uint32(self) >> 5,
-  b = vl_rand_uint32(self) >> 6 ;
-  return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0) ;
-}
-
-/* VL_RANDOM_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/rodrigues.c b/opensfm/src/third_party/vlfeat/vl/rodrigues.c
deleted file mode 100644
index 14958c9df..000000000
--- a/opensfm/src/third_party/vlfeat/vl/rodrigues.c
+++ /dev/null
@@ -1,329 +0,0 @@
-/** @file rodrigues.c
- ** @brief Rodrigues formulas - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#include "generic.h"
-#include "mathop.h"
-#include "rodrigues.h"
-
-#include <math.h>
-
-/** @brief Rodrigues' formula
- ** @param R_pt  3x3 matrix - array of 9 double (in) .
- ** @param dR_pt 9x3 matrix - array of 27 double (in).
- ** @param om_pt 3 vector - array of 3 dobule (out).
- **/
-
-void
-vl_rodrigues(double* R_pt, double* dR_pt, const double* om_pt)
-{
-  /*
-    Let
-
-       th = |om|,  r=w/th,
-       sth=sin(th),  cth=cos(th),
-       ^om = hat(om)
-
-    Then the rodrigues formula is an expansion of the exponential
-    function:
-
-     rodrigues(om) = exp ^om = I + ^r sth + ^r^2 (1 - cth).
-
-    The derivative can be computed by elementary means and
-    results:
-
-    d(vec rodrigues(om))    sth  d ^r    1 - cth  d (^r)^2
-    -------------------- =  ---- ----- + -------  -------- +
-          d om^T             th  d r^T     th      d r^T
-
-                          sth                     1 - cth
-          + vec^r (cth - -----) + vec^r^2 (sth - 2-------)r^T
-                          th                         th
-  */
-
-#define OM(i)   om_pt[(i)]
-#define R(i,j)  R_pt[(i)+3*(j)]
-#define DR(i,j) dR_pt[(i)+9*(j)]
-#undef small
-
-  const double small = 1e-6 ;
-
-  double th = sqrt( OM(0)*OM(0) +
-                    OM(1)*OM(1) +
-                    OM(2)*OM(2) ) ;
-
-  if( th < small ) {
-    R(0,0) = 1.0 ; R(0,1) = 0.0 ; R(0,2) = 0.0 ;
-    R(1,0) = 0.0 ; R(1,1) = 1.0 ; R(1,2) = 0.0 ;
-    R(2,0) = 0.0 ; R(2,1) = 0.0 ; R(2,2) = 1.0 ;
-
-    if(dR_pt) {
-      DR(0,0) = 0  ; DR(0,1) = 0   ; DR(0,2) = 0 ;
-      DR(1,0) = 0  ; DR(1,1) = 0   ; DR(1,2) = 1 ;
-      DR(2,0) = 0  ; DR(2,1) = -1  ; DR(2,2) = 0 ;
-
-      DR(3,0) = 0  ; DR(3,1) = 0   ; DR(3,2) = -1 ;
-      DR(4,0) = 0  ; DR(4,1) = 0   ; DR(4,2) = 0 ;
-      DR(5,0) = 1  ; DR(5,1) = 0   ; DR(5,2) = 0 ;
-
-      DR(6,0) = 0  ; DR(6,1) = 1   ; DR(6,2) = 0 ;
-      DR(7,0) = -1 ; DR(7,1) = 0   ; DR(7,2) = 0 ;
-      DR(8,0) = 0  ; DR(8,1) = 0   ; DR(8,2) = 0 ;
-    }
-    return ;
-  }
-
-  {
-    double x = OM(0) / th ;
-    double y = OM(1) / th ;
-    double z = OM(2) / th ;
-
-    double xx = x*x ;
-    double xy = x*y ;
-    double xz = x*z ;
-    double yy = y*y ;
-    double yz = y*z ;
-    double zz = z*z ;
-
-    const double yx = xy ;
-    const double zx = xz ;
-    const double zy = yz ;
-
-    double sth  = sin(th) ;
-    double cth  = cos(th) ;
-    double mcth = 1.0 - cth ;
-
-    R(0,0) = 1          - mcth * (yy+zz) ;
-    R(1,0) =     sth*z  + mcth * xy ;
-    R(2,0) =   - sth*y  + mcth * xz ;
-
-    R(0,1) =   - sth*z  + mcth * yx ;
-    R(1,1) = 1          - mcth * (zz+xx) ;
-    R(2,1) =     sth*x  + mcth * yz ;
-
-    R(0,2) =     sth*y  + mcth * xz ;
-    R(1,2) =   - sth*x  + mcth * yz ;
-    R(2,2) = 1          - mcth * (xx+yy) ;
-
-    if(dR_pt) {
-      double a =  sth / th ;
-      double b = mcth / th ;
-      double c = cth - a ;
-      double d = sth - 2*b ;
-
-      DR(0,0) =                         - d * (yy+zz) * x ;
-      DR(1,0) =        b*y   + c * zx   + d * xy      * x ;
-      DR(2,0) =        b*z   - c * yx   + d * xz      * x ;
-
-      DR(3,0) =        b*y   - c * zx   + d * xy      * x ;
-      DR(4,0) =     -2*b*x              - d * (zz+xx) * x ;
-      DR(5,0) =  a           + c * xx   + d * yz      * x ;
-
-      DR(6,0) =        b*z   + c * yx   + d * zx      * x ;
-      DR(7,0) = -a           - c * xx   + d * zy      * x ;
-      DR(8,0) =     -2*b*x              - d * (yy+xx) * x ;
-
-      DR(0,1) =     -2*b*y              - d * (yy+zz) * y ;
-      DR(1,1) =        b*x   + c * zy   + d * xy      * y ;
-      DR(2,1) = -a           - c * yy   + d * xz      * y ;
-
-      DR(3,1) =        b*x   - c * zy   + d * xy      * y ;
-      DR(4,1) =                         - d * (zz+xx) * y ;
-      DR(5,1) =        b*z   + c * xy   + d * yz      * y ;
-
-      DR(6,1) = a            + c * yy   + d * zx      * y ;
-      DR(7,1) =        b*z   - c * xy   + d * zy      * y ;
-      DR(8,1) =     -2*b*y              - d * (yy+xx) * y ;
-
-      DR(0,2) =     -2*b*z              - d * (yy+zz) * z ;
-      DR(1,2) =  a           + c * zz   + d * xy      * z ;
-      DR(2,2) =        b*x   - c * yz   + d * xz      * z ;
-
-      DR(3,2) =  -a          - c * zz   + d * xy      * z ;
-      DR(4,2) =     -2*b*z              - d * (zz+xx) * z ;
-      DR(5,2) =        b*y   + c * xz   + d * yz      * z ;
-
-      DR(6,2) =        b*x   + c * yz   + d * zx      * z ;
-      DR(7,2) =        b*y   - c * xz   + d * zy      * z ;
-      DR(8,2) =                         - d * (yy+xx) * z ;
-    }
-  }
-
-#undef OM
-#undef R
-#undef DR
-
-}
-
-/** @brief Inverse Rodrigues formula
- ** @param om_pt  3    vector - array of 3   dobule (out).
- ** @param dom_pt 3x9  matrix - array of 3x9 dobule (out).
- ** @param R_pt   3x3  matrix - array of 9   double (in).
- **
- ** This function computes the Rodrigues formula of the argument @a
- ** om_pt. The result is stored int the matrix @a R_pt. If @a dR_pt is
- ** non null, then the derivative of the Rodrigues formula is computed
- ** and stored into the matrix @a dR_pt.
- **/
-
-VL_EXPORT
-void vl_irodrigues(double* om_pt, double* dom_pt, const double* R_pt)
-{
-  /*
-                    tr R - 1          1    [ R32 - R23 ]
-      th = cos^{-1} --------,  r =  ------ [ R13 - R31 ], w = th r.
-                        2           2 sth  [ R12 - R21 ]
-
-      sth = sin(th)
-
-       dw    th*cth-sth      dw     th   [di3 dj2 - di2 dj3]
-      ---- = ---------- r,  ---- = ----- [di1 dj3 - di3 dj1].
-      dRii     2 sth^2      dRij   2 sth [di1 dj2 - di2 dj1]
-
-      trace(A) < -1 only for small num. errors.
-  */
-
-#define OM(i)    om_pt[(i)]
-#define DOM(i,j) dom_pt[(i)+3*(j)]
-#define R(i,j)   R_pt[(i)+3*(j)]
-#define W(i,j)   W_pt[(i)+3*(j)]
-
-  const double small = 1e-6 ;
-
-  double th = acos
-    (0.5*(VL_MAX(R(0,0)+R(1,1)+R(2,2),-1.0) - 1.0)) ;
-
-  double sth = sin(th) ;
-  double cth = cos(th) ;
-
-  if(fabs(sth) < small && cth < 0) {
-    /*
-      we have this singularity when the rotation  is about pi (or -pi)
-      we use the fact that in this case
-
-      hat( sqrt(1-cth) * r )^2 = W = (0.5*(R+R') - eye(3))
-
-      which gives
-
-      (1-cth) rx^2 = 0.5 * (W(1,1)-W(2,2)-W(3,3))
-      (1-cth) ry^2 = 0.5 * (W(2,2)-W(3,3)-W(1,1))
-      (1-cth) rz^2 = 0.5 * (W(3,3)-W(1,1)-W(2,2))
-    */
-
-    double W_pt [9], x, y, z ;
-    W_pt[0] = 0.5*( R(0,0) + R(0,0) ) - 1.0 ;
-    W_pt[1] = 0.5*( R(1,0) + R(0,1) ) ;
-    W_pt[2] = 0.5*( R(2,0) + R(0,2) );
-
-    W_pt[3] = 0.5*( R(0,1) + R(1,0) );
-    W_pt[4] = 0.5*( R(1,1) + R(1,1) ) - 1.0;
-    W_pt[5] = 0.5*( R(2,1) + R(1,2) );
-
-    W_pt[6] =  0.5*( R(0,2) + R(2,0) ) ;
-    W_pt[7] =  0.5*( R(1,2) + R(2,1) ) ;
-    W_pt[8] =  0.5*( R(2,2) + R(2,2) ) - 1.0 ;
-
-    /* these are only absolute values */
-    x = sqrt( 0.5 * (W(0,0)-W(1,1)-W(2,2)) ) ;
-    y = sqrt( 0.5 * (W(1,1)-W(2,2)-W(0,0)) ) ;
-    z = sqrt( 0.5 * (W(2,2)-W(0,0)-W(1,1)) ) ;
-
-    /* set the biggest component to + and use the element of the
-    ** matrix W to determine the sign of the other components
-    ** then the solution is either (x,y,z) or its opposite */
-    if( x >= y && x >= z ) {
-      y = (W(1,0) >=0) ? y : -y ;
-      z = (W(2,0) >=0) ? z : -z ;
-    } else if( y >= x && y >= z ) {
-      z = (W(2,1) >=0) ? z : -z ;
-      x = (W(1,0) >=0) ? x : -x ;
-    } else {
-      x = (W(2,0) >=0) ? x : -x ;
-      y = (W(2,1) >=0) ? y : -y ;
-    }
-
-    /* we are left to chose between (x,y,z) and (-x,-y,-z)
-    ** unfortunately we cannot (as the rotation is too close to pi) and
-    ** we just keep what we have. */
-    {
-      double scale = th / sqrt( 1 - cth ) ;
-      OM(0) = scale * x ;
-      OM(1) = scale * y ;
-      OM(2) = scale * z ;
-
-      if( dom_pt ) {
-        int k ;
-        for(k=0; k<3*9; ++k)
-          dom_pt [k] = VL_NAN_D ;
-      }
-      return ;
-    }
-
-  } else {
-    double a = (fabs(sth) < small) ? 1 : th/sin(th) ;
-    double b ;
-    OM(0) = 0.5*a*(R(2,1) - R(1,2)) ;
-    OM(1) = 0.5*a*(R(0,2) - R(2,0)) ;
-    OM(2) = 0.5*a*(R(1,0) - R(0,1)) ;
-
-    if( dom_pt ) {
-      if( fabs(sth) < small ) {
-        a = 0.5 ;
-        b = 0 ;
-      } else {
-        a = th/(2*sth) ;
-        b = (th*cth - sth)/(2*sth*sth)/th ;
-      }
-
-      DOM(0,0) = b*OM(0) ;
-      DOM(1,0) = b*OM(1) ;
-      DOM(2,0) = b*OM(2) ;
-
-      DOM(0,1) = 0 ;
-      DOM(1,1) = 0 ;
-      DOM(2,1) = a ;
-
-      DOM(0,2) = 0 ;
-      DOM(1,2) = -a ;
-      DOM(2,2) = 0 ;
-
-      DOM(0,3) = 0 ;
-      DOM(1,3) = 0 ;
-      DOM(2,3) = -a ;
-
-      DOM(0,4) = b*OM(0) ;
-      DOM(1,4) = b*OM(1) ;
-      DOM(2,4) = b*OM(2) ;
-
-      DOM(0,5) = a ;
-      DOM(1,5) = 0 ;
-      DOM(2,5) = 0 ;
-
-      DOM(0,6) = 0 ;
-      DOM(1,6) = a ;
-      DOM(2,6) = 0 ;
-
-      DOM(0,7) = -a ;
-      DOM(1,7) = 0 ;
-      DOM(2,7) = 0 ;
-
-      DOM(0,8) = b*OM(0) ;
-      DOM(1,8) = b*OM(1) ;
-      DOM(2,8) = b*OM(2) ;
-    }
-  }
-
-#undef OM
-#undef DOM
-#undef R
-#undef W
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/rodrigues.h b/opensfm/src/third_party/vlfeat/vl/rodrigues.h
deleted file mode 100644
index d752725ba..000000000
--- a/opensfm/src/third_party/vlfeat/vl/rodrigues.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/** @file rodrigues.h
- ** @brief Rodrigues formulas
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file rodrigues.h
-
-@section rodrigues Rodrigues formulas
-
-- Use ::vl_rodrigues to compute the Rodrigues formula and its derivative.
-- Use ::vl_irodrigues to compute the inverse Rodrigues formula and
-  its derivative.
-
-**/
-
-#ifndef VL_RODRIGUES
-#define VL_RODRIGUES
-
-#include "generic.h"
-
-VL_EXPORT void vl_rodrigues  (double* R_pt,  double* dR_pt, const double* om_pt) ;
-VL_EXPORT void vl_irodrigues (double* om_pt, double* dom_pt, const double* R_pt) ;
-
-/* VL_RODRIGUES */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/scalespace.c b/opensfm/src/third_party/vlfeat/vl/scalespace.c
deleted file mode 100644
index 962f28526..000000000
--- a/opensfm/src/third_party/vlfeat/vl/scalespace.c
+++ /dev/null
@@ -1,821 +0,0 @@
-/** @file scalespace.c
- ** @brief Scale Space - Definition
- ** @author Karel Lenc
- ** @author Andrea Vedaldi
- ** @author Michal Perdoch
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page scalespace Gaussian Scale Space (GSS)
-@author Karel Lenc
-@author Andrea Vedaldi
-@author Michal Perdoch
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref scalespace.h implements a Gaussian scale space, a data structure
-representing an image at multiple resolutions
-@cite{witkin83scale-space} @cite{koenderink84the-structure}
-@cite{lindeberg94scale-space}. Scale spaces have many use, including
-the detection of co-variant local features
-@cite{lindeberg98principles} such as SIFT, Hessian-Affine,
-Harris-Affine, Harris-Laplace, etc. @ref scalespace-starting
-demonstreates how to use the C API to compute the scalespace of an
-image. For further details refer to:
-
-- @subpage scalespace-fundamentals
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-@section scalespace-starting Getting started
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
-
-Given an input image `image`, the following example uses the
-::VlScaleSpace object to compute its Gaussian scale space and return
-the image `level` at scale `(o,s)`, where `o` is the octave and `s` is
-the octave subdivision or sublevel:
-
-@code
-float* level ;
-VlScaleSpace ss = vl_scalespace_new(imageWidth, imageHeight) ;
-vl_scalespace_put_image(ss, image) ;
-level = vl_scalespace_get_level(ss, o, s) ;
-@endcode
-
-The image `level` is obtained by convolving `image` by a Gaussian
-filter of isotropic standard deviation given by
-
-@code
-double sigma = vl_scalespace_get_sigma(ss, o, s) ;
-@endcode
-
-The resolution of `level` is in general different from the resolution
-of `image` and is determined by the octave `o`. It can be obtained as
-follows:
-
-@code
-VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(ss, o) ;
-ogeom.width // width of level (in number of pixels)
-ogeom.height // height of level (in number of pixels)
-ogeom.step // spatial sampling step
-@endcode
-
-The parameter `ogeom.step` is the sampling step relatively to the
-sampling of the input image `image`. The ranges of valid octaves and
-scale sublevels can be obtained as
-
-@code
-VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(ss) ;
-geom.firstOctave // Index of the fisrt octave
-geom.lastOctave // Index of the last octave
-geom.octaveResolution ; // Number of octave subdivisions
-geom.octaveFirstSubdivision // Index of the first octave subdivision
-geom.octaveLastSubdivision  // Index of the last octave subdivision
-@endcode
-
-So for example `o` minimum value is `geom.firstOctave` and maximum
-value is `geom.lastOctave`. The subdivision index `s` naturally spans
-the range 0 to `geom.octaveResolution-1`. However, the scale space
-object is flexible in that it allows different ranges of subdivisions
-to be computed and `s` varies in the range
-`geom.octaveFirstSubdivision` to `geom.octaveLastSubdivision`. See
-@ref scalespace-fundamentals for further details.
-
-The geometry of the scale space can be customized upon creation, as
-follows:
-
-@code
-VlScaleSpaceGeometry geom = vl_scalespace_get_default_geometry(imageWidth, imageHeight) ;
-geom.firstOctave = -1 ;
-geom.octaveFirstSubdivision = -1 ;
-geom.octaveLastSubdivision = geom.octaveResolution ;
-VlScaleSpacae ss = vl_scalespace_new_with_geometry (geom) ;
-@endcode
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page scalespace-fundamentals Gaussian scale space fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page discusses the notion of *Gaussian scale space* and the
-relative data structure. For the C API see @ref scalespace.h and @ref
-scalespace-starting.
-
-A *scale space* is representation of an image at multiple resolution
-levels. An image is a function $\ell(x,y)$ of two coordinates $x$,
-$y$; the scale space $\ell(x,y,\sigma)$ adds a third coordinate
-$\sigma$ indexing the *scale*. Here the focus is the Gaussian scale
-space, where the image $\ell(x,y,\sigma)$ is obtained by smoothing
-$\ell(x,y)$ by a Gaussian kernel of isotropic standard deviation
-$\sigma$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section scalespace-definition Scale space definition
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Formally, the *Gaussian scale space* of an image $\ell(x,y)$ is
-defined as
-
-\[
-   \ell(x,y,\sigma) =
-   [g_{\sigma} * \ell](x,y,\sigma)
-\]
-
-where $g_\sigma$ denotes a 2D Gaussian kernel of isotropic standard
-deviation $\sigma$:
-
-\[
-  g_{\sigma}(x,y) = \frac{1}{2\pi\sigma^2}
-  \exp\left(
-  - \frac{x^2 + y^2}{2\sigma^2}
-  \right).
-\]
-
-An important detail is that the algorithm computing the scale space
-assumes that the input image $\ell(x,y)$ is pre-smoothed, roughly
-capturing the effect of the finite pixel size in a CCD. This is
-modelled by assuming that the input is not $\ell(x,y)$, but
-$\ell(x,y,\sigma_n)$, where $\sigma_n$ is a *nominal smoothing*,
-usually taken to be 0.5 (half a pixel standard deviation). This also
-means that $\sigma = \sigma_n = 0.5$ is the *finest scale* that can
-actually be computed.
-
-The scale space structure stores samples of the function
-$\ell(x,y,\sigma)$. The density of the sampling of the spatial
-coordinates $x$ and $y$ is adjusted as a function of the scale
-$\sigma$, corresponding to the intuition that images at a coarse
-resolution can be sampled more coarsely without loss of
-information. Thus, the scale space has the structure of a *pyramid*: a
-collection of digital images sampled at progressively coarser spatial
-resolution and hence of progressively smaller size (in pixels).
-
-The following figure illustrates the scale space pyramid structure:
-
-@image html scalespace-basic.png "A scalespace structure with 2 octaves and S=3 subdivisions per octave"
-
-The pyramid is organised in a number of *octaves*, indexed by a
-parameter `o`. Each octave is further subdivided into *sublevels*,
-indexed by a parameter `s`. These are related to the scale $\sigma$ by
-the equation
-
-\[
-  \sigma(s,o) = \sigma_o 2^{\displaystyle o + \frac{s}{\mathtt{octaveResolution}}}
-\]
-
-where `octaveResolution` is the resolution of the octave subsampling
-$\sigma_0$ is the *base smoothing*.
-
-At each octave the spatial resolution is doubled, in the sense that
-samples are take with a step of
-\[
-\mathtt{step} = 2^o.
-\]
-Hence, denoting as `level[i,j]` the corresponding samples, one has
-$\ell(x,y,\sigma) = \mathtt{level}[i,j]$, where
-\[
- (x,y) = (i,j) \times \mathtt{step},
-\quad
-\sigma = \sigma(o,s),
- \quad
- 0 \leq i < \mathtt{lwidth},
-\quad
- 0 \leq j < \mathtt{lheight},
-\]
-where
-\[
-  \mathtt{lwidth} = \lfloor \frac{\mathtt{width}}{2^\mathtt{o}}\rfloor, \quad
-  \mathtt{lheight} = \lfloor \frac{\mathtt{height}}{2^\mathtt{o}}\rfloor.
-\]
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section scalespace-geometry Scale space geometry
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In addition to the parameters discussed above, the geometry of the
-data stored in a scale space structure depends on the range of
-allowable octaves `o` and scale sublevels `s`.
-
-While `o` may range in any reasonable value given the size of the
-input image `image`, usually its minimum value is either 0 or -1. The
-latter corresponds to doubling the resolution of the image in the
-first octave of the scale space and it is often used in feature
-extraction. While there is no information added to the image by
-upsampling in this manner, fine scale filters, including derivative
-filters, are much easier to compute by upsalmpling first. The maximum
-practical value is dictated by the image resolution, as it should be
-$2^o\leq\min\{\mathtt{width},\mathtt{height}\}$. VLFeat has the
-flexibility of specifying the range of `o` using the `firstOctave` and
-`lastOctave` parameters of the ::VlScaleSpaceGeometry structure.
-
-The sublevel `s` varies naturally in the range
-$\{0,\dots,\mathtt{octaveResolution}-1\}$. However, it is often
-convenient to store a few extra levels per octave (e.g. to compute the
-local maxima of a function in scale or the Difference of Gaussian
-cornerness measure). Thus VLFeat scale space structure allows this
-parameter to vary in an arbitrary range, specified by the parameters
-`octaveFirstSubdivision` and `octaveLastSubdivision` of
-::VlScaleSpaceGeometry.
-
-Overall the possible values of the indexes `o` and `s` are:
-
-\[
-\mathtt{firstOctave} \leq o \leq \mathtt{lastOctave},
-\qquad
-\mathtt{octaveFirstSubdivision} \leq s \leq \mathtt{octaveLastSubdivision}.
-\]
-
-Note that, depending on these ranges, there could be *redundant pairs*
-of indexes `o` and `s` that represent the *same* pyramid level at more
-than one sampling resolution. In practice, the ability to generate
-such redundant information is very useful in algorithms using
-scalespaces, as coding multiscale operations using a fixed sampling
-resolution is far easier. For example, the DoG feature detector
-computes the scalespace with three redundant levels per octave, as
-follows:
-
-@image html scalespace.png "A scalespace containing redundant representation of certain scale levels."
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section scalespace-algorithm Algorithm and limitations
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Given $\ell(x,y,\sigma_n)$, any of a vast number digitial filtering
-techniques can be used to compute the scale levels. Presently, VLFeat
-uses a basic FIR implementation of the Gaussian filters.
-
-The FIR implementation is obtained by sampling the Gaussian function
-and re-normalizing it to have unit norm. This simple construction does
-not account properly for sampling effect, which may be a problem for
-very small Gausisan kernels. As a rule of thumb, such filters work
-sufficiently well for, say, standard deviation $\sigma$ at least 1.6
-times the sampling step. A work around to apply this basic FIR
-implementation to very small Gaussian filters is to upsample the image
-first.
-
-The limitations on the FIR filters have relatively important for the
-pyramid construction, as the latter is obtained by *incremental
-smoothing*: each successive level is obtained from the previous one by
-adding the needed amount of smoothing. In this manner, the size of the
-FIR filters remains small, which makes them efficient; at the same
-time, for what discussed, excessively small filters are not
-represented properly.
-
-*/
-
-#include "scalespace.h"
-#include "mathop.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <stdio.h>
-
-/** @file scalespace.h
- ** @struct VlScaleSpace
- ** @brief Scale space class
- **
- ** This is an opaque class used to compute the scale space of an
- ** image.
- **/
-
-struct _VlScaleSpace
-{
-  VlScaleSpaceGeometry geom ; /**< Geometry of the scale space */
-  float **octaves ; /**< Data */
-} ;
-
-/* ---------------------------------------------------------------- */
-/** @brief Get the default geometry for a given image size.
- ** @param width image width.
- ** @param height image height.
- ** @return the default scale space geometry.
- **
- ** Both @a width and @a height must be at least one pixel wide.
- **/
-
-VlScaleSpaceGeometry
-vl_scalespace_get_default_geometry (vl_size width, vl_size height)
-{
-  VlScaleSpaceGeometry geom ;
-  assert(width >= 1) ;
-  assert(height >= 1) ;
-  geom.width = width ;
-  geom.height = height ;
-  geom.firstOctave = 0 ;
-  geom.lastOctave = VL_MAX(floor(vl_log2_d(VL_MIN(width, height))) - 3, 0) ;
-  geom.octaveResolution= 3 ;
-  geom.octaveFirstSubdivision = 0 ;
-  geom.octaveLastSubdivision = geom.octaveResolution - 1 ;
-  geom.baseScale = 1.6 * pow(2.0, 1.0 / geom.octaveResolution) ;
-  geom.nominalScale = 0.5 ;
-  return geom ;
-}
-
-#define is_valid_geometry(geom) (\
-geom.firstOctave <= geom.lastOctave && \
-geom.octaveResolution >= 1 && \
-geom.octaveFirstSubdivision <= geom.octaveLastSubdivision && \
-geom.baseScale >= 0.0 && \
-geom.nominalScale >= 0.0)
-
-/** @brief Check scale space geometries for equality
- ** @param a first geometry.
- ** @param b second geometry.
- ** @return true if equal.
- **/
-
-vl_bool
-vl_scalespacegeometry_is_equal (VlScaleSpaceGeometry a,
-                                VlScaleSpaceGeometry b)
-{
-  return
-  a.width == b.width &&
-  a.height == b.height &&
-  a.firstOctave == b.firstOctave &&
-  a.lastOctave == b.lastOctave &&
-  a.octaveResolution == b.octaveResolution &&
-  a.octaveFirstSubdivision == b.octaveLastSubdivision &&
-  a.baseScale == b.baseScale &&
-  a.nominalScale == b.nominalScale ;
-}
-
-/** @brief Get the geometry of the scale space.
- ** @param self object.
- ** @return the scale space geometry.
- **/
-
-VlScaleSpaceGeometry
-vl_scalespace_get_geometry (VlScaleSpace const * self)
-{
-  return self->geom ;
-}
-
-/** @brief Get the geometry of an octave of the scalespace.
- ** @param self object.
- ** @param o octave index.
- ** @return the geometry of octave @a o.
- **/
-
-VlScaleSpaceOctaveGeometry
-vl_scalespace_get_octave_geometry (VlScaleSpace const * self, vl_index o)
-{
-  VlScaleSpaceOctaveGeometry ogeom ;
-  ogeom.width = VL_SHIFT_LEFT(self->geom.width, -o) ;
-  ogeom.height = VL_SHIFT_LEFT(self->geom.height, -o) ;
-  ogeom.step = pow(2.0, o) ;
-  return ogeom ;
-}
-
-/** @brief Get the data of a scale space level
- ** @param self object.
- ** @param o octave index.
- ** @param s level index.
- ** @return pointer to the data for octave @a o, level @a s.
- **
- ** The octave index @a o must be in the range @c firstOctave
- ** to @c lastOctave and the scale index @a s must be in the
- ** range @c octaveFirstSubdivision to @c octaveLastSubdivision.
- **/
-
-float *
-vl_scalespace_get_level (VlScaleSpace *self, vl_index o, vl_index s)
-{
-  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
-  float * octave ;
-  assert(self) ;
-  assert(o >= self->geom.firstOctave) ;
-  assert(o <= self->geom.lastOctave) ;
-  assert(s >= self->geom.octaveFirstSubdivision) ;
-  assert(s <= self->geom.octaveLastSubdivision) ;
-
-  octave = self->octaves[o - self->geom.firstOctave] ;
-  return octave + ogeom.width * ogeom.height * (s - self->geom.octaveFirstSubdivision) ;
-}
-
-/** @brief Get the data of a scale space level (const)
- ** @param self object.
- ** @param o octave index.
- ** @param s level index.
- ** @return pointer to the data for octave @a o, level @a s.
- **
- ** This function is the same as ::vl_scalespace_get_level but reutrns
- ** a @c const pointer to the data.
- **/
-
-float const *
-vl_scalespace_get_level_const (VlScaleSpace const * self, vl_index o, vl_index s)
-{
-  return vl_scalespace_get_level((VlScaleSpace*)self, o, s) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the scale of a given octave and sublevel
- ** @param self object.
- ** @param o octave index.
- ** @param s sublevel index.
- **
- ** The function returns the scale $\sigma(o,s)$ as a function of the
- ** octave index @a o and sublevel @a s.
- **/
-
-double
-vl_scalespace_get_level_sigma (VlScaleSpace const *self, vl_index o, vl_index s)
-{
-  return self->geom.baseScale * pow(2.0, o + (double) s / self->geom.octaveResolution) ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Upsample the rows and take the transpose
- ** @param destination output image.
- ** @param source input image.
- ** @param width input image width.
- ** @param height input image height.
- **
- ** The output image has dimensions @a height by 2 @a width (so the
- ** destination buffer must be at least as big as two times the
- ** input buffer).
- **
- ** Upsampling is performed by linear interpolation.
- **/
-
-static void
-copy_and_upsample
-(float *destination,
- float const *source, vl_size width, vl_size height)
-{
-  vl_index x, y, ox, oy ;
-  float v00, v10, v01, v11 ;
-
-  assert(destination) ;
-  assert(source) ;
-
-  for(y = 0 ; y < (signed)height ; ++y) {
-    oy = (y < ((signed)height - 1)) * width ;
-    v10 = source[0] ;
-    v11 = source[oy] ;
-    for(x = 0 ; x < (signed)width ; ++x) {
-      ox = x < ((signed)width - 1) ;
-      v00 = v10 ;
-      v01 = v11 ;
-      v10 = source[ox] ;
-      v11 = source[ox + oy] ;
-      destination[0] = v00 ;
-      destination[1] = 0.5f * (v00 + v10) ;
-      destination[2*width] = 0.5f * (v00 + v01) ;
-      destination[2*width+1] = 0.25f * (v00 + v01 + v10 + v11) ;
-      destination += 2 ;
-      source ++;
-    }
-    destination += 2*width ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Downsample
- ** @param destination output imgae buffer.
- ** @param source input image buffer.
- ** @param width input image width.
- ** @param height input image height.
- ** @param numOctaves octaves (non negative).
- **
- ** The function downsamples the image @a d times, reducing it to @c
- ** 1/2^d of its original size. The parameters @a width and @a height
- ** are the size of the input image. The destination image @a dst is
- ** assumed to be <code>floor(width/2^d)</code> pixels wide and
- ** <code>floor(height/2^d)</code> pixels high.
- **/
-
-static void
-copy_and_downsample
-(float *destination,
- float const *source,
- vl_size width, vl_size height, vl_size numOctaves)
-{
-  vl_index x, y ;
-  vl_size step = 1 << numOctaves ; /* step = 2^numOctaves */
-
-  assert(destination) ;
-  assert(source) ;
-
-  if (numOctaves == 0) {
-    memcpy(destination, source, sizeof(float) * width * height) ;
-  } else {
-    for(y = 0 ; y < (signed)height ; y += step) {
-      float const *p = source + y * width ;
-      for(x = 0 ; x < (signed)width - ((signed)step - 1) ; x += step) {
-        *destination++ = *p ;
-        p += step ;
-      }
-    }
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Create a new scale space object
- ** @param width image width.
- ** @param height image height.
- ** @return new scale space object.
- **
- ** This function is the same as ::vl_scalespace_new_with_geometry()
- ** but it uses ::vl_scalespace_get_default_geometry to initialise
- ** the geometry of the scale space from the image size.
- **
- ** @sa ::vl_scalespace_new_with_geometry(), ::vl_scalespace_delete().
- **/
-
-VlScaleSpace *
-vl_scalespace_new (vl_size width, vl_size height)
-{
-  VlScaleSpaceGeometry geom ;
-  geom = vl_scalespace_get_default_geometry(width, height) ;
-  return vl_scalespace_new_with_geometry(geom) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new scale space with the specified geometry
- ** @param geom scale space geomerty.
- ** @return new scale space object.
- **
- ** If the geometry is not valid (see ::VlScaleSpaceGeometry), the
- ** result is unpredictable.
- **
- ** The function returns `NULL` if it was not possible to allocate the
- ** object because of an out-of-memory condition.
- **
- ** @sa ::VlScaleSpaceGeometry, ::vl_scalespace_delete().
- **/
-
-VlScaleSpace *
-vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom)
-{
-
-  vl_index o ;
-  vl_size numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
-  vl_size numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
-  VlScaleSpace *self ;
-
-  assert(is_valid_geometry(geom)) ;
-  numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
-  numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
-
-  self = vl_calloc(1, sizeof(VlScaleSpace)) ;
-  if (self == NULL) goto err_alloc_self ;
-  self->geom = geom ;
-  self->octaves = vl_calloc(numOctaves, sizeof(float*)) ;
-  if (self->octaves == NULL) goto err_alloc_octave_list ;
-  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
-    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
-    vl_size octaveSize = ogeom.width * ogeom.height * numSublevels ;
-    self->octaves[o - self->geom.firstOctave] = vl_malloc(octaveSize * sizeof(float)) ;
-    if (self->octaves[o - self->geom.firstOctave] == NULL) goto err_alloc_octaves;
-  }
-  return self ;
-
-err_alloc_octaves:
-  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
-    if (self->octaves[o - self->geom.firstOctave]) {
-      vl_free(self->octaves[o - self->geom.firstOctave]) ;
-    }
-  }
-err_alloc_octave_list:
-  vl_free(self) ;
-err_alloc_self:
-  return NULL ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Create a new copy of the object
- ** @param self object to copy from.
- **
- ** The function returns `NULL` if the copy cannot be made due to an
- ** out-of-memory condition.
- **/
-
-VlScaleSpace *
-vl_scalespace_new_copy (VlScaleSpace* self)
-{
-  vl_index o  ;
-  VlScaleSpace * copy = vl_scalespace_new_shallow_copy(self) ;
-  if (copy == NULL) return NULL ;
-
-  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
-    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
-    vl_size numSubevels = self->geom.octaveLastSubdivision - self->geom.octaveFirstSubdivision + 1;
-    memcpy(copy->octaves[o - self->geom.firstOctave],
-           self->octaves[o - self->geom.firstOctave],
-           ogeom.width * ogeom.height * numSubevels * sizeof(float)) ;
-  }
-  return copy ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Create a new shallow copy of the object
- ** @param self object to copy from.
- **
- ** The function works like ::vl_scalespace_new_copy() but only allocates
- ** the scale space, without actually copying the data.
- **/
-
-VlScaleSpace *
-vl_scalespace_new_shallow_copy (VlScaleSpace* self)
-{
-  return vl_scalespace_new_with_geometry (self->geom) ;
-}
-
-/* ---------------------------------------------------------------- */
-/** @brief Delete object
- ** @param self object to delete.
- ** @sa ::vl_scalespace_new()
- **/
-
-void
-vl_scalespace_delete (VlScaleSpace * self)
-{
-  if (self) {
-    if (self->octaves) {
-      vl_index o ;
-      for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
-        if (self->octaves[o - self->geom.firstOctave]) {
-          vl_free(self->octaves[o - self->geom.firstOctave]) ;
-        }
-      }
-      vl_free(self->octaves) ;
-    }
-    vl_free(self) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @internal @brief Fill octave starting from the first level
- ** @param self object instance.
- ** @param o octave to process.
- **
- ** The function takes the first sublevel of octave @a o (the one at
- ** sublevel `octaveFirstLevel` and iteratively
- ** smoothes it to obtain the other octave levels.
- **/
-
-void
-_vl_scalespace_fill_octave (VlScaleSpace *self, vl_index o)
-{
-  vl_index s ;
-  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
-
-  for(s = self->geom.octaveFirstSubdivision + 1 ;
-      s <= self->geom.octaveLastSubdivision ; ++s) {
-    double sigma = vl_scalespace_get_level_sigma(self, o, s) ;
-    double previousSigma = vl_scalespace_get_level_sigma(self, o, s - 1) ;
-    double deltaSigma = sqrtf(sigma*sigma - previousSigma*previousSigma) ;
-
-    float* level = vl_scalespace_get_level (self, o, s) ;
-    float* previous = vl_scalespace_get_level (self, o, s-1) ;
-    vl_imsmooth_f (level, ogeom.width,
-                   previous, ogeom.width, ogeom.height, ogeom.width,
-                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @internal @brief Initialize the first level of an octave from an image
- ** @param self ::VlScaleSpace object instance.
- ** @param image image data.
- ** @param o octave to start.
- **
- ** The function initializes the first level of octave @a o from
- ** image @a image. The dimensions of the image are the ones set
- ** during the creation of the ::VlScaleSpace object instance.
- **/
-
-static void
-_vl_scalespace_start_octave_from_image (VlScaleSpace *self,
-                                        float const *image,
-                                        vl_index o)
-{
-  float *level ;
-  double sigma, imageSigma ;
-  vl_index op ;
-
-  assert(self) ;
-  assert(image) ;
-  assert(o >= self->geom.firstOctave) ;
-  assert(o <= self->geom.lastOctave) ;
-
-  /*
-   * Copy the image to self->geom.octaveFirstSubdivision of octave o, upscaling or
-   * downscaling as needed.
-   */
-
-  level = vl_scalespace_get_level(self, VL_MAX(0, o), self->geom.octaveFirstSubdivision) ;
-  copy_and_downsample(level, image, self->geom.width, self->geom.height, VL_MAX(0, o)) ;
-
-  for (op = -1 ; op >= o ; --op) {
-    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, op + 1) ;
-    float *succLevel = vl_scalespace_get_level(self, op + 1, self->geom.octaveFirstSubdivision) ;
-    level = vl_scalespace_get_level(self, op, self->geom.octaveFirstSubdivision) ;
-    copy_and_upsample(level, succLevel, ogeom.width, ogeom.height) ;
-  }
-
-  /*
-   * Adjust the smoothing of the first level just initialised, accounting
-   * for the fact that the input image is assumed to be a nominal scale
-   * level.
-   */
-
-  sigma = vl_scalespace_get_level_sigma(self, o, self->geom.octaveFirstSubdivision) ;
-  imageSigma = self->geom.nominalScale ;
-
-  if (sigma > imageSigma) {
-    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
-    double deltaSigma = sqrt (sigma*sigma - imageSigma*imageSigma) ;
-    level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
-    vl_imsmooth_f (level, ogeom.width,
-                   level, ogeom.width, ogeom.height, ogeom.width,
-                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
-  }
-}
-
-/** @internal @brief Initialize the first level of an octave from the previous octave
- ** @param self object.
- ** @param o octave to initialize.
- **
- ** The function initializes the first level of octave @a o from the
- ** content of octave <code>o - 1</code>.
- **/
-
-static void
-_vl_scalespace_start_octave_from_previous_octave (VlScaleSpace *self, vl_index o)
-{
-  double sigma, prevSigma ;
-  float *level, *prevLevel ;
-  vl_index prevLevelIndex ;
-  VlScaleSpaceOctaveGeometry ogeom ;
-
-  assert(self) ;
-  assert(o > self->geom.firstOctave) ; /* must not be the first octave */
-  assert(o <= self->geom.lastOctave) ;
-
-  /*
-   * From the previous octave pick the level which is closer to
-   * self->geom.octaveFirstSubdivision in this octave.
-   * The is self->geom.octaveFirstSubdivision + self->numLevels since there are
-   * self->geom.octaveResolution levels in an octave, provided that
-   * this value does not exceed self->geom.octaveLastSubdivision.
-   */
-
-  prevLevelIndex = VL_MIN(self->geom.octaveFirstSubdivision
-                          + (signed)self->geom.octaveResolution,
-                          self->geom.octaveLastSubdivision) ;
-  prevLevel = vl_scalespace_get_level (self, o - 1, prevLevelIndex) ;
-  level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
-  ogeom = vl_scalespace_get_octave_geometry(self, o - 1) ;
-
-  copy_and_downsample (level, prevLevel, ogeom.width, ogeom.height, 1) ;
-
-  /*
-   * Add remaining smoothing, if any.
-   */
-
-  sigma = vl_scalespace_get_level_sigma(self, o, self->geom.octaveFirstSubdivision) ;
-  prevSigma = vl_scalespace_get_level_sigma(self, o - 1, prevLevelIndex) ;
-
-  if (sigma > prevSigma) {
-    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
-    double deltaSigma = sqrt (sigma*sigma - prevSigma*prevSigma) ;
-    level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
-
-    /* todo: this may fail due to an out-of-memory condition */
-    vl_imsmooth_f (level, ogeom.width,
-                   level, ogeom.width, ogeom.height, ogeom.width,
-                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
-  }
-}
-
-/** @brief Initialise Scale space with new image
- ** @param self ::VlScaleSpace object instance.
- ** @param image image to process.
- **
- ** Compute the data of all the defined octaves and scales of the scale
- ** space @a self.
- **/
-
-void
-vl_scalespace_put_image (VlScaleSpace *self, float const *image)
-{
-  vl_index o ;
-  _vl_scalespace_start_octave_from_image(self, image, self->geom.firstOctave) ;
-  _vl_scalespace_fill_octave(self, self->geom.firstOctave) ;
-  for (o = self->geom.firstOctave + 1 ; o <= self->geom.lastOctave ; ++o) {
-    _vl_scalespace_start_octave_from_previous_octave(self, o) ;
-    _vl_scalespace_fill_octave(self, o) ;
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/scalespace.h b/opensfm/src/third_party/vlfeat/vl/scalespace.h
deleted file mode 100644
index 3f7af38d8..000000000
--- a/opensfm/src/third_party/vlfeat/vl/scalespace.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/** @file scalespace.h
- ** @brief Scale Space (@ref scalespace)
- ** @author Andrea Vedaldi
- ** @author Karel Lenc
- ** @author Michal Perdoch
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_SCALESPACE_H
-#define VL_SCALESPACE_H
-
-#include "generic.h"
-#include "imopv.h"
-#include "mathop.h"
-
-/* ---------------------------------------------------------------- */
-/*                                             VlScaleSpaceGeometry */
-/* ---------------------------------------------------------------- */
-
-/** @brief Geometry of a scale space
- **
- ** There are a few restrictions on the valid geometrties.
- */
-typedef struct _VlScaleSpaceGeometry
-{
-  vl_size width ; /**< Image width */
-  vl_size height ; /**< Image height */
-  vl_index firstOctave ; /**< Index of the fisrt octave */
-  vl_index lastOctave ; /**< Index of the last octave */
-  vl_size octaveResolution ; /**< Number of octave subdivisions */
-  vl_index octaveFirstSubdivision ; /**< Index of the first octave subdivision */
-  vl_index octaveLastSubdivision ; /**< Index of the last octave subdivision */
-  double baseScale ; /**< Base smoothing (smoothing of octave 0, level 0) */
-  double nominalScale ; /**< Nominal smoothing of the original image */
-} VlScaleSpaceGeometry ;
-
-VL_EXPORT
-vl_bool vl_scalespacegeometry_is_equal (VlScaleSpaceGeometry a,
-                                        VlScaleSpaceGeometry b) ;
-
-/* ---------------------------------------------------------------- */
-/*                                       VlScaleSpaceOctaveGeometry */
-/* ---------------------------------------------------------------- */
-
-/** @brief Geometry of one octave of a scale space */
-typedef struct _VlScaleSpaceOctaveGeometry
-{
-  vl_size width ; /**< Width (number of pixels) */
-  vl_size height ; /**< Height (number of pixels) */
-  double step ; /**< Sampling step (size of a pixel) */
-} VlScaleSpaceOctaveGeometry ;
-
-/* ---------------------------------------------------------------- */
-/*                                                     VlScaleSpace */
-/* ---------------------------------------------------------------- */
-
-typedef struct _VlScaleSpace VlScaleSpace ;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT VlScaleSpaceGeometry vl_scalespace_get_default_geometry(vl_size width, vl_size height) ;
-VL_EXPORT VlScaleSpace * vl_scalespace_new (vl_size width, vl_size height) ;
-VL_EXPORT VlScaleSpace * vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom) ;
-VL_EXPORT VlScaleSpace * vl_scalespace_new_copy (VlScaleSpace* src);
-VL_EXPORT VlScaleSpace * vl_scalespace_new_shallow_copy (VlScaleSpace* src);
-VL_EXPORT void vl_scalespace_delete (VlScaleSpace *self) ;
-/** @} */
-
-/** @name Process data
- ** @{
- **/
-VL_EXPORT void
-vl_scalespace_put_image (VlScaleSpace *self, float const* image);
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{
- **/
-VL_EXPORT VlScaleSpaceGeometry vl_scalespace_get_geometry (VlScaleSpace const * self) ;
-VL_EXPORT VlScaleSpaceOctaveGeometry vl_scalespace_get_octave_geometry (VlScaleSpace const * self, vl_index o) ;
-VL_EXPORT float *
-vl_scalespace_get_level (VlScaleSpace * self, vl_index o, vl_index s) ;
-VL_EXPORT float const *
-vl_scalespace_get_level_const (VlScaleSpace const * self, vl_index o, vl_index s) ;
-VL_EXPORT double
-vl_scalespace_get_level_sigma (VlScaleSpace const *self, vl_index o, vl_index s) ;
-/** @} */
-
-/* VL_SCALESPACE_H */
-#endif
-
diff --git a/opensfm/src/third_party/vlfeat/vl/shuffle-def.h b/opensfm/src/third_party/vlfeat/vl/shuffle-def.h
deleted file mode 100644
index 4b74ea6bd..000000000
--- a/opensfm/src/third_party/vlfeat/vl/shuffle-def.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/** @file   shuffle-def.h
- ** @brief  Shuffle preprocessor metaprogram
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file shuffle-def.h
-
- @todo large array compatibility.
- **/
-
-#include "host.h"
-#include "random.h"
-#include <assert.h>
-
-#ifndef VL_SHUFFLE_prefix
-#error "VL_SHUFFLE_prefix must be defined"
-#endif
-
-#ifndef VL_SHUFFLE_array
-#ifndef VL_SHUFFLE_type
-#error "VL_SHUFFLE_type must be defined if VL_SHUFFLE_array is not"
-#endif
-#define VL_SHUFFLE_array VL_SHUFFLE_type*
-#endif
-
-#ifdef __DOXYGEN__
-#define VL_SHUFFLE_prefix  ShufflePrefix       /**< Prefix of the shuffle functions */
-#define VL_SHUFFLE_type    ShuffleType         /**< Data type of the shuffle elements */
-#define VL_SHUFFLE_array   ShuffleType*        /**< Data type of the shuffle container */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_SHUFFLE_swap) || defined(__DOXYGEN__)
-#define VL_SHUFFLE_swap VL_XCAT(VL_SHUFFLE_prefix, _swap)
-
-/** @brief Swap two array elements
- ** @param array shuffle array.
- ** @param indexA index of the first element to swap.
- ** @param indexB index of the second element to swap.
- **
- ** The function swaps the two elements @a a and @ b. The function
- ** uses a temporary element of type ::VL_SHUFFLE_type
- ** and the copy operator @c =.
- **/
-
-VL_INLINE void
-VL_SHUFFLE_swap
-(VL_SHUFFLE_array array,
- vl_uindex indexA,
- vl_uindex indexB)
-{
-  VL_SHUFFLE_type t = array [indexA] ;
-  array [indexA] = array [indexB] ;
-  array [indexB] = t ;
-}
-
-/* VL_SHUFFLE_swap */
-#endif
-
-/* ---------------------------------------------------------------- */
-
-#if ! defined(VL_SHUFFLE_shuffle) || defined(__DOXYGEN__)
-#define VL_SHUFFLE_shuffle VL_XCAT(VL_SHUFFLE_prefix, _shuffle)
-
-/** @brief Shuffle
- ** @param array (in/out) pointer to the array.
- ** @param size size of the array.
- ** @param rand random number generator to use.
- **
- ** The function randomly permutes the array.
- **/
-
-VL_INLINE void
-VL_SHUFFLE_shuffle
-(VL_SHUFFLE_array array, vl_size size, VlRand * rand)
-{
-  vl_uindex n = size ;
-  while (n > 1) {
-    vl_uindex k = vl_rand_uindex (rand, n) ;
-    n -- ;
-    VL_SHUFFLE_swap (array, n, k) ;
-  }
-}
-
-/* VL_SHUFFLE_shuffle */
-#endif
-
-#undef VL_SHUFFLE_prefix
-#undef VL_SHUFFLE_swap
-#undef VL_SHUFFLE_shuffle
-#undef VL_SHUFFLE_type
-#undef VL_SHUFFLE_array
diff --git a/opensfm/src/third_party/vlfeat/vl/sift.c b/opensfm/src/third_party/vlfeat/vl/sift.c
deleted file mode 100644
index 03963fe6f..000000000
--- a/opensfm/src/third_party/vlfeat/vl/sift.c
+++ /dev/null
@@ -1,2197 +0,0 @@
-/** @file sift.c
- ** @brief SIFT - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page sift Scale Invariant Feature Transform (SIFT)
-@author Andrea Vedaldi
-@par "Credits:" May people have contributed with suggestions and bug
-reports. Although the following list is certainly incomplete, we would
-like to thank: Wei Dong, Loic, Giuseppe, Liu, Erwin, P. Ivanov, and
-Q. S. Luo.
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref sift.h implements a @ref sift-usage "SIFT filter object", a
-reusable object to extract SIFT features @cite{lowe99object} from one
-or multiple images.
-
-This is the original VLFeat implementation of SIFT, designed to be
-compatible with Lowe's original SIFT. See @ref covdet for a different
-version of SIFT integrated in the more general covariant feature
-detector engine.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section sift-intro Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A SIFT feature is a selected image region (also called keypoint) with
-an associated descriptor. Keypoints are extracted by the <b>@ref
-sift-intro-detector "SIFT detector"</b> and their descriptors are
-computed by the <b>@ref sift-intro-descriptor "SIFT descriptor"</b>.  It is
-also common to use independently the SIFT detector (i.e. computing the
-keypoints without descriptors) or the SIFT descriptor (i.e.  computing
-descriptors of custom keypoints).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-intro-detector SIFT detector
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A SIFT <em>keypoint</em> is a circular image region with an
-orientation. It is described by a geometric <em>frame</em> of four
-parameters: the keypoint center coordinates @e x and @e y, its @e
-scale (the radius of the region), and its @e orientation (an angle
-expressed in radians). The SIFT detector uses as keypoints image
-structures which resemble &ldquo;blobs&rdquo;. By searching for blobs
-at multiple scales and positions, the SIFT detector is invariant (or,
-more accurately, covariant) to translation, rotations, and re scaling
-of the image.
-
-The keypoint orientation is also determined from the local image
-appearance and is covariant to image rotations. Depending on the
-symmetry of the keypoint appearance, determining the orientation can
-be ambiguous. In this case, the SIFT detectors returns a list of up to
-four possible orientations, constructing up to four frames (differing
-only by their orientation) for each detected image blob.
-
-@image html sift-frame.png "SIFT keypoints are circular image regions with an orientation."
-
-There are several parameters that influence the detection of SIFT
-keypoints. First, searching keypoints at multiple scales is obtained
-by constructing a so-called &ldquo;Gaussian scale space&rdquo;. The
-scale space is just a collection of images obtained by progressively
-smoothing the input image, which is analogous to gradually reducing
-the image resolution. Conventionally, the smoothing level is called
-<em>scale</em> of the image. The construction of the scale space is
-influenced by the following parameters, set when creating the SIFT
-filter object by ::vl_sift_new():
-
-- <b>Number of octaves</b>. Increasing the scale by an octave means
-  doubling the size of the smoothing kernel, whose effect is roughly
-  equivalent to halving the image resolution. By default, the scale
-  space spans as many octaves as possible (i.e. roughly <code>
-  log2(min(width,height)</code>), which has the effect of searching
-  keypoints of all possible sizes.
-- <b>First octave index</b>. By convention, the octave of index 0
-  starts with the image full resolution. Specifying an index greater
-  than 0 starts the scale space at a lower resolution (e.g. 1 halves
-  the resolution). Similarly, specifying a negative index starts the
-  scale space at an higher resolution image, and can be useful to
-  extract very small features (since this is obtained by interpolating
-  the input image, it does not make much sense to go past -1).
-- <b>Number of levels per octave</b>. Each octave is sampled at this
-  given number of intermediate scales (by default 3). Increasing this
-  number might in principle return more refined keypoints, but in
-  practice can make their selection unstable due to noise (see [1]).
-
-Keypoints are further refined by eliminating those that are likely to
-be unstable, either because they are selected nearby an image edge,
-rather than an image blob, or are found on image structures with low
-contrast. Filtering is controlled by the follow:
-
-- <b>Peak threshold.</b> This is the minimum amount of contrast to
-  accept a keypoint. It is set by configuring the SIFT filter object
-  by ::vl_sift_set_peak_thresh().
-- <b>Edge threshold.</b> This is the edge rejection threshold. It is
-  set by configuring the SIFT filter object by
-  ::vl_sift_set_edge_thresh().
-
-<table>
- <caption>Summary of the parameters influencing the SIFT detector.</caption>
- <tr style="font-weight:bold;">
- <td>Parameter</td>
- <td>See also</td>
- <td>Controlled by</td>
- <td>Comment</td>
- </tr>
- <tr>
- <td>number of octaves</td>
- <td> @ref sift-intro-detector </td>
- <td>::vl_sift_new</td>
- <td></td>
- </tr>
- <tr>
- <td>first octave index</td>
- <td> @ref sift-intro-detector </td>
- <td>::vl_sift_new</td>
- <td>set to -1 to extract very small features</td>
- </tr>
- <tr>
- <td>number of scale levels per octave</td>
- <td> @ref sift-intro-detector </td>
- <td>::vl_sift_new</td>
- <td>can affect the number of extracted keypoints</td>
- </tr>
- <tr>
- <td>edge threshold</td>
- <td> @ref sift-intro-detector </td>
- <td>::vl_sift_set_edge_thresh</td>
- <td>decrease to eliminate more keypoints</td>
- </tr>
- <tr>
- <td>peak threshold</td>
- <td> @ref sift-intro-detector </td>
- <td>::vl_sift_set_peak_thresh</td>
- <td>increase to eliminate more keypoints</td>
- </tr>
-</table>
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-intro-descriptor SIFT Descriptor
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@sa @ref sift-tech-descriptor "Descriptor technical details"
-
-A SIFT descriptor is a 3-D spatial histogram of the image gradients in
-characterizing the appearance of a keypoint. The gradient at each
-pixel is regarded as a sample of a three-dimensional elementary
-feature vector, formed by the pixel location and the gradient
-orientation. Samples are weighed by the gradient norm and accumulated
-in a 3-D histogram @em h, which (up to normalization and clamping)
-forms the SIFT descriptor of the region. An additional Gaussian
-weighting function is applied to give less importance to gradients
-farther away from the keypoint center. Orientations are quantized into
-eight bins and the spatial coordinates into four each, as follows:
-
-@image html sift-descr-easy.png "The SIFT descriptor is a spatial histogram of the image gradient."
-
-SIFT descriptors are computed by either calling
-::vl_sift_calc_keypoint_descriptor or
-::vl_sift_calc_raw_descriptor. They accept as input a keypoint
-frame, which specifies the descriptor center, its size, and its
-orientation on the image plane. The following parameters influence the
-descriptor calculation:
-
-- <b>magnification factor</b>. The descriptor size is determined by
-multiplying the keypoint scale by this factor. It is set by
-::vl_sift_set_magnif.
-- <b>Gaussian window size</b>. The descriptor support is determined by
-a Gaussian window, which discounts gradient contributions farther away
-from the descriptor center. The standard deviation of this window is
-set by ::vl_sift_set_window_size and expressed in unit of bins.
-
-VLFeat SIFT descriptor uses the following convention. The @em y axis
-points downwards and angles are measured clockwise (to be consistent
-with the standard image convention). The 3-D histogram (consisting of
-@f$ 8 \times 4 \times 4 = 128 @f$ bins) is stacked as a single
-128-dimensional vector, where the fastest varying dimension is the
-orientation and the slowest the @em y spatial coordinate. This is
-illustrated by the following figure.
-
-@image html sift-conv-vlfeat.png "VLFeat conventions"
-
-@note Keypoints (frames) D. Lowe's SIFT implementation convention is
-slightly different: The @em y axis points upwards and the angles are
-measured counter-clockwise.
-
-@image html sift-conv.png "D. Lowes' SIFT implementation conventions"
-
-<table>
- <caption>Summary of the parameters influencing the SIFT descriptor.</caption>
- <tr style="font-weight:bold;">
- <td>Parameter</td>
- <td>See also</td>
- <td>Controlled by</td>
- <td>Comment</td>
- </tr>
- <tr>
- <td>magnification factor</td>
- <td> @ref sift-intro-descriptor </td>
- <td>::vl_sift_set_magnif</td>
- <td>increase this value to enlarge the image region described</td>
- </tr>
- <tr>
- <td>Gaussian window size</td>
- <td> @ref sift-intro-descriptor </td>
- <td>::vl_sift_set_window_size</td>
- <td>smaller values let the center of the descriptor count more</td>
- </tr>
-</table>
-
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section sift-intro-extensions Extensions
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<b>Eliminating low-contrast descriptors.</b> Near-uniform patches do
-not yield stable keypoints or descriptors. ::vl_sift_set_norm_thresh()
-can be used to set a threshold on the average norm of the local
-gradient to zero-out descriptors that correspond to very low contrast
-regions. By default, the threshold is equal to zero, which means that
-no descriptor is zeroed. Normally this option is useful only with
-custom keypoints, as detected keypoints are implicitly selected at
-high contrast image regions.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section sift-usage Using the SIFT filter object
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The code provided in this module can be used in different ways.  You
-can instantiate and use a <b>SIFT filter</b> to extract both SIFT
-keypoints and descriptors from one or multiple images. Alternatively,
-you can use one of the low level functions to run only a part of the
-SIFT algorithm (for instance, to compute the SIFT descriptors of
-custom keypoints).
-
-To use a <b>SIFT filter</b> object:
-
-- Initialize a SIFT filter object with ::vl_sift_new(). The filter can
-  be reused for multiple images of the same size (e.g. for an entire
-  video sequence).
-- For each octave in the scale space:
-  - Compute the next octave of the DOG scale space using either
-   ::vl_sift_process_first_octave() or ::vl_sift_process_next_octave()
-   (stop processing if ::VL_ERR_EOF is returned).
-  - Run the SIFT detector with ::vl_sift_detect() to get the keypoints.
-  - For each keypoint:
-    - Use ::vl_sift_calc_keypoint_orientations() to get the keypoint orientation(s).
-    - For each orientation:
-      - Use ::vl_sift_calc_keypoint_descriptor() to get the keypoint descriptor.
-- Delete the SIFT filter by ::vl_sift_delete().
-
-To compute SIFT descriptors of custom keypoints, use
-::vl_sift_calc_raw_descriptor().
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section sift-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-tech-ss Scale space
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-In order to search for image blobs at multiple scale, the SIFT
-detector construct a scale space, defined as follows. Let
-@f$I_0(\mathbf{x})@f$ denote an idealized <em>infinite resolution</em>
-image. Consider the  <em>Gaussian kernel</em>
-
-@f[
- g_{\sigma}(\mathbf{x})
- =
- \frac{1}{2\pi\sigma^2}
- \exp
- \left(
- -\frac{1}{2}
- \frac{\mathbf{x}^\top\mathbf{x}}{\sigma^2}
- \right)
-@f]
-
-The <b>Gaussian scale space</b> is the collection of smoothed images
-
-@f[
- I_\sigma = g_\sigma * I,  \quad \sigma \geq 0.
-@f]
-
-The image at infinite resolution @f$ I_0 @f$ is useful conceptually,
-but is not available to us; instead, the input image @f$ I_{\sigma_n}
-@f$ is assumed to be pre-smoothed at a nominal level @f$ \sigma_n =
-0.5 @f$ to account for the finite resolution of the pixels. Thus in
-practice the scale space is computed by
-
-@f[
-I_\sigma = g_{\sqrt{\sigma^2 - \sigma_n^2}} * I_{\sigma_n},
-\quad \sigma \geq \sigma_n.
-@f]
-
-Scales are sampled at logarithmic steps given by
-
-@f[
-\sigma = \sigma_0 2^{o+s/S},
-\quad s = 0,\dots,S-1,
-\quad o = o_{\min}, \dots, o_{\min}+O-1,
-@f]
-
-where @f$ \sigma_0 = 1.6 @f$ is the <em>base scale</em>, @f$ o_{\min}
-@f$ is the <em>first octave index</em>, @em O the <em>number of
-octaves</em> and @em S the <em>number of scales per octave</em>.
-
-Blobs are detected as local extrema of the <b>Difference of
-Gaussians</b> (DoG) scale space, obtained by subtracting successive
-scales of the Gaussian scale space:
-
-@f[
-\mathrm{DoG}_{\sigma(o,s)} = I_{\sigma(o,s+1)} - I_{\sigma(o,s)}
-@f]
-
-At each next octave, the resolution of the images is halved to save
-computations. The images composing the Gaussian and DoG scale space
-can then be arranged as in the following figure:
-
-@image html sift-ss.png  "GSS and DoG scale space  structures."
-
-The black vertical segments represent images of the Gaussian Scale
-Space (GSS), arranged by increasing scale @f$\sigma@f$.  Notice that
-the scale level index @e s varies in a slightly redundant set
-
-@f[
-s = -1, \dots, S+2
-@f]
-
-This simplifies glueing together different octaves and extracting DoG
-maxima (required by the SIFT detector).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-tech-detector Detector
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The SIFT frames (keypoints) are extracted based on local extrema
-(peaks) of the DoG scale space. Numerically, local extrema are
-elements whose @f$ 3 \times 3 \times 3 @f$ neighbors (in space and
-scale) have all smaller (or larger) value.  Once extracted, local
-extrema are quadratically interpolated (this is very important
-especially at the lower resolution scales in order to have accurate
-keypoint localization at the full resolution).  Finally, they are
-filtered to eliminate low-contrast responses or responses close to
-edges and the orientation(s) are assigned, as explained next.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsubsection sift-tech-detector-peak Eliminating low contrast responses
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Peaks which are too short may have been generated by noise and are
-discarded.  This is done by comparing the absolute value of the DoG
-scale space at the peak with the <b>peak threshold</b> @f$t_p@f$ and
-discarding the peak its value is below the threshold.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsubsection sift-tech-detector-edge Eliminating edge responses
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Peaks which are too flat are often generated by edges and do not yield
-stable features. These peaks are detected and removed as follows.
-Given a peak @f$x,y,\sigma@f$, the algorithm evaluates the @em x,@em y
-Hessian of of the DoG scale space at the scale @f$\sigma@f$.  Then the
-following score (similar to the Harris function) is computed:
-
-@f[
-\frac{(\mathrm{tr}\,D(x,y,\sigma))^2}{\det D(x,y,\sigma)},
-\quad
-D =
-\left[
-\begin{array}{cc}
-\frac{\partial^2 \mathrm{DoG}}{\partial x^2} &
-\frac{\partial^2 \mathrm{DoG}}{\partial x\partial y} \\
-\frac{\partial^2 \mathrm{DoG}}{\partial x\partial y} &
-\frac{\partial^2 \mathrm{DoG}}{\partial y^2}
-\end{array}
-\right].
- @f]
-
-This score has a minimum (equal to 4) when both eigenvalues of the
-Jacobian are equal (curved peak) and increases as one of the
-eigenvalues grows and the other stays small. Peaks are retained if the
-score is below the quantity @f$(t_e+1)(t_e+1)/t_e@f$, where @f$t_e@f$
-is the <b>edge threshold</b>. Notice that this quantity has a minimum
-equal to 4 when @f$t_e=1@f$ and grows thereafter. Therefore the range
-of the edge threshold is @f$[1,\infty)@f$.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-tech-detector-orientation Orientation assignment
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A peak in the DoG scale space fixes 2 parameters of the keypoint: the
-position and scale. It remains to choose an orientation. In order to
-do this, SIFT computes an histogram of the gradient orientations in a
-Gaussian window with a standard deviation which is 1.5 times bigger
-than the scale @f$\sigma@f$ of the keypoint.
-
-@image html sift-orient.png
-
-This histogram is then smoothed and the maximum is selected.  In
-addition to the biggest mode, up to other three modes whose amplitude
-is within the 80% of the biggest mode are retained and returned as
-additional orientations.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsection sift-tech-descriptor Descriptor
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-A SIFT descriptor of a local region (keypoint) is a 3-D spatial
-histogram of the image gradients.  The gradient at each pixel is
-regarded as a sample of a three-dimensional elementary feature vector,
-formed by the pixel location and the gradient orientation. Samples are
-weighed by the gradient norm and accumulated in a 3-D histogram @em h,
-which (up to normalization and clamping) forms the SIFT descriptor of
-the region. An additional Gaussian weighting function is applied to
-give less importance to gradients farther away from the keypoint
-center.
-
-<!-- @image html sift-bins.png -->
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsubsection sift-tech-descriptor-can Construction in the canonical frame
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Denote the gradient vector field computed at the scale @f$ \sigma @f$ by
-@f[
-  J(x,y) = \nabla I_\sigma(x,y)
-  =
-  \left[\begin{array}{cc}
-  \frac{\partial I_\sigma}{\partial x} &
-  \frac{\partial I_\sigma}{\partial y} &
-  \end{array}\right]
-@f]
-
-The descriptor is a 3-D spatial histogram capturing the distribution
-of @f$ J(x,y) @f$. It is convenient to describe its construction in
-the <em>canonical frame</em>. In this frame, the image and descriptor
-axes coincide and each spatial bin has side 1. The histogram has @f$
-N_\theta \times N_x \times N_y @f$ bins (usually @f$ 8 \times 4 \times
-4 @f$), as in the following figure:
-
-@image html sift-can.png Canonical SIFT descriptor and spatial binning functions
-
-Bins are indexed by a triplet of indexes <em>t, i, j</em> and their
-centers are given by
-
-@f{eqnarray*}
- \theta_t &=& \frac{2\pi}{N_\theta} t, \quad t = 0,\dots,N_{\theta}-1, \\
- x_i &=& i - \frac{N_x -1}{2}, \quad i = 0,\dots,N_x-1, \\
- y_j &=& j - \frac{N_x -1}{2}, \quad j = 0,\dots,N_y-1. \\
-@f}
-
-The histogram is computed by using trilinear interpolation, i.e.  by
-weighing contributions by the <em>binning functions</em>
-
-@f{eqnarray*}
-  \displaystyle
-  w(z) &=& \mathrm{max}(0, 1 - |z|),
-  \\
-  \displaystyle
-  w_\mathrm{ang}(z) &=& \sum_{k=-\infty}^{+\infty}
-  w\left(
-  \frac{N_\theta}{2\pi} z + N_\theta k
-  \right).
-@f}
-
-The gradient vector field is transformed in a three-dimensional
-density map of weighed contributions
-
-@f[
-   f(\theta, x, y) = |J(x,y)| \delta(\theta - \angle J(x,y))
-@f]
-
-The historam is localized in the keypoint support by a Gaussian window
-of standard deviation @f$ \sigma_{\mathrm{win}} @f$. The histogram is
-then given by
-
-@f{eqnarray*}
- h(t,i,j) &=& \int
- g_{\sigma_\mathrm{win}}(x,y)
- w_\mathrm{ang}(\theta - \theta_t) w(x-x_i) w(y-y_j)
- f(\theta,x,y)
- d\theta\,dx\,dy
-\\
-&=& \int
- g_{\sigma_\mathrm{win}}(x,y)
- w_\mathrm{ang}(\angle J(x,y) - \theta_t) w(x-x_i) w(y-y_j)
- |J(x,y)|\,dx\,dy
-@f}
-
-In post processing, the histogram is @f$ l^2 @f$ normalized, then
-clamped at 0.2, and @f$ l^2 @f$ normalized again.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsubsection sift-tech-descriptor-image Calculation in the image frame
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-Invariance to similarity transformation is attained by attaching
-descriptors to SIFT keypoints (or other similarity-covariant frames).
-Then projecting the image in the canonical descriptor frames has the
-effect of undoing the image deformation.
-
-In practice, however, it is convenient to compute the descriptor
-directly in the image frame. To do this, denote with a hat quantities
-relative to the canonical frame and without a hat quantities relative
-to the image frame (so for instance @f$ \hat x @f$ is the @e
-x-coordinate in the canonical frame and @f$ x @f$ the x-coordinate in
-the image frame). Assume that canonical and image frame are
-related by an affinity:
-
-@f[
-  \mathbf{x} = A \hat{\mathbf{x}} + T,
-  \qquad
-  \mathbf{x} =
-  \begin{bmatrix}{c}
-    x \\
-    y
-  \end{bmatrix},
-  \quad
-  \mathbf{x} =
-  \begin{bmatrix}{c}
-    \hat x \\
-    \hat y
-  \end{bmatrix}.
-@f]
-
-@image html sift-image-frame.png
-
-Then all quantities can be computed in the image frame directly. For instance,
-the image at infinite resolution in the two frames are related by
-
-@f[
- \hat I_0(\hat{\mathbf{x}})  = I_0(\mathbf{x}),
- \qquad
- \mathbf{x} = A \hat{\mathbf{x}} + T.
-@f]
-
-The canonized image at scale @f$ \hat \sigma @f$ is in relation with the scaled image
-
-@f[
- \hat I_{\hat{\sigma}}(\hat{\mathbf{x}})  = I_{A\hat{\sigma}}(\mathbf{x}),
- \qquad \mathbf{x} = A \hat{\mathbf{x}} + T
-@f]
-
-where, by generalizing the previous definitions, we have
-
-@f[
- I_{A\hat \sigma}(\mathbf{x}) = (g_{A\hat\sigma} * I_0)(\mathbf{x}),
-\quad
- g_{A\hat\sigma}(\mathbf{x})
- =
- \frac{1}{2\pi|A|\hat \sigma^2}
- \exp
- \left(
- -\frac{1}{2}
- \frac{\mathbf{x}^\top A^{-\top}A^{-1}\mathbf{x}}{\hat \sigma^2}
- \right)
-@f]
-
-Deriving shows that the gradient fields are in relation
-
-@f[
-  \hat J(\hat{\mathbf{x}}) = J(\mathbf{x}) A,
- \quad J(\mathbf{x}) = (\nabla I_{A\hat\sigma})(\mathbf{x}),
- \qquad \mathbf{x} = A \hat{\mathbf{x}} + T.
-@f]
-
-Therefore we can compute the descriptor either in the image or canonical frame as:
-
-@f{eqnarray*}
- h(t,i,j)
- &=&
- \int
- g_{\hat \sigma_\mathrm{win}}(\hat{\mathbf{x}})\,
- w_\mathrm{ang}(\angle \hat J(\hat{\mathbf{x}}) - \theta_t)\,
- w_{ij}(\hat{\mathbf{x}})\,
- |\hat J(\hat{\mathbf{x}})|\,
- d\hat{\mathbf{x}}
- \\
- &=& \int
- g_{A \hat \sigma_\mathrm{win}}(\mathbf{x} - T)\,
- w_\mathrm{ang}(\angle J(\mathbf{x})A - \theta_t)\,
- w_{ij}(A^{-1}(\mathbf{x} - T))\,
- |J(\mathbf{x})A|\,
- d\mathbf{x}.
-@f}
-
-where we defined the product of the two spatial binning functions
-
-@f[
- w_{ij}(\hat{\mathbf{x}}) = w(\hat x - \hat x_i) w(\hat y - \hat y_j)
-@f]
-
-
-In the actual implementation, this integral is computed by visiting a
-rectangular area of the image that fully contains the keypoint grid
-(along with half a bin border to fully include the bin windowing
-function). Since the descriptor can be rotated, this area is a
-rectangle of sides @f$m/2\sqrt{2} (N_x+1,N_y+1)@f$ (see also the
-illustration).
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@subsubsection sift-tech-descriptor-std Standard SIFT descriptor
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-For a SIFT-detected keypoint of center @f$ T @f$, scale @f$ \sigma @f$
-and orientation @f$ \theta @f$, the affine transformation @f$ (A,T)
-@f$ reduces to the similarity transformation
-
-@f[
-     \mathbf{x} = m \sigma R(\theta) \hat{\mathbf{x}} + T
-@f]
-
-where @f$ R(\theta) @f$ is a counter-clockwise rotation of @f$ \theta
-@f$ radians, @f$ m \mathcal{\sigma} @f$ is the size of a descriptor
-bin in pixels, and @e m is the <b>descriptor magnification factor</b>
-which expresses how much larger a descriptor bin is compared to
-the scale of the keypoint @f$ \sigma @f$
-(the default value is @e m = 3). Moreover, the
-standard SIFT descriptor computes the image gradient at the scale of
-the keypoints, which in the canonical frame is equivalent to a
-smoothing of @f$ \hat \sigma = 1/m @f$. Finally, the default
-Gaussian window size is set to have standard deviation
- @f$ \hat \sigma_\mathrm{win} = 2 @f$. This yields the formula
-
-@f{eqnarray*}
- h(t,i,j)
- &=&
- m \sigma \int
- g_{\sigma_\mathrm{win}}(\mathbf{x} - T)\,
- w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta  - \theta_t)\,
- w_{ij}\left(\frac{R(\theta)^\top \mathbf{x} - T}{m\sigma}\right)\,
- |J(\mathbf{x})|\,
- d\mathbf{x},
-\\
-\sigma_{\mathrm{win}} &=& m\sigma\hat \sigma_{\mathrm{win}},
-\\
- J(\mathbf{x})
- &=& \nabla (g_{m \sigma \hat \sigma} * I)(\mathbf{x})
- = \nabla (g_{\sigma} * I)(\mathbf{x})
- = \nabla I_{\sigma} (\mathbf{x}).
-@f}
-
-
-
-**/
-
-#include "sift.h"
-#include "imopv.h"
-#include "mathop.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <stdio.h>
-
-/** @internal @brief Use bilinear interpolation to compute orientations */
-#define VL_SIFT_BILINEAR_ORIENTATIONS 1
-
-#define EXPN_SZ  256          /**< ::fast_expn table size @internal */
-#define EXPN_MAX 25.0         /**< ::fast_expn table max  @internal */
-double expn_tab [EXPN_SZ+1] ; /**< ::fast_expn table      @internal */
-
-#define NBO 8
-#define NBP 4
-
-#define log2(x) (log(x)/VL_LOG_OF_2)
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Fast @f$exp(-x)@f$ approximation
- **
- ** @param x argument.
- **
- ** The argument must be in the range [0, ::EXPN_MAX] .
- **
- ** @return approximation of @f$exp(-x)@f$.
- **/
-
-VL_INLINE double
-fast_expn (double x)
-{
-  double a,b,r ;
-  int i ;
-  /*assert(0 <= x && x <= EXPN_MAX) ;*/
-
-  if (x > EXPN_MAX) return 0.0 ;
-
-  x *= EXPN_SZ / EXPN_MAX ;
-  i = (int)vl_floor_d (x) ;
-  r = x - i ;
-  a = expn_tab [i    ] ;
-  b = expn_tab [i + 1] ;
-  return a + r * (b - a) ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Initialize tables for ::fast_expn
- **/
-
-VL_INLINE void
-fast_expn_init ()
-{
-  int k  ;
-  for(k = 0 ; k < EXPN_SZ + 1 ; ++ k) {
-    expn_tab [k] = exp (- (double) k * (EXPN_MAX / EXPN_SZ)) ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Copy image, upsample rows and take transpose
- **
- ** @param dst     output image buffer.
- ** @param src     input image buffer.
- ** @param width   input image width.
- ** @param height  input image height.
- **
- ** The output image has dimensions @a height by 2 @a width (so the
- ** destination buffer must be at least as big as two times the
- ** input buffer).
- **
- ** Upsampling is performed by linear interpolation.
- **/
-
-static void
-copy_and_upsample_rows
-(vl_sift_pix       *dst,
- vl_sift_pix const *src, int width, int height)
-{
-  int x, y ;
-  vl_sift_pix a, b ;
-
-  for(y = 0 ; y < height ; ++y) {
-    b = a = *src++ ;
-    for(x = 0 ; x < width - 1 ; ++x) {
-      b = *src++ ;
-      *dst = a ;             dst += height ;
-      *dst = 0.5 * (a + b) ; dst += height ;
-      a = b ;
-    }
-    *dst = b ; dst += height ;
-    *dst = b ; dst += height ;
-    dst += 1 - width * 2 * height ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Smooth an image
- ** @param self        SIFT filter.
- ** @param outputImage output imgae buffer.
- ** @param tempImage   temporary image buffer.
- ** @param inputImage  input image buffer.
- ** @param width       input image width.
- ** @param height      input image height.
- ** @param sigma       smoothing.
- **/
-
-static void
-_vl_sift_smooth (VlSiftFilt * self,
-                 vl_sift_pix * outputImage,
-                 vl_sift_pix * tempImage,
-                 vl_sift_pix const * inputImage,
-                 vl_size width,
-                 vl_size height,
-                 double sigma)
-{
-  /* prepare Gaussian filter */
-  if (self->gaussFilterSigma != sigma) {
-    vl_uindex j ;
-    vl_sift_pix acc = 0 ;
-    if (self->gaussFilter) vl_free (self->gaussFilter) ;
-    self->gaussFilterWidth = VL_MAX(ceil(4.0 * sigma), 1) ;
-    self->gaussFilterSigma = sigma ;
-    self->gaussFilter = vl_malloc (sizeof(vl_sift_pix) * (2 * self->gaussFilterWidth + 1)) ;
-
-    for (j = 0 ; j < 2 * self->gaussFilterWidth + 1 ; ++j) {
-      vl_sift_pix d = ((vl_sift_pix)((signed)j - (signed)self->gaussFilterWidth)) / ((vl_sift_pix)sigma) ;
-      self->gaussFilter[j] = (vl_sift_pix) exp (- 0.5 * (d*d)) ;
-      acc += self->gaussFilter[j] ;
-    }
-    for (j = 0 ; j < 2 * self->gaussFilterWidth + 1 ; ++j) {
-      self->gaussFilter[j] /= acc ;
-    }
-  }
-
-  if (self->gaussFilterWidth == 0) {
-    memcpy (outputImage, inputImage, sizeof(vl_sift_pix) * width * height) ;
-    return ;
-  }
-
-  vl_imconvcol_vf (tempImage, height,
-                   inputImage, width, height, width,
-                   self->gaussFilter,
-                   - self->gaussFilterWidth, self->gaussFilterWidth,
-                   1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
-
-  vl_imconvcol_vf (outputImage, width,
-                   tempImage, height, width, height,
-                   self->gaussFilter,
-                   - self->gaussFilterWidth, self->gaussFilterWidth,
-                   1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
-}
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Copy and downsample an image
- **
- ** @param dst    output imgae buffer.
- ** @param src    input  image buffer.
- ** @param width  input  image width.
- ** @param height input  image height.
- ** @param d      octaves (non negative).
- **
- ** The function downsamples the image @a d times, reducing it to @c
- ** 1/2^d of its original size. The parameters @a width and @a height
- ** are the size of the input image. The destination image @a dst is
- ** assumed to be <code>floor(width/2^d)</code> pixels wide and
- ** <code>floor(height/2^d)</code> pixels high.
- **/
-
-static void
-copy_and_downsample
-(vl_sift_pix       *dst,
- vl_sift_pix const *src,
- int width, int height, int d)
-{
-  int x, y ;
-
-  d = 1 << d ; /* d = 2^d */
-  for(y = 0 ; y < height ; y+=d) {
-    vl_sift_pix const * srcrowp = src + y * width ;
-    for(x = 0 ; x < width - (d-1) ; x+=d) {
-      *dst++ = *srcrowp ;
-      srcrowp += d ;
-    }
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Create a new SIFT filter
- **
- ** @param width    image width.
- ** @param height   image height.
- ** @param noctaves number of octaves.
- ** @param nlevels  number of levels per octave.
- ** @param o_min    first octave index.
- **
- ** The function allocates and returns a new SIFT filter for the
- ** specified image and scale space geometry.
- **
- ** Setting @a O to a negative value sets the number of octaves to the
- ** maximum possible value depending on the size of the image.
- **
- ** @return the new SIFT filter.
- ** @sa ::vl_sift_delete().
- **/
-
-VL_EXPORT
-VlSiftFilt *
-vl_sift_new (int width, int height,
-             int noctaves, int nlevels,
-             int o_min)
-{
-  VlSiftFilt *f = vl_malloc (sizeof(VlSiftFilt)) ;
-
-  int w   = VL_SHIFT_LEFT (width,  -o_min) ;
-  int h   = VL_SHIFT_LEFT (height, -o_min) ;
-  int nel = w * h ;
-
-  /* negative value O => calculate max. value */
-  if (noctaves < 0) {
-    noctaves = VL_MAX (floor (log2 (VL_MIN(width, height))) - o_min - 3, 1) ;
-  }
-
-  f-> width   = width ;
-  f-> height  = height ;
-  f-> O       = noctaves ;
-  f-> S       = nlevels ;
-  f-> o_min   = o_min ;
-  f-> s_min   = -1 ;
-  f-> s_max   = nlevels + 1 ;
-  f-> o_cur   = o_min ;
-
-  f-> temp    = vl_malloc (sizeof(vl_sift_pix) * nel    ) ;
-  f-> octave  = vl_malloc (sizeof(vl_sift_pix) * nel
-                        * (f->s_max - f->s_min + 1)  ) ;
-  f-> dog     = vl_malloc (sizeof(vl_sift_pix) * nel
-                        * (f->s_max - f->s_min    )  ) ;
-  f-> grad    = vl_malloc (sizeof(vl_sift_pix) * nel * 2
-                        * (f->s_max - f->s_min    )  ) ;
-
-  f-> sigman  = 0.5 ;
-  f-> sigmak  = pow (2.0, 1.0 / nlevels) ;
-  f-> sigma0  = 1.6 * f->sigmak ;
-  f-> dsigma0 = f->sigma0 * sqrt (1.0 - 1.0 / (f->sigmak*f->sigmak)) ;
-
-  f-> gaussFilter = NULL ;
-  f-> gaussFilterSigma = 0 ;
-  f-> gaussFilterWidth = 0 ;
-
-  f-> octave_width  = 0 ;
-  f-> octave_height = 0 ;
-
-  f-> keys     = 0 ;
-  f-> nkeys    = 0 ;
-  f-> keys_res = 0 ;
-
-  f-> peak_thresh = 0.0 ;
-  f-> edge_thresh = 10.0 ;
-  f-> norm_thresh = 0.0 ;
-  f-> magnif      = 3.0 ;
-  f-> windowSize  = NBP / 2 ;
-
-  f-> grad_o  = o_min - 1 ;
-
-  /* initialize fast_expn stuff */
-  fast_expn_init () ;
-
-  return f ;
-}
-
-/** -------------------------------------------------------------------
- ** @brief Delete SIFT filter
- **
- ** @param f SIFT filter to delete.
- **
- ** The function frees the resources allocated by ::vl_sift_new().
- **/
-
-VL_EXPORT
-void
-vl_sift_delete (VlSiftFilt* f)
-{
-  if (f) {
-    if (f->keys) vl_free (f->keys) ;
-    if (f->grad) vl_free (f->grad) ;
-    if (f->dog) vl_free (f->dog) ;
-    if (f->octave) vl_free (f->octave) ;
-    if (f->temp) vl_free (f->temp) ;
-    if (f->gaussFilter) vl_free (f->gaussFilter) ;
-    vl_free (f) ;
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Start processing a new image
- **
- ** @param f  SIFT filter.
- ** @param im image data.
- **
- ** The function starts processing a new image by computing its
- ** Gaussian scale space at the lower octave. It also empties the
- ** internal keypoint buffer.
- **
- ** @return error code. The function returns ::VL_ERR_EOF if there are
- ** no more octaves to process.
- **
- ** @sa ::vl_sift_process_next_octave().
- **/
-
-VL_EXPORT
-int
-vl_sift_process_first_octave (VlSiftFilt *f, vl_sift_pix const *im)
-{
-  int o, s, h, w ;
-  double sa, sb ;
-  vl_sift_pix *octave ;
-
-  /* shortcuts */
-  vl_sift_pix *temp   = f-> temp ;
-  int width           = f-> width ;
-  int height          = f-> height ;
-  int o_min           = f-> o_min ;
-  int s_min           = f-> s_min ;
-  int s_max           = f-> s_max ;
-  double sigma0       = f-> sigma0 ;
-  double sigmak       = f-> sigmak ;
-  double sigman       = f-> sigman ;
-  double dsigma0      = f-> dsigma0 ;
-
-  /* restart from the first */
-  f->o_cur = o_min ;
-  f->nkeys = 0 ;
-  w = f-> octave_width  = VL_SHIFT_LEFT(f->width,  - f->o_cur) ;
-  h = f-> octave_height = VL_SHIFT_LEFT(f->height, - f->o_cur) ;
-
-  /* is there at least one octave? */
-  if (f->O == 0)
-    return VL_ERR_EOF ;
-
-  /* ------------------------------------------------------------------
-   *                     Compute the first sublevel of the first octave
-   * --------------------------------------------------------------- */
-
-  /*
-   * If the first octave has negative index, we upscale the image; if
-   * the first octave has positive index, we downscale the image; if
-   * the first octave has index zero, we just copy the image.
-   */
-
-  octave = vl_sift_get_octave (f, s_min) ;
-
-  if (o_min < 0) {
-    /* double once */
-    copy_and_upsample_rows (temp,   im,   width,      height) ;
-    copy_and_upsample_rows (octave, temp, height, 2 * width ) ;
-
-    /* double more */
-    for(o = -1 ; o > o_min ; --o) {
-      copy_and_upsample_rows (temp, octave,
-                              width << -o,      height << -o ) ;
-      copy_and_upsample_rows (octave, temp,
-                              width << -o, 2 * (height << -o)) ;
-    }
-  }
-  else if (o_min > 0) {
-    /* downsample */
-    copy_and_downsample (octave, im, width, height, o_min) ;
-  }
-  else {
-    /* direct copy */
-    memcpy(octave, im, sizeof(vl_sift_pix) * width * height) ;
-  }
-
-  /*
-   * Here we adjust the smoothing of the first level of the octave.
-   * The input image is assumed to have nominal smoothing equal to
-   * f->simgan.
-   */
-
-  sa = sigma0 * pow (sigmak,   s_min) ;
-  sb = sigman * pow (2.0,    - o_min) ;
-
-  if (sa > sb) {
-    double sd = sqrt (sa*sa - sb*sb) ;
-    _vl_sift_smooth (f, octave, temp, octave, w, h, sd) ;
-  }
-
-  /* -----------------------------------------------------------------
-   *                                          Compute the first octave
-   * -------------------------------------------------------------- */
-
-  for(s = s_min + 1 ; s <= s_max ; ++s) {
-    double sd = dsigma0 * pow (sigmak, s) ;
-    _vl_sift_smooth (f, vl_sift_get_octave(f, s), temp,
-                     vl_sift_get_octave(f, s - 1), w, h, sd) ;
-  }
-
-  return VL_ERR_OK ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Process next octave
- **
- ** @param f SIFT filter.
- **
- ** The function computes the next octave of the Gaussian scale space.
- ** Notice that this clears the record of any feature detected in the
- ** previous octave.
- **
- ** @return error code. The function returns the error
- ** ::VL_ERR_EOF when there are no more octaves to process.
- **
- ** @sa ::vl_sift_process_first_octave().
- **/
-
-VL_EXPORT
-int
-vl_sift_process_next_octave (VlSiftFilt *f)
-{
-
-  int s, h, w, s_best ;
-  double sa, sb ;
-  vl_sift_pix *octave, *pt ;
-
-  /* shortcuts */
-  vl_sift_pix *temp   = f-> temp ;
-  int O               = f-> O ;
-  int S               = f-> S ;
-  int o_min           = f-> o_min ;
-  int s_min           = f-> s_min ;
-  int s_max           = f-> s_max ;
-  double sigma0       = f-> sigma0 ;
-  double sigmak       = f-> sigmak ;
-  double dsigma0      = f-> dsigma0 ;
-
-  /* is there another octave ? */
-  if (f->o_cur == o_min + O - 1)
-    return VL_ERR_EOF ;
-
-  /* retrieve base */
-  s_best = VL_MIN(s_min + S, s_max) ;
-  w      = vl_sift_get_octave_width  (f) ;
-  h      = vl_sift_get_octave_height (f) ;
-  pt     = vl_sift_get_octave        (f, s_best) ;
-  octave = vl_sift_get_octave        (f, s_min) ;
-
-  /* next octave */
-  copy_and_downsample (octave, pt, w, h, 1) ;
-
-  f-> o_cur            += 1 ;
-  f-> nkeys             = 0 ;
-  w = f-> octave_width  = VL_SHIFT_LEFT(f->width,  - f->o_cur) ;
-  h = f-> octave_height = VL_SHIFT_LEFT(f->height, - f->o_cur) ;
-
-  sa = sigma0 * powf (sigmak, s_min     ) ;
-  sb = sigma0 * powf (sigmak, s_best - S) ;
-
-  if (sa > sb) {
-    double sd = sqrt (sa*sa - sb*sb) ;
-    _vl_sift_smooth (f, octave, temp, octave, w, h, sd) ;
-  }
-
-  /* ------------------------------------------------------------------
-   *                                                        Fill octave
-   * --------------------------------------------------------------- */
-
-  for(s = s_min + 1 ; s <= s_max ; ++s) {
-    double sd = dsigma0 * pow (sigmak, s) ;
-    _vl_sift_smooth (f, vl_sift_get_octave(f, s), temp,
-                     vl_sift_get_octave(f, s - 1), w, h, sd) ;
-  }
-
-  return VL_ERR_OK ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Detect keypoints
- **
- ** The function detect keypoints in the current octave filling the
- ** internal keypoint buffer. Keypoints can be retrieved by
- ** ::vl_sift_get_keypoints().
- **
- ** @param f SIFT filter.
- **/
-
-VL_EXPORT
-void
-vl_sift_detect (VlSiftFilt * f)
-{
-  vl_sift_pix* dog   = f-> dog ;
-  int          s_min = f-> s_min ;
-  int          s_max = f-> s_max ;
-  int          w     = f-> octave_width ;
-  int          h     = f-> octave_height ;
-  double       te    = f-> edge_thresh ;
-  double       tp    = f-> peak_thresh ;
-
-  int const    xo    = 1 ;      /* x-stride */
-  int const    yo    = w ;      /* y-stride */
-  int const    so    = w * h ;  /* s-stride */
-
-  double       xper  = pow (2.0, f->o_cur) ;
-
-  int x, y, s, i, ii, jj ;
-  vl_sift_pix *pt, v ;
-  VlSiftKeypoint *k ;
-
-  /* clear current list */
-  f-> nkeys = 0 ;
-
-  /* compute difference of gaussian (DoG) */
-  pt = f-> dog ;
-  for (s = s_min ; s <= s_max - 1 ; ++s) {
-    vl_sift_pix* src_a = vl_sift_get_octave (f, s    ) ;
-    vl_sift_pix* src_b = vl_sift_get_octave (f, s + 1) ;
-    vl_sift_pix* end_a = src_a + w * h ;
-    while (src_a != end_a) {
-      *pt++ = *src_b++ - *src_a++ ;
-    }
-  }
-
-  /* -----------------------------------------------------------------
-   *                                          Find local maxima of DoG
-   * -------------------------------------------------------------- */
-
-  /* start from dog [1,1,s_min+1] */
-  pt  = dog + xo + yo + so ;
-
-  for(s = s_min + 1 ; s <= s_max - 2 ; ++s) {
-    for(y = 1 ; y < h - 1 ; ++y) {
-      for(x = 1 ; x < w - 1 ; ++x) {
-        v = *pt ;
-
-#define CHECK_NEIGHBORS(CMP,SGN)                    \
-        ( v CMP ## = SGN 0.8 * tp &&                \
-          v CMP *(pt + xo) &&                       \
-          v CMP *(pt - xo) &&                       \
-          v CMP *(pt + so) &&                       \
-          v CMP *(pt - so) &&                       \
-          v CMP *(pt + yo) &&                       \
-          v CMP *(pt - yo) &&                       \
-                                                    \
-          v CMP *(pt + yo + xo) &&                  \
-          v CMP *(pt + yo - xo) &&                  \
-          v CMP *(pt - yo + xo) &&                  \
-          v CMP *(pt - yo - xo) &&                  \
-                                                    \
-          v CMP *(pt + xo      + so) &&             \
-          v CMP *(pt - xo      + so) &&             \
-          v CMP *(pt + yo      + so) &&             \
-          v CMP *(pt - yo      + so) &&             \
-          v CMP *(pt + yo + xo + so) &&             \
-          v CMP *(pt + yo - xo + so) &&             \
-          v CMP *(pt - yo + xo + so) &&             \
-          v CMP *(pt - yo - xo + so) &&             \
-                                                    \
-          v CMP *(pt + xo      - so) &&             \
-          v CMP *(pt - xo      - so) &&             \
-          v CMP *(pt + yo      - so) &&             \
-          v CMP *(pt - yo      - so) &&             \
-          v CMP *(pt + yo + xo - so) &&             \
-          v CMP *(pt + yo - xo - so) &&             \
-          v CMP *(pt - yo + xo - so) &&             \
-          v CMP *(pt - yo - xo - so) )
-
-        if (CHECK_NEIGHBORS(>,+) ||
-            CHECK_NEIGHBORS(<,-) ) {
-
-          /* make room for more keypoints */
-          if (f->nkeys >= f->keys_res) {
-            f->keys_res += 500 ;
-            if (f->keys) {
-              f->keys = vl_realloc (f->keys,
-                                    f->keys_res *
-                                    sizeof(VlSiftKeypoint)) ;
-            } else {
-              f->keys = vl_malloc (f->keys_res *
-                                   sizeof(VlSiftKeypoint)) ;
-            }
-          }
-
-          k = f->keys + (f->nkeys ++) ;
-
-          k-> ix = x ;
-          k-> iy = y ;
-          k-> is = s ;
-        }
-        pt += 1 ;
-      }
-      pt += 2 ;
-    }
-    pt += 2 * yo ;
-  }
-
-  /* -----------------------------------------------------------------
-   *                                               Refine local maxima
-   * -------------------------------------------------------------- */
-
-  /* this pointer is used to write the keypoints back */
-  k = f->keys ;
-
-  for (i = 0 ; i < f->nkeys ; ++i) {
-
-    int x = f-> keys [i] .ix ;
-    int y = f-> keys [i] .iy ;
-    int s = f-> keys [i]. is ;
-
-    double Dx=0,Dy=0,Ds=0,Dxx=0,Dyy=0,Dss=0,Dxy=0,Dxs=0,Dys=0 ;
-    double A [3*3], b [3] ;
-
-    int dx = 0 ;
-    int dy = 0 ;
-
-    int iter, i, j ;
-
-    for (iter = 0 ; iter < 5 ; ++iter) {
-
-      x += dx ;
-      y += dy ;
-
-      pt = dog
-        + xo * x
-        + yo * y
-        + so * (s - s_min) ;
-
-      /** @brief Index GSS @internal */
-#define at(dx,dy,ds) (*( pt + (dx)*xo + (dy)*yo + (ds)*so))
-
-      /** @brief Index matrix A @internal */
-#define Aat(i,j)     (A[(i)+(j)*3])
-
-      /* compute the gradient */
-      Dx = 0.5 * (at(+1,0,0) - at(-1,0,0)) ;
-      Dy = 0.5 * (at(0,+1,0) - at(0,-1,0));
-      Ds = 0.5 * (at(0,0,+1) - at(0,0,-1)) ;
-
-      /* compute the Hessian */
-      Dxx = (at(+1,0,0) + at(-1,0,0) - 2.0 * at(0,0,0)) ;
-      Dyy = (at(0,+1,0) + at(0,-1,0) - 2.0 * at(0,0,0)) ;
-      Dss = (at(0,0,+1) + at(0,0,-1) - 2.0 * at(0,0,0)) ;
-
-      Dxy = 0.25 * ( at(+1,+1,0) + at(-1,-1,0) - at(-1,+1,0) - at(+1,-1,0) ) ;
-      Dxs = 0.25 * ( at(+1,0,+1) + at(-1,0,-1) - at(-1,0,+1) - at(+1,0,-1) ) ;
-      Dys = 0.25 * ( at(0,+1,+1) + at(0,-1,-1) - at(0,-1,+1) - at(0,+1,-1) ) ;
-
-      /* solve linear system ....................................... */
-      Aat(0,0) = Dxx ;
-      Aat(1,1) = Dyy ;
-      Aat(2,2) = Dss ;
-      Aat(0,1) = Aat(1,0) = Dxy ;
-      Aat(0,2) = Aat(2,0) = Dxs ;
-      Aat(1,2) = Aat(2,1) = Dys ;
-
-      b[0] = - Dx ;
-      b[1] = - Dy ;
-      b[2] = - Ds ;
-
-      /* Gauss elimination */
-      for(j = 0 ; j < 3 ; ++j) {
-        double maxa    = 0 ;
-        double maxabsa = 0 ;
-        int    maxi    = -1 ;
-        double tmp ;
-
-        /* look for the maximally stable pivot */
-        for (i = j ; i < 3 ; ++i) {
-          double a    = Aat (i,j) ;
-          double absa = vl_abs_d (a) ;
-          if (absa > maxabsa) {
-            maxa    = a ;
-            maxabsa = absa ;
-            maxi    = i ;
-          }
-        }
-
-        /* if singular give up */
-        if (maxabsa < 1e-10f) {
-          b[0] = 0 ;
-          b[1] = 0 ;
-          b[2] = 0 ;
-          break ;
-        }
-
-        i = maxi ;
-
-        /* swap j-th row with i-th row and normalize j-th row */
-        for(jj = j ; jj < 3 ; ++jj) {
-          tmp = Aat(i,jj) ; Aat(i,jj) = Aat(j,jj) ; Aat(j,jj) = tmp ;
-          Aat(j,jj) /= maxa ;
-        }
-        tmp = b[j] ; b[j] = b[i] ; b[i] = tmp ;
-        b[j] /= maxa ;
-
-        /* elimination */
-        for (ii = j+1 ; ii < 3 ; ++ii) {
-          double x = Aat(ii,j) ;
-          for (jj = j ; jj < 3 ; ++jj) {
-            Aat(ii,jj) -= x * Aat(j,jj) ;
-          }
-          b[ii] -= x * b[j] ;
-        }
-      }
-
-      /* backward substitution */
-      for (i = 2 ; i > 0 ; --i) {
-        double x = b[i] ;
-        for (ii = i-1 ; ii >= 0 ; --ii) {
-          b[ii] -= x * Aat(ii,i) ;
-        }
-      }
-
-      /* .......................................................... */
-      /* If the translation of the keypoint is big, move the keypoint
-       * and re-iterate the computation. Otherwise we are all set.
-       */
-
-      dx= ((b[0] >  0.6 && x < w - 2) ?  1 : 0)
-        + ((b[0] < -0.6 && x > 1    ) ? -1 : 0) ;
-
-      dy= ((b[1] >  0.6 && y < h - 2) ?  1 : 0)
-        + ((b[1] < -0.6 && y > 1    ) ? -1 : 0) ;
-
-      if (dx == 0 && dy == 0) break ;
-    }
-
-    /* check threshold and other conditions */
-    {
-      double val   = at(0,0,0)
-        + 0.5 * (Dx * b[0] + Dy * b[1] + Ds * b[2]) ;
-      double score = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
-      double xn = x + b[0] ;
-      double yn = y + b[1] ;
-      double sn = s + b[2] ;
-
-      vl_bool good =
-        vl_abs_d (val)  > tp                  &&
-        score           < (te+1)*(te+1)/te    &&
-        score           >= 0                  &&
-        vl_abs_d (b[0]) <  1.5                &&
-        vl_abs_d (b[1]) <  1.5                &&
-        vl_abs_d (b[2]) <  1.5                &&
-        xn              >= 0                  &&
-        xn              <= w - 1              &&
-        yn              >= 0                  &&
-        yn              <= h - 1              &&
-        sn              >= s_min              &&
-        sn              <= s_max ;
-
-      if (good) {
-        k-> o     = f->o_cur ;
-        k-> ix    = x ;
-        k-> iy    = y ;
-        k-> is    = s ;
-        k-> s     = sn ;
-        k-> x     = xn * xper ;
-        k-> y     = yn * xper ;
-        k-> sigma = f->sigma0 * pow (2.0, sn/f->S) * xper ;
-        ++ k ;
-      }
-
-    } /* done checking */
-  } /* next keypoint to refine */
-
-  /* update keypoint count */
-  f-> nkeys = (int)(k - f->keys) ;
-}
-
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Update gradients to current GSS octave
- **
- ** @param f SIFT filter.
- **
- ** The function makes sure that the gradient buffer is up-to-date
- ** with the current GSS data.
- **
- ** @remark The minimum octave size is 2x2xS.
- **/
-
-static void
-update_gradient (VlSiftFilt *f)
-{
-  int       s_min = f->s_min ;
-  int       s_max = f->s_max ;
-  int       w     = vl_sift_get_octave_width  (f) ;
-  int       h     = vl_sift_get_octave_height (f) ;
-  int const xo    = 1 ;
-  int const yo    = w ;
-  int const so    = h * w ;
-  int y, s ;
-
-  if (f->grad_o == f->o_cur) return ;
-
-  for (s  = s_min + 1 ;
-       s <= s_max - 2 ; ++ s) {
-
-    vl_sift_pix *src, *end, *grad, gx, gy ;
-
-#define SAVE_BACK                                                       \
-    *grad++ = vl_fast_sqrt_f (gx*gx + gy*gy) ;                          \
-    *grad++ = vl_mod_2pi_f   (vl_fast_atan2_f (gy, gx) + 2*VL_PI) ;     \
-    ++src ;                                                             \
-
-    src  = vl_sift_get_octave (f,s) ;
-    grad = f->grad + 2 * so * (s - s_min -1) ;
-
-    /* first pixel of the first row */
-    gx = src[+xo] - src[0] ;
-    gy = src[+yo] - src[0] ;
-    SAVE_BACK ;
-
-    /* middle pixels of the  first row */
-    end = (src - 1) + w - 1 ;
-    while (src < end) {
-      gx = 0.5 * (src[+xo] - src[-xo]) ;
-      gy =        src[+yo] - src[0] ;
-      SAVE_BACK ;
-    }
-
-    /* last pixel of the first row */
-    gx = src[0]   - src[-xo] ;
-    gy = src[+yo] - src[0] ;
-    SAVE_BACK ;
-
-    for (y = 1 ; y < h -1 ; ++y) {
-
-      /* first pixel of the middle rows */
-      gx =        src[+xo] - src[0] ;
-      gy = 0.5 * (src[+yo] - src[-yo]) ;
-      SAVE_BACK ;
-
-      /* middle pixels of the middle rows */
-      end = (src - 1) + w - 1 ;
-      while (src < end) {
-        gx = 0.5 * (src[+xo] - src[-xo]) ;
-        gy = 0.5 * (src[+yo] - src[-yo]) ;
-        SAVE_BACK ;
-      }
-
-      /* last pixel of the middle row */
-      gx =        src[0]   - src[-xo] ;
-      gy = 0.5 * (src[+yo] - src[-yo]) ;
-      SAVE_BACK ;
-    }
-
-    /* first pixel of the last row */
-    gx = src[+xo] - src[0] ;
-    gy = src[  0] - src[-yo] ;
-    SAVE_BACK ;
-
-    /* middle pixels of the last row */
-    end = (src - 1) + w - 1 ;
-    while (src < end) {
-      gx = 0.5 * (src[+xo] - src[-xo]) ;
-      gy =        src[0]   - src[-yo] ;
-      SAVE_BACK ;
-    }
-
-    /* last pixel of the last row */
-    gx = src[0]   - src[-xo] ;
-    gy = src[0]   - src[-yo] ;
-    SAVE_BACK ;
-  }
-  f->grad_o = f->o_cur ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Calculate the keypoint orientation(s)
- **
- ** @param f        SIFT filter.
- ** @param angles   orientations (output).
- ** @param k        keypoint.
- **
- ** The function computes the orientation(s) of the keypoint @a k.
- ** The function returns the number of orientations found (up to
- ** four). The orientations themselves are written to the vector @a
- ** angles.
- **
- ** @remark The function requires the keypoint octave @a k->o to be
- ** equal to the filter current octave ::vl_sift_get_octave. If this
- ** is not the case, the function returns zero orientations.
- **
- ** @remark The function requires the keypoint scale level @c k->s to
- ** be in the range @c s_min+1 and @c s_max-2 (where usually @c
- ** s_min=0 and @c s_max=S+2). If this is not the case, the function
- ** returns zero orientations.
- **
- ** @return number of orientations found.
- **/
-
-VL_EXPORT
-int
-vl_sift_calc_keypoint_orientations (VlSiftFilt *f,
-                                    double angles [4],
-                                    VlSiftKeypoint const *k)
-{
-  double const winf   = 1.5 ;
-  double       xper   = pow (2.0, f->o_cur) ;
-
-  int          w      = f-> octave_width ;
-  int          h      = f-> octave_height ;
-  int const    xo     = 2 ;         /* x-stride */
-  int const    yo     = 2 * w ;     /* y-stride */
-  int const    so     = 2 * w * h ; /* s-stride */
-  double       x      = k-> x     / xper ;
-  double       y      = k-> y     / xper ;
-  double       sigma  = k-> sigma / xper ;
-
-  int          xi     = (int) (x + 0.5) ;
-  int          yi     = (int) (y + 0.5) ;
-  int          si     = k-> is ;
-
-  double const sigmaw = winf * sigma ;
-  int          W      = VL_MAX(floor (3.0 * sigmaw), 1) ;
-
-  int          nangles= 0 ;
-
-  enum {nbins = 36} ;
-
-  double hist [nbins], maxh ;
-  vl_sift_pix const * pt ;
-  int xs, ys, iter, i ;
-
-  /* skip if the keypoint octave is not current */
-  if(k->o != f->o_cur)
-    return 0 ;
-
-  /* skip the keypoint if it is out of bounds */
-  if(xi < 0            ||
-     xi > w - 1        ||
-     yi < 0            ||
-     yi > h - 1        ||
-     si < f->s_min + 1 ||
-     si > f->s_max - 2  ) {
-    return 0 ;
-  }
-
-  /* make gradient up to date */
-  update_gradient (f) ;
-
-  /* clear histogram */
-  memset (hist, 0, sizeof(double) * nbins) ;
-
-  /* compute orientation histogram */
-  pt = f-> grad + xo*xi + yo*yi + so*(si - f->s_min - 1) ;
-
-#undef  at
-#define at(dx,dy) (*(pt + xo * (dx) + yo * (dy)))
-
-  for(ys  =  VL_MAX (- W,       - yi) ;
-      ys <=  VL_MIN (+ W, h - 1 - yi) ; ++ys) {
-
-    for(xs  = VL_MAX (- W,       - xi) ;
-        xs <= VL_MIN (+ W, w - 1 - xi) ; ++xs) {
-
-
-      double dx = (double)(xi + xs) - x;
-      double dy = (double)(yi + ys) - y;
-      double r2 = dx*dx + dy*dy ;
-      double wgt, mod, ang, fbin ;
-
-      /* limit to a circular window */
-      if (r2 >= W*W + 0.6) continue ;
-
-      wgt  = fast_expn (r2 / (2*sigmaw*sigmaw)) ;
-      mod  = *(pt + xs*xo + ys*yo    ) ;
-      ang  = *(pt + xs*xo + ys*yo + 1) ;
-      fbin = nbins * ang / (2 * VL_PI) ;
-
-#if defined(VL_SIFT_BILINEAR_ORIENTATIONS)
-      {
-        int bin = (int) vl_floor_d (fbin - 0.5) ;
-        double rbin = fbin - bin - 0.5 ;
-        hist [(bin + nbins) % nbins] += (1 - rbin) * mod * wgt ;
-        hist [(bin + 1    ) % nbins] += (    rbin) * mod * wgt ;
-      }
-#else
-      {
-        int    bin  = vl_floor_d (fbin) ;
-        bin = vl_floor_d (nbins * ang / (2*VL_PI)) ;
-        hist [(bin) % nbins] += mod * wgt ;
-      }
-#endif
-
-    } /* for xs */
-  } /* for ys */
-
-  /* smooth histogram */
-  for (iter = 0; iter < 6; iter ++) {
-    double prev  = hist [nbins - 1] ;
-    double first = hist [0] ;
-    int i ;
-    for (i = 0; i < nbins - 1; i++) {
-      double newh = (prev + hist[i] + hist[(i+1) % nbins]) / 3.0;
-      prev = hist[i] ;
-      hist[i] = newh ;
-    }
-    hist[i] = (prev + hist[i] + first) / 3.0 ;
-  }
-
-  /* find the histogram maximum */
-  maxh = 0 ;
-  for (i = 0 ; i < nbins ; ++i)
-    maxh = VL_MAX (maxh, hist [i]) ;
-
-  /* find peaks within 80% from max */
-  nangles = 0 ;
-  for(i = 0 ; i < nbins ; ++i) {
-    double h0 = hist [i] ;
-    double hm = hist [(i - 1 + nbins) % nbins] ;
-    double hp = hist [(i + 1 + nbins) % nbins] ;
-
-    /* is this a peak? */
-    if (h0 > 0.8*maxh && h0 > hm && h0 > hp) {
-
-      /* quadratic interpolation */
-      double di = - 0.5 * (hp - hm) / (hp + hm - 2 * h0) ;
-      double th = 2 * VL_PI * (i + di + 0.5) / nbins ;
-      angles [ nangles++ ] = th ;
-      if( nangles == 4 )
-        goto enough_angles ;
-    }
-  }
- enough_angles:
-  return nangles ;
-}
-
-
-/** ------------------------------------------------------------------
- ** @internal
- ** @brief Normalizes in norm L_2 a descriptor
- ** @param begin begin of histogram.
- ** @param end   end of histogram.
- **/
-
-VL_INLINE vl_sift_pix
-normalize_histogram
-(vl_sift_pix *begin, vl_sift_pix *end)
-{
-  vl_sift_pix* iter ;
-  vl_sift_pix  norm = 0.0 ;
-
-  for (iter = begin ; iter != end ; ++ iter)
-    norm += (*iter) * (*iter) ;
-
-  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;
-
-  for (iter = begin; iter != end ; ++ iter)
-    *iter /= norm ;
-
-  return norm;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Run the SIFT descriptor on raw data
- **
- ** @param f        SIFT filter.
- ** @param grad     image gradients.
- ** @param descr    SIFT descriptor (output).
- ** @param width    image width.
- ** @param height   image height.
- ** @param x        keypoint x coordinate.
- ** @param y        keypoint y coordinate.
- ** @param sigma    keypoint scale.
- ** @param angle0   keypoint orientation.
- **
- ** The function runs the SIFT descriptor on raw data. Here @a image
- ** is a 2 x @a width x @a height array (by convention, the memory
- ** layout is a s such the first index is the fastest varying
- ** one). The first @a width x @a height layer of the array contains
- ** the gradient magnitude and the second the gradient angle (in
- ** radians, between 0 and @f$ 2\pi @f$). @a x, @a y and @a sigma give
- ** the keypoint center and scale respectively.
- **
- ** In order to be equivalent to a standard SIFT descriptor the image
- ** gradient must be computed at a smoothing level equal to the scale
- ** of the keypoint. In practice, the actual SIFT algorithm makes the
- ** following additional approximation, which influence the result:
- **
- ** - Scale is discretized in @c S levels.
- ** - The image is downsampled once for each octave (if you do this,
- **   the parameters @a x, @a y and @a sigma must be
- **   scaled too).
- **/
-
-VL_EXPORT
-void
-vl_sift_calc_raw_descriptor (VlSiftFilt const *f,
-                             vl_sift_pix const* grad,
-                             vl_sift_pix *descr,
-                             int width, int height,
-                             double x, double y,
-                             double sigma,
-                             double angle0)
-{
-  double const magnif = f-> magnif ;
-
-  int          w      = width ;
-  int          h      = height ;
-  int const    xo     = 2 ;         /* x-stride */
-  int const    yo     = 2 * w ;     /* y-stride */
-
-  int          xi     = (int) (x + 0.5) ;
-  int          yi     = (int) (y + 0.5) ;
-
-  double const st0    = sin (angle0) ;
-  double const ct0    = cos (angle0) ;
-  double const SBP    = magnif * sigma + VL_EPSILON_D ;
-  int    const W      = floor
-    (sqrt(2.0) * SBP * (NBP + 1) / 2.0 + 0.5) ;
-
-  int const binto = 1 ;          /* bin theta-stride */
-  int const binyo = NBO * NBP ;  /* bin y-stride */
-  int const binxo = NBO ;        /* bin x-stride */
-
-  int bin, dxi, dyi ;
-  vl_sift_pix const *pt ;
-  vl_sift_pix       *dpt ;
-
-  /* check bounds */
-  if(xi    <  0               ||
-     xi    >= w               ||
-     yi    <  0               ||
-     yi    >= h -    1        )
-    return ;
-
-  /* clear descriptor */
-  memset (descr, 0, sizeof(vl_sift_pix) * NBO*NBP*NBP) ;
-
-  /* Center the scale space and the descriptor on the current keypoint.
-   * Note that dpt is pointing to the bin of center (SBP/2,SBP/2,0).
-   */
-  pt  = grad + xi*xo + yi*yo ;
-  dpt = descr + (NBP/2) * binyo + (NBP/2) * binxo ;
-
-#undef atd
-#define atd(dbinx,dbiny,dbint) *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
-
-  /*
-   * Process pixels in the intersection of the image rectangle
-   * (1,1)-(M-1,N-1) and the keypoint bounding box.
-   */
-  for(dyi =  VL_MAX(- W,   - yi   ) ;
-      dyi <= VL_MIN(+ W, h - yi -1) ; ++ dyi) {
-
-    for(dxi =  VL_MAX(- W,   - xi   ) ;
-        dxi <= VL_MIN(+ W, w - xi -1) ; ++ dxi) {
-
-      /* retrieve */
-      vl_sift_pix mod   = *( pt + dxi*xo + dyi*yo + 0 ) ;
-      vl_sift_pix angle = *( pt + dxi*xo + dyi*yo + 1 ) ;
-      vl_sift_pix theta = vl_mod_2pi_f (angle - angle0) ;
-
-      /* fractional displacement */
-      vl_sift_pix dx = xi + dxi - x;
-      vl_sift_pix dy = yi + dyi - y;
-
-      /* get the displacement normalized w.r.t. the keypoint
-         orientation and extension */
-      vl_sift_pix nx = ( ct0 * dx + st0 * dy) / SBP ;
-      vl_sift_pix ny = (-st0 * dx + ct0 * dy) / SBP ;
-      vl_sift_pix nt = NBO * theta / (2 * VL_PI) ;
-
-      /* Get the Gaussian weight of the sample. The Gaussian window
-       * has a standard deviation equal to NBP/2. Note that dx and dy
-       * are in the normalized frame, so that -NBP/2 <= dx <=
-       * NBP/2. */
-      vl_sift_pix const wsigma = f->windowSize ;
-      vl_sift_pix win = fast_expn
-        ((nx*nx + ny*ny)/(2.0 * wsigma * wsigma)) ;
-
-      /* The sample will be distributed in 8 adjacent bins.
-         We start from the ``lower-left'' bin. */
-      int         binx = (int)vl_floor_f (nx - 0.5) ;
-      int         biny = (int)vl_floor_f (ny - 0.5) ;
-      int         bint = (int)vl_floor_f (nt) ;
-      vl_sift_pix rbinx = nx - (binx + 0.5) ;
-      vl_sift_pix rbiny = ny - (biny + 0.5) ;
-      vl_sift_pix rbint = nt - bint ;
-      int         dbinx ;
-      int         dbiny ;
-      int         dbint ;
-
-      /* Distribute the current sample into the 8 adjacent bins*/
-      for(dbinx = 0 ; dbinx < 2 ; ++dbinx) {
-        for(dbiny = 0 ; dbiny < 2 ; ++dbiny) {
-          for(dbint = 0 ; dbint < 2 ; ++dbint) {
-
-            if (binx + dbinx >= - (NBP/2) &&
-                binx + dbinx <    (NBP/2) &&
-                biny + dbiny >= - (NBP/2) &&
-                biny + dbiny <    (NBP/2) ) {
-              vl_sift_pix weight = win
-                * mod
-                * vl_abs_f (1 - dbinx - rbinx)
-                * vl_abs_f (1 - dbiny - rbiny)
-                * vl_abs_f (1 - dbint - rbint) ;
-
-              atd(binx+dbinx, biny+dbiny, (bint+dbint) % NBO) += weight ;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /* Standard SIFT descriptors are normalized, truncated and normalized again */
-  if(1) {
-
-    /* normalize L2 norm */
-    vl_sift_pix norm = normalize_histogram (descr, descr + NBO*NBP*NBP) ;
-
-    /*
-       Set the descriptor to zero if it is lower than our
-       norm_threshold.  We divide by the number of samples in the
-       descriptor region because the Gaussian window used in the
-       calculation of the descriptor is not normalized.
-     */
-    int numSamples =
-      (VL_MIN(W, w - xi -1) - VL_MAX(-W, - xi) + 1) *
-      (VL_MIN(W, h - yi -1) - VL_MAX(-W, - yi) + 1) ;
-
-    if(f-> norm_thresh && norm < f-> norm_thresh * numSamples) {
-        for(bin = 0; bin < NBO*NBP*NBP ; ++ bin)
-            descr [bin] = 0;
-    }
-    else {
-      /* truncate at 0.2. */
-      for(bin = 0; bin < NBO*NBP*NBP ; ++ bin) {
-        if (descr [bin] > 0.2) descr [bin] = 0.2;
-      }
-
-      /* normalize again. */
-      normalize_histogram (descr, descr + NBO*NBP*NBP) ;
-    }
-  }
-}
-
-/** ------------------------------------------------------------------
- ** @brief Compute the descriptor of a keypoint
- **
- ** @param f        SIFT filter.
- ** @param descr    SIFT descriptor (output)
- ** @param k        keypoint.
- ** @param angle0   keypoint direction.
- **
- ** The function computes the SIFT descriptor of the keypoint @a k of
- ** orientation @a angle0. The function fills the buffer @a descr
- ** which must be large enough to hold the descriptor.
- **
- ** The function assumes that the keypoint is on the current octave.
- ** If not, it does not do anything.
- **/
-
-VL_EXPORT
-void
-vl_sift_calc_keypoint_descriptor (VlSiftFilt *f,
-                                  vl_sift_pix *descr,
-                                  VlSiftKeypoint const* k,
-                                  double angle0)
-{
-  /*
-     The SIFT descriptor is a three dimensional histogram of the
-     position and orientation of the gradient.  There are NBP bins for
-     each spatial dimension and NBO bins for the orientation dimension,
-     for a total of NBP x NBP x NBO bins.
-
-     The support of each spatial bin has an extension of SBP = 3sigma
-     pixels, where sigma is the scale of the keypoint.  Thus all the
-     bins together have a support SBP x NBP pixels wide. Since
-     weighting and interpolation of pixel is used, the support extends
-     by another half bin. Therefore, the support is a square window of
-     SBP x (NBP + 1) pixels. Finally, since the patch can be
-     arbitrarily rotated, we need to consider a window 2W += sqrt(2) x
-     SBP x (NBP + 1) pixels wide.
-  */
-
-  double const magnif      = f-> magnif ;
-
-  double       xper        = pow (2.0, f->o_cur) ;
-
-  int          w           = f-> octave_width ;
-  int          h           = f-> octave_height ;
-  int const    xo          = 2 ;         /* x-stride */
-  int const    yo          = 2 * w ;     /* y-stride */
-  int const    so          = 2 * w * h ; /* s-stride */
-  double       x           = k-> x     / xper ;
-  double       y           = k-> y     / xper ;
-  double       sigma       = k-> sigma / xper ;
-
-  int          xi          = (int) (x + 0.5) ;
-  int          yi          = (int) (y + 0.5) ;
-  int          si          = k-> is ;
-
-  double const st0         = sin (angle0) ;
-  double const ct0         = cos (angle0) ;
-  double const SBP         = magnif * sigma + VL_EPSILON_D ;
-  int    const W           = floor
-    (sqrt(2.0) * SBP * (NBP + 1) / 2.0 + 0.5) ;
-
-  int const binto = 1 ;          /* bin theta-stride */
-  int const binyo = NBO * NBP ;  /* bin y-stride */
-  int const binxo = NBO ;        /* bin x-stride */
-
-  int bin, dxi, dyi ;
-  vl_sift_pix const *pt ;
-  vl_sift_pix       *dpt ;
-
-  /* check bounds */
-  if(k->o  != f->o_cur        ||
-     xi    <  0               ||
-     xi    >= w               ||
-     yi    <  0               ||
-     yi    >= h -    1        ||
-     si    <  f->s_min + 1    ||
-     si    >  f->s_max - 2     )
-    return ;
-
-  /* synchronize gradient buffer */
-  update_gradient (f) ;
-
-  /* VL_PRINTF("W = %d ; magnif = %g ; SBP = %g\n", W,magnif,SBP) ; */
-
-  /* clear descriptor */
-  memset (descr, 0, sizeof(vl_sift_pix) * NBO*NBP*NBP) ;
-
-  /* Center the scale space and the descriptor on the current keypoint.
-   * Note that dpt is pointing to the bin of center (SBP/2,SBP/2,0).
-   */
-  pt  = f->grad + xi*xo + yi*yo + (si - f->s_min - 1)*so ;
-  dpt = descr + (NBP/2) * binyo + (NBP/2) * binxo ;
-
-#undef atd
-#define atd(dbinx,dbiny,dbint) *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
-
-  /*
-   * Process pixels in the intersection of the image rectangle
-   * (1,1)-(M-1,N-1) and the keypoint bounding box.
-   */
-  for(dyi =  VL_MAX (- W, 1 - yi    ) ;
-      dyi <= VL_MIN (+ W, h - yi - 2) ; ++ dyi) {
-
-    for(dxi =  VL_MAX (- W, 1 - xi    ) ;
-        dxi <= VL_MIN (+ W, w - xi - 2) ; ++ dxi) {
-
-      /* retrieve */
-      vl_sift_pix mod   = *( pt + dxi*xo + dyi*yo + 0 ) ;
-      vl_sift_pix angle = *( pt + dxi*xo + dyi*yo + 1 ) ;
-      vl_sift_pix theta = vl_mod_2pi_f (angle - angle0) ;
-
-      /* fractional displacement */
-      vl_sift_pix dx = xi + dxi - x;
-      vl_sift_pix dy = yi + dyi - y;
-
-      /* get the displacement normalized w.r.t. the keypoint
-         orientation and extension */
-      vl_sift_pix nx = ( ct0 * dx + st0 * dy) / SBP ;
-      vl_sift_pix ny = (-st0 * dx + ct0 * dy) / SBP ;
-      vl_sift_pix nt = NBO * theta / (2 * VL_PI) ;
-
-      /* Get the Gaussian weight of the sample. The Gaussian window
-       * has a standard deviation equal to NBP/2. Note that dx and dy
-       * are in the normalized frame, so that -NBP/2 <= dx <=
-       * NBP/2. */
-      vl_sift_pix const wsigma = f->windowSize ;
-      vl_sift_pix win = fast_expn
-        ((nx*nx + ny*ny)/(2.0 * wsigma * wsigma)) ;
-
-      /* The sample will be distributed in 8 adjacent bins.
-         We start from the ``lower-left'' bin. */
-      int         binx = (int)vl_floor_f (nx - 0.5) ;
-      int         biny = (int)vl_floor_f (ny - 0.5) ;
-      int         bint = (int)vl_floor_f (nt) ;
-      vl_sift_pix rbinx = nx - (binx + 0.5) ;
-      vl_sift_pix rbiny = ny - (biny + 0.5) ;
-      vl_sift_pix rbint = nt - bint ;
-      int         dbinx ;
-      int         dbiny ;
-      int         dbint ;
-
-      /* Distribute the current sample into the 8 adjacent bins*/
-      for(dbinx = 0 ; dbinx < 2 ; ++dbinx) {
-        for(dbiny = 0 ; dbiny < 2 ; ++dbiny) {
-          for(dbint = 0 ; dbint < 2 ; ++dbint) {
-
-            if (binx + dbinx >= - (NBP/2) &&
-                binx + dbinx <    (NBP/2) &&
-                biny + dbiny >= - (NBP/2) &&
-                biny + dbiny <    (NBP/2) ) {
-              vl_sift_pix weight = win
-                * mod
-                * vl_abs_f (1 - dbinx - rbinx)
-                * vl_abs_f (1 - dbiny - rbiny)
-                * vl_abs_f (1 - dbint - rbint) ;
-
-              atd(binx+dbinx, biny+dbiny, (bint+dbint) % NBO) += weight ;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /* Standard SIFT descriptors are normalized, truncated and normalized again */
-  if(1) {
-
-    /* Normalize the histogram to L2 unit length. */
-    vl_sift_pix norm = normalize_histogram (descr, descr + NBO*NBP*NBP) ;
-
-    /* Set the descriptor to zero if it is lower than our norm_threshold */
-    if(f-> norm_thresh && norm < f-> norm_thresh) {
-        for(bin = 0; bin < NBO*NBP*NBP ; ++ bin)
-            descr [bin] = 0;
-    }
-    else {
-
-      /* Truncate at 0.2. */
-      for(bin = 0; bin < NBO*NBP*NBP ; ++ bin) {
-        if (descr [bin] > 0.2) descr [bin] = 0.2;
-      }
-
-      /* Normalize again. */
-      normalize_histogram (descr, descr + NBO*NBP*NBP) ;
-    }
-  }
-
-}
-
-/** ------------------------------------------------------------------
- ** @brief Initialize a keypoint from its position and scale
- **
- ** @param f     SIFT filter.
- ** @param k     SIFT keypoint (output).
- ** @param x     x coordinate of the keypoint center.
- ** @param y     y coordinate of the keypoint center.
- ** @param sigma keypoint scale.
- **
- ** The function initializes a keypoint structure @a k from
- ** the location @a x
- ** and @a y and the scale @a sigma of the keypoint. The keypoint structure
- ** maps the keypoint to an octave and scale level of the discretized
- ** Gaussian scale space, which is required for instance to compute the
- ** keypoint SIFT descriptor.
- **
- ** @par Algorithm
- **
- ** The formula linking the keypoint scale sigma to the octave and
- ** scale indexes is
- **
- ** @f[ \sigma(o,s) = \sigma_0 2^{o+s/S} @f]
- **
- ** In addition to the scale index @e s (which can be fractional due
- ** to scale interpolation) a keypoint has an integer scale index @e
- ** is too (which is the index of the scale level where it was
- ** detected in the DoG scale space). We have the constraints (@ref
- ** sift-tech-detector see also the "SIFT detector"):
- **
- ** - @e o is integer in the range @f$ [o_\mathrm{min},
- **   o_{\mathrm{min}}+O-1] @f$.
- ** - @e is is integer in the range @f$ [s_\mathrm{min}+1,
- **   s_\mathrm{max}-2] @f$.  This depends on how the scale is
- **   determined during detection, and must be so here because
- **   gradients are computed only for this range of scale levels
- **   and are required for the calculation of the SIFT descriptor.
- ** - @f$ |s - is| < 0.5 @f$ for detected keypoints in most cases due
- **   to the interpolation technique used during detection. However
- **   this is not necessary.
- **
- ** Thus octave o represents scales @f$ \{ \sigma(o, s) : s \in
- ** [s_\mathrm{min}+1-.5, s_\mathrm{max}-2+.5] \} @f$. Note that some
- ** scales may be represented more than once. For each scale, we
- ** select the largest possible octave that contains it, i.e.
- **
- ** @f[
- **  o(\sigma)
- **  = \max \{ o \in \mathbb{Z} :
- **    \sigma_0 2^{\frac{s_\mathrm{min}+1-.5}{S}} \leq \sigma \}
- **  = \mathrm{floor}\,\left[
- **    \log_2(\sigma / \sigma_0) - \frac{s_\mathrm{min}+1-.5}{S}\right]
- ** @f]
- **
- ** and then
- **
- ** @f[
- ** s(\sigma) = S  \left[\log_2(\sigma / \sigma_0) - o(\sigma)\right],
- ** \quad
- ** is(\sigma) = \mathrm{round}\,(s(\sigma))
- ** @f]
- **
- ** In practice, both @f$ o(\sigma) @f$ and @f$ is(\sigma) @f$ are
- ** clamped to their feasible range as determined by the SIFT filter
- ** parameters.
- **/
-
-VL_EXPORT
-void
-vl_sift_keypoint_init (VlSiftFilt const *f,
-                       VlSiftKeypoint *k,
-                       double x,
-                       double y,
-                       double sigma)
-{
-  int    o, ix, iy, is ;
-  double s, phi, xper ;
-
-  phi = log2 ((sigma + VL_EPSILON_D) / f->sigma0) ;
-  o   = (int)vl_floor_d (phi -  ((double) f->s_min + 0.5) / f->S) ;
-  o   = VL_MIN (o, f->o_min + f->O - 1) ;
-  o   = VL_MAX (o, f->o_min           ) ;
-  s   = f->S * (phi - o) ;
-
-  is  = (int)(s + 0.5) ;
-  is  = VL_MIN(is, f->s_max - 2) ;
-  is  = VL_MAX(is, f->s_min + 1) ;
-
-  xper = pow (2.0, o) ;
-  ix   = (int)(x / xper + 0.5) ;
-  iy   = (int)(y / xper + 0.5) ;
-
-  k -> o  = o ;
-
-  k -> ix = ix ;
-  k -> iy = iy ;
-  k -> is = is ;
-
-  k -> x = x ;
-  k -> y = y ;
-  k -> s = s ;
-
-  k->sigma = sigma ;
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/sift.h b/opensfm/src/third_party/vlfeat/vl/sift.h
deleted file mode 100644
index 50e03f434..000000000
--- a/opensfm/src/third_party/vlfeat/vl/sift.h
+++ /dev/null
@@ -1,418 +0,0 @@
-/** @file sift.h
- ** @brief SIFT (@ref sift)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_SIFT_H
-#define VL_SIFT_H
-
-#include <stdio.h>
-#include "generic.h"
-
-/** @brief SIFT filter pixel type */
-typedef float vl_sift_pix ;
-
-/** ------------------------------------------------------------------
- ** @brief SIFT filter keypoint
- **
- ** This structure represent a keypoint as extracted by the SIFT
- ** filter ::VlSiftFilt.
- **/
-
-typedef struct _VlSiftKeypoint
-{
-  int o ;           /**< o coordinate (octave). */
-
-  int ix ;          /**< Integer unnormalized x coordinate. */
-  int iy ;          /**< Integer unnormalized y coordinate. */
-  int is ;          /**< Integer s coordinate. */
-
-  float x ;     /**< x coordinate. */
-  float y ;     /**< y coordinate. */
-  float s ;     /**< s coordinate. */
-  float sigma ; /**< scale. */
-} VlSiftKeypoint ;
-
-/** ------------------------------------------------------------------
- ** @brief SIFT filter
- **
- ** This filter implements the SIFT detector and descriptor.
- **/
-
-typedef struct _VlSiftFilt
-{
-  double sigman ;       /**< nominal image smoothing. */
-  double sigma0 ;       /**< smoothing of pyramid base. */
-  double sigmak ;       /**< k-smoothing */
-  double dsigma0 ;      /**< delta-smoothing. */
-
-  int width ;           /**< image width. */
-  int height ;          /**< image height. */
-  int O ;               /**< number of octaves. */
-  int S ;               /**< number of levels per octave. */
-  int o_min ;           /**< minimum octave index. */
-  int s_min ;           /**< minimum level index. */
-  int s_max ;           /**< maximum level index. */
-  int o_cur ;           /**< current octave. */
-
-  vl_sift_pix *temp ;   /**< temporary pixel buffer. */
-  vl_sift_pix *octave ; /**< current GSS data. */
-  vl_sift_pix *dog ;    /**< current DoG data. */
-  int octave_width ;    /**< current octave width. */
-  int octave_height ;   /**< current octave height. */
-
-  vl_sift_pix *gaussFilter ;  /**< current Gaussian filter */
-  double gaussFilterSigma ;   /**< current Gaussian filter std */
-  vl_size gaussFilterWidth ;  /**< current Gaussian filter width */
-
-  VlSiftKeypoint* keys ;/**< detected keypoints. */
-  int nkeys ;           /**< number of detected keypoints. */
-  int keys_res ;        /**< size of the keys buffer. */
-
-  double peak_thresh ;  /**< peak threshold. */
-  double edge_thresh ;  /**< edge threshold. */
-  double norm_thresh ;  /**< norm threshold. */
-  double magnif ;       /**< magnification factor. */
-  double windowSize ;   /**< size of Gaussian window (in spatial bins) */
-
-  vl_sift_pix *grad ;   /**< GSS gradient data. */
-  int grad_o ;          /**< GSS gradient data octave. */
-
-} VlSiftFilt ;
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT
-VlSiftFilt*  vl_sift_new    (int width, int height,
-                             int noctaves, int nlevels,
-                             int o_min) ;
-VL_EXPORT
-void         vl_sift_delete (VlSiftFilt *f) ;
-/** @} */
-
-/** @name Process data
- ** @{
- **/
-
-VL_EXPORT
-int   vl_sift_process_first_octave       (VlSiftFilt *f,
-                                          vl_sift_pix const *im) ;
-
-VL_EXPORT
-int   vl_sift_process_next_octave        (VlSiftFilt *f) ;
-
-VL_EXPORT
-void  vl_sift_detect                     (VlSiftFilt *f) ;
-
-VL_EXPORT
-int   vl_sift_calc_keypoint_orientations (VlSiftFilt *f,
-                                          double angles [4],
-                                          VlSiftKeypoint const*k);
-VL_EXPORT
-void  vl_sift_calc_keypoint_descriptor   (VlSiftFilt *f,
-                                          vl_sift_pix *descr,
-                                          VlSiftKeypoint const* k,
-                                          double angle) ;
-
-VL_EXPORT
-void  vl_sift_calc_raw_descriptor        (VlSiftFilt const *f,
-                                          vl_sift_pix const* image,
-                                          vl_sift_pix *descr,
-                                          int widht, int height,
-                                          double x, double y,
-                                          double s, double angle0) ;
-
-VL_EXPORT
-void  vl_sift_keypoint_init              (VlSiftFilt const *f,
-                                          VlSiftKeypoint *k,
-                                          double x,
-                                          double y,
-                                          double sigma) ;
-/** @} */
-
-/** @name Retrieve data and parameters
- ** @{
- **/
-VL_INLINE int    vl_sift_get_octave_index   (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_noctaves       (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_octave_first   (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_octave_width   (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_octave_height  (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_nlevels        (VlSiftFilt const *f) ;
-VL_INLINE int    vl_sift_get_nkeypoints     (VlSiftFilt const *f) ;
-VL_INLINE double vl_sift_get_peak_thresh    (VlSiftFilt const *f) ;
-VL_INLINE double vl_sift_get_edge_thresh    (VlSiftFilt const *f) ;
-VL_INLINE double vl_sift_get_norm_thresh    (VlSiftFilt const *f) ;
-VL_INLINE double vl_sift_get_magnif         (VlSiftFilt const *f) ;
-VL_INLINE double vl_sift_get_window_size    (VlSiftFilt const *f) ;
-
-VL_INLINE vl_sift_pix *vl_sift_get_octave  (VlSiftFilt const *f, int s) ;
-VL_INLINE VlSiftKeypoint const *vl_sift_get_keypoints (VlSiftFilt const *f) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_INLINE void vl_sift_set_peak_thresh (VlSiftFilt *f, double t) ;
-VL_INLINE void vl_sift_set_edge_thresh (VlSiftFilt *f, double t) ;
-VL_INLINE void vl_sift_set_norm_thresh (VlSiftFilt *f, double t) ;
-VL_INLINE void vl_sift_set_magnif      (VlSiftFilt *f, double m) ;
-VL_INLINE void vl_sift_set_window_size (VlSiftFilt *f, double m) ;
-/** @} */
-
-/* -------------------------------------------------------------------
- *                                     Inline functions implementation
- * ---------------------------------------------------------------- */
-
-/** ------------------------------------------------------------------
- ** @brief Get current octave index.
- ** @param f SIFT filter.
- ** @return index of the current octave.
- **/
-
-VL_INLINE int
-vl_sift_get_octave_index (VlSiftFilt const *f)
-{
-  return f-> o_cur ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get number of octaves.
- ** @param f SIFT filter.
- ** @return number of octaves.
- **/
-
-VL_INLINE int
-vl_sift_get_noctaves (VlSiftFilt const *f)
-{
-  return f-> O ;
-}
-
-/**-------------------------------------------------------------------
- ** @brief Get first octave.
- ** @param f SIFT filter.
- ** @return index of the first octave.
- **/
-
-VL_INLINE int
-vl_sift_get_octave_first (VlSiftFilt const *f)
-{
-  return f-> o_min ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get current octave width
- ** @param f SIFT filter.
- ** @return current octave width.
- **/
-
-VL_INLINE int
-vl_sift_get_octave_width (VlSiftFilt const *f)
-{
-  return f-> octave_width ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get current octave height
- ** @param f SIFT filter.
- ** @return current octave height.
- **/
-
-VL_INLINE int
-vl_sift_get_octave_height (VlSiftFilt const *f)
-{
-  return f-> octave_height ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get current octave data
- ** @param f SIFT filter.
- ** @param s level index.
- **
- ** The level index @a s ranges in the interval <tt>s_min = -1</tt>
- ** and <tt> s_max = S + 2</tt>, where @c S is the number of levels
- ** per octave.
- **
- ** @return pointer to the octave data for level @a s.
- **/
-
-VL_INLINE vl_sift_pix *
-vl_sift_get_octave (VlSiftFilt const *f, int s)
-{
-  int w = vl_sift_get_octave_width  (f) ;
-  int h = vl_sift_get_octave_height (f) ;
-  return f->octave + w * h * (s - f->s_min) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get number of levels per octave
- ** @param f SIFT filter.
- ** @return number of leves per octave.
- **/
-
-VL_INLINE int
-vl_sift_get_nlevels (VlSiftFilt const *f)
-{
-  return f-> S ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get number of keypoints.
- ** @param f SIFT filter.
- ** @return number of keypoints.
- **/
-
-VL_INLINE int
-vl_sift_get_nkeypoints (VlSiftFilt const *f)
-{
-  return f-> nkeys ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get keypoints.
- ** @param f SIFT filter.
- ** @return pointer to the keypoints list.
- **/
-
-VL_INLINE VlSiftKeypoint const *
-vl_sift_get_keypoints (VlSiftFilt const *f)
-{
-  return f-> keys ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get peaks treashold
- ** @param f SIFT filter.
- ** @return threshold ;
- **/
-
-VL_INLINE double
-vl_sift_get_peak_thresh (VlSiftFilt const *f)
-{
-  return f -> peak_thresh ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get edges threshold
- ** @param f SIFT filter.
- ** @return threshold.
- **/
-
-VL_INLINE double
-vl_sift_get_edge_thresh (VlSiftFilt const *f)
-{
-  return f -> edge_thresh ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get norm threshold
- ** @param f SIFT filter.
- ** @return threshold.
- **/
-
-VL_INLINE double
-vl_sift_get_norm_thresh (VlSiftFilt const *f)
-{
-  return f -> norm_thresh ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the magnification factor
- ** @param f SIFT filter.
- ** @return magnification factor.
- **/
-
-VL_INLINE double
-vl_sift_get_magnif (VlSiftFilt const *f)
-{
-  return f -> magnif ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get the Gaussian window size.
- ** @param f SIFT filter.
- ** @return standard deviation of the Gaussian window (in spatial bin units).
- **/
-
-VL_INLINE double
-vl_sift_get_window_size (VlSiftFilt const *f)
-{
-  return f -> windowSize ;
-}
-
-
-
-/** ------------------------------------------------------------------
- ** @brief Set peaks threshold
- ** @param f SIFT filter.
- ** @param t threshold.
- **/
-
-VL_INLINE void
-vl_sift_set_peak_thresh (VlSiftFilt *f, double t)
-{
-  f -> peak_thresh = t ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set edges threshold
- ** @param f SIFT filter.
- ** @param t threshold.
- **/
-
-VL_INLINE void
-vl_sift_set_edge_thresh (VlSiftFilt *f, double t)
-{
-  f -> edge_thresh = t ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set norm threshold
- ** @param f SIFT filter.
- ** @param t threshold.
- **/
-
-VL_INLINE void
-vl_sift_set_norm_thresh (VlSiftFilt *f, double t)
-{
-  f -> norm_thresh = t ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set the magnification factor
- ** @param f SIFT filter.
- ** @param m magnification factor.
- **/
-
-VL_INLINE void
-vl_sift_set_magnif (VlSiftFilt *f, double m)
-{
-  f -> magnif = m ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Set the Gaussian window size
- ** @param f SIFT filter.
- ** @param x Gaussian window size (in units of spatial bin).
- **
- ** This is the parameter @f$ \hat \sigma_{\text{win}} @f$ of
- ** the standard SIFT descriptor @ref sift-tech-descriptor-std.
- **/
-
-VL_INLINE void
-vl_sift_set_window_size (VlSiftFilt *f, double x)
-{
-  f -> windowSize = x ;
-}
-
-/* VL_SIFT_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/slic.c b/opensfm/src/third_party/vlfeat/vl/slic.c
deleted file mode 100644
index f6043e0b5..000000000
--- a/opensfm/src/third_party/vlfeat/vl/slic.c
+++ /dev/null
@@ -1,411 +0,0 @@
-/** @file slic.c
- ** @brief SLIC superpixels - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page slic Simple Linear Iterative Clustering (SLIC)
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref slic.h implements the *Simple Linear Iterative Clustering* (SLIC)
-algorithm, an image segmentation method described in @cite{achanta10slic}.
-
-- @ref slic-overview
-- @ref slic-usage
-- @ref slic-tech
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section slic-overview Overview
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-SLIC @cite{achanta10slic} is a simple and efficient method to decompose
-an image in visually homogeneous regions. It is based on a spatially
-localized version of k-means clustering. Similar to mean shift or
-quick shift (@ref quickshift.h), each pixel is associated to a feature
-vector
-
-@f[
-\Psi(x,y) =
-\left[
-\begin{array}{c}
-\lambda x \\
-\lambda y \\
-I(x,y)
-\end{array}
-\right]
-@f]
-
-and then k-means clustering is run on those. As discussed below, the
-coefficient @f$ \lambda @f$ balances the spatial and appearance
-components of the feature vectors, imposing a degree of spatial
-regularization to the extracted regions.
-
-SLIC takes two parameters: the nominal size of the regions
-(superpixels) @c regionSize and the strength of the spatial
-regularization @c regularizer. The image is first divided into a grid
-with step @c regionSize. The center of each grid tile is then used to
-initialize a corresponding k-means (up to a small shift to avoid
-image edges). Finally, the k-means centers and clusters are refined by
-using the Lloyd algorithm, yielding segmenting the image. As a
-further restriction and simplification, during the k-means iterations
-each pixel can be assigned to only the <em>2 x 2</em> centers
-corresponding to grid tiles adjacent to the pixel.
-
-The parameter @c regularizer sets the trade-off between clustering
-appearance and spatial regularization. This is obtained by setting
-
-@f[
- \lambda = \frac{\mathtt{regularizer}}{\mathtt{regionSize}}
-@f]
-
-in the definition of the feature @f$ \psi(x,y) @f$.
-
-After the k-means step, SLIC optionally
-removes any segment whose area is smaller than a threshld @c minRegionSize
-by merging them into larger ones.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section slic-usage Usage from the C library
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-To compute the SLIC superpixels of an image use the function
-::vl_slic_segment.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section slic-tech Technical details
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-SLIC starts by dividing the image domain into a regular grid with @f$
-M \times N @f$ tiles, where
-
-@f[
-   M = \lceil \frac{\mathtt{imageWidth}}{\mathtt{regionSize}} \rceil,
-   \quad
-   N = \lceil \frac{\mathtt{imageHeight}}{\mathtt{regionSize}} \rceil.
-@f]
-
-A region (superpixel or k-means cluster) is initialized from each grid
-center
-
-@f[
-  x_i = \operatorname{round} i \frac{\mathtt{imageWidth}}{\mathtt{regionSize}}
-  \quad
-  y_j = \operatorname{round} j \frac{\mathtt{imageWidth}}{\mathtt{regionSize}}.
-@f]
-
-In order to avoid placing these centers on top of image
-discontinuities, the centers are then moved in a 3 x 3
-neighbourohood to minimize the edge strength
-
-@f[
-   \operatorname{edge}(x,y) =
-   \| I(x+1,y) - I(x-1,y) \|_2^2 +
-   \| I(x,y+1) - I(x,y-1) \|_2^2.
-@f]
-
-Then the regions are obtained by running k-means clustering, started
-from the centers
-
-@f[
-  C = \{ \Psi(x_i,y_j), i=0,1,\dots,M-1\ j=0,1,\dots,N-1 \}
-@f]
-
-thus obtained. K-means uses the standard LLoyd algorithm alternating
-assigning pixels to the clostest centers a re-estiamting the centers
-as the average of the corresponding feature vectors of the pixel
-assigned to them. The only difference compared to standard k-means is
-that each pixel can be assigned only to the center originated from the
-neighbour tiles. This guarantees that there are exactly four
-pixel-to-center comparisons at each round of minimization, which
-threfore cost @f$ O(n) @f$, where @f$ n @f$ is the number of
-superpixels.
-
-After k-means has converged, SLIC eliminates any connected region whose
-area is less than @c minRegionSize pixels. This is done by greedily
-merging regions to neighbour ones: the pixels @f$ p @f$ are scanned in
-lexicographical order and the corresponding connected components
-are visited. If a region has already been visited, it is skipped; if not,
-its area is computed and if this is less than  @c minRegionSize its label
-is changed to the one of a neighbour
-region at @f$ p @f$ that has already been vistied (there is always one
-except for the very first pixel).
-
-*/
-
-#include "slic.h"
-#include "mathop.h"
-#include <math.h>
-#include <string.h>
-
-/** @brief SLIC superpixel segmentation
- ** @param segmentation segmentation.
- ** @param image image to segment.
- ** @param width image width.
- ** @param height image height.
- ** @param numChannels number of image channels (depth).
- ** @param regionSize nominal size of the regions.
- ** @param regularization trade-off between appearance and spatial terms.
- ** @param minRegionSize minimum size of a segment.
- **
- ** The function computes the SLIC superpixels of the specified image @a image.
- ** @a image is a pointer to an @c width by @c height by @c by numChannles array of @c float.
- ** @a segmentation is a pointer to a @c width by @c height array of @c vl_uint32.
- ** @a segmentation contain the labels of each image pixels, from 0 to
- ** the number of regions minus one.
- **
- ** @sa @ref slic-overview, @ref slic-tech
- **/
-
-void
-vl_slic_segment (vl_uint32 * segmentation,
-                 float const * image,
-                 vl_size width,
-                 vl_size height,
-                 vl_size numChannels,
-                 vl_size regionSize,
-                 float regularization,
-                 vl_size minRegionSize)
-{
-  vl_index i, x, y, u, v, k, region ;
-  vl_uindex iter ;
-  vl_size const numRegionsX = (vl_size) ceil((double) width / regionSize) ;
-  vl_size const numRegionsY = (vl_size) ceil((double) height / regionSize) ;
-  vl_size const numRegions = numRegionsX * numRegionsY ;
-  vl_size const numPixels = width * height ;
-  float * centers ;
-  float * edgeMap ;
-  float previousEnergy = VL_INFINITY_F ;
-  float startingEnergy ;
-  vl_uint32 * masses ;
-  vl_size const maxNumIterations = 100 ;
-
-  assert(segmentation) ;
-  assert(image) ;
-  assert(width >= 1) ;
-  assert(height >= 1) ;
-  assert(numChannels >= 1) ;
-  assert(regionSize >= 1) ;
-  assert(regularization >= 0) ;
-
-#define atimage(x,y,k) image[(x)+(y)*width+(k)*width*height]
-#define atEdgeMap(x,y) edgeMap[(x)+(y)*width]
-
-  edgeMap = vl_calloc(numPixels, sizeof(float)) ;
-  masses = vl_malloc(sizeof(vl_uint32) * numPixels) ;
-  centers = vl_malloc(sizeof(float) * (2 + numChannels) * numRegions) ;
-
-  /* compute edge map (gradient strength) */
-  for (k = 0 ; k < (signed)numChannels ; ++k) {
-    for (y = 1 ; y < (signed)height-1 ; ++y) {
-      for (x = 1 ; x < (signed)width-1 ; ++x) {
-        float a = atimage(x-1,y,k) ;
-        float b = atimage(x+1,y,k) ;
-        float c = atimage(x,y+1,k) ;
-        float d = atimage(x,y-1,k) ;
-        atEdgeMap(x,y) += (a - b)  * (a - b) + (c - d) * (c - d) ;
-      }
-    }
-  }
-
-  /* initialize K-means centers */
-  i = 0 ;
-  for (v = 0 ; v < (signed)numRegionsY ; ++v) {
-    for (u = 0 ; u < (signed)numRegionsX ; ++u) {
-      vl_index xp ;
-      vl_index yp ;
-      vl_index centerx = 0 ;
-      vl_index centery = 0 ;
-      float minEdgeValue = VL_INFINITY_F ;
-
-      x = (vl_index) vl_round_d(regionSize * (u + 0.5)) ;
-      y = (vl_index) vl_round_d(regionSize * (v + 0.5)) ;
-
-      x = VL_MAX(VL_MIN(x, (signed)width-1),0) ;
-      y = VL_MAX(VL_MIN(y, (signed)height-1),0) ;
-
-      /* search in a 3x3 neighbourhood the smallest edge response */
-      for (yp = VL_MAX(0, y-1) ; yp <= VL_MIN((signed)height-1, y+1) ; ++ yp) {
-        for (xp = VL_MAX(0, x-1) ; xp <= VL_MIN((signed)width-1, x+1) ; ++ xp) {
-          float thisEdgeValue = atEdgeMap(xp,yp) ;
-          if (thisEdgeValue < minEdgeValue) {
-            minEdgeValue = thisEdgeValue ;
-            centerx = xp ;
-            centery = yp ;
-          }
-        }
-      }
-
-      /* initialize the new center at this location */
-      centers[i++] = (float) centerx ;
-      centers[i++] = (float) centery ;
-      for (k  = 0 ; k < (signed)numChannels ; ++k) {
-        centers[i++] = atimage(centerx,centery,k) ;
-      }
-    }
-  }
-
-  /* run k-means iterations */
-  for (iter = 0 ; iter < maxNumIterations ; ++iter) {
-    float factor = regularization / (regionSize * regionSize) ;
-    float energy = 0 ;
-
-    /* assign pixels to centers */
-    for (y = 0 ; y < (signed)height ; ++y) {
-      for (x = 0 ; x < (signed)width ; ++x) {
-        vl_index u = floor((double)x / regionSize - 0.5) ;
-        vl_index v = floor((double)y / regionSize - 0.5) ;
-        vl_index up, vp ;
-        float minDistance = VL_INFINITY_F ;
-
-        for (vp = VL_MAX(0, v) ; vp <= VL_MIN((signed)numRegionsY-1, v+1) ; ++vp) {
-          for (up = VL_MAX(0, u) ; up <= VL_MIN((signed)numRegionsX-1, u+1) ; ++up) {
-            vl_index region = up  + vp * numRegionsX ;
-            float centerx = centers[(2 + numChannels) * region + 0]  ;
-            float centery = centers[(2 + numChannels) * region + 1] ;
-            float spatial = (x - centerx) * (x - centerx) + (y - centery) * (y - centery) ;
-            float appearance = 0 ;
-            float distance ;
-            for (k = 0 ; k < (signed)numChannels ; ++k) {
-              float centerz = centers[(2 + numChannels) * region + k + 2]  ;
-              float z = atimage(x,y,k) ;
-              appearance += (z - centerz) * (z - centerz) ;
-            }
-            distance = appearance + factor * spatial ;
-            if (minDistance > distance) {
-              minDistance = distance ;
-              segmentation[x + y * width] = (vl_uint32)region ;
-            }
-          }
-        }
-        energy += minDistance ;
-      }
-    }
-
-    /*
-     VL_PRINTF("vl:slic: iter %d: energy: %g\n", iter, energy) ;
-    */
-
-    /* check energy termination conditions */
-    if (iter == 0) {
-      startingEnergy = energy ;
-    } else {
-      if ((previousEnergy - energy) < 1e-5 * (startingEnergy - energy)) {
-        break ;
-      }
-    }
-    previousEnergy = energy ;
-
-    /* recompute centers */
-    memset(masses, 0, sizeof(vl_uint32) * width * height) ;
-    memset(centers, 0, sizeof(float) * (2 + numChannels) * numRegions) ;
-
-    for (y = 0 ; y < (signed)height ; ++y) {
-      for (x = 0 ; x < (signed)width ; ++x) {
-        vl_index pixel = x + y * width ;
-        vl_index region = segmentation[pixel] ;
-        masses[region] ++ ;
-        centers[region * (2 + numChannels) + 0] += x ;
-        centers[region * (2 + numChannels) + 1] += y ;
-        for (k = 0 ; k < (signed)numChannels ; ++k) {
-          centers[region * (2 + numChannels) + k + 2] += atimage(x,y,k) ;
-        }
-      }
-    }
-
-    for (region = 0 ; region < (signed)numRegions ; ++region) {
-      float mass = VL_MAX(masses[region], 1e-8) ;
-      for (i = (2 + numChannels) * region ;
-           i < (signed)(2 + numChannels) * (region + 1) ;
-           ++i) {
-        centers[i] /= mass ;
-      }
-    }
-  }
-
-  vl_free(masses) ;
-  vl_free(centers) ;
-  vl_free(edgeMap) ;
-
-  /* elimiate small regions */
-  {
-    vl_uint32 * cleaned = vl_calloc(numPixels, sizeof(vl_uint32)) ;
-    vl_uindex * segment = vl_malloc(sizeof(vl_uindex) * numPixels) ;
-    vl_size segmentSize ;
-    vl_uint32 label ;
-    vl_uint32 cleanedLabel ;
-    vl_size numExpanded ;
-    vl_index const dx [] = {+1, -1,  0,  0} ;
-    vl_index const dy [] = { 0,  0, +1, -1} ;
-    vl_index direction ;
-    vl_index pixel ;
-
-    for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) {
-      if (cleaned[pixel]) continue ;
-      label = segmentation[pixel] ;
-      numExpanded = 0 ;
-      segmentSize = 0 ;
-      segment[segmentSize++] = pixel ;
-
-      /*
-       find cleanedLabel as the label of an already cleaned
-       region neihbour of this pixel
-       */
-      cleanedLabel = label + 1 ;
-      cleaned[pixel] = label + 1 ;
-      x = pixel % width ;
-      y = pixel / width ;
-      for (direction = 0 ; direction < 4 ; ++direction) {
-        vl_index xp = x + dx[direction] ;
-        vl_index yp = y + dy[direction] ;
-        vl_index neighbor = xp + yp * width ;
-        if (0 <= xp && xp < (signed)width &&
-            0 <= yp && yp < (signed)height &&
-            cleaned[neighbor]) {
-          cleanedLabel = cleaned[neighbor] ;
-        }
-      }
-
-      /* expand the segment */
-      while (numExpanded < segmentSize) {
-        vl_index open = segment[numExpanded++] ;
-        x = open % width ;
-        y = open / width ;
-        for (direction = 0 ; direction < 4 ; ++direction) {
-          vl_index xp = x + dx[direction] ;
-          vl_index yp = y + dy[direction] ;
-          vl_index neighbor = xp + yp * width ;
-          if (0 <= xp && xp < (signed)width &&
-              0 <= yp && yp < (signed)height &&
-              cleaned[neighbor] == 0 &&
-              segmentation[neighbor] == label) {
-            cleaned[neighbor] = label + 1 ;
-            segment[segmentSize++] = neighbor ;
-          }
-        }
-      }
-
-      /* change label to cleanedLabel if the semgent is too small */
-      if (segmentSize < minRegionSize) {
-        while (segmentSize > 0) {
-          cleaned[segment[--segmentSize]] = cleanedLabel ;
-        }
-      }
-    }
-    /* restore base 0 indexing of the regions */
-    for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) cleaned[pixel] -- ;
-
-    memcpy(segmentation, cleaned, numPixels * sizeof(vl_uint32)) ;
-    vl_free(cleaned) ;
-    vl_free(segment) ;
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/slic.h b/opensfm/src/third_party/vlfeat/vl/slic.h
deleted file mode 100644
index 1bffcdecf..000000000
--- a/opensfm/src/third_party/vlfeat/vl/slic.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/** @file slic.h
- ** @brief SLIC superpixels (@ref slic)
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_SLIC_H
-#define VL_SLIC_H
-
-#include "generic.h"
-
-VL_EXPORT void
-vl_slic_segment (vl_uint32 * segmentation,
-                 float const * image,
-                 vl_size width,
-                 vl_size height,
-                 vl_size numChannels,
-                 vl_size regionSize,
-                 float regularization,
-                 vl_size minRegionSize) ;
-
-/* VL_SLIC_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/stringop.c b/opensfm/src/third_party/vlfeat/vl/stringop.c
deleted file mode 100644
index 5f92df340..000000000
--- a/opensfm/src/third_party/vlfeat/vl/stringop.c
+++ /dev/null
@@ -1,462 +0,0 @@
-/** @file stringop.c
- ** @brief String operations - Definition
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-@file stringop.h
-@brief String operations
-@author Andrea Vedaldi
-@tableofcontents
-
-@ref stringop.h implements basic string operations. All functions that
-write to strings use range checking, which makes them safer than some
-standard POSIX equivalent (see @ref vl-stringop-err).
-
-@section vl-stringop-enumeration Enumerations
-
-@ref stringop.h defines a simple enumeration data type. This is given
-by an array of enumeration members, represented by
-instances of the ::VlEnumerator strucutre, each storing a
-name-value pair. The enumeration must end by a member whose
-name is set to @c NULL.
-
-Use ::vl_enumeration_get and ::vl_enumeration_get_casei
-to retrieve an enumeration member by name.
-
-@section vl-stringop-file-protocols File protocols
-
-@ref stringop.h defines a few file "protocols" and helps parsing them
-from URL-like formatted strings. The supported protocols are:
-
-<table>
-<caption>File protocols</caption>
-<tr><td>Protocol</td><td>Code</td><td>URL prefix</td></tr>
-<tr><td>ASCII</td><td>::VL_PROT_ASCII</td><td><code>ascii://</code></td></tr>
-<tr><td>BINARY</td><td>::VL_PROT_BINARY</td><td><code>binary://</code></td></tr>
-</table>
-
-@section vl-stringop-err Detecting overflow
-
-@ref stringop.h functions that write a string to a character buffer take
-both the buffer and its size @c n as input. If @c n is not large
-enough, the output may be truncated but it is always a null terminated
-string (provided that @c n &gt;= 1). Such functions also return the
-length of the string that would have been written @c r (which does not
-include the terminating null character) had the buffer been large
-enough.  Hence an <em>overflow</em> can be detected by testing if @c r
-&gt;= @c n, @c r can be used to re-allocate a buffer large enough to
-contain the result, and the operation can be repeated.
-**/
-
-#include "stringop.h"
-
-#include <string.h>
-#include <ctype.h>
-
-/** ------------------------------------------------------------------
- ** @brief Extract the protocol prefix from a string
- ** @param string string.
- ** @param protocol protocol code (output).
- ** @return pointer to the first character after the protocol prefix.
- **
- ** The function extracts the prefix of the string @a string
- ** terminated by the first occurrence of the @c :// substring (if
- ** any). It then matches the suffix terminated by @c :// to the
- ** supported @ref vl-stringop-file-protocols protocols. If @c protocol is not
- ** @c NULL, the corresponding protocol code is written to @a protocol
- **
- ** The function writes to @a protocol the value ::VL_PROT_NONE if no
- ** suffix is detected and ::VL_PROT_UNKNOWN if there is a suffix but
- ** it cannot be matched to any of the supported protocols.
- **/
-
-VL_EXPORT char *
-vl_string_parse_protocol (char const *string, int *protocol)
-{
-  char const * cpt ;
-  int dummy ;
-
-  /* handle the case prot = 0 */
-  if (protocol == 0)
-    protocol = &dummy ;
-
-  /* look for :// */
-  cpt = strstr(string, "://") ;
-
-  if (cpt == 0) {
-    *protocol = VL_PROT_NONE ;
-    cpt = string ;
-  }
-  else {
-    if (strncmp(string, "ascii", cpt - string) == 0) {
-      *protocol = VL_PROT_ASCII ;
-    }
-    else if (strncmp(string, "bin",   cpt - string) == 0) {
-      *protocol = VL_PROT_BINARY ;
-    }
-    else {
-      *protocol = VL_PROT_UNKNOWN ;
-    }
-    cpt += 3 ;
-  }
-  return (char*) cpt ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Get protocol name
- ** @param protocol protocol code.
- ** @return pointer protocol name string.
- **
- ** The function returns a pointer to a string containing the name of
- ** the protocol @a protocol (see the @a vl-file-protocols protocols
- ** list).  If the protocol is unknown the function returns the empty
- ** string.
- **/
-
-VL_EXPORT char const *
-vl_string_protocol_name (int protocol)
-{
-  switch (protocol) {
-  case VL_PROT_ASCII:
-    return "ascii" ;
-  case VL_PROT_BINARY:
-    return "bin" ;
-  case VL_PROT_NONE :
-    return "" ;
-  default:
-    return 0 ;
-  }
-}
-
-
-/** ------------------------------------------------------------------
- ** @brief Extract base of file name
- ** @param destination destination buffer.
- ** @param destinationSize size of destination buffer.
- ** @param source input string.
- ** @param maxNumStrippedExtensions maximum number of extensions to strip.
- ** @return length of the destination string.
- **
- ** The function removes the leading path and up to @c
- ** maxNumStrippedExtensions trailing extensions from the string @a
- ** source and writes the result to the buffer @a destination.
- **
- ** The leading path is the longest suffix that ends with either the
- ** @c \ or @c / characters. An extension is a string starting with
- ** the <code>.</code> character not containing it. For instance, the string @c
- ** file.png contains the extension <code>.png</code> and the string @c
- ** file.tar.gz contains two extensions (<code>.tar</code> and @c <code>.gz</code>).
- **
- ** @sa @ref vl-stringop-err.
- **/
-
-VL_EXPORT vl_size
-vl_string_basename (char * destination,
-                    vl_size destinationSize,
-                    char const * source,
-                    vl_size maxNumStrippedExtensions)
-{
-  char c ;
-  vl_uindex k = 0, beg, end ;
-
-  /* find beginning */
-  beg = 0 ;
-  for (k = 0 ; (c = source[k]) ; ++ k) {
-    if (c == '\\' || c == '/') beg = k + 1 ;
-  }
-
-  /* find ending */
-  end = strlen (source) ;
-  for (k = end ; k > beg ; --k) {
-    if (source[k - 1] == '.' && maxNumStrippedExtensions > 0) {
-      -- maxNumStrippedExtensions ;
-      end = k - 1 ;
-    }
-  }
-
-  return vl_string_copy_sub (destination, destinationSize,
-                             source + beg, source + end) ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Replace wildcard characters by a string
- ** @param destination output buffer.
- ** @param destinationSize size of the output buffer.
- ** @param source input string.
- ** @param wildcardChar wildcard character.
- ** @param escapeChar escape character.
- ** @param replacement replacement string.
- **
- ** The function replaces the occurrence of the specified wildcard
- ** character @a wildcardChar by the string @a replacement. The result
- ** is written to the buffer @a destination of size @a
- ** destinationSize.
- **
- ** Wildcard characters may be escaped by preceding them by the @a esc
- ** character. More in general, anything following an occurrence of @a
- ** esc character is copied verbatim. To disable the escape characters
- ** simply set @a esc to 0.
- **
- ** @return length of the result.
- ** @sa @ref vl-stringop-err.
- **/
-
-VL_EXPORT vl_size
-vl_string_replace_wildcard (char * destination,
-                            vl_size destinationSize,
-                            char const * source,
-                            char wildcardChar,
-                            char escapeChar,
-                            char const * replacement)
-{
-  char c ;
-  vl_uindex k = 0 ;
-  vl_bool escape = 0 ;
-
-  while ((c = *source++)) {
-
-    /* enter escape mode ? */
-    if (! escape && c == escapeChar) {
-      escape = 1 ;
-      continue ;
-    }
-
-    /* wildcard or regular? */
-    if (! escape && c == wildcardChar) {
-      char const * repl = replacement ;
-      while ((c = *repl++)) {
-        if (destination && k + 1 < destinationSize) {
-          destination[k] = c ;
-        }
-        ++ k ;
-      }
-    }
-    /* regular character */
-    else {
-      if (destination && k + 1 < destinationSize) {
-        destination[k] = c ;
-      }
-      ++ k ;
-    }
-    escape = 0 ;
-  }
-
-  /* add trailing 0 */
-  if (destinationSize > 0) {
-    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
-  }
-  return  k ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Copy string
- ** @param destination output buffer.
- ** @param destinationSize size of the output buffer.
- ** @param source string to copy.
- ** @return length of the source string.
- **
- ** The function copies the string @a source to the buffer @a
- ** destination of size @a destinationSize.
- **
- ** @sa @ref vl-stringop-err.
- **/
-
-VL_EXPORT vl_size
-vl_string_copy (char * destination, vl_size destinationSize,
-                char const * source)
-{
-  char c ;
-  vl_uindex k = 0 ;
-
-  while ((c = *source++)) {
-    if (destination && k + 1 < destinationSize) {
-      destination[k] = c ;
-    }
-    ++ k ;
-  }
-
-  /* finalize */
-  if (destinationSize > 0) {
-    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
-  }
-  return  k ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Copy substring
- ** @param destination output buffer.
- ** @param destinationSize  size of output buffer.
- ** @param beginning start of the substring.
- ** @param end end of the substring.
- ** @return length of the destination string.
- **
- ** The function copies the substring from at @a beginning to @a end
- ** (not included) to the buffer @a destination of size @a
- ** destinationSize. If, however, the null character is found before
- ** @a end, the substring terminates there.
- **
- ** @sa @ref vl-stringop-err.
- **/
-
-VL_EXPORT vl_size
-vl_string_copy_sub (char * destination,
-                    vl_size destinationSize,
-                    char const * beginning,
-                    char const * end)
-{
-  char c ;
-  vl_uindex k = 0 ;
-
-  while (beginning < end && (c = *beginning++)) {
-    if (destination && k + 1 < destinationSize) {
-      destination[k] = c ;
-    }
-    ++ k ;
-  }
-
-  /* finalize */
-  if (destinationSize > 0) {
-    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
-  }
-  return  k ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Search character in reversed order
- ** @param beginning pointer to the substring beginning.
- ** @param end pointer to the substring end.
- ** @param c character to search for.
- ** @return pointer to last occurrence of @a c, or 0 if none.
- **
- ** The function searches for the last occurrence of the character @a c
- ** in the substring from @a beg to @a end (the latter not being included).
- **/
-
-VL_EXPORT char *
-vl_string_find_char_rev (char const *beginning, char const* end, char c)
-{
-  while (end -- != beginning) {
-    if (*end == c) {
-      return (char*) end ;
-    }
-  }
-  return 0 ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Calculate string length
- ** @param string string.
- ** @return string length.
- **/
-
-VL_EXPORT vl_size
-vl_string_length (char const *string)
-{
-  vl_uindex i ;
-  for (i = 0 ; string[i] ; ++i) ;
-  return i ;
-}
-
-/** ------------------------------------------------------------------
- ** @brief Compare strings case-insensitive
- ** @param string1 fisrt string.
- ** @param string2 second string.
- ** @return an integer =,<,> 0 if @c string1 =,<,> @c string2
- **/
-
-VL_EXPORT int
-vl_string_casei_cmp (const char * string1, const char * string2)
-{
-  while (tolower((char unsigned)*string1) ==
-         tolower((char unsigned)*string2))
-  {
-    if (*string1 == 0) {
-      return 0 ;
-    }
-    string1 ++ ;
-    string2 ++ ;
-  }
-  return
-    (int)tolower((char unsigned)*string1) -
-    (int)tolower((char unsigned)*string2) ;
-}
-
-/* -------------------------------------------------------------------
- *                                                       VlEnumeration
- * ---------------------------------------------------------------- */
-
-/** @brief Get a member of an enumeration by name
- ** @param enumeration array of ::VlEnumerator objects.
- ** @param name the name of the desired member.
- ** @return enumerator matching @a name.
- **
- ** If @a name is not found in the enumeration, then the value
- ** @c NULL is returned.
- **
- ** @sa vl-stringop-enumeration
- **/
-
-VL_EXPORT VlEnumerator *
-vl_enumeration_get (VlEnumerator const *enumeration, char const *name)
-{
-  assert(enumeration) ;
-  while (enumeration->name) {
-    if (strcmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
-    enumeration ++ ;
-  }
-  return NULL ;
-}
-
-/** @brief Get a member of an enumeration by name (case insensitive)
- ** @param enumeration array of ::VlEnumerator objects.
- ** @param name the name of the desired member.
- ** @return enumerator matching @a name.
- **
- ** If @a name is not found in the enumeration, then the value
- ** @c NULL is returned. @a string is matched case insensitive.
- **
- **  @sa vl-stringop-enumeration
- **/
-
-VL_EXPORT VlEnumerator *
-vl_enumeration_get_casei (VlEnumerator const *enumeration, char const *name)
-{
-  assert(enumeration) ;
-  while (enumeration->name) {
-    if (vl_string_casei_cmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
-    enumeration ++ ;
-  }
-  return NULL ;
-}
-
-/** @brief Get a member of an enumeration by value
- ** @param enumeration array of ::VlEnumerator objects.
- ** @param value value of the desired member.
- ** @return enumerator matching @a value.
- **
- ** If @a value is not found in the enumeration, then the value
- ** @c NULL is returned.
- **
- ** @sa vl-stringop-enumeration
- **/
-
-VL_EXPORT VlEnumerator *
-vl_enumeration_get_by_value (VlEnumerator const *enumeration, vl_index value)
-{
-  assert(enumeration) ;
-  while (enumeration->name) {
-    if (enumeration->value == value) return (VlEnumerator*)enumeration ;
-    enumeration ++ ;
-  }
-  return NULL ;
-}
-
diff --git a/opensfm/src/third_party/vlfeat/vl/stringop.h b/opensfm/src/third_party/vlfeat/vl/stringop.h
deleted file mode 100644
index f5f6a524f..000000000
--- a/opensfm/src/third_party/vlfeat/vl/stringop.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/** @file stringop.h
- ** @brief String operations
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_STRINGOP_H
-#define VL_STRINGOP_H
-
-#include "generic.h"
-
-/** @brief File protocols */
-enum {
-  VL_PROT_UNKNOWN = -1, /**< unknown protocol */
-  VL_PROT_NONE    =  0, /**< no protocol      */
-  VL_PROT_ASCII,        /**< ASCII protocol   */
-  VL_PROT_BINARY        /**< Binary protocol  */
-} ;
-
-
-VL_EXPORT vl_size vl_string_copy (char *destination, vl_size destinationSize, char const *source) ;
-VL_EXPORT vl_size vl_string_copy_sub (char *destination, vl_size destinationSize,
-                                      char const *beginning, char const *end) ;
-VL_EXPORT char *vl_string_parse_protocol (char const *string, int *protocol) ;
-VL_EXPORT char const *vl_string_protocol_name (int prot) ;
-VL_EXPORT vl_size vl_string_basename (char *destination, vl_size destinationSize,
-                                      char const *source, vl_size maxNumStrippedExtension) ;
-VL_EXPORT vl_size vl_string_replace_wildcard (char * destination, vl_size destinationSize,
-                                              char const *src, char wildcardChar, char escapeChar,
-                                              char const *replacement) ;
-VL_EXPORT char *vl_string_find_char_rev (char const *beginning, char const *end, char c) ;
-VL_EXPORT vl_size vl_string_length (char const *string) ;
-VL_EXPORT int vl_string_casei_cmp (const char *string1, const char *string2) ;
-
-/** @name String enumerations
- ** @{ */
-
-/** @brief Member of an enumeration */
-typedef struct _VlEnumerator
-{
-  char const *name ; /**< enumeration member name. */
-  vl_index value ;   /**< enumeration member value. */
-} VlEnumerator ;
-
-VL_EXPORT VlEnumerator *vl_enumeration_get (VlEnumerator const *enumeration, char const *name) ;
-VL_EXPORT VlEnumerator *vl_enumeration_get_casei (VlEnumerator const *enumeration, char const *name) ;
-VL_EXPORT VlEnumerator *vl_enumeration_get_by_value (VlEnumerator const *enumeration, vl_index value) ;
-/** @} */
-
-/* VL_STRINGOP_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svm.c b/opensfm/src/third_party/vlfeat/vl/svm.c
deleted file mode 100644
index 49af2ebe3..000000000
--- a/opensfm/src/third_party/vlfeat/vl/svm.c
+++ /dev/null
@@ -1,2172 +0,0 @@
-/** @file svm.c
- ** @brief Support Vector Machines (SVM) - Implementation
- ** @author Milan Sulc
- ** @author Daniele Perrone
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 Milan Sulc.
-Copyright (C) 2012 Daniele Perrone.
-Copyright (C) 2011-13 Andrea Vedaldi.
-
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/** @file svm.h
- ** @see @ref svm.
- **/
-
-/**
-<!-- ------------------------------------------------------------- -->
-@page svm Support Vector Machines (SVM)
-@author Milan Sulc
-@author Daniele Perrone
-@author Andrea Vedaldi
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-*Support Vector Machines* (SVMs) are one of the most popular types of
-discriminate classifiers. VLFeat implements two solvers, SGD and SDCA,
-capable of learning linear SVMs on a large scale. These linear solvers
-can be combined with explicit feature maps to learn non-linear models
-as well. The solver supports a few variants of the standard
-SVM formulation, including using loss functions other than the hinge
-loss.
-
-@ref svm-starting demonstrates how to use VLFeat to learn an SVM.
-Information on SVMs and the corresponding optimization algorithms as
-implemented by VLFeat are given in:
-
-- @subpage svm-fundamentals - Linear SVMs and their learning.
-- @subpage svm-advanced - Loss functions, dual objective, and other details.
-- @subpage svm-sgd - The SGD algorithm.
-- @subpage svm-sdca - The SDCA algorithm.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-starting Getting started
-<!-- ------------------------------------------------------------- -->
-
-This section demonstrates how to learn an SVM by using VLFeat. SVM
-learning is implemented by the ::VlSvm object type. Let's
-start by a complete example:
-
-@code
-#include <stdio.h>
-#include <vl/svm.h>
-
-int main()
-{
-  vl_size const numData = 4 ;
-  vl_size const dimension = 2 ;
-  double x [dimension * numData] = {
-    0.0, -0.5,
-    0.6, -0.3,
-    0.0,  0.5
-    0.6,  0.0} ;
-  double y [numData] = {1, 1, -1, 1} ;
-  double lambda = 0.01;
-  double * const model ;
-  double bias ;
-
-  VlSvm * svm = vl_svm_new(VlSvmSolverSgd,
-                           x, dimension, numData,
-                           y,
-                           lambda) ;
-  vl_svm_train(svm) ;
-
-  model = vl_svm_get_model(svm) ;
-  bias = vl_svm_get_bias(svm) ;
-
-  printf("model w = [ %f , %f ] , bias b = %f \n",
-         model[0],
-         model[1],
-         bias);
-
-  vl_svm_delete(svm) ;
-  return 0;
-}
-@endcode
-
-This code learns a binary linear SVM using the SGD algorithm on
-four two-dimensional points using 0.01 as regularization parameter.
-
-::VlSvmSolverSdca can be specified in place of ::VlSvmSolverSdca
-in orer to use the SDCA algorithm instead.
-
-Convergence and other diagnostic information can be obtained after
-training by using the ::vl_svm_get_statistics function. Algorithms
-regularly check for convergence (usally after each pass over the data).
-The ::vl_svm_set_diagnostic_function can be used to specify a callback
-to be invoked when diagnostic is run. This can be used, for example,
-to dump information on the screen as the algorithm progresses.
-
-Convergence is reached after a maximum number of iterations
-(::vl_svm_set_max_num_iterations) or after a given criterion falls
-below a threshold (::vl_svm_set_epsilon). The meaning of these
-may depend on the specific algorithm (see @ref svm for further details).
-
-::VlSvm is a quite powerful object. Algorithms only need to perform
-inner product and accumulation operation on the data (see @ref svm-advanced).
-This is used to abstract from the data type and support almost anything
-by speciying just two functions (::vl_svm_set_data_functions).
-
-A simple interface to this advanced functionality is provided by the
-::VlSvmDataset object. This supports natively @c float and @c double
-data types, as well as applying on the fly the homogeneous kernel map
-(@ref homkermap). This is exemplified in @ref svmdataset-starting.
-
-*/
-
-/**
-<!-- ------------------------------------------------------------- -->
-@page svm-fundamentals SVM fundamentals
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-This page introduces the SVM formulation used in VLFeat. See @ref svm
-for more information on VLFeat SVM support.
-
-Let $ \bx \in \real^d $ be a vector representing, for example, an
-image, an audio track, or a fragment of text. Our goal is to design a
-*classifier*, i.e. a function that associates to each vector $\bx$ a
-positive or negative label based on a desired criterion, for example
-the fact that the image contains or not a cat, that the audio track
-contains or not English speech, or that the text is or not a
-scientific paper.
-
-The vector $\bx$ is classified by looking at the sign of a *linear
-scoring function* $\langle \bx, \bw \rangle$. The goal of learning is
-to estimate the parameter $\bw \in \real^d$ in such a way that the
-score is positive if the vector $\bx$ belongs to the positive class
-and negative otherwise. In fact, in the standard SVM formulation the
-the goal is to have a score of *at least 1* in the first case, and of
-*at most -1* in the second one, imposing a *margin*.
-
-The parameter $\bw$ is estimated or *learned* by fitting the scoring
-function to a training set of $n$ example pairs $(\bx_i,y_i),
-i=1,\dots,n$. Here $y_i \in \{-1,1\}$ are the *ground truth labels* of
-the corresponding example vectors. The fit quality is measured by a
-*loss function* which, in standard SVMs, is the *hinge loss*:
-
-\[
-\ell_i(\langle \bw,\bx\rangle) = \max\{0, 1 - y_i \langle \bw,\bx\rangle\}.
-\]
-
-Note that the hinge loss is zero only if the score $\langle
-\bw,\bx\rangle$ is at least 1 or at most -1, depending on the label
-$y_i$.
-
-Fitting the training data is usually insufficient. In order for the
-scoring function *generalize to future data* as well, it is usually
-preferable to trade off the fitting accuracy with the *regularity* of
-the learned scoring function $\langle \bx, \bw \rangle$. Regularity in
-the standard formulation is measured by the norm of the parameter
-vector $\|\bw\|^2$ (see @ref svm-advanced). Averaging the loss on all
-training samples and adding to it the regularizer weighed by a
-parameter $\lambda$ yields the *regularized loss objective*
-
-@f{equation}{
-\boxed{\displaystyle
-E(\bw) =  \frac{\lambda}{2} \left\| \bw \right\|^2
-+ \frac{1}{n} \sum_{i=1}^n \max\{0, 1 - y_i \langle \bw,\bx\rangle\}.
-\label{e:svm-primal-hinge}
-}
-@f}
-
-Note that this objective function is *convex*, so that there exists a
-single global optimum.
-
-The scoring function $\langle \bx, \bw \rangle$ considered so far has
-been linear and unbiased. @ref svm-bias discusses how a bias term can
-be added to the SVM and @ref svm-feature-maps shows how non-linear
-SVMs can be reduced to the linear case by computing suitable feature
-maps.
-
-@ref svm-learning shows how VLFeat can be used to learn an SVM by
-minimizing $E(\bw)$.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-learning Learning
-<!-- ------------------------------------------------------------- -->
-
-Learning an SVM amounts to finding the minimizer $\bw^*$ of the cost
-function $E(\bw)$. While there are dozens of methods that can be used
-to do so, VLFeat implements two large scale methods, designed to work
-with linear SVMs (see @ref svm-feature-maps to go beyond linear):
-
-- @ref svm-sgd
-- @ref svm-sdca
-
-Using these solvers is exemplified in @ref svm-starting.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-bias Adding a bias
-<!-- ------------------------------------------------------------- -->
-
-It is common to add to the SVM scoring function a *bias term* $b$, and
-to consider the score $\langle \bx,\bw \rangle + b$. In practice the
-bias term can be crucial to fit the training data optimally, as there
-is no reason why the inner products $\langle \bx,\bw \rangle$ should
-be naturally centered at zero.
-
-Some SVM learning algorithms can estimate both $\bw$ and $b$
-directly. However, other algorithms such as SGD and SDCA cannot. In
-this case, a simple workaround is to add a constant component $B > 0$
-(we call this constant the *bias multiplier*) to the data,
-i.e. consider the extended data vectors:
-\[
-\bar \bx = \begin{bmatrix} \bx \\ B \end{bmatrix},
-\quad
-\bar \bw = \begin{bmatrix} \bw \\ w_b \end{bmatrix}.
-\]
-In this manner the scoring function incorporates implicitly a bias $b = B w_b$:
-\[
-\langle \bar\bx, \bar\bw \rangle =
-\langle \bx, \bw \rangle + B w_b.
-\]
-
-The disadvantage of this reduction is that the term $w_b^2$ becomes
-part of the SVM regularizer, which shrinks the bias $b$ towards
-zero. This effect can be alleviated by making $B$ sufficiently large,
-because in this case $\|\bw\|^2 \gg w_b^2$ and the shrinking effect is
-negligible.
-
-Unfortunately, making $B$ too large makes the problem numerically
-unbalanced, so a reasonable trade-off between shrinkage and stability
-is generally sought. Typically, a good trade-off is obtained by
-normalizing the data to have unitary Euclidean norm and then choosing
-$B \in [1, 10]$.
-
-Specific implementations of SGD and SDCA may provide explicit support
-to learn the bias in this manner, but it is important to understand
-the implications on speed and accuracy of the learning if this is
-done.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-feature-maps Non-linear SVMs and feature maps
-<!-- ------------------------------------------------------------- -->
-
-So far only linear scoring function $\langle \bx,\bw \rangle$ have
-been considered. Implicitly, however, this assumes that the objects to
-be classified (e.g. images) have been encoded as vectors $\bx$ in a
-way that makes linear classification possible. This encoding step can
-be made explicit by introducing the *feature map* $\Phi(\bx) \in
-\real^d$. Including the feature map yields a scoring function
-*non-linear* in $\bx$:
-\[
-\bx\in\mathcal{X} \quad\longrightarrow\quad \langle \Phi(\bx), \bw \rangle.
-\]
-The nature of the input space $\mathcal{X}$ can be arbitrary and might
-not have a vector space structure at all.
-
-The representation or encoding captures a notion of *similarity*
-between objects: if two vectors $\Phi(\bx_1)$ and $\Phi(\bx_2)$ are
-similar, then their scores will also be similar. Note that choosing a
-feature map amounts to incorporating this information in the model
-*prior* to learning.
-
-The relation of feature maps to similarity functions is formalized by
-the notion of a *kernel*, a positive definite function $K(\bx,\bx')$
-measuring the similarity of a pair of objects. A feature map defines a
-kernel by
-
-\[
-K(\bx,\bx') = \langle \Phi(\bx),\Phi(\bx') \rangle.
-\]
-
-Viceversa, any kernel function can be represented by a feature map in
-this manner, establishing an equivalence.
-
-So far, all solvers in VLFeat assume that the feature map $\Psi(\bx)$
-can be explicitly computed. Although classically kernels were
-introduced to generalize solvers to non-linear SVMs for which a
-feature map *cannot* be computed (e.g. for a Gaussian kernel the
-feature map is infinite dimensional), in practice using explicit
-feature representations allow to use much faster solvers, so it makes
-sense to *reverse* this process.
-*/
-
-/**
-<!-- ------------------------------------------------------------- -->
-@page svm-advanced Advanced SVM topics
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-This page discusses advanced SVM topics. For an introduction to SVMs,
-please refer to @ref svm and @ref svm-fundamentals.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-loss-functions Loss functions
-<!-- ------------------------------------------------------------- -->
-
-The SVM formulation given in @ref svm-fundamentals uses the
-hinge loss, which is only one of a variety of loss functions that
-are often used for SVMs. More in general, one
-can consider the objective
-
-@f{equation}{
-E(\bw) =  \frac{\lambda}{2} \left\| \bw \right\|^2 + \frac{1}{n} \sum_{i=1}^n \ell_i(\langle \bw,\bx\rangle).
-\label{e:svm-primal}
-@f}
-
-where the loss $\ell_i(z)$ is a convex function of the scalar variable
-$z$. Losses differ by: (i) their purpose (some are suitable for
-classification, other for regression), (ii) their smoothness (which
-usually affects how quickly the SVM objective function can be
-minimized), and (iii) their statistical interpretation (for example
-the logistic loss can be used to learn logistic models).
-
-Concrete examples are the:
-
-<table>
-<tr>
-<td>Name</td>
-<td>Loss $\ell_i(z)$</td>
-<td>Description</td>
-</tr>
-<tr>
-<td>Hinge</td>
-<td>$\max\{0, 1-y_i z\}$</td>
-<td>The standard SVM loss function.</td>
-</tr>
-<tr>
-<td>Square hinge</td>
-<td>$\max\{0, 1-y_i z\}^2$</td>
-<td>The standard SVM loss function, but squared. This version is
-smoother and may yield numerically easier problems.</td>
-</tr>
-<tr>
-<td>Square or l2</td>
-<td>$(y_i - z)^2$</td>
-<td>This loss yields the ridge regression model (l2 regularised least
-square).</td>
-</tr>
-<tr>
-<td>Linear or l1</td>
-<td>$|y_i - z|$</td>
-<td>Another loss suitable for regression, usually more robust but
-harder to optimize than the squared one.</td>
-</tr>
-<tr>
-<td>Insensitive l1</td>
-<td>$\max\{0, |y_i - z| - \epsilon\}$.</td>
-<td>This is a variant of the previous loss, proposed in the original
-Support Vector Regression formulation. Differently from the previous
-two losses, the insensitivity may yield to a sparse selection of
-support vectors.</td>
-</tr>
-<tr>
-<td>Logistic</td>
-<td>$\log(1 + e^{-y_i z})$</td>
-<td>This corresponds to regularized logisitc regression. The loss can
-be seen as a negative log-likelihood: $\ell_i(z) = -\log P[y_i | z] =
-- \log \sigma(y_iz/2)$, where $\sigma(z) = e^z/(1 + e^z)$ is the
-sigmoid function, mapping a score $z$ to a probability. The $1/2$
-factor in the sigmoid is due to the fact that labels are in $\{-1,1\}$
-rather than $\{0,1\}$ as more common for the standard sigmoid
-model.</td>
-</tr>
-</table>
-
-<!-- ------------------------------------------------------------- -->
-@section svm-data-abstraction Data abstraction: working with compressed data
-<!-- ------------------------------------------------------------- -->
-
-VLFeat learning algorithms (SGD and SDCA) access the data by means of
-only two operations:
-
-- *inner product*: computing the inner product between the model and
-a data vector, i.e. $\langle \bw, \bx \rangle$.
-- *accumulation*: summing a data vector to the model, i.e. $\bw
-\leftarrow \bw + \beta \bx$.
-
-VLFeat learning algorithms are *parameterized* in these two
-operations. As a consequence, the data can be stored in any format
-suitable to the user (e.g. dense matrices, sparse matrices,
-block-sparse matrices, disk caches, and so on) provided that these two
-operations can be implemented efficiently. Differently from the data,
-however, the model vector $\bw$ is represented simply as a dense array
-of doubles. This choice is adequate in almost any case.
-
-A particularly useful aspect of this design choice is that the
-training data can be store in *compressed format* (for example by
-using product quantization (PQ)). Furthermore, higher-dimensional
-encodings such as the homogeneous kernel map (@ref homkermap) and the
-intersection kernel map can be *computed on the fly*. Such techniques
-are very important when dealing with GBs of data.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-dual-problem Dual problem
-<!-- ------------------------------------------------------------- -->
-
-In optimization, the *dual objective* $D(\balpha)$ of the SVM
-objective $E(\bw)$ is of great interest. To obtain the dual objective,
-one starts by approximating each loss term from below by a family of planes:
-\[
-\ell_i(z) = \sup_{u} (u z - \ell_i^*(u) ),
-\qquad
-\ell_i^*(u) = \sup_{z} (z u - \ell_i(z) )
-\]
-where $\ell_i^*(u)$ is the *dual conjugate* of the loss and gives the
-intercept of each approximating plane as a function of the slope. When
-the loss function is convex, the approximation is in fact exact. Examples
-include:
-
-<table>
-<tr>
-<td>Name</td>
-<td>Loss $\ell_i(z)$</td>
-<td>Conjugate loss $\ell_i^*(u)$</td>
-</tr>
-<tr>
-<td>Hinge</td>
-<td>$\max\{0, 1-y_i z\}$</td>
-<td>\[
-\ell_i^*(u) =
-\begin{cases}
-y_i u, & -1 \leq y_i u \leq 0, \\
-+\infty, & \text{otherwise}
-\end{cases}
-\]</td>
-</tr>
-<tr>
-<td>Square hinge</td>
-<td>$\max\{0, 1-y_i z\}^2$</td>
-<td>\[\ell_i^*(u) =
-\begin{cases}
-y_i u + \frac{u^2}{4}, & y_i u \leq 0, \\
-+\infty, & \text{otherwise} \\
-\end{cases}\]</td>
-</tr>
-<tr>
-<td>Linear or l1</td>
-<td>$|y_i - z|$</td>
-<td>\[\ell_i^*(u) =
-\begin{cases}
-y_i u, & -1 \leq y_i u \leq 1, \\
-+\infty, & \text{otherwise} \\
-\end{cases}\]</td>
-</tr>
-<tr>
-<td>Square or l2</td>
-<td>$(y_i - z)^2$</td>
-<td>\[\ell_i^*(u)=y_iu + \frac{u^2}{4}\]</td>
-</tr>
-<tr>
-<td>Insensitive l1</td>
-<td>$\max\{0, |y_i - z| - \epsilon\}$.</td>
-<td></td>
-</tr>
-<tr>
-<td>Logistic</td>
-<td>$\log(1 + e^{-y_i z})$</td>
-<td>\[\ell_i^*(u) =
- \begin{cases}
- (1+u) \log(1+u) - u \log(-u), & -1 \leq y_i u \leq 0, \\
- +\infty, & \text{otherwise} \\
- \end{cases}\]
-</td>
-</tr>
-</table>
-
-Since each plane $- z \alpha_i - \ell^*_i(-\alpha_i) \leq \ell_i(z)$
-bounds the loss from below, by substituting in $E(\bw)$ one can write
-a lower bound for the SVM objective
-\[
-F(\bw,\balpha) = \frac{\lambda}{2} \|\bw\|^2 -
-\frac{1}{n}\sum_{i=1}^n (\bw^\top \bx_i\alpha_i + \ell_i^*(-\alpha_i))
-\leq E(\bw).
-\]
-for each setting of the *dual variables* $\alpha_i$. The dual
-objective function $D(\balpha)$ is obtained by minimizing the lower
-bound $F(\bw,\balpha)$ w.r.t. to $\bw$:
-\[
-D(\balpha) = \inf_{\bw} F(\bw,\balpha) \leq E(\bw).
-\]
-The minimizer and the dual objective are now easy to find:
-\[
-\boxed{\displaystyle
-\bw(\balpha) =
-\frac{1}{\lambda n}
-\sum_{i=1}^n \bx_i \alpha_i = \frac{1}{\lambda n} X\balpha,
-\quad
-D(\balpha) = - \frac{1}{2\lambda n^2} \balpha^\top X^\top X \balpha +
-\frac{1}{n} \sum_{i=1}^n - \ell_i^*(-\alpha_i)
-}
-\]
-where $X = [\bx_1, \dots, \bx_n]$ is the data matrix. Since the dual
-is uniformly smaller than the primal, one has the *duality gap* bound:
-\[
-D(\balpha) \leq P(\bw^*) \leq P(\bw(\balpha))
-\]
-This bound can be used to evaluate how far off $\bw(\balpha)$ is from
-the primal minimizer $\bw^*$. In fact, due to convexity, this bound
-can be shown to be zero when $\balpha^*$ is the dual maximizer (strong
-duality):
-\[
-D(\balpha^*) = P(\bw^*) = P(\bw(\balpha^*)),
-\quad \bw^* = \bw(\balpha^*).
-\]
-
-<!-- ------------------------------------------------------------- -->
-@section svm-C Parametrization in C
-<!-- ------------------------------------------------------------- -->
-
-Often a slightly different form of the SVM objective is considered,
-where a parameter $C$ is used to scale the loss instead of the regularizer:
-
-\[
-E_C(\bw) = \frac{1}{2} \|\bw\|^2 + C \sum_{i=1}^n \ell_i(\langle \bx_i, \bw\rangle)
-\]
-
-This and the objective function $E(\bw)$ in $\lambda$ are equivalent
-(proportional) if
-
-\[
-\lambda = \frac{1}{nC},
-\qquad C = \frac{1}{n\lambda}.
-\] up to an overall scaling factor to the problem.
-
-**/
-
-/**
-
-<!-- ------------------------------------------------------------- -->
-@page svm-sdca Stochastic Dual Coordinate Ascent
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-This page describes the *Stochastic Dual Coordinate Ascent* (SDCA)
-linear SVM solver. Please see @ref svm for an overview of VLFeat SVM
-support.
-
-SDCA maximizes the dual SVM objective (see @ref svm-dual-problem
-for a derivation of this expression):
-
-\[
-D(\balpha) = - \frac{1}{2\lambda n^2} \balpha^\top X^\top X \balpha +
-\frac{1}{n} \sum_{i=1}^n - \ell_i^*(-\alpha_i)
-\]
-
-where $X$ is the data matrix. Recall that the primal parameter
-corresponding to a given setting of the dual variables is:
-
-\[
-\bw(\balpha) = \frac{1}{\lambda n} \sum_{i=1}^n \bx_i \alpha_i = \frac{1}{\lambda n} X\balpha
-\]
-
-In its most basic form, the *SDCA algorithm* can be summarized as follows:
-
-- Let $\balpha_0 = 0$.
-- Until the duality gap $P(\bw(\balpha_t)) -  D(\balpha_t) < \epsilon$
-  - Pick a dual variable $q$ uniformly at random in $1, \dots, n$.
-  - Maximize the dual with respect to this variable: $\Delta\alpha_q = \max_{\Delta\alpha_q} D(\balpha_t + \Delta\alpha_q \be_q )$
-  - Update $\balpha_{t+1} = \balpha_{t} + \be_q \Delta\alpha_q$.
-
-In VLFeat, we partially use the nomenclature from @cite{shwartz13a-dual} and @cite{hsieh08a-dual}.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-sdca-dual-max Dual coordinate maximization
-<!-- ------------------------------------------------------------- -->
-
-The updated dual objective can be expanded as:
-\[
-D(\balpha_t + \be_q \Delta\alpha_q) =
-\text{const.}
-- \frac{1}{2\lambda n^2} \bx_q^\top \bx_q (\Delta\alpha_q)^2
-- \frac{1}{n} \bx_q^\top \frac{X\alpha_t}{\lambda n} \Delta\alpha_q
-- \frac{1}{n} \ell^*_q(- \alpha_q - \Delta\alpha_q)
-\]
-This can also be written as
-@f{align*}
-D(\balpha_t + \be_q \Delta\alpha_q) &\propto
-- \frac{A}{2} (\Delta\alpha_q)^2
-- B \Delta\alpha_q
-- \ell^*_q(- \alpha_q - \Delta\alpha_q),
-\\
-A &= \frac{1}{\lambda n} \bx_q^\top \bx_q = \frac{1}{\lambda n} \| \bx_q \|^2,
-\\
-B &= \bx_q^\top \frac{X\balpha_t}{\lambda n} = \bx_q^\top \bw_t.
-@f}
-Maximizing this quantity in the scalar variable $\Delta\balpha$ is usually
-not difficult. It is convenient to store and incrementally
-update the model $\bw_t$ after the optimal step $\Delta\balpha$ has been
-determined:
-\[
-\bw_t = \frac{X \balpha_t}{\lambda n},
-\quad \bw_{t+1} = \bw_t + \frac{1}{\lambda n }\bx_q \be_q \Delta\alpha_q.
-\]
-
-For example, consider the hinge loss as given in @ref svm-advanced :
-\[
-\ell_q^*(u) =
-\begin{cases}
-y_q u, & -1 \leq y_q u \leq 0, \\
-+\infty, & \text{otherwise}.
-\end{cases}
-\]
-The maximizer $\Delta\alpha_q$ of the update objective must be in the
-range where the conjugate loss is not infinite. Ignoring such bounds,
-the update can be obtained by setting the derivative of the objective
-to zero, obtaining
-\[
-\tilde {\Delta \alpha_q}= \frac{y_q - B}{A}.
-\]
-Note that $B$ is simply current score associated by the SVM to
-the sample $\bx_q$. Incorporating the constraint $-1 \leq - y_q
-(\alpha_q + \Delta \alpha_q) \leq 0$,
-i.e. $0 \leq y_q (\alpha_q + \Delta \alpha_q) \leq 1$, one obtains the update
-\[
-\Delta\alpha_q =  y_q \max\{0, \min\{1, y_q (\tilde {\Delta\alpha_q } + \alpha_q)\}\} - \alpha_q.
-\]
-
-<!-- ------------------------------------------------------------ --->
-@section svm-sdca-details Implementation details
-<!-- ------------------------------------------------------------ --->
-
-Rather than visiting points completely at random, VLFeat SDCA follows
-the best practice of visiting all the points at every epoch (pass
-through the data), changing the order of the visit randomly by picking
-every time a new random permutation.
-**/
-
-/**
-<!-- ------------------------------------------------------------- -->
-@page svm-sgd Stochastic Gradient Descent
-@tableofcontents
-<!-- ------------------------------------------------------------- -->
-
-This page describes the *Stochastic Gradient Descent* (SGD) linear SVM
-solver. SGD minimizes directly the primal SVM objective (see @ref svm):
-
-\[
-E(\bw) = \frac{\lambda}{2} \left\| \bw \right\|^2 + \frac{1}{n} \sum_{i=1}^n
-\ell_i(\langle \bw,\bx\rangle)
-\]
-
-Firts, rewrite the objective as the average
-
-\[
-E(\bw) = \frac{1}{n} \sum_{i=1}^n E_i(\bw),
-\quad
-E_i(\bw) = \frac{\lambda}{2}  \left\| \bw \right\|^2 + \ell_i(\langle \bw,\bx\rangle).
-\]
-
-Then SGD performs gradient steps by considering at each iteration
-one term $E_i(\bw)$ selected at random from this average.
-In its most basic form, the algorithm is:
-
-- Start with $\bw_0 = 0$.
-- For $t=1,2,\dots T$:
-  - Sample one index $i$ in $1,\dots,n$ uniformly at random.
-  - Compute a subgradient $\bg_t$ of $E_i(\bw)$ at $\bw_t$.
-  - Compute the learning rate $\eta_t$.
-  - Update $\bw_{t+1} = \bw_t - \eta_t \bg_t$.
-
-Provided that the learning rate $\eta_t$ is chosen correctly, this
-simple algorithm is guaranteed to converge to the minimizer $\bw^*$ of
-$E$.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-sgd-convergence Convergence and speed
-<!-- ------------------------------------------------------------- -->
-
-The goal of the SGD algorithm is to bring the *primal suboptimality*
-below a threshold $\epsilon_P$:
-\[
-E(\bw_t) - E(\bw^*) \leq \epsilon_P.
-\]
-
-If the learning rate $\eta_t$ is selected appropriately, SGD can be
-shown to converge properly. For example,
-@cite{shalev-shwartz07pegasos} show that, since $E(\bw)$ is
-$\lambda$-strongly convex, then using the learning rate
-\[
-\boxed{\eta_t = \frac{1}{\lambda t}}
-\]
-guarantees that the algorithm reaches primal-suboptimality $\epsilon_P$ in
-\[
-\tilde O\left( \frac{1}{\lambda \epsilon_P} \right).
-\]
-iterations. This particular SGD variant is sometimes known as PEGASOS
-@cite{shalev-shwartz07pegasos} and is the version implemented in
-VLFeat.
-
-The *convergence speed* is not sufficient to tell the *learning speed*,
-i.e. how quickly an algorithm can learn an SVM that performs optimally
-on the test set. The following two observations
-can be used to link convergence speed to learning speed:
-
-- The regularizer strength is often heuristically selected to be
-  inversely proportional to the number of training samples: $\lambda =
-  \lambda_0 /n$. This reflects the fact that with more training data
-  the prior should count less.
-- The primal suboptimality $\epsilon_P$ should be about the same as
-  the estimation error of the SVM primal. This estimation error is due
-  to the finite training set size and can be shown to be of the order
-  of $1/\lambda n = 1 / \lambda_0$.
-
-Under these two assumptions, PEGASOS can learn a linear SVM in time
-$\tilde O(n)$, which is *linear in the number of training
-examples*. This fares much better with $O(n^2)$ or worse of non-linear
-SVM solvers.
-
-<!-- ------------------------------------------------------------- -->
-@section svm-sgd-bias The bias term
-<!-- ------------------------------------------------------------- -->
-
-Adding a bias $b$ to the SVM scoring function $\langle \bw, \bx
-\rangle +b$ is done, as explained in @ref svm-bias, by appending a
-constant feature $B$ (the *bias multiplier*) to the data vectors $\bx$
-and a corresponding weight element $w_b$ to the weight vector $\bw$,
-so that $b = B w_b$ As noted, the bias multiplier should be
-relatively large in order to avoid shrinking the bias towards zero,
-but small to make the optimization stable. In particular, setting $B$
-to zero learns an unbiased SVM (::vl_svm_set_bias_multiplier).
-
-To counter instability caused by a large bias multiplier, the learning
-rate of the bias is slowed down by multiplying the overall learning
-rate $\eta_t$ by a bias-specific rate coefficient
-(::vl_svm_set_bias_learning_rate).
-
-As a rule of thumb, if the data vectors $\bx$ are $l^2$ normalized (as
-they typically should for optimal performance), then a reasonable bias
-multiplier is in the range 1 to 10 and a reasonable bias learning rate
-is somewhere in the range of the inverse of that (in this manner the
-two parts of the extended feature vector $(\bx, B)$ are balanced).
-
-<!-- ------------------------------------------------------------- -->
-@section svm-sgd-starting-iteration Adjusting the learning rate
-<!-- ------------------------------------------------------------- -->
-
-Initially, the learning rate $\eta_t = 1/\lambda t$ is usually too
-fast: as usually $\lambda \ll 1$, $\eta_1 \gg 1$. But this is clearly
-excessive (for example, without a loss term, the best learning rate at
-the first iteration is simply $\eta_1=1$, as this nails the optimum in
-one step). Thus, the learning rate formula is modified to be $\eta_t =
-1 / \lambda (t + t_0)$, where $t_0 \approx 2/\lambda$, which is
-equivalent to start $t_0$ iterations later. In this manner $\eta_1
-\approx 1/2$.
-
-<!-- ------------------------------------------------------------ --->
-@subsection svm-sgd-warm-start Warm start
-<!-- ------------------------------------------------------------ --->
-
-Starting from a given model $\bw$ is easy in SGD as the optimization
-runs in the primal. However, the starting iteration index $t$ should
-also be advanced for a warm start, as otherwise the initial setting of
-$\bw$ is rapidly forgot (::vl_svm_set_model, ::vl_svm_set_bias,
-::vl_svm_set_iteration_number).
-
-<!-- ------------------------------------------------------------- -->
-@section svm-sgd-details Implementation details
-<!-- ------------------------------------------------------------- -->
-
-@par "Random sampling of points"
-
-Rather than visiting points completely at random, VLFeat SDCA follows
-the best practice of visiting all the points at every epoch (pass
-through the data), changing the order of the visit randomly by picking
-every time a new random permutation.
-
-@par "Factored representation"
-
-At each iteration, the SGD algorithm updates the vector $\bw$
-(including the additional bias component $w_b$) as $\bw_{t+1}
-\leftarrow \bw_t - \lambda \eta_t \bw_t - \eta_t \bg_t$, where
-$\eta_t$ is the learning rate. If the subgradient of the loss function
-$\bg_t$ is zero at a given iteration, this amounts to simply shrink
-$\bw$ towards the origin by multiplying it by the factor $1 - \lambda
-\eta_t$. Thus such an iteration can be accelerated significantly by
-representing internally $\bw_t = f_t \bu_t$, where $f_t$ is a scaling
-factor. Then, the update becomes
-\[
-   f_{t+1} \bu_{t+1}
-   = f_{t} \bu_{t} - \lambda \eta_t f_{t} \bu_{t} - \eta_t \bg_t
-   = (1-\lambda \eta_t) f_{t} \bu_{t} - \eta_t \bg_t.
-\]
-Setting $f_{t+1} = (1-\lambda \eta_t) f_{t}$, this gives the update
-equation for $\bu_t$
-\[
-\bu_{t+1} = \bu_{t} - \frac{\eta_t}{f_{t+1}} \bg_t.
-\]
-but this step can be skipped whenever $\bg_t$ is equal to zero.
-
-When the bias component has a different learning rate, this scheme
-must be adjusted slightly by adding a separated factor for the bias,
-but it is otherwise identical.
-
-
-**/
-
-/*
-
-<!-- ------------------------------------------------------------ --->
-@section svm-pegasos PEGASOS
-<!-- ------------------------------------------------------------ --->
-
-<!-- ------------------------------------------------------------ --->
-@subsection svm-pegasos-algorithm Algorithm
-<!-- ------------------------------------------------------------ --->
-
-PEGASOS @cite{shalev-shwartz07pegasos} is a stochastic subgradient
-optimizer. At the <em>t</em>-th iteration the algorithm:
-
-- Samples uniformly at random as subset @f$ A_t @f$ of <em>k</em> of
-training pairs @f$(x,y)@f$ from the <em>m</em> pairs provided for
-training (this subset is called mini batch).
-- Computes a subgradient @f$ \nabla_t @f$ of the function @f$ E_t(w) =
-\frac{1}{2}\|w\|^2 + \frac{1}{k} \sum_{(x,y) \in A_t} \ell(w;(x,y))
-@f$ (this is the SVM objective function restricted to the
-minibatch).
-- Compute an intermediate weight vector @f$ w_{t+1/2} @f$ by doing a
-step @f$ w_{t+1/2} = w_t - \alpha_t \nabla_t @f$ with learning rate
-@f$ \alpha_t = 1/(\eta t) @f$ along the subgradient. Note that the
-learning rate is inversely proportional to the iteration number.
-- Back projects the weight vector @f$ w_{t+1/2} @f$ on the
-hypersphere of radius @f$ \sqrt{\lambda} @f$ to obtain the next
-model estimate @f$ w_{t+1} @f$:
-@f[
-w_t = \min\{1, \sqrt{\lambda}/\|w\|\} w_{t+1/2}.
-@f]
-The hypersphere is guaranteed to contain the optimal weight vector
-@f$ w^* @f$.
-
-VLFeat implementation fixes to one the size of the mini batches @f$ k
-@f$.
-
-
-<!-- ------------------------------------------------------------ --->
-@subsection svm-pegasos-permutation Permutation
-<!-- ------------------------------------------------------------ --->
-
-VLFeat PEGASOS can use a user-defined permutation to decide the order
-in which data points are visited (instead of using random
-sampling). By specifying a permutation the algorithm is guaranteed to
-visit each data point exactly once in each loop. The permutation needs
-not to be bijective. This can be used to visit certain data samples
-more or less often than others, implicitly reweighting their relative
-importance in the SVM objective function. This can be used to balance
-the data.
-
-<!-- ------------------------------------------------------------ --->
-@subsection svm-pegasos-kernels Non-linear kernels
-<!-- ------------------------------------------------------------ --->
-
-PEGASOS can be extended to non-linear kernels, but the algorithm is
-not particularly efficient in this setting [1]. When possible, it may
-be preferable to work with explicit feature maps.
-
-Let @f$ k(x,y) @f$ be a positive definite kernel. A <em>feature
-map</em> is a function @f$ \Psi(x) @f$ such that @f$ k(x,y) = \langle
-\Psi(x), \Psi(y) \rangle @f$. Using this representation the non-linear
-SVM learning objective function writes:
-
-@f[
-\min_{w} \frac{\lambda}{2} \|w\|^2 + \frac{1}{m} \sum_{i=1}^n
-\ell(w; (\Psi(x)_i,y_i)).
-@f]
-
-Thus the only difference with the linear case is that the feature @f$
-\Psi(x) @f$ is used in place of the data @f$ x @f$.
-
-@f$ \Psi(x) @f$ can be learned off-line, for instance by using the
-incomplete Cholesky decomposition @f$ V^\top V @f$ of the Gram matrix
-@f$ K = [k(x_i,x_j)] @f$ (in this case @f$ \Psi(x_i) @f$ is the
-<em>i</em>-th columns of <em>V</em>). Alternatively, for additive
-kernels (e.g. intersection, Chi2) the explicit feature map computed by
-@ref homkermap.h can be used.
-
-For additive kernels it is also possible to perform the feature
-expansion online inside the solver, setting the specific feature map
-via ::vl_svmdataset_set_map. This is particular useful to keep the
-size of the training data small, when the number of the samples is big
-or the memory is limited.
-*/
-
-#include "svm.h"
-#include "mathop.h"
-#include <string.h>
-
-struct VlSvm_ {
-  VlSvmSolverType solver ;      /**< SVM solver type. */
-
-  vl_size dimension ;           /**< Model dimension. */
-  double * model ;              /**< Model ($\bw$ vector). */
-  double bias ;                 /**< Bias. */
-  double biasMultiplier ;       /**< Bias feature multiplier. */
-
-  /* valid during a run */
-  double lambda ;               /**< Regularizer multiplier. */
-  void const * data ;
-  vl_size numData ;
-  double const * labels ;       /**< Data labels. */
-  double const * weights ;      /**< Data weights. */
-
-  VlSvmDataset * ownDataset ;   /**< Optional owned dataset. */
-
-  VlSvmDiagnosticFunction diagnosticFn ;
-  void * diagnosticFnData ;
-  vl_size diagnosticFrequency ; /**< Frequency of diagnostic. */
-
-  VlSvmLossFunction lossFn ;
-  VlSvmLossFunction conjugateLossFn ;
-  VlSvmLossFunction lossDerivativeFn ;
-  VlSvmDcaUpdateFunction dcaUpdateFn ;
-  VlSvmInnerProductFunction innerProductFn ;
-  VlSvmAccumulateFunction accumulateFn ;
-
-  vl_size iteration ;           /**< Current iterations number. */
-  vl_size maxNumIterations ;    /**< Maximum number of iterations. */
-  double epsilon ;              /**< Stopping threshold. */
-
-  /* Book keeping */
-  VlSvmStatistics statistics ;  /**< Statistcs. */
-  double * scores ;
-
-  /* SGD specific */
-  double  biasLearningRate ;    /**< Bias learning rate. */
-
-  /* SDCA specific */
-  double * alpha ;              /**< Dual variables. */
-} ;
-
-/* ---------------------------------------------------------------- */
-
-/** @brief Create a new object with plain data.
- ** @param type type of SMV solver.
- ** @param data a pointer to a matrix of data.
- ** @param dimension dimension of the SVM model.
- ** @param numData number of training samples.
- ** @param labels training labels.
- ** @param lambda regularizer parameter.
- ** @return the new object.
- **
- ** @a data has one column per sample, in @c double format.
- ** More advanced inputs can be used with ::vl_svm_new_with_dataset
- ** and ::vl_svm_new_with_abstract_data.
- **
- ** @sa ::vl_svm_delete
- **/
-
-VlSvm *
-vl_svm_new (VlSvmSolverType type,
-            double const * data,
-            vl_size dimension,
-            vl_size numData,
-            double const * labels,
-            double lambda)
-{
-  VlSvmDataset * dataset = vl_svmdataset_new(VL_TYPE_DOUBLE, (void*)data, dimension, numData) ;
-  VlSvm * self = vl_svm_new_with_dataset (type, dataset, labels, lambda) ;
-  self->ownDataset = dataset ;
-  return self ;
-}
-
-/** @brief Create a new object with a dataset.
- ** @param solver type of SMV solver.
- ** @param dataset SVM dataset object
- ** @param labels training samples labels.
- ** @param lambda regularizer parameter.
- ** @return the new object.
- ** @sa ::vl_svm_delete
- **/
-
-VlSvm *
-vl_svm_new_with_dataset (VlSvmSolverType solver,
-                         VlSvmDataset * dataset,
-                         double const * labels,
-                         double lambda)
-{
-  VlSvm * self = vl_svm_new_with_abstract_data (solver,
-                                             dataset,
-                                             vl_svmdataset_get_dimension(dataset),
-                                             vl_svmdataset_get_num_data(dataset),
-                                             labels,
-                                             lambda) ;
-  vl_svm_set_data_functions (self,
-                             vl_svmdataset_get_inner_product_function(dataset),
-                             vl_svmdataset_get_accumulate_function(dataset)) ;
-  return self ;
-}
-
-/** @brief Create a new object with abstract data.
- ** @param solver type of SMV solver.
- ** @param data pointer to the data.
- ** @param dimension dimension of the SVM model.
- ** @param numData num training samples.
- ** @param labels training samples labels.
- ** @param lambda regularizer parameter.
- ** @return the new object.
- **
- ** After calling this function, ::vl_svm_set_data_functions *must*
- ** be used to setup suitable callbacks for the inner product
- ** and accumulation operations (@see svm-data-abstraction).
- **
- ** @sa ::vl_svm_delete
- **/
-
-VlSvm *
-vl_svm_new_with_abstract_data (VlSvmSolverType solver,
-                               void * data,
-                               vl_size dimension,
-                               vl_size numData,
-                               double const * labels,
-                               double lambda)
-{
-  VlSvm * self = vl_calloc(1,sizeof(VlSvm)) ;
-
-  assert(dimension >= 1) ;
-  assert(numData >= 1) ;
-  assert(labels) ;
-
-  self->solver = solver ;
-
-  self->dimension = dimension ;
-  self->model = 0 ;
-  self->bias = 0 ;
-  self->biasMultiplier = 1.0 ;
-
-  self->lambda = lambda ;
-  self->data = data ;
-  self->numData = numData ;
-  self->labels = labels ;
-
-  self->diagnosticFrequency = numData ;
-  self->diagnosticFn = 0 ;
-  self->diagnosticFnData = 0 ;
-
-  self->lossFn = vl_svm_hinge_loss ;
-  self->conjugateLossFn = vl_svm_hinge_conjugate_loss ;
-  self->lossDerivativeFn = vl_svm_hinge_loss_derivative ;
-  self->dcaUpdateFn = vl_svm_hinge_dca_update ;
-
-  self->innerProductFn = 0 ;
-  self->accumulateFn = 0 ;
-
-  self->iteration = 0 ;
-  self->maxNumIterations = VL_MAX((double)numData, vl_ceil_f(10.0 / lambda)) ;
-  self->epsilon = 1e-2 ;
-
-  /* SGD */
-  self->biasLearningRate = 0.01 ;
-
-  /* SDCA */
-  self->alpha = 0 ;
-
-  /* allocations */
-  self->model = vl_calloc(dimension, sizeof(double)) ;
-  if (self->model == NULL) goto err_alloc ;
-
-  if (self->solver == VlSvmSolverSdca) {
-    self->alpha = vl_calloc(self->numData, sizeof(double)) ;
-    if (self->alpha == NULL) goto err_alloc ;
-  }
-
-  self->scores = vl_calloc(numData, sizeof(double)) ;
-  if (self->scores == NULL) goto err_alloc ;
-
-  return self ;
-
-err_alloc:
-  if (self->scores) {
-    vl_free (self->scores) ;
-    self->scores = 0 ;
-  }
-  if (self->model) {
-    vl_free (self->model) ;
-    self->model = 0 ;
-  }
-  if (self->alpha) {
-    vl_free (self->alpha) ;
-    self->alpha = 0 ;
-  }
-  return 0 ;
-}
-
-/** @brief Delete object.
- ** @param self object.
- ** @sa ::vl_svm_new
- **/
-
-void
-vl_svm_delete (VlSvm * self)
-{
-  if (self->model) {
-    vl_free (self->model) ;
-    self->model = 0 ;
-  }
-  if (self->alpha) {
-    vl_free (self->alpha) ;
-    self->alpha = 0 ;
-  }
-  if (self->ownDataset) {
-    vl_svmdataset_delete(self->ownDataset) ;
-    self->ownDataset = 0 ;
-  }
-  vl_free (self) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                              Setters and getters */
-/* ---------------------------------------------------------------- */
-
-/** @brief Set the convergence threshold
- ** @param self object
- ** @param epsilon threshold (non-negative).
- **/
-
-void vl_svm_set_epsilon (VlSvm *self, double epsilon)
-{
-  assert(self) ;
-  assert(epsilon >= 0) ;
-  self->epsilon = epsilon ;
-}
-
-/** @brief Get the convergence threshold
- ** @param self object
- ** @return epsilon threshold.
- **/
-
-double vl_svm_get_epsilon (VlSvm const *self)
-{
-  assert(self) ;
-  return self->epsilon ;
-}
-
-/** @brief Set the bias learning rate
- ** @param self object
- ** @param rate bias learning rate (positive).
- **
- ** This parameter applies only to the SGD solver.
- **/
-
-void vl_svm_set_bias_learning_rate (VlSvm *self, double rate)
-{
-  assert(self) ;
-  assert(rate > 0) ;
-  self->biasLearningRate = rate ;
-}
-
-/** @brief Get the bias leraning rate.
- ** @param self object
- ** @return bias learning rate.
- **/
-
-double vl_svm_get_bias_learning_rate (VlSvm const *self)
-{
-  assert(self) ;
-  return self->biasLearningRate ;
-}
-
-/** @brief Set the bias multiplier.
- ** @param self object
- ** @param b bias multiplier.
- **
- ** The *bias multiplier* is the value of the constant feature
- ** appended to the data vectors to implement the bias (@ref svm-bias).
- **/
-
-void vl_svm_set_bias_multiplier (VlSvm * self, double b)
-{
-  assert(self) ;
-  assert(b >= 0) ;
-  self->biasMultiplier = b ;
-}
-
-/** @brief Get the bias multiplier.
- ** @param self object.
- ** @return bias multiplier.
- **/
-
-double vl_svm_get_bias_multiplier (VlSvm const * self)
-{
-  assert(self) ;
-  return self->biasMultiplier ;
-}
-
-/** @brief Set the current iteratio number.
- ** @param self object.
- ** @param n iteration number.
- **
- ** If called before training,
- ** this can be used with SGD for a warm start, as the net
- ** effect is to slow down the learning rate.
- **/
-
-void vl_svm_set_iteration_number (VlSvm *self, vl_uindex n)
-{
-  assert(self) ;
-  self->iteration = n ;
-}
-
-/** @brief Get the current iteration number.
- ** @param self object.
- ** @return current iteration number.
- **/
-
-vl_size vl_svm_get_iteration_number (VlSvm const *self)
-{
-  assert(self) ;
-  return self->iteration ;
-}
-
-/** @brief Set the maximum number of iterations.
- ** @param self object.
- ** @param n maximum number of iterations.
- **/
-
-void vl_svm_set_max_num_iterations (VlSvm *self, vl_size n)
-{
-  assert(self) ;
-  self->maxNumIterations = n ;
-}
-
-/** @brief Get the maximum number of iterations.
- ** @param self object.
- ** @return maximum number of iterations.
- **/
-
-vl_size vl_svm_get_max_num_iterations (VlSvm const *self)
-{
-  assert(self) ;
-  return self->maxNumIterations ;
-}
-
-/** @brief Set the diagnostic frequency.
- ** @param self object.
- ** @param f diagnostic frequency (@c >= 1).
- **
- ** A diagnostic round (to test for convergence and to printout
- ** information) is performed every @a f iterations.
- **/
-
-void vl_svm_set_diagnostic_frequency (VlSvm *self, vl_size f)
-{
-  assert(self) ;
-  assert(f > 0) ;
-  self->diagnosticFrequency = f ;
-}
-
-/** @brief Get the diagnostic frequency.
- ** @param self object.
- ** @return diagnostic frequency.
- **/
-
-vl_size vl_svm_get_diagnostic_frequency (VlSvm const *self)
-{
-  assert(self) ;
-  return self->diagnosticFrequency ;
-}
-
-/** @brief Get the SVM solver type.
- ** @param self object.
- ** @return SVM solver type.
- **/
-
-VlSvmSolverType vl_svm_get_solver (VlSvm const * self)
-{
-  assert(self) ;
-  return self->solver ;
-}
-
-/** @brief Set the regularizer parameter lambda.
- ** @param self object.
- ** @param lambda regularizer parameter.
- **
- ** Note that @a lambda is usually set when calling a
- ** constructor for ::VlSvm as certain parameters, such
- ** as the maximum number of iterations, are tuned accordingly.
- ** This tuning is not performed when @a lambda is changed
- ** using this function.
- **/
-
-void vl_svm_set_lambda (VlSvm * self, double lambda)
-{
-  assert(self) ;
-  assert(lambda >= 0) ;
-  self->lambda = lambda ;
-}
-
-/** @brief Get the regularizer parameter lambda.
- ** @param self object.
- ** @return diagnostic frequency.
- **/
-
-double vl_svm_get_lambda (VlSvm const * self)
-{
-  assert(self) ;
-  return self->lambda ;
-}
-
-/** @brief Set the data weights.
- ** @param self object.
- ** @param weights data weights.
- **
- ** @a weights must be an array of non-negative weights.
- ** The loss of each data point is multiplied by the corresponding
- ** weight.
- **
- ** Set @a weights to @c NULL to weight the data uniformly by 1 (default).
- **
- ** Note that the @a weights array is *not* copied and must be valid
- ** througout the object lifetime (unless it is replaced).
- **/
-
-void vl_svm_set_weights (VlSvm * self, double const *weights)
-{
-  assert(self) ;
-  self->weights = weights ;
-}
-
-/** @brief Get the data weights.
- ** @param self object.
- ** @return data weights.
- **/
-
-double const *vl_svm_get_weights (VlSvm const * self)
-{
-  assert(self) ;
-  return self->weights ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                         Get data */
-/* ---------------------------------------------------------------- */
-
-/** @brief Get the model dimenison.
- ** @param self object.
- ** @return model dimension.
- **
- ** This is the dimensionality of the weight vector $\bw$.
- **/
-
-vl_size vl_svm_get_dimension (VlSvm *self)
-{
-  assert(self) ;
-  return self->dimension ;
-}
-
-/** @brief Get the number of data samples.
- ** @param self object.
- ** @return model number of data samples
- **
- ** This is the dimensionality of the weight vector $\bw$.
- **/
-
-vl_size vl_svm_get_num_data (VlSvm *self)
-{
-  assert(self) ;
-  return self->numData ;
-}
-
-/** @brief Get the SVM model.
- ** @param self object.
- ** @return model.
- **
- ** This is the weight vector $\bw$.
- **/
-
-double const * vl_svm_get_model (VlSvm const *self)
-{
-  assert(self) ;
-  return self->model ;
-}
-
-/** @brief Set the SVM model.
- ** @param self object.
- ** @param model model.
- **
- ** The function *copies* the content of the vector @a model to the
- ** internal model buffer. This operation can be used for warm start
- ** with the SGD algorithm, but has undefined effect with the SDCA algorithm.
- **/
-
-void vl_svm_set_model (VlSvm *self, double const *model)
-{
-  assert(self) ;
-  assert(model) ;
-  memcpy(self->model, model, sizeof(double) * vl_svm_get_dimension(self)) ;
-}
-
-/** @brief Set the SVM bias.
- ** @param self object.
- ** @param b bias.
- **
- ** The function set the internal representation of the SVM bias to
- ** be equal to @a b (the bias multiplier
- ** is applied). The same remark
- ** that applies to ::vl_svm_set_model applies here too.
- **/
-
-void vl_svm_set_bias (VlSvm *self, double b)
-{
-  assert(self);
-  if (self->biasMultiplier) {
-    self->bias = b / self->biasMultiplier ;
-  }
-}
-
-/** @brief Get the value of the bias.
- ** @param self object.
- ** @return bias $b$.
- **
- ** The value of the bias returned already include the effect of
- ** bias mutliplier.
- **/
-
-double vl_svm_get_bias (VlSvm const *self)
-{
-  assert(self) ;
-  return self->bias * self->biasMultiplier ;
-}
-
-/** @brief Get the solver statistics.
- ** @param self object.
- ** @return statistics.
- **/
-
-VlSvmStatistics const * vl_svm_get_statistics (VlSvm const *self)
-{
-  assert(self) ;
-  return &self->statistics ;
-}
-
-/** @brief Get the scores of the data points.
- ** @param self object.
- ** @return vector of scores.
- **
- ** After training or during the diagnostic callback,
- ** this function can be used to retrieve the scores
- ** of the points, i.e. $\langle \bx_i, \bw \rangle + b$.
- **/
-
-double const * vl_svm_get_scores (VlSvm const *self)
-{
-  return self->scores ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                        Callbacks */
-/* ---------------------------------------------------------------- */
-
-/** @typedef VlSvmDiagnosticFunction
- ** @brief SVM diagnostic function pointer.
- ** @param svm is an instance of ::VlSvm .
- **/
-
-/** @typedef VlSvmAccumulateFunction
- ** @brief Pointer to a function that adds to @a model the data point at
- ** position @a element multiplied by the constant @a multiplier.
- **/
-
-/** @typedef VlSvmInnerProductFunction
- ** @brief Pointer to a function that defines the inner product
- ** between the data point at position @a element and the SVM model
- **/
-
-/** @brief Set the diagnostic function callback
- ** @param self object.
- ** @param f diagnostic function pointer.
- ** @param data pointer to data used by the diagnostic function.
- **/
-
-void
-vl_svm_set_diagnostic_function (VlSvm *self, VlSvmDiagnosticFunction f, void *data) {
-  self->diagnosticFn = f ;
-  self->diagnosticFnData = data ;
-}
-
-/** @brief Set the data functions.
- ** @param self object.
- ** @param inner inner product function.
- ** @param acc accumulate function.
- **
- ** See @ref svm-data-abstraction.
- **/
-
-void vl_svm_set_data_functions (VlSvm *self, VlSvmInnerProductFunction inner, VlSvmAccumulateFunction acc)
-{
-  assert(self) ;
-  assert(inner) ;
-  assert(acc) ;
-  self->innerProductFn = inner ;
-  self->accumulateFn = acc ;
-}
-
-/** @brief Set the loss function callback.
- ** @param self object.
- ** @param f loss function callback.
- **
- ** Note that setting up a loss requires specifying more than just one
- ** callback. See @ref svm-loss-functions for details.
- **/
-
-void vl_svm_set_loss_function (VlSvm *self, VlSvmLossFunction f)
-{
-  assert(self) ;
-  self->lossFn = f ;
-}
-
-/** @brief Set the loss derivative function callback.
- ** @copydetails vl_svm_set_loss_function.
- **/
-
-void vl_svm_set_loss_derivative_function (VlSvm *self, VlSvmLossFunction f)
-{
-  assert(self) ;
-  self->lossDerivativeFn = f ;
-}
-
-/** @brief Set the conjugate loss function callback.
- ** @copydetails vl_svm_set_loss_function.
- **/
-
-void vl_svm_set_conjugate_loss_function (VlSvm *self, VlSvmLossFunction f)
-{
-  assert(self) ;
-  self->conjugateLossFn = f ;
-}
-
-/** @brief Set the DCA update function callback.
- ** @copydetails vl_svm_set_loss_function.
- **/
-
-void vl_svm_set_dca_update_function (VlSvm *self, VlSvmDcaUpdateFunction f)
-{
-  assert(self) ;
-  self->dcaUpdateFn = f ;
-}
-
-/** @brief Set the loss function to one of the default types.
- ** @param self object.
- ** @param loss type of loss function.
- ** @sa @ref svm-loss-functions.
- **/
-
-void
-vl_svm_set_loss (VlSvm *self, VlSvmLossType loss)
-{
-#define SETLOSS(x,y) \
-case VlSvmLoss ## x: \
-  vl_svm_set_loss_function(self, vl_svm_ ## y ## _loss) ; \
-  vl_svm_set_loss_derivative_function(self, vl_svm_ ## y ## _loss_derivative) ; \
-  vl_svm_set_conjugate_loss_function(self, vl_svm_ ## y ## _conjugate_loss) ; \
-  vl_svm_set_dca_update_function(self, vl_svm_ ## y ## _dca_update) ; \
-  break;
-
-  switch (loss) {
-      SETLOSS(Hinge, hinge) ;
-      SETLOSS(Hinge2, hinge2) ;
-      SETLOSS(L1, l1) ;
-      SETLOSS(L2, l2) ;
-      SETLOSS(Logistic, logistic) ;
-    default:
-      assert(0) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                               Pre-defined losses */
-/* ---------------------------------------------------------------- */
-
-/** @typedef VlSvmLossFunction
- ** @brief SVM loss function pointer.
- ** @param inner inner product between sample and model $\bw^\top \bx$.
- ** @param label sample label $y$.
- ** @return value of the loss.
- **
- ** The interface is the same for a loss function, its derivative,
- ** or the conjugate loss.
- **
- ** @sa @ref svm-fundamentals
- **/
-
-/** @typedef VlSvmDcaUpdateFunction
- ** @brief SVM SDCA update function pointer.
- ** @param alpha current value of the dual variable.
- ** @param inner inner product $\bw^\top \bx$ of the sample with the SVM model.
- ** @param norm2 normalization factor $\|\bx\|^2/\lambda n$.
- ** @param label label $y$ of the sample.
- ** @return incremental update $\Delta\alpha$ of the dual variable.
- **
- ** @sa @ref svm-sdca
- **/
-
-/** @brief SVM hinge loss
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_hinge_loss (double inner, double label)
-{
-  return VL_MAX(1 - label * inner, 0.0);
-}
-
-/** @brief SVM hinge loss derivative
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_hinge_loss_derivative (double inner, double label)
-{
-  if (label * inner < 1.0) {
-    return - label ;
-  } else {
-    return 0.0 ;
-  }
-}
-
-/** @brief SVM hinge loss conjugate
- ** @param u dual variable.
- ** @param label label value.
- ** @return conjugate loss.
- **/
-double
-vl_svm_hinge_conjugate_loss (double u, double label) {
-  double z = label * u ;
-  if (-1 <= z && z <= 0) {
-    return label * u ;
-  } else {
-    return VL_INFINITY_D ;
-  }
-}
-
-/** @brief SVM hinge loss DCA update
- ** @copydetails VlSvmDcaUpdateFunction */
-double
-vl_svm_hinge_dca_update (double alpha, double inner, double norm2, double label) {
-  double palpha = (label - inner) / norm2 + alpha ;
-  return label * VL_MAX(0, VL_MIN(1, label * palpha)) - alpha ;
-}
-
-/** @brief SVM square hinge loss
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_hinge2_loss (double inner,double label)
-{
-  double z = VL_MAX(1 - label * inner, 0.0) ;
-  return z*z ;
-}
-
-/** @brief SVM square hinge loss derivative
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_hinge2_loss_derivative (double inner, double label)
-{
-  if (label * inner < 1.0) {
-    return 2 * (inner - label) ;
-  } else {
-    return 0 ;
-  }
-}
-
-/** @brief SVM square hinge loss conjugate
- ** @copydetails vl_svm_hinge_conjugate_loss */
-double
-vl_svm_hinge2_conjugate_loss (double u, double label) {
-  if (label * u <= 0) {
-    return (label + u/4) * u ;
-  } else {
-    return VL_INFINITY_D ;
-  }
-}
-
-/** @brief SVM square hinge loss DCA update
- ** @copydetails VlSvmDcaUpdateFunction */
-double
-vl_svm_hinge2_dca_update (double alpha, double inner, double norm2, double label) {
-  double palpha = (label - inner - 0.5*alpha) / (norm2 + 0.5) + alpha ;
-  return label * VL_MAX(0, label * palpha) - alpha ;
-}
-
-/** @brief SVM l1 loss
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_l1_loss (double inner,double label)
-{
-  return vl_abs_d(label - inner) ;
-}
-
-/** @brief SVM l1 loss derivative
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_l1_loss_derivative (double inner, double label)
-{
-  if (label > inner) {
-    return - 1.0 ;
-  } else {
-    return + 1.0 ;
-  }
-}
-
-/** @brief SVM l1 loss conjugate
- ** @copydetails vl_svm_hinge_conjugate_loss */
-double
-vl_svm_l1_conjugate_loss (double u, double label) {
-  if (vl_abs_d(u) <= 1) {
-    return label*u ;
-  } else {
-    return VL_INFINITY_D ;
-  }
-}
-
-/** @brief SVM l1 loss DCA update
- ** @copydetails VlSvmDcaUpdateFunction */
-double
-vl_svm_l1_dca_update (double alpha, double inner, double norm2, double label) {
-  if (vl_abs_d(alpha) <= 1) {
-    double palpha = (label - inner) / norm2 + alpha ;
-    return VL_MAX(-1.0, VL_MIN(1.0, palpha)) - alpha ;
-  } else {
-    return VL_INFINITY_D ;
-  }
-}
-
-/** @brief SVM l2 loss
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_l2_loss (double inner,double label)
-{
-  double z = label - inner ;
-  return z*z ;
-}
-
-/** @brief SVM l2 loss derivative
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_l2_loss_derivative (double inner, double label)
-{
-  return - 2 * (label - inner) ;
-}
-
-/** @brief SVM l2 loss conjugate
- ** @copydetails vl_svm_hinge_conjugate_loss */
-double
-vl_svm_l2_conjugate_loss (double u, double label) {
-  return (label + u/4) * u ;
-}
-
-/** @brief SVM l2 loss DCA update
- ** @copydetails VlSvmDcaUpdateFunction */
-double
-vl_svm_l2_dca_update (double alpha, double inner, double norm2, double label) {
-  return (label - inner - 0.5*alpha) / (norm2 + 0.5) ;
-}
-
-/** @brief SVM l2 loss
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_logistic_loss (double inner,double label)
-{
-  double z = label * inner ;
-  if (z >= 0) {
-    return log(1.0 + exp(-z)) ;
-  } else {
-    return -z + log(exp(z) + 1.0) ;
-  }
-}
-
-/** @brief SVM l2 loss derivative
- ** @copydetails VlSvmLossFunction */
-double
-vl_svm_logistic_loss_derivative (double inner, double label)
-{
-  double z = label * inner ;
-  double t = 1 / (1 + exp(-z)) ; /* this is stable for z << 0 too */
-  return label * (t - 1) ; /*  = -label exp(-z) / (1 + exp(-z)) */
-}
-
-VL_INLINE double xlogx(double x)
-{
-  if (x <= 1e-10) return 0 ;
-  return x*log(x) ;
-}
-
-/** @brief SVM l2 loss conjugate
- ** @copydetails vl_svm_hinge_conjugate_loss */
-double
-vl_svm_logistic_conjugate_loss (double u, double label) {
-  double z = label * u ;
-  if (-1 <= z && z <= 0) {
-    return xlogx(-z) + xlogx(1+z) ;
-  } else {
-    return VL_INFINITY_D ;
-  }
-}
-
-/** @brief SVM l2 loss DCA update
- ** @copydetails VlSvmDcaUpdateFunction */
-double
-vl_svm_logistic_dca_update (double alpha, double inner, double norm2, double label) {
-  /*
-   The goal is to solve the problem
-
-   min_delta A/2 delta^2 + B delta + l*(-alpha - delta|y),  -1 <= - y (alpha+delta) <= 0
-
-   where A = norm2, B = inner, and y = label. To simplify the notation, we set
-
-     f(beta) = beta * log(beta) + (1 - beta) * log(1 - beta)
-
-   where beta = y(alpha + delta) such that
-
-     l*(-alpha - delta |y) = f(beta).
-
-   Hence 0 <= beta <= 1, delta = + y beta - alpha. Substituting
-
-     min_beta A/2 beta^2 + y (B - A alpha) beta + f(beta) + const
-
-   The Newton step is then given by
-
-     beta = beta - (A beta + y(B - A alpha) + df) / (A + ddf).
-
-   However, the function is singluar for beta=0 and beta=1 (infinite
-   first and second order derivatives). Since the function is monotonic
-   (second derivarive always strictly greater than zero) and smooth,
-   we canuse bisection to find the zero crossing of the first derivative.
-   Once one is sufficiently close to the optimum, a one or two Newton
-   steps are sufficien to land on it with excellent accuracy.
-   */
-
-  double  df, ddf, der, dder ;
-  vl_index t ;
-
-  /* bisection */
-  double beta1 = 0 ;
-  double beta2 = 1 ;
-  double beta = 0.5 ;
-
-  for (t = 0 ; t < 5 ; ++t) {
-    df = log(beta) - log(1-beta) ;
-    der = norm2 * beta + label * (inner - norm2*alpha) + df ;
-    if (der >= 0) {
-      beta2 = beta ;
-    } else {
-      beta1 = beta ;
-    }
-    beta = 0.5 * (beta1 + beta2) ;
-  }
-
-#if 1
-  /* a final Newton step, but not too close to the singularities */
-  for (t = 0 ; (t < 2) & (beta > VL_EPSILON_D) & (beta < 1-VL_EPSILON_D) ; ++t) {
-    df = log(beta) - log(1-beta) ;
-    ddf = 1 / (beta * (1-beta)) ;
-    der = norm2 * beta + label * (inner - norm2*alpha) + df ;
-    dder = norm2 + ddf ;
-    beta -= der / dder ;
-    beta = VL_MAX(0, VL_MIN(1, beta)) ;
-  }
-#endif
-
-  return label * beta - alpha ;
-}
-
-/* ---------------------------------------------------------------- */
-
-/** @internal @brief Update SVM statistics
- ** @param self object.
- **/
-
-void _vl_svm_update_statistics (VlSvm *self)
-{
-  vl_size i, k ;
-  double inner, p ;
-
-  memset(&self->statistics, 0, sizeof(VlSvmStatistics)) ;
-
-  self->statistics.regularizer = self->bias * self->bias ;
-  for (i = 0; i < self->dimension; i++) {
-    self->statistics.regularizer += self->model[i] * self->model[i] ;
-  }
-  self->statistics.regularizer *= self->lambda * 0.5 ;
-
-  for (k = 0; k < self->numData ; k++) {
-    p = (self->weights) ? self->weights[k] : 1.0 ;
-    if (p <= 0) continue ;
-    inner = self->innerProductFn(self->data, k, self->model) ;
-    inner += self->bias * self->biasMultiplier ;
-    self->scores[k] = inner ;
-    self->statistics.loss += p * self->lossFn(inner, self->labels[k]) ;
-    if (self->solver == VlSvmSolverSdca) {
-
-      self->statistics.dualLoss -= p * self->conjugateLossFn(- self->alpha[k] / p, self->labels[k]) ;
-    }
-  }
-
-  self->statistics.loss /= self->numData ;
-  self->statistics.objective = self->statistics.regularizer + self->statistics.loss ;
-
-  if (self->solver == VlSvmSolverSdca) {
-    self->statistics.dualLoss /= self->numData ;
-    self->statistics.dualObjective = - self->statistics.regularizer + self->statistics.dualLoss ;
-    self->statistics.dualityGap = self->statistics.objective - self->statistics.dualObjective ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                                       Evaluate rather than solve */
-/* ---------------------------------------------------------------- */
-
-void _vl_svm_evaluate (VlSvm *self)
-{
-  double startTime = vl_get_cpu_time () ;
-
-  _vl_svm_update_statistics (self) ;
-
-  self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
-  self->statistics.iteration = 0 ;
-  self->statistics.epoch = 0 ;
-  self->statistics.status = VlSvmStatusConverged ;
-
-  if (self->diagnosticFn) {
-    self->diagnosticFn(self, self->diagnosticFnData) ;
-  }
-}
-
-/* ---------------------------------------------------------------- */
-/*                         Stochastic Dual Coordinate Ascent Solver */
-/* ---------------------------------------------------------------- */
-
-void _vl_svm_sdca_train (VlSvm *self)
-{
-  double * norm2 ;
-  vl_index * permutation ;
-  vl_uindex i, t  ;
-  double inner, delta, multiplier, p ;
-
-  double startTime = vl_get_cpu_time () ;
-  VlRand * rand = vl_get_rand() ;
-
-  norm2 = (double*) vl_calloc(self->numData, sizeof(double));
-  permutation = vl_calloc(self->numData, sizeof(vl_index)) ;
-
-  {
-    double * buffer = vl_calloc(self->dimension, sizeof(double)) ;
-    for (i = 0 ; i < (unsigned)self->numData; i++) {
-      double n2 ;
-      permutation [i] = i ;
-      memset(buffer, 0, self->dimension * sizeof(double)) ;
-      self->accumulateFn (self->data, i, buffer, 1) ;
-      n2 = self->innerProductFn (self->data, i, buffer) ;
-      n2 += self->biasMultiplier * self->biasMultiplier ;
-      norm2[i] = n2 / (self->lambda * self->numData) ;
-    }
-    vl_free(buffer) ;
-  }
-
-  for (t = 0 ; 1 ; ++t) {
-
-    if (t % self->numData == 0) {
-      /* once a new epoch is reached (all data have been visited),
-       change permutation */
-      vl_rand_permute_indexes(rand, permutation, self->numData) ;
-    }
-
-    /* pick a sample and compute update */
-    i = permutation[t % self->numData] ;
-    p = (self->weights) ? self->weights[i] : 1.0 ;
-    if (p > 0) {
-      inner = self->innerProductFn(self->data, i, self->model) ;
-      inner += self->bias * self->biasMultiplier ;
-      delta = p * self->dcaUpdateFn(self->alpha[i] / p, inner, p * norm2[i], self->labels[i]) ;
-    } else {
-      delta = 0 ;
-    }
-
-    /* apply update */
-    if (delta != 0) {
-      self->alpha[i] += delta ;
-      multiplier = delta / (self->numData * self->lambda) ;
-      self->accumulateFn(self->data,i,self->model,multiplier) ;
-      self->bias += self->biasMultiplier * multiplier;
-    }
-
-    /* call diagnostic occasionally */
-    if ((t + 1) % self->diagnosticFrequency == 0 || t + 1 == self->maxNumIterations) {
-      _vl_svm_update_statistics (self) ;
-      self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
-      self->statistics.iteration = t ;
-      self->statistics.epoch = t / self->numData ;
-
-      self->statistics.status = VlSvmStatusTraining ;
-      if (self->statistics.dualityGap < self->epsilon) {
-        self->statistics.status = VlSvmStatusConverged ;
-      }
-      else if (t + 1 == self->maxNumIterations) {
-        self->statistics.status = VlSvmStatusMaxNumIterationsReached ;
-      }
-
-      if (self->diagnosticFn) {
-        self->diagnosticFn(self, self->diagnosticFnData) ;
-      }
-
-      if (self->statistics.status != VlSvmStatusTraining) {
-        break ;
-      }
-    }
-  } /* next iteration */
-
-  vl_free (norm2) ;
-  vl_free (permutation) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                               Stochastic Gradient Descent Solver */
-/* ---------------------------------------------------------------- */
-
-void _vl_svm_sgd_train (VlSvm *self)
-{
-  vl_index * permutation ;
-  double * scores ;
-  double * previousScores ;
-  vl_uindex i, t, k ;
-  double inner, gradient, rate, biasRate, p ;
-  double factor = 1.0 ;
-  double biasFactor = 1.0 ; /* to allow slower bias learning rate */
-  vl_index t0 = VL_MAX(2, vl_ceil_d(1.0 / self->lambda)) ;
-  //t0=2 ;
-
-  double startTime = vl_get_cpu_time () ;
-  VlRand * rand = vl_get_rand() ;
-
-  permutation = vl_calloc(self->numData, sizeof(vl_index)) ;
-  scores = vl_calloc(self->numData * 2, sizeof(double)) ;
-  previousScores = scores + self->numData ;
-
-  for (i = 0 ; i < (unsigned)self->numData; i++) {
-    permutation [i] = i ;
-    previousScores [i] = - VL_INFINITY_D ;
-  }
-
-  /*
-   We store the w vector as the product fw (factor * model).
-   We also use a different factor for the bias: biasFactor * biasMultiplier
-   to enable a slower learning rate for the bias.
-
-   Given this representation, it is easy to carry the two key operations:
-
-   * Inner product: <fw,x> = f <w,x>
-
-   * Model update: fp wp = fw - rate * lambda * w - rate * g
-                         = f(1 - rate * lambda) w - rate * g
-
-     Thus the update equations are:
-
-                   fp = f(1 - rate * lambda), and
-                   wp = w + rate / fp * g ;
-
-   * Realization of the scaling factor. Before the statistics function
-     is called, or training finishes, the factor (and biasFactor)
-     are explicitly applied to the model and the bias.
-  */
-
-  for (t = 0 ; 1 ; ++t) {
-
-    if (t % self->numData == 0) {
-      /* once a new epoch is reached (all data have been visited),
-       change permutation */
-      vl_rand_permute_indexes(rand, permutation, self->numData) ;
-    }
-
-    /* pick a sample and compute update */
-    i = permutation[t % self->numData] ;
-    p = (self->weights) ? self->weights[i] : 1.0 ;
-    p = VL_MAX(0.0, p) ; /* we assume non-negative weights, so this is just for robustness */
-    inner = factor * self->innerProductFn(self->data, i, self->model) ;
-    inner += biasFactor * (self->biasMultiplier * self->bias) ;
-    gradient = p * self->lossDerivativeFn(inner, self->labels[i]) ;
-    previousScores[i] = scores[i] ;
-    scores[i] = inner ;
-
-    /* apply update */
-    rate = 1.0 /  (self->lambda * (t + t0)) ;
-    biasRate = rate * self->biasLearningRate ;
-    factor *= (1.0 - self->lambda * rate) ;
-    biasFactor *= (1.0 - self->lambda * biasRate) ;
-
-    /* debug: realize the scaling factor all the times */
-    /*
-    for (k = 0 ; k < self->dimension ; ++k) self->model[k] *= factor ;
-    self->bias *= biasFactor;
-    factor = 1.0 ;
-    biasFactor = 1.0 ;
-    */
-
-    if (gradient != 0) {
-      self->accumulateFn(self->data, i, self->model, - gradient * rate / factor) ;
-      self->bias += self->biasMultiplier * (- gradient * biasRate / biasFactor) ;
-    }
-
-    /* call diagnostic occasionally */
-    if ((t + 1) % self->diagnosticFrequency == 0 || t + 1 == self->maxNumIterations) {
-
-      /* realize factor before computing statistics or completing training */
-      for (k = 0 ; k < self->dimension ; ++k) self->model[k] *= factor ;
-      self->bias *= biasFactor;
-      factor = 1.0 ;
-      biasFactor = 1.0 ;
-
-      _vl_svm_update_statistics (self) ;
-
-      for (k = 0 ; k < self->numData ; ++k) {
-        double delta = scores[k] - previousScores[k] ;
-        self->statistics.scoresVariation += delta * delta ;
-      }
-      self->statistics.scoresVariation = sqrt(self->statistics.scoresVariation) / self->numData ;
-
-      self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
-      self->statistics.iteration = t ;
-      self->statistics.epoch = t / self->numData ;
-
-      self->statistics.status = VlSvmStatusTraining ;
-      if (self->statistics.scoresVariation < self->epsilon) {
-        self->statistics.status = VlSvmStatusConverged ;
-      }
-      else if (t + 1 == self->maxNumIterations) {
-        self->statistics.status = VlSvmStatusMaxNumIterationsReached ;
-      }
-
-      if (self->diagnosticFn) {
-        self->diagnosticFn(self, self->diagnosticFnData) ;
-      }
-
-      if (self->statistics.status != VlSvmStatusTraining) {
-        break ;
-      }
-    }
-  } /* next iteration */
-
-  vl_free (scores) ;
-  vl_free (permutation) ;
-}
-
-/* ---------------------------------------------------------------- */
-/*                                                       Dispatcher */
-/* ---------------------------------------------------------------- */
-
-/** @brief Run the SVM solver
- ** @param self object.
- **
- ** The data on which the SVM operates is passed upon the cration of
- ** the ::VlSvm object. This function runs a solver to learn a
- ** corresponding model. See @ref svm-starting.
- **/
-
-void vl_svm_train (VlSvm * self)
-{
-  assert (self) ;
-  switch (self->solver) {
-    case VlSvmSolverSdca:
-      _vl_svm_sdca_train(self) ;
-      break ;
-    case VlSvmSolverSgd:
-      _vl_svm_sgd_train(self) ;
-      break ;
-    case VlSvmSolverNone:
-      _vl_svm_evaluate(self) ;
-      break ;
-    default:
-      assert(0) ;
-  }
-}
diff --git a/opensfm/src/third_party/vlfeat/vl/svm.h b/opensfm/src/third_party/vlfeat/vl/svm.h
deleted file mode 100644
index 1fcc6d474..000000000
--- a/opensfm/src/third_party/vlfeat/vl/svm.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/** @file svm.h
- ** @brief Support Vector Machines (@ref svm)
- ** @author Milan Sulc
- ** @author Daniele Perrone
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 Milan Sulc.
-Copyright (C) 2012 Daniele Perrone.
-Copyright (C) 2011-13 Andrea Vedaldi.
-
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_SVM_H
-#define VL_SVM_H
-
-#include "generic.h"
-#include "svmdataset.h"
-
-/** @typedef VlSvm
- ** @brief SVM solver.
- ** This object implements VLFeat SVM solvers (see @ref svm.h).
- **/
-
-#ifndef __DOXYGEN__
-struct VlSvm_ ;
-typedef struct VlSvm_ VlSvm ;
-#else
-typedef OPAQUE VlSvm ;
-#endif
-
-/** @brief Type of SVM solver */
-typedef enum
-{
-  VlSvmSolverNone = 0, /**< No solver (used to evaluate an SVM). */
-  VlSvmSolverSgd = 1,  /**< SGD algorithm (@ref svm-sgd). */
-  VlSvmSolverSdca      /**< SDCA algorithm (@ref svm-sdca). */
-} VlSvmSolverType ;
-
-/** @brief Type of SVM loss
- **
- ** Default SVM loss types. The loss can be set by using ::vl_svm_set_loss.
- ** Note that custom losses can be used too by using ::vl_svm_set_loss_function,
- ** ::vl_svm_set_loss_derivative_function, etc.
- **
- ** @sa svm-loss-functions
- **/
-typedef enum
-{
-  VlSvmLossHinge = 0,   /**< Standard hinge loss. */
-  VlSvmLossHinge2 = 1,  /**< Hinge loss squared. */
-  VlSvmLossL1,          /**< L1 loss. */
-  VlSvmLossL2,          /**< L2 loss. */
-  VlSvmLossLogistic     /**< Logistic loss. */
-} VlSvmLossType ;
-
-/** @brief Solver status */
-typedef enum
-{
-  VlSvmStatusTraining = 1, /**< Optimization in progress. */
-  VlSvmStatusConverged, /**< Optimization finished because the convergence criterion was met. */
-  VlSvmStatusMaxNumIterationsReached /**< Optimization finished without convergence. */
-} VlSvmSolverStatus ;
-
-/** @brief SVM statistics
- ** This structure contains statistics characterising the state of
- ** the SVM solver, such as the current value of the objective function.
- **
- ** Not all fields are used by all solvers.
- **/
-typedef struct VlSvmStatistics_ {
-  VlSvmSolverStatus status ;    /**< Solver status. */
-  vl_size iteration ;           /**< Solver iteration. */
-  vl_size epoch ;               /**< Solver epoch (iteration / num samples). */
-  double objective ;            /**< Objective function value. */
-  double regularizer ;          /**< Regularizer value. */
-  double loss ;                 /**< Loss value. */
-  double dualObjective ;        /**< Dual objective value. */
-  double dualLoss ;             /**< Dual loss value. */
-  double dualityGap ;           /**< Duality gap = objective - dualObjective. */
-  double scoresVariation ;      /**< Variance of the score updates. */
-  double elapsedTime ;          /**< Time elapsed from the start of training. */
-} VlSvmStatistics ;
-
-/** @name Create and destroy
- ** @{ */
-VL_EXPORT VlSvm * vl_svm_new (VlSvmSolverType type,
-                              double const * data,
-                              vl_size dimension,
-                              vl_size numData,
-                              double const * labels,
-                              double lambda) ;
-
-VL_EXPORT VlSvm * vl_svm_new_with_dataset (VlSvmSolverType type,
-                                           VlSvmDataset * dataset,
-                                           double const * labels,
-                                           double lambda) ;
-
-VL_EXPORT VlSvm * vl_svm_new_with_abstract_data (VlSvmSolverType type,
-                                              void * data,
-                                              vl_size dimension,
-                                              vl_size numData,
-                                              double const * labels,
-                                              double lambda) ;
-
-VL_EXPORT void vl_svm_delete (VlSvm * self) ;
-/** @} */
-
-/** @name Retrieve parameters and data
- ** @{ */
-VL_EXPORT VlSvmStatistics const * vl_svm_get_statistics (VlSvm const *self) ;
-VL_EXPORT double const * vl_svm_get_model (VlSvm const *self) ;
-VL_EXPORT double vl_svm_get_bias (VlSvm const *self) ;
-VL_EXPORT vl_size vl_svm_get_dimension (VlSvm *self) ;
-VL_EXPORT vl_size vl_svm_get_num_data (VlSvm *self) ;
-VL_EXPORT double vl_svm_get_epsilon (VlSvm const *self) ;
-VL_EXPORT double vl_svm_get_bias_learning_rate (VlSvm const *self) ;
-VL_EXPORT vl_size vl_svm_get_max_num_iterations (VlSvm const *self) ;
-VL_EXPORT vl_size vl_svm_get_diagnostic_frequency (VlSvm const *self) ;
-VL_EXPORT VlSvmSolverType vl_svm_get_solver (VlSvm const *self) ;
-VL_EXPORT double vl_svm_get_bias_multiplier (VlSvm const *self) ;
-VL_EXPORT double vl_svm_get_lambda (VlSvm const *self) ;
-VL_EXPORT vl_size vl_svm_get_iteration_number (VlSvm const *self) ;
-VL_EXPORT double const * vl_svm_get_scores (VlSvm const *self) ;
-VL_EXPORT double const * vl_svm_get_weights (VlSvm const *self) ;
-/** @} */
-
-/** @name Set parameters
- ** @{ */
-VL_EXPORT void vl_svm_set_epsilon (VlSvm *self, double epsilon) ;
-VL_EXPORT void vl_svm_set_bias_learning_rate (VlSvm *self, double rate) ;
-VL_EXPORT void vl_svm_set_max_num_iterations (VlSvm *self, vl_size maxNumIterations) ;
-VL_EXPORT void vl_svm_set_diagnostic_frequency (VlSvm *self, vl_size f) ;
-VL_EXPORT void vl_svm_set_bias_multiplier (VlSvm *self, double b) ;
-VL_EXPORT void vl_svm_set_model (VlSvm *self, double const *model) ;
-VL_EXPORT void vl_svm_set_bias (VlSvm *self, double b) ;
-VL_EXPORT void vl_svm_set_iteration_number (VlSvm *self, vl_uindex n) ;
-VL_EXPORT void vl_svm_set_weights (VlSvm *self, double const *weights) ;
-
-VL_EXPORT void vl_svm_set_diagnostic_function (VlSvm *self, VlSvmDiagnosticFunction f, void *data) ;
-VL_EXPORT void vl_svm_set_loss_function (VlSvm *self, VlSvmLossFunction f) ;
-VL_EXPORT void vl_svm_set_loss_derivative_function (VlSvm *self, VlSvmLossFunction f) ;
-VL_EXPORT void vl_svm_set_conjugate_loss_function (VlSvm *self, VlSvmLossFunction f) ;
-VL_EXPORT void vl_svm_set_dca_update_function (VlSvm *self, VlSvmDcaUpdateFunction f) ;
-VL_EXPORT void vl_svm_set_data_functions (VlSvm *self, VlSvmInnerProductFunction inner, VlSvmAccumulateFunction acc) ;
-VL_EXPORT void vl_svm_set_loss (VlSvm *self, VlSvmLossType loss) ;
-/** @} */
-
-/** @name Process data
- ** @{ */
-VL_EXPORT void vl_svm_train (VlSvm * self) ;
-/** @} */
-
-/** @name Loss functions
- ** @sa @ref svm-advanced
- ** @{ */
-
-/* hinge */
-VL_EXPORT double vl_svm_hinge_loss (double label, double inner) ;
-VL_EXPORT double vl_svm_hinge_loss_derivative (double label, double inner) ;
-VL_EXPORT double vl_svm_hinge_conjugate_loss (double label, double u) ;
-VL_EXPORT double vl_svm_hinge_dca_update (double alpha, double inner, double norm2, double label) ;
-
-/* square hinge */
-VL_EXPORT double vl_svm_hinge2_loss (double label, double inner) ;
-VL_EXPORT double vl_svm_hinge2_loss_derivative (double label, double inner) ;
-VL_EXPORT double vl_svm_hinge2_conjugate_loss (double label, double u) ;
-VL_EXPORT double vl_svm_hinge2_dca_update (double alpha, double inner, double norm2, double label) ;
-
-/* l1 */
-VL_EXPORT double vl_svm_l1_loss (double label, double inner) ;
-VL_EXPORT double vl_svm_l1_loss_derivative (double label, double inner) ;
-VL_EXPORT double vl_svm_l1_conjugate_loss (double label, double u) ;
-VL_EXPORT double vl_svm_l1_dca_update (double alpha, double inner, double norm2, double label) ;
-
-/* l2 */
-VL_EXPORT double vl_svm_l2_loss (double label, double inner) ;
-VL_EXPORT double vl_svm_l2_loss_derivative (double label, double inner) ;
-VL_EXPORT double vl_svm_l2_conjugate_loss (double label, double u) ;
-VL_EXPORT double vl_svm_l2_dca_update (double alpha, double inner, double norm2, double label) ;
-
-/* logistic */
-VL_EXPORT double vl_svm_logistic_loss (double label, double inner) ;
-VL_EXPORT double vl_svm_logistic_loss_derivative (double label, double inner) ;
-VL_EXPORT double vl_svm_logistic_conjugate_loss (double label, double u) ;
-VL_EXPORT double vl_svm_logistic_dca_update (double alpha, double inner, double norm2, double label) ;
-/** } */
-
-/* VL_SVM_H */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svmdataset.c b/opensfm/src/third_party/vlfeat/vl/svmdataset.c
deleted file mode 100644
index a4100d11c..000000000
--- a/opensfm/src/third_party/vlfeat/vl/svmdataset.c
+++ /dev/null
@@ -1,407 +0,0 @@
-/** @file svmdataset.c
- ** @brief SVM Dataset - Definition
- ** @author Daniele Perrone
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2012 Daniele Perrone.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-@file svmdataset.h
-@tableofcontents
-@author Daniele Perrone
-@author Andrea Vedaldi
-
-The SVM solver object ::VlSvm, supporting SVM learning in VLFeat,
-uses an abstraction mechanism to work on arbitrary data types.
-This module provides an helper object, ::VlSvmDataset,
-that simplify taking advantage of this functionality, supporting for example
-different data types and the computation of feature maps out of the box.
-
-<!-- ------------------------------------------------------------- -->
-@section svmdataset-starting Getting started
-<!-- ------------------------------------------------------------- -->
-
-As discussed in @ref svm-advanced, most linear SVM solvers,
-such as the ones implemented in VLFeat in @ref svm, require only two
-operations to be defined on the data:
-
-- *Inner product* between a data point $\bx$ and the model vector $\bw$.
-  This is implemented by a function of type ::VlSvmInnerProductFunction.
-- *Accumulation* of a dataobint $\bx$ to the model vector $\bw$:
-  $\bw \leftarrow \bw + \alpha \bx$. This is implemented
-  by a function of the type ::VlSvmAccumulateFunction .
-
-The SVM solver needs to know nothing about the data once these two
-operations are defined. These functions can do any number of things,
-such as supporting different formats for the data (dense or sparse,
-float or double), computing feature maps, or expanding compressed
-representations such as Product Quantization.
-
-VLFeat provides the helper object ::VlSvmDataset to support some
-of these functionalities out of the box (it is important to remark
-that its use with the SVM solver ::VlSvm is entirely optional).
-
-Presently, ::VlSvmDataset supports:
-
-- @c float and @c double dense arrays.
-- The on-the-fly application of the homogeneous kernel map to implement
-  additive non-linear kernels (see @ref homkermap).
-
-For example, to learn a linear SVM on SINGLE data:
-
-@code
-int main()
-{
-  vl_size const numData = 4 ;
-  vl_size const dimension = 2 ;
-  single x [dimension * numData] = {
-    0.0, -0.5,
-    0.6, -0.3,
-    0.0,  0.5,
-    0.6,  0.0} ;
-  double y [numData] = {1, 1, -1, 1} ;
-  double lambda = 0.01;
-  double * const model ;
-  double bias ;
-
-  VlSvmDataset * dataset = vl_svmdataset_new (VL_TYPE_SINGLE, x, dimension, numData) ;
-  VlSvm * svm = vl_svm_new_with_dataset (VlSvmSolverSgd, dataset, y, lambda) ;
-
-  vl_svm_train(svm) ;
-
-  model = vl_svm_get_model(svm) ;
-  bias = vl_svm_get_bias(svm) ;
-
-  printf("model w = [ %f , %f ] , bias b = %f \n",
-         model[0],
-         model[1],
-         bias);
-
-  vl_svm_delete(svm) ;
-  vl_svmdataset_delete(dataset) ;
-  return 0;
-}
-@endcode
-
-**/
-
-/* ---------------------------------------------------------------- */
-#ifndef VL_SVMDATASET_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-#include "svmdataset.h"
-#include <string.h>
-#include <math.h>
-
-struct VlSvmDataset_ {
-  vl_type dataType ;                /**< Data type. */
-  void * data ;                     /**< Pointer to data. */
-  vl_size numData ;                 /**< Number of wrapped data. */
-  vl_size dimension ;               /**< Data point dimension. */
-  VlHomogeneousKernelMap * hom ;    /**< Homogeneous kernel map (optional). */
-  void * homBuffer ;                /**< Homogeneous kernel map buffer. */
-  vl_size homDimension ;            /**< Homogeneous kernel map dimension. */
-} ;
-
-/* templetized parts of the implementation */
-#define FLT VL_TYPE_FLOAT
-#define VL_SVMDATASET_INSTANTIATING
-#include "svmdataset.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define VL_SVMDATASET_INSTANTIATING
-#include "svmdataset.c"
-
-/** @brief Create a new object wrapping a dataset.
- ** @param dataType of data (@c float and @c double supported).
- ** @param data pointer to the data.
- ** @param dimension the dimension of a data vector.
- ** @param numData number of wrapped data vectors.
- ** @return new object.
- **
- ** The function allocates and returns a new SVM dataset object
- ** wrapping the data pointed by @a data. Note that no copy is made
- ** of data, so the caller should keep the data allocated as the object exists.
- **
- ** @sa ::vl_svmdataset_delete
- **/
-
-VlSvmDataset*
-vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData)
-{
-  VlSvmDataset * self ;
-  assert(dataType == VL_TYPE_DOUBLE || dataType == VL_TYPE_FLOAT) ;
-  assert(data) ;
-
-  self = vl_calloc(1, sizeof(VlSvmDataset)) ;
-  if (self == NULL) return NULL ;
-
-  self->dataType = dataType ;
-  self->data = data ;
-  self->dimension = dimension ;
-  self->numData = numData ;
-  self->hom = NULL ;
-  self->homBuffer = NULL ;
-  return self ;
-}
-
-/** @brief Delete the object.
- ** @param self object to delete.
- **
- ** The function frees the resources allocated by
- ** ::vl_svmdataset_new(). Notice that the wrapped data will *not*
- ** be freed as it is not owned by the object.
- **/
-
-void vl_svmdataset_delete (VlSvmDataset *self)
-{
-  if (self->homBuffer) {
-    vl_free(self->homBuffer) ;
-    self->homBuffer = 0 ;
-  }
-  vl_free (self) ;
-}
-
-/** @brief Get the wrapped data.
- ** @param self object.
- ** @return a pointer to the wrapped data.
- **/
-
-void*
-vl_svmdataset_get_data (VlSvmDataset const *self)
-{
-  return self->data ;
-}
-
-/** @brief Get the number of wrapped data elements.
- ** @param self object.
- ** @return number of wrapped data elements.
- **/
-
-vl_size
-vl_svmdataset_get_num_data (VlSvmDataset const *self)
-{
-  return self->numData ;
-}
-
-/** @brief Get the dimension of the wrapped data.
- ** @param self object.
- ** @return dimension of the wrapped data.
- **/
-
-vl_size
-vl_svmdataset_get_dimension (VlSvmDataset const *self)
-{
-  if (self->hom) {
-    return self->dimension * vl_homogeneouskernelmap_get_dimension(self->hom) ;
-  }
-  return self->dimension ;
-}
-
-/** @brief Get the homogeneous kernel map object.
- ** @param self object.
- ** @return homogenoeus kernel map object (or @c NULL if any).
- **/
-
-VlHomogeneousKernelMap *
-vl_svmdataset_get_homogeneous_kernel_map (VlSvmDataset const *self)
-{
-  assert(self) ;
-  return self->hom ;
-}
-
-/** @brief Set the homogeneous kernel map object.
- ** @param self object.
- ** @param hom homogeneous kernel map object to use.
- **
- ** After changing the kernel map, the inner product and accumulator
- ** function should be queried again (::vl_svmdataset_get_inner_product_function
- ** adn ::vl_svmdataset_get_accumulate_function).
- **
- ** Set this to @c NULL to avoid using a kernel map.
- **
- ** Note that this does *not* transfer the ownership of the object
- ** to the function. Furthermore, ::VlSvmDataset holds to the
- ** object until it is destroyed or the object is replaced or removed
- ** by calling this function again.
- **/
-
-void
-vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
-                                          VlHomogeneousKernelMap * hom)
-{
-  assert(self) ;
-  self->hom = hom ;
-  self->homDimension = 0 ;
-  if (self->homBuffer) {
-    vl_free (self->homBuffer) ;
-    self->homBuffer = 0 ;
-  }
-  if (self->hom) {
-    self->homDimension = vl_homogeneouskernelmap_get_dimension(self->hom) ;
-    self->homBuffer = vl_calloc(self->homDimension, vl_get_type_size(self->dataType)) ;
-  }
-}
-
-/** @brief Get the accumulate function
- ** @param self object.
- ** @return a pointer to the accumulate function to use with this data.
- **/
-
-VlSvmAccumulateFunction
-vl_svmdataset_get_accumulate_function(VlSvmDataset const *self)
-{
-  if (self->hom == NULL) {
-    switch (self->dataType) {
-      case VL_TYPE_FLOAT:
-        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_f ;
-        break ;
-      case VL_TYPE_DOUBLE:
-        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_d ;
-        break ;
-    }
-  } else {
-    switch (self->dataType) {
-      case VL_TYPE_FLOAT:
-        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_f ;
-        break ;
-      case VL_TYPE_DOUBLE:
-        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_d ;
-        break ;
-    }
-  }
-  assert(0) ;
-  return NULL ;
-}
-
-/** @brief Get the inner product function.
- ** @param self object.
- ** @return a pointer to the inner product function to use with this data.
- **/
-
-VlSvmInnerProductFunction
-vl_svmdataset_get_inner_product_function (VlSvmDataset const *self)
-{
-  if (self->hom == NULL) {
-    switch (self->dataType) {
-      case VL_TYPE_FLOAT:
-        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_f ;
-        break ;
-      case VL_TYPE_DOUBLE:
-        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_d ;
-        break ;
-      default:
-        assert(0) ;
-    }
-  } else {
-    switch (self->dataType) {
-      case VL_TYPE_FLOAT:
-        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_f ;
-        break ;
-      case VL_TYPE_DOUBLE:
-        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_d ;
-        break ;
-      default:
-        assert(0) ;
-    }
-  }
-
-  return NULL;
-}
-
-/* VL_SVMDATASET_INSTANTIATING */
-#endif
-
-/* ---------------------------------------------------------------- */
-#ifdef VL_SVMDATASET_INSTANTIATING
-/* ---------------------------------------------------------------- */
-
-#include "float.h"
-
-double
-VL_XCAT(_vl_svmdataset_inner_product_,SFX) (VlSvmDataset const *self,
-                                            vl_uindex element,
-                                            double const *model)
-{
-  double product = 0 ;
-  T* data = ((T*)self->data) + self->dimension * element ;
-  T* end = data + self->dimension ;
-  while (data != end) {
-    product += (*data++) * (*model++) ;
-  }
-  return product ;
-}
-
-void
-VL_XCAT(vl_svmdataset_accumulate_,SFX)(VlSvmDataset const *self,
-                                       vl_uindex element,
-                                       double *model,
-                                       const double multiplier)
-{
-  T* data = ((T*)self->data) + self->dimension * element ;
-  T* end = data + self->dimension ;
-  while (data != end) {
-    *model += (*data++) * multiplier ;
-    model++ ;
-  }
-}
-
-double
-VL_XCAT(_vl_svmdataset_inner_product_hom_,SFX) (VlSvmDataset const *self,
-                                                vl_uindex element,
-                                                double const *model)
-{
-  double product = 0 ;
-  T* data = ((T*)self->data) + self->dimension * element ;
-  T* end = data + self->dimension ;
-  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
-  while (data != end) {
-    /* TODO: zeros in data could be optimized by skipping over them */
-    T* buf = self->homBuffer ;
-    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
-                                                   self->homBuffer,
-                                                   1,
-                                                   (*data++)) ;
-    while (buf != bufEnd) {
-      product += (*buf++) * (*model++) ;
-    }
-  }
-  return product ;
-}
-
-void
-VL_XCAT(vl_svmdataset_accumulate_hom_,SFX)(VlSvmDataset const *self,
-                                           vl_uindex element,
-                                           double *model,
-                                           const double multiplier)
-{
-  T* data = ((T*)self->data) + self->dimension * element ;
-  T* end = data + self->dimension ;
-  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
-  while (data != end) {
-    /* TODO: zeros in data could be optimized by skipping over them */
-    T* buf = self->homBuffer ;
-    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
-                                                   self->homBuffer,
-                                                   1,
-                                                   (*data++)) ;
-    while (buf != bufEnd) {
-      *model += (*buf++) * multiplier ;
-      model++ ;
-    }
-  }
-}
-
-#undef FLT
-#undef VL_SVMDATASET_INSTANTIATING
-
-/* VL_SVMDATASET_INSTANTIATING */
-#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svmdataset.h b/opensfm/src/third_party/vlfeat/vl/svmdataset.h
deleted file mode 100644
index c2e1c6204..000000000
--- a/opensfm/src/third_party/vlfeat/vl/svmdataset.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/** @file svmdataset.h
- ** @brief SVM Dataset
- ** @author Daniele Perrone
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2012 Daniele Perrone.
-Copyright (C) 2013 Andrea Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_SVMDATASET_H
-#define VL_SVMDATASET_H
-
-#include "generic.h"
-#include "homkermap.h"
-
-struct VlSvm_ ;
-
-/** @typedef VlSvmDataset
- ** @brief SVM dataset object
- **
- ** This objects contain a training set to be used in combination with
- ** the SVM solver object ::VlSvm. Its main purpose is to implement
- ** the two basic operations inner product (::VlSvmInnerProductFunction)
- ** and accumulation (::VlSvmAccumulateFunction).
- **
- ** See @ref svm and @ref svm-advanced for further information.
- **/
-
-#ifndef __DOXYGEN__
-struct VlSvmDataset_ ;
-typedef struct VlSvmDataset_ VlSvmDataset ;
-#else
-typedef OPAQUE VlSvmDataset ;
-#endif
-
-/** @name SVM callbacks
- ** @{ */
-typedef void (*VlSvmDiagnosticFunction) (struct VlSvm_ *svm, void *data) ;
-typedef double (*VlSvmLossFunction) (double inner, double label) ;
-typedef double (*VlSvmDcaUpdateFunction) (double alpha, double inner, double norm2, double label) ;
-typedef double (*VlSvmInnerProductFunction)(const void *data, vl_uindex element, double *model) ;
-typedef void (*VlSvmAccumulateFunction) (const void *data, vl_uindex element, double *model, double multiplier) ;
-/* typedef double (*VlSvmSquareNormFunction) (const void *data, vl_uindex element) ; */
-/** @} */
-
-/** @name Create and destroy
- ** @{
- **/
-VL_EXPORT VlSvmDataset* vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData) ;
-VL_EXPORT void vl_svmdataset_delete (VlSvmDataset * dataset) ;
-/** @} */
-
-/** @name Set parameters
- ** @{
- **/
-VL_EXPORT void vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
-                                                         VlHomogeneousKernelMap * hom) ;
-/** @} */
-
-/** @name Get data and parameters
- ** @{
- **/
-VL_EXPORT void* vl_svmdataset_get_data (VlSvmDataset const *self) ;
-VL_EXPORT vl_size vl_svmdataset_get_num_data (VlSvmDataset const *self) ;
-VL_EXPORT vl_size vl_svmdataset_get_dimension (VlSvmDataset const *self) ;
-VL_EXPORT void* vl_svmdataset_get_map (VlSvmDataset const *self) ;
-VL_EXPORT vl_size vl_svmdataset_get_mapDim (VlSvmDataset const *self) ;
-VL_EXPORT VlSvmAccumulateFunction vl_svmdataset_get_accumulate_function (VlSvmDataset const *self) ;
-VL_EXPORT VlSvmInnerProductFunction vl_svmdataset_get_inner_product_function (VlSvmDataset const * self) ;
-VL_EXPORT VlHomogeneousKernelMap * vl_svmdataset_get_homogeneous_kernel_map (VlSvmDataset const * self) ;
-/** @} */
-
-/* VL_SVMDATASET_H */
-#endif
-
-
diff --git a/opensfm/src/third_party/vlfeat/vl/vlad.c b/opensfm/src/third_party/vlfeat/vl/vlad.c
deleted file mode 100644
index 8b6bd6ac1..000000000
--- a/opensfm/src/third_party/vlfeat/vl/vlad.c
+++ /dev/null
@@ -1,323 +0,0 @@
-/** @file vlad.c
- ** @brief VLAD - Declaration
- ** @author David Novotny
- ** @author Andrea Vedaldi
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andera Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-/**
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page vlad Vector of Locally Aggregated Descriptors (VLAD) encoding
-@author David Novotny
-@author Andrea Vedaldi
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-@ref vlad.h implements the *Vector of Linearly Aggregated Descriptors*
-(VLAD) image representation @cite{jegou10aggregating}
-@cite{arandjelovic13all-about}.
-
-@ref vlad-starting demonstreates how to use the C API to compute the
-VLAD representation of an image. For further details on the VLAD image
-representation refer to:
-
-- @subpage vlad-fundamentals - VLAD definition and computation.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section vlad-starting Getting started with VLAD
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-The VLAD encoding of a set of features is obtained by using the
-function ::vl_vlad_encode.  The function can be applied to both @c
-float or @c double data types.
-
-::vl_vlad_encode requires a visual dictionary, for example obtained by
-using @ref kmeans. Furthermore, the assignments of features to
-dictionary elements must be pre-computed, for example by using @ref
-kdtree.
-
-In the following example code, the vocabulary is first created using
-the KMeans clustering, then the points, that are to be encoded are
-assigned to its corresponding nearest vocabulary words, after that the
-original vlad encoding routine without any normalization option takes place.
-At the end of the process the encoding is stored in the @c enc variable.
-
-@code
-vl_uint32 * indexes;
-float * assignments;
-float * enc
-int i;
-
-// create a KMeans object and run clustering to get vocabulary words (centers)
-kmeans = vl_kmeans_new (VLDistanceL2, VL_TYPE_FLOAT) ;
-vl_kmeans_cluster (kmeans,
-                   data,
-                   dimension,
-                   numData,
-                   numCenters) ;
-
-// find nearest cliuster centers for the data that should be encoded
-indexes = vl_malloc(sizeof(vl_uint32) * numDataToEncode);
-vl_kmeans_quantize(kmeans,indexes,dataToEncode,numDataToEncode);
-
-// convert indexes array to assignments array,
-// which can be processed by vl_vlad_encode
-assignments = vl_malloc(sizeof(float) * numDataToEncode * numCenters);
-memset(assignments, 0, sizeof(float) * numDataToEncode * numCenters);
-for(i = 0; i < numDataToEncode; i++) {
-  assignments[i * numCenters + indexes[i]] = 1.;
-}
-
-// allocate space for vlad encoding
-enc = vl_malloc(sizeof(TYPE) * dimension * numCenters);
-
-// do the encoding job
-vl_vlad_encode (enc, VL_F_TYPE,
-                vl_kmeans_get_centers(kmeans), dimension, numCenters,
-                data, numData,
-                assignments,
-                0) ;
-@endcode
-
-Various @ref vlad-normalization normalizations can be applied to the
-VLAD vectors. These are controlled by the parameter @a flag of
-::vl_vlad_encode.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@page vlad-fundamentals VLAD fundamentals
-@tableofcontents
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-This page describes the *Vector of Locally Aggregated Descriptors*
-(VLAD) image encoding of @cite{jegou10aggregating}. See @ref vlad for
-an overview of the C API.
-
-VLAD is a *feature encoding and pooling* method, similar to @ref
-fisher "Fisher vectors". VLAD encodes a set of local feature
-descriptors $I=(\bx_1,\dots,\bx_n)$ extracted from an image using a
-dictionary built using a clustering method such as @ref gmm or @ref
-kmeans. Let $q_{ik}$ be the strength of the association of data vector
-$\bx_i$ to cluster $\mu_k$, such that $q_{ik} \geq 0$ and
-$\sum_{k=1}^K q_{ik} = 1$. The association may be either soft
-(e.g. obtained as the posterior probabilities of the GMM clusters) or
-hard (e.g. obtained by vector quantization with K-means).
-
-$\mu_k$ are the cluster *means*, vectors of the same dimension as the
-data $\bx_i$. VLAD encodes feature $\bx$ by considering the *residuals*
-\[
- \bv_k = \sum_{i=1}^{N} q_{ik} (\bx_{i} - \mu_k).
-\]
-The residulas are stacked together to obtain the vector
-\[
-\hat\Phi(I) =
-\begin{bmatrix}
-\vdots \\
-\bv_k \\
-\vdots
-\end{bmatrix}
-\]
-
-Before the VLAD encoding is used it is usually normalized, as
-explained @ref vlad-normalization next.
-
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-@section vlad-normalization VLAD normalization
-<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
-
-VLFeat VLAD implementation supports a number of different
-normalization strategies. These are optionally applied in this order:
-
-- **Component-wise mass normalization.** Each vector $\bv_k$ is
-  divided by the total mass of features associated to it $\sum_{i=1}^N
-  q_{ik}$.
-
-- **Square-rooting.** The function $\sign(z)\sqrt{|z|}$ is applied to
-  all scalar components of the VLAD descriptor.
-
-- **Component-wise $l^2$ normalization.** The vectors $\bv_k$ are
-  divided by their norm $\|\bv_k\|_2$.
-
-- **Global $l^2$ normalization.** The VLAD descriptor $\hat\Phi(I)$ is
-  divided by its norm $\|\hat\Phi(I)\|_2$.
-*/
-
-#include "vlad.h"
-#include "mathop.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if defined(_OPENMP)
-#include <omp.h>
-#endif
-
-/* ================================================================ */
-#ifdef VL_VLAD_INSTANTIATING
-
-static void
-VL_XCAT(_vl_vlad_encode_, SFX)
-(TYPE * enc,
- TYPE const * means, vl_size dimension, vl_size numClusters,
- TYPE const * data, vl_size numData,
- TYPE const * assignments,
- int flags)
-{
-  vl_uindex dim ;
-  vl_index i_cl, i_d ;
-
-  memset(enc, 0, sizeof(TYPE) * dimension * numClusters) ;
-
-#if defined(_OPENMP)
-#pragma omp parallel for default(shared) private(i_cl,i_d,dim) num_threads(vl_get_max_threads())
-#endif
-  for (i_cl = 0; i_cl < (signed)numClusters; i_cl++) {
-    double clusterMass = 0 ;
-    for (i_d = 0; i_d < (signed)numData; i_d++) {
-      if (assignments[i_d*numClusters + i_cl] > 0) {
-        double q = assignments[i_d*numClusters+i_cl] ;
-        clusterMass +=  q ;
-        for(dim = 0; dim < dimension; dim++) {
-          enc [i_cl * dimension + dim] += q * data [i_d  * dimension + dim] ;
-        }
-      }
-    }
-
-    if (clusterMass > 0) {
-      if (flags & VL_VLAD_FLAG_NORMALIZE_MASS) {
-        for(dim = 0; dim < dimension; dim++) {
-          enc[i_cl*dimension + dim] /= clusterMass ;
-          enc[i_cl*dimension + dim] -= means[i_cl*dimension+dim];
-        }
-      } else {
-        for(dim = 0; dim < dimension; dim++) {
-          enc[i_cl*dimension + dim] -= clusterMass * means[i_cl*dimension+dim];
-        }
-      }
-    }
-
-    if (flags & VL_VLAD_FLAG_SQUARE_ROOT) {
-      for(dim = 0; dim < dimension; dim++) {
-        TYPE z = enc[i_cl*dimension + dim] ;
-        if (z >= 0) {
-          enc[i_cl*dimension + dim] = VL_XCAT(vl_sqrt_, SFX)(z) ;
-        } else {
-          enc[i_cl*dimension + dim] = - VL_XCAT(vl_sqrt_, SFX)(- z) ;
-        }
-      }
-    }
-
-    if (flags & VL_VLAD_FLAG_NORMALIZE_COMPONENTS) {
-      TYPE n = 0 ;
-      dim = 0 ;
-      for(dim = 0; dim < dimension; dim++) {
-        TYPE z = enc[i_cl*dimension + dim] ;
-        n += z * z ;
-      }
-      n = VL_XCAT(vl_sqrt_, SFX)(n) ;
-      n = VL_MAX(n, 1e-12) ;
-      for(dim = 0; dim < dimension; dim++) {
-        enc[i_cl*dimension + dim] /= n ;
-      }
-    }
-  }
-
-  if (! (flags & VL_VLAD_FLAG_UNNORMALIZED)) {
-    TYPE n = 0 ;
-    for(dim = 0 ; dim < dimension * numClusters ; dim++) {
-      TYPE z = enc [dim] ;
-      n += z * z ;
-    }
-    n = VL_XCAT(vl_sqrt_, SFX)(n) ;
-    n = VL_MAX(n, 1e-12) ;
-    for(dim = 0 ; dim < dimension * numClusters ; dim++) {
-      enc[dim] /= n ;
-    }
-  }
-}
-
-/* VL_FISHER_INSTANTIATING */
-#else
-
-#ifndef __DOXYGEN__
-#define FLT VL_TYPE_FLOAT
-#define TYPE float
-#define SFX f
-#define VL_VLAD_INSTANTIATING
-#include "vlad.c"
-
-#define FLT VL_TYPE_DOUBLE
-#define TYPE double
-#define SFX d
-#define VL_VLAD_INSTANTIATING
-#include "vlad.c"
-#endif
-
-/* VL_VLAD_INSTANTIATING */
-#endif
-
-/* ================================================================ */
-#ifndef VL_VLAD_INSTANTIATING
-
-/** @brief VLAD encoding of a set of vectors.
- ** @param enc output VLAD encoding (out).
- ** @param dataType the type of the input data (::VL_TYPE_DOUBLE or ::VL_TYPE_FLOAT).
- ** @param numData number of data vectors to encode.
- ** @param means cluster means.
- ** @param numClusters number of clusters.
- ** @param data the data vectors to encode.
- ** @param dimension dimensionality of the data.
- ** @param assignments data to cluster soft assignments.
- ** @param flags options.
- **
- ** @a enc is the VLAD vector of size @a numClusters by
- ** @a dimension. @a means is a matrix with @a numClusters columns and
- ** @a dimension rows. @a data is the matrix of vectors to be encoded,
- ** with @a dimension rows and @a numData columns. @a assignments is a
- ** matrix with @a numClusters rows and @a numData columns.
- ** All the matrices should be stored in column-major order.
- **
- ** @a flag allows controlling further options:
- ** ::VL_VLAD_FLAG_NORMALIZE_COMPONENTS, ::VL_VLAD_FLAG_SQUARE_ROOT,
- ** ::VL_VLAD_FLAG_UNNORMALIZED, and ::VL_VLAD_FLAG_NORMALIZE_MASS.
- **
- ** @sa @ref vlad
- **/
-
-void
-vl_vlad_encode (void * enc, vl_type dataType,
-                void const * means, vl_size dimension, vl_size numClusters,
-                void const * data, vl_size numData,
-                void const * assignments,
-                int flags)
-{
-  switch(dataType) {
-    case VL_TYPE_FLOAT:
-      _vl_vlad_encode_f ((float *) enc,
-                         (float const *) means, dimension, numClusters,
-                         (float const *) data,  numData,
-                         (float const *) assignments, flags) ;
-      break;
-    case VL_TYPE_DOUBLE:
-      _vl_vlad_encode_d ((double *) enc,
-                         (double const *) means, dimension, numClusters,
-                         (double const *) data, numData,
-                         (double const *) assignments, flags) ;
-      break;
-    default:
-      abort();
-  }
-}
-
-/* ! VL_VLAD_INSTANTIATING */
-#endif
-
-#undef SFX
-#undef TYPE
-#undef FLT
-#undef VL_VLAD_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/vlad.h b/opensfm/src/third_party/vlfeat/vl/vlad.h
deleted file mode 100644
index 72ca6dc93..000000000
--- a/opensfm/src/third_party/vlfeat/vl/vlad.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/** @file vlad.h
- ** @brief VLAD encoding (@ref vlad)
- ** @author David Novotny
- ** @author Andrea Vedaldi
- ** @see @ref vlad
- **/
-
-/*
-Copyright (C) 2013 David Novotny and Andera Vedaldi.
-All rights reserved.
-
-This file is part of the VLFeat library and is made available under
-the terms of the BSD license (see the COPYING file).
-*/
-
-#ifndef VL_VLAD_H
-#define VL_VLAD_H
-
-#include "generic.h"
-
-/** @name VLAD options
- ** @{ */
-#define VL_VLAD_FLAG_NORMALIZE_COMPONENTS (0x1 << 0)
-#define VL_VLAD_FLAG_SQUARE_ROOT          (0x1 << 1)
-#define VL_VLAD_FLAG_UNNORMALIZED         (0x1 << 2)
-#define VL_VLAD_FLAG_NORMALIZE_MASS       (0x1 << 3)
-
-/** @def VL_VLAD_FLAG_NORMALIZE_COMPONENTS
- ** @brief Normalize each VLAD component individually.
- **/
-
-/** @def VL_VLAD_FLAG_SQUARE_ROOT
- ** @brief Use signed squared-root.
- **/
-
-/** @def VL_VLAD_FLAG_UNNORMALIZED
- ** @brief Do not globally normalize the VLAD descriptor.
- **/
-
-/** @def VL_VLAD_FLAG_NORMALIZE_MASS
- ** @brief Normalize each component by the number of features assigned to it.
- **/
-/** @} */
-
-VL_EXPORT void vl_vlad_encode
-  (void * enc, vl_type dataType,
-   void const * means, vl_size dimension, vl_size numClusters,
-   void const * data, vl_size numData,
-   void const * assignments,
-   int flags) ;
-
-/* VL_VLAD_H */
-#endif

From c8eb66b1ec73b513d169853f3abc28872312dd8b Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Mon, 21 Oct 2024 02:07:54 -0700
Subject: [PATCH 093/235] removing base_module]
 fbcode/mapillary/opensfm/annotation_gui_gcp/TARGETS

Reviewed By: xeob

Differential Revision: D64670888

fbshipit-source-id: 2e90fbd5bce8a016a046517f9e94d185f7d1fb9f
---
 annotation_gui_gcp/main.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/annotation_gui_gcp/main.py b/annotation_gui_gcp/main.py
index 41388dbe5..ea27639b5 100644
--- a/annotation_gui_gcp/main.py
+++ b/annotation_gui_gcp/main.py
@@ -8,9 +8,9 @@
 from typing import Union
 
 import numpy as np
-from annotation_gui_gcp.lib import GUI
-from annotation_gui_gcp.lib.gcp_manager import GroundControlPointManager
-from annotation_gui_gcp.lib.image_manager import ImageManager
+from mapillary.opensfm.annotation_gui_gcp.lib import GUI
+from mapillary.opensfm.annotation_gui_gcp.lib.gcp_manager import GroundControlPointManager
+from mapillary.opensfm.annotation_gui_gcp.lib.image_manager import ImageManager
 from flask import Flask
 from opensfm import dataset, io
 

From 537275b730d7a6417fce68c3645f69c834bddca3 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Tue, 22 Oct 2024 20:56:58 -0700
Subject: [PATCH 094/235] Clean up errors and remove unused ignores]
 [batch:134/562] [shard:2/N]

Reviewed By: MaggieMoss

Differential Revision: D64684764

fbshipit-source-id: 38998fde328826e2dcc951552b98a310a3e4e816
---
 annotation_gui_gcp/lib/GUI.py                  | 4 ++++
 annotation_gui_gcp/lib/views/cad_view.py       | 6 ++++++
 annotation_gui_gcp/lib/views/cp_finder_view.py | 3 +++
 annotation_gui_gcp/lib/views/image_view.py     | 2 ++
 annotation_gui_gcp/lib/views/tools_view.py     | 2 ++
 5 files changed, 17 insertions(+)

diff --git a/annotation_gui_gcp/lib/GUI.py b/annotation_gui_gcp/lib/GUI.py
index 44a999ec3..9f5ee59b4 100644
--- a/annotation_gui_gcp/lib/GUI.py
+++ b/annotation_gui_gcp/lib/GUI.py
@@ -7,9 +7,13 @@
 from collections import defaultdict
 
 import flask
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.cad_view`.
 from annotation_gui_gcp.lib.views.cad_view import CADView
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.cp_finder_view`.
 from annotation_gui_gcp.lib.views.cp_finder_view import ControlPointFinderView
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.image_view`.
 from annotation_gui_gcp.lib.views.image_view import ImageView
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.tools_view`.
 from annotation_gui_gcp.lib.views.tools_view import ToolsView
 from opensfm import dataset
 
diff --git a/annotation_gui_gcp/lib/views/cad_view.py b/annotation_gui_gcp/lib/views/cad_view.py
index 29d1320d3..5671ab41e 100644
--- a/annotation_gui_gcp/lib/views/cad_view.py
+++ b/annotation_gui_gcp/lib/views/cad_view.py
@@ -5,6 +5,7 @@
 from typing import Any, Dict, Tuple
 
 import rasterio
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
 from annotation_gui_gcp.lib.views.web_view import WebView, distinct_colors
 from flask import send_file
 from PIL import ImageColor
@@ -23,6 +24,7 @@ def _load_georeference_metadata(path_cad_model) -> Dict[str, Any]:
     return metadata
 
 
+# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class CADView(WebView):
     def __init__(
         self,
@@ -32,6 +34,7 @@ def __init__(
         path_cad_file,
         is_geo_reference=False,
     )-> None:
+        # pyre-fixme[19]: Expected 0 positional arguments.
         super().__init__(main_ui, web_app, route_prefix)
 
         self.main_ui = main_ui
@@ -42,6 +45,7 @@ def __init__(
         self.load_georeference_metadata(path_cad_file)
         self.is_geo_reference = is_geo_reference
 
+        # pyre-fixme[16]: `CADView` has no attribute `app`.
         self.app.add_url_rule(
             f"{route_prefix}/model",
             f"{route_prefix}_model",
@@ -100,6 +104,7 @@ def display_points(self) -> None:
 
     def refocus(self, lat, lon)->None:
         x, y, z = self.latlon_to_xyz(lat, lon)
+        # pyre-fixme[16]: `CADView` has no attribute `send_sse_message`.
         self.send_sse_message(
             {"x": x, "y": y, "z": z},
             event_type="move_camera",
@@ -166,4 +171,5 @@ def sync_to_client(self)->None:
                         point_id
                     ]
 
+        # pyre-fixme[16]: `CADView` has no attribute `send_sse_message`.
         self.send_sse_message(data)
diff --git a/annotation_gui_gcp/lib/views/cp_finder_view.py b/annotation_gui_gcp/lib/views/cp_finder_view.py
index b8b491402..23cd529e9 100644
--- a/annotation_gui_gcp/lib/views/cp_finder_view.py
+++ b/annotation_gui_gcp/lib/views/cp_finder_view.py
@@ -1,9 +1,11 @@
 # pyre-unsafe
 import typing as t
 
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.image_view`.
 from annotation_gui_gcp.lib.views.image_view import ImageView
 
 
+# pyre-fixme[11]: Annotation `ImageView` is not defined as a type.
 class ControlPointFinderView(ImageView):
     def __init__(
         self,
@@ -18,6 +20,7 @@ def template_name(self):
 
     def get_candidate_images(self) -> t.List[str]:
         images_in_existing_views = []
+        # pyre-fixme[16]: `ControlPointFinderView` has no attribute `main_ui`.
         for v in self.main_ui.sequence_views:
             images_in_existing_views.extend(v.image_list)
 
diff --git a/annotation_gui_gcp/lib/views/image_view.py b/annotation_gui_gcp/lib/views/image_view.py
index efc1a1bdf..8e6d9d1c6 100644
--- a/annotation_gui_gcp/lib/views/image_view.py
+++ b/annotation_gui_gcp/lib/views/image_view.py
@@ -1,6 +1,7 @@
 # pyre-unsafe
 from typing import Dict, Any
 
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
 from annotation_gui_gcp.lib.views.web_view import WebView, distinct_colors
 
 
@@ -9,6 +10,7 @@ def point_color(point_id: str) -> str:
     return hex_color
 
 
+# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class ImageView(WebView):
     def __init__(
         self,
diff --git a/annotation_gui_gcp/lib/views/tools_view.py b/annotation_gui_gcp/lib/views/tools_view.py
index 22a5e9bca..c3048a391 100644
--- a/annotation_gui_gcp/lib/views/tools_view.py
+++ b/annotation_gui_gcp/lib/views/tools_view.py
@@ -1,9 +1,11 @@
 # pyre-unsafe
 from typing import Dict, Any
 
+# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
 from annotation_gui_gcp.lib.views.web_view import WebView
 
 
+# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class ToolsView(WebView):
     def __init__(self, main_ui, web_app):
         super().__init__(main_ui, web_app, "/tools")

From 07336692fc307659fbfd65f2b5bb637347342eec Mon Sep 17 00:00:00 2001
From: Kamil Nikel <kami@meta.com>
Date: Mon, 28 Oct 2024 08:02:25 -0700
Subject: [PATCH 095/235] Fix for T205280497 ("An automatically generated diff
 you reviewed, D64670888, broke some tests")

Summary:
This diff was created by the [Meta Engineering Agent](https://fb.workplace.com/groups/1205375940786433/permalink/1205378807452813/) to automatically fix the broken tests assigned to you / your team in T205280497:
- The agent searched for and edited the files it deemed relevant for fixing the tests
- After generating the patch, the broken test(s) were rerun to verify they now pass
- Regression tests were also run to verify CI still passes

 ---

**If this diff is the correct fix for T205280497, please accept the diff**. *Note that while we set a high quality bar for the agent publishing these diffs, LLM-powered agents still make mistakes, so your critical review is much appreciated and will help us improve!*

**If changes need to be made:** Please commandeer the diff, or comment with the specific changes needed.

 ---

*P.S. If you have broader feedback, please post in the [Meta Engineering Agent - Users group](https://fb.workplace.com/groups/1205375940786433)! We would love to hear from you on improving the agent to better assist you in your daily work.*

Reviewed By: bal-a

Differential Revision: D64686668

fbshipit-source-id: b984ca2b9f2173f767d92a791f60ba14b8073b94
---
 annotation_gui_gcp/lib/GUI.py                  | 12 ++++--------
 annotation_gui_gcp/lib/views/cad_view.py       |  4 +---
 annotation_gui_gcp/lib/views/cp_finder_view.py |  4 +---
 annotation_gui_gcp/lib/views/image_view.py     |  3 +--
 annotation_gui_gcp/lib/views/tools_view.py     |  4 +---
 5 files changed, 8 insertions(+), 19 deletions(-)

diff --git a/annotation_gui_gcp/lib/GUI.py b/annotation_gui_gcp/lib/GUI.py
index 9f5ee59b4..2ca3822a6 100644
--- a/annotation_gui_gcp/lib/GUI.py
+++ b/annotation_gui_gcp/lib/GUI.py
@@ -7,14 +7,10 @@
 from collections import defaultdict
 
 import flask
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.cad_view`.
-from annotation_gui_gcp.lib.views.cad_view import CADView
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.cp_finder_view`.
-from annotation_gui_gcp.lib.views.cp_finder_view import ControlPointFinderView
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.image_view`.
-from annotation_gui_gcp.lib.views.image_view import ImageView
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.tools_view`.
-from annotation_gui_gcp.lib.views.tools_view import ToolsView
+from .views.cad_view import CADView
+from .views.cp_finder_view import ControlPointFinderView
+from .views.image_view import ImageView
+from .views.tools_view import ToolsView
 from opensfm import dataset
 
 
diff --git a/annotation_gui_gcp/lib/views/cad_view.py b/annotation_gui_gcp/lib/views/cad_view.py
index 5671ab41e..d5f79e930 100644
--- a/annotation_gui_gcp/lib/views/cad_view.py
+++ b/annotation_gui_gcp/lib/views/cad_view.py
@@ -5,8 +5,7 @@
 from typing import Any, Dict, Tuple
 
 import rasterio
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
-from annotation_gui_gcp.lib.views.web_view import WebView, distinct_colors
+from ..views.web_view import WebView, distinct_colors
 from flask import send_file
 from PIL import ImageColor
 
@@ -24,7 +23,6 @@ def _load_georeference_metadata(path_cad_model) -> Dict[str, Any]:
     return metadata
 
 
-# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class CADView(WebView):
     def __init__(
         self,
diff --git a/annotation_gui_gcp/lib/views/cp_finder_view.py b/annotation_gui_gcp/lib/views/cp_finder_view.py
index 23cd529e9..cee24084f 100644
--- a/annotation_gui_gcp/lib/views/cp_finder_view.py
+++ b/annotation_gui_gcp/lib/views/cp_finder_view.py
@@ -1,11 +1,9 @@
 # pyre-unsafe
 import typing as t
 
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.image_view`.
-from annotation_gui_gcp.lib.views.image_view import ImageView
+from .image_view import ImageView
 
 
-# pyre-fixme[11]: Annotation `ImageView` is not defined as a type.
 class ControlPointFinderView(ImageView):
     def __init__(
         self,
diff --git a/annotation_gui_gcp/lib/views/image_view.py b/annotation_gui_gcp/lib/views/image_view.py
index 8e6d9d1c6..ec20e7543 100644
--- a/annotation_gui_gcp/lib/views/image_view.py
+++ b/annotation_gui_gcp/lib/views/image_view.py
@@ -1,8 +1,7 @@
 # pyre-unsafe
 from typing import Dict, Any
 
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
-from annotation_gui_gcp.lib.views.web_view import WebView, distinct_colors
+from .web_view import WebView, distinct_colors
 
 
 def point_color(point_id: str) -> str:
diff --git a/annotation_gui_gcp/lib/views/tools_view.py b/annotation_gui_gcp/lib/views/tools_view.py
index c3048a391..a0d5fb223 100644
--- a/annotation_gui_gcp/lib/views/tools_view.py
+++ b/annotation_gui_gcp/lib/views/tools_view.py
@@ -1,11 +1,9 @@
 # pyre-unsafe
 from typing import Dict, Any
 
-# pyre-fixme[21]: Could not find module `annotation_gui_gcp.lib.views.web_view`.
-from annotation_gui_gcp.lib.views.web_view import WebView
+from .web_view import WebView
 
 
-# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class ToolsView(WebView):
     def __init__(self, main_ui, web_app):
         super().__init__(main_ui, web_app, "/tools")

From c83b97d4d6ce0467a013ae22e95481727cf9df5d Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Thu, 31 Oct 2024 13:48:08 -0700
Subject: [PATCH 096/235] Pre-silence Pyre Errors for upcoming upgrade]
 [batch:94/596] [shard:2/N]

Reviewed By: MaggieMoss

Differential Revision: D65224532

fbshipit-source-id: 694104b691efcec7777a9cfa46979332c60f9f8e
---
 opensfm/actions/create_submodels.py |  1 +
 opensfm/actions/export_colmap.py    |  8 +++++
 opensfm/stats.py                    |  4 +++
 opensfm/test/test_bundle.py         |  5 +++
 opensfm/transformations.py          | 48 +++++++++++++++++++++++++++++
 5 files changed, 66 insertions(+)

diff --git a/opensfm/actions/create_submodels.py b/opensfm/actions/create_submodels.py
index 2716a0603..3d98fba91 100644
--- a/opensfm/actions/create_submodels.py
+++ b/opensfm/actions/create_submodels.py
@@ -96,6 +96,7 @@ def _cluster_images(meta_data: MetaDataSet, cluster_size: float) -> None:
     K = float(images.shape[0]) / cluster_size
     K = int(np.ceil(K))
 
+    # pyre-fixme[23]: Unable to unpack single value, 2 were expected.
     labels, centers = tools.kmeans(positions, K)[1:]
 
     images = images.ravel()
diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index a8b7a5ccb..913c2faa9 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -197,6 +197,7 @@ def blob_to_array(blob, dtype, shape: Tuple[int] = (-1,)):
         return np.frombuffer(blob, dtype=dtype).reshape(*shape)
 
 
+# pyre-fixme[11]: Annotation `Connection` is not defined as a type.
 class COLMAPDatabase(sqlite3.Connection):
     @staticmethod
     def connect(database_path) -> t.Any:
@@ -205,6 +206,7 @@ def connect(database_path) -> t.Any:
     def __init__(self, *args, **kwargs) -> None:
         super(COLMAPDatabase, self).__init__(*args, **kwargs)
 
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `executescript`.
         self.create_tables = lambda: self.executescript(CREATE_ALL)
         self.create_cameras_table = lambda: self.executescript(CREATE_CAMERAS_TABLE)
         self.create_descriptors_table = lambda: self.executescript(
@@ -222,6 +224,7 @@ def add_camera(
         self, model, width, height, params, prior_focal_length=False, camera_id=None
     ) -> t.Any:
         params = np.asarray(params, np.float64)
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         cursor = self.execute(
             "INSERT INTO cameras VALUES (?, ?, ?, ?, ?, ?)",
             (
@@ -238,6 +241,7 @@ def add_camera(
     def add_image(
         self, name, camera_id, prior_q=(0, 0, 0, 0), prior_t=(0, 0, 0), image_id=None
     ) -> t.Any:
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         cursor = self.execute(
             "INSERT INTO images VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
@@ -260,6 +264,7 @@ def add_keypoints(self, image_id, keypoints) -> None:
         assert keypoints.shape[1] in [2, 4, 6]
 
         keypoints = np.asarray(keypoints, np.float32)
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO keypoints VALUES (?, ?, ?, ?)",
             (image_id,) + keypoints.shape + (array_to_blob(keypoints),),
@@ -267,6 +272,7 @@ def add_keypoints(self, image_id, keypoints) -> None:
 
     def add_descriptors(self, image_id, descriptors) -> None:
         descriptors = np.ascontiguousarray(descriptors, np.uint8)
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO descriptors VALUES (?, ?, ?, ?)",
             (image_id,) + descriptors.shape + (array_to_blob(descriptors),),
@@ -281,6 +287,7 @@ def add_matches(self, image_id1, image_id2, matches) -> None:
 
         pair_id = image_ids_to_pair_id(image_id1, image_id2)
         matches = np.asarray(matches, np.uint32)
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO matches VALUES (?, ?, ?, ?)",
             (pair_id,) + matches.shape + (array_to_blob(matches),),
@@ -300,6 +307,7 @@ def add_two_view_geometry(
         F = np.asarray(F, dtype=np.float64)
         E = np.asarray(E, dtype=np.float64)
         H = np.asarray(H, dtype=np.float64)
+        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO two_view_geometries VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
             (pair_id,)
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 44dc31a05..061485b5a 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -511,6 +511,10 @@ def save_matchgraph(
             continue
         o1 = reconstructions[comp1].shots[node1].pose.get_origin()
         o2 = reconstructions[comp2].shots[node2].pose.get_origin()
+        # pyre-fixme[58]: `-` is not supported for operand types `int` and
+        #  `floating[Any]`.
+        # pyre-fixme[58]: `/` is not supported for operand types `int` and
+        #  `floating[Any]`.
         c = max(0, min(1.0, 1 - (edge - lowest) / (highest - lowest)))
         plt.plot([o1[0], o2[0]], [o1[1], o2[1]], linestyle="-", color=cmap(c))
 
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index 27aff4d8e..d3d499560 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -108,13 +108,18 @@ def test_bundle_projection_fixed_internals(scene_synthetic) -> None:
                 color = g_obs["feature_color"]
                 pt = g_obs["feature"]
                 obs = pymap.Observation(
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[0],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     pt[1],
                     # pyre-fixme[6]: For 3rd argument expected `float` but got
                     #  `Dict[str, typing.Any]`.
                     g_obs["feature_scale"],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[0],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[1],
+                    # pyre-fixme[6]: For 1st argument expected `str` but got `int`.
                     color[2],
                     # pyre-fixme[6]: For 7th argument expected `int` but got
                     #  `Dict[str, typing.Any]`.
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index dfd2d142d..14ac8e306 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -1133,11 +1133,15 @@ def euler_matrix(ai: float, aj: float, ak: float, axes: str = "sxyz") -> numpy.n
     try:
         firstaxis, parity, repetition, frame = _AXES2TUPLE[axes]
     except (AttributeError, KeyError):
+        # pyre-fixme[6]: For 1st argument expected `tuple[int, ...]` but got `str`.
         _TUPLE2AXES[axes]  # validation
         firstaxis, parity, repetition, frame = axes
 
     i = firstaxis
+    # pyre-fixme[6]: For 1st argument expected `int` but got `Union[int, str]`.
     j = _NEXT_AXIS[i + parity]
+    # pyre-fixme[58]: `-` is not supported for operand types `Union[int, str]` and
+    #  `Union[int, str]`.
     k = _NEXT_AXIS[i - parity + 1]
 
     if frame:
@@ -1198,32 +1202,69 @@ def euler_from_matrix(
     try:
         firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]
     except (AttributeError, KeyError):
+        # pyre-fixme[6]: For 1st argument expected `tuple[int, ...]` but got `str`.
         _TUPLE2AXES[axes]  # validation
         firstaxis, parity, repetition, frame = axes
 
     i = firstaxis
+    # pyre-fixme[6]: For 1st argument expected `int` but got `Union[int, str]`.
     j = _NEXT_AXIS[i + parity]
+    # pyre-fixme[58]: `-` is not supported for operand types `Union[int, str]` and
+    #  `Union[int, str]`.
     k = _NEXT_AXIS[i - parity + 1]
 
     M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:3, :3]
     if repetition:
+        # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any, dtype[Any]],
+        #  tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[Union[int, str],
+        #  int]`.
         sy = math.sqrt(M[i, j] * M[i, j] + M[i, k] * M[i, k])
         if sy > _EPS:
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got
+            #  `Tuple[Union[int, str], int]`.
             ax = math.atan2(M[i, j], M[i, k])
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got
+            #  `Tuple[Union[int, str], Union[int, str]]`.
             ay = math.atan2(sy, M[i, i])
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[int,
+            #  Union[int, str]]`.
             az = math.atan2(M[j, i], -M[k, i])
         else:
             ax = math.atan2(-M[j, k], M[j, j])
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got
+            #  `Tuple[Union[int, str], Union[int, str]]`.
             ay = math.atan2(sy, M[i, i])
             az = 0.0
     else:
+        # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any, dtype[Any]],
+        #  tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[Union[int, str],
+        #  Union[int, str]]`.
+        # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any, dtype[Any]],
+        #  tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[int, Union[int,
+        #  str]]`.
         cy = math.sqrt(M[i, i] * M[i, i] + M[j, i] * M[j, i])
         if cy > _EPS:
             ax = math.atan2(M[k, j], M[k, k])
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[int,
+            #  Union[int, str]]`.
             ay = math.atan2(-M[k, i], cy)
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[int,
+            #  Union[int, str]]`.
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got
+            #  `Tuple[Union[int, str], Union[int, str]]`.
             az = math.atan2(M[j, i], M[i, i])
         else:
             ax = math.atan2(-M[j, k], M[j, j])
+            # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any,
+            #  dtype[Any]], tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[int,
+            #  Union[int, str]]`.
             ay = math.atan2(-M[k, i], cy)
             az = 0.0
 
@@ -1263,11 +1304,18 @@ def quaternion_from_euler(
     try:
         firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]
     except (AttributeError, KeyError):
+        # pyre-fixme[6]: For 1st argument expected `tuple[int, ...]` but got `str`.
         _TUPLE2AXES[axes]  # validation
         firstaxis, parity, repetition, frame = axes
 
+    # pyre-fixme[58]: `+` is not supported for operand types `Union[int, str]` and
+    #  `int`.
     i = firstaxis + 1
+    # pyre-fixme[58]: `+` is not supported for operand types `int` and `Union[int,
+    #  str]`.
     j = _NEXT_AXIS[i + parity - 1] + 1
+    # pyre-fixme[58]: `-` is not supported for operand types `int` and `Union[int,
+    #  str]`.
     k = _NEXT_AXIS[i - parity] + 1
 
     if frame:

From 480556d5d34c7eace684ebd4217d95865120fca5 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Mon, 18 Nov 2024 19:22:22 -0800
Subject: [PATCH 097/235] Remove unused-variable in
 language_technology/jedi/moses/TranslationOptionCollectionLattice.cpp +3

Summary:
LLVM-15 has a warning `-Wunused-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused variables can compromise readability or, worse, performance.

This diff either (a) removes an unused variable and, possibly, it's associated code or (b) qualifies the variable with `[[maybe_unused]]`.

#buildsonlynotests - Builds are sufficient

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: wuyuoss

Differential Revision: D66143547

fbshipit-source-id: be5d1696be4454358dd919e283f5e2d44a1c1f73
---
 opensfm/src/third_party/akaze/lib/AKAZE.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index d8356a066..34ff21418 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -410,7 +410,6 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
           if (kpts[i].response < kpts[j].response) {
             float dx_ = kpts[j].pt.x - kpts[i].pt.x;
             float dy_ = kpts[j].pt.y - kpts[i].pt.y;
-            float sigma_ = kpts[j].size;
             float radius_ = dx_ * dx_ + dy_ * dy_;  // TODO(pau) use sigma to compute a 3d radius
             if (radius_ < radius) {
               radius = radius_;

From fb6cdbe087dc5cc767f2bccd161239956d9d3b7d Mon Sep 17 00:00:00 2001
From: Zeina Migeed <migeedz@meta.com>
Date: Tue, 19 Nov 2024 13:40:53 -0800
Subject: [PATCH 098/235] Turn typing on for mapillary

Summary:
We are turning typing on for untyped directory.
to type check your project:

`arc pyre check //buck/pattern/...`

You can enable this by adding `typing = True` to individual buck targets OR

`# in a PACKAGE file
load("fbcode_macros//build_defs:python.bzl", "python") python.set_typing(True)`

will type check all buck targets nested underneath.
This directory contains numerous type annotations that are not currently being type checked by a type checker. This can often lead to a false sense of security, since engineers expect feedback on their type annotations.

Reviewed By: MaggieMoss

Differential Revision: D66179514

fbshipit-source-id: 2279b119a7bc093c3e6f2c66dc92217383e391ef
---
 annotation_gui_gcp/lib/views/cad_view.py       | 4 ----
 annotation_gui_gcp/lib/views/cp_finder_view.py | 1 -
 annotation_gui_gcp/lib/views/image_view.py     | 1 -
 opensfm/dataset.py                             | 2 --
 4 files changed, 8 deletions(-)

diff --git a/annotation_gui_gcp/lib/views/cad_view.py b/annotation_gui_gcp/lib/views/cad_view.py
index d5f79e930..5cb199246 100644
--- a/annotation_gui_gcp/lib/views/cad_view.py
+++ b/annotation_gui_gcp/lib/views/cad_view.py
@@ -32,7 +32,6 @@ def __init__(
         path_cad_file,
         is_geo_reference=False,
     )-> None:
-        # pyre-fixme[19]: Expected 0 positional arguments.
         super().__init__(main_ui, web_app, route_prefix)
 
         self.main_ui = main_ui
@@ -43,7 +42,6 @@ def __init__(
         self.load_georeference_metadata(path_cad_file)
         self.is_geo_reference = is_geo_reference
 
-        # pyre-fixme[16]: `CADView` has no attribute `app`.
         self.app.add_url_rule(
             f"{route_prefix}/model",
             f"{route_prefix}_model",
@@ -102,7 +100,6 @@ def display_points(self) -> None:
 
     def refocus(self, lat, lon)->None:
         x, y, z = self.latlon_to_xyz(lat, lon)
-        # pyre-fixme[16]: `CADView` has no attribute `send_sse_message`.
         self.send_sse_message(
             {"x": x, "y": y, "z": z},
             event_type="move_camera",
@@ -169,5 +166,4 @@ def sync_to_client(self)->None:
                         point_id
                     ]
 
-        # pyre-fixme[16]: `CADView` has no attribute `send_sse_message`.
         self.send_sse_message(data)
diff --git a/annotation_gui_gcp/lib/views/cp_finder_view.py b/annotation_gui_gcp/lib/views/cp_finder_view.py
index cee24084f..42705e7e6 100644
--- a/annotation_gui_gcp/lib/views/cp_finder_view.py
+++ b/annotation_gui_gcp/lib/views/cp_finder_view.py
@@ -18,7 +18,6 @@ def template_name(self):
 
     def get_candidate_images(self) -> t.List[str]:
         images_in_existing_views = []
-        # pyre-fixme[16]: `ControlPointFinderView` has no attribute `main_ui`.
         for v in self.main_ui.sequence_views:
             images_in_existing_views.extend(v.image_list)
 
diff --git a/annotation_gui_gcp/lib/views/image_view.py b/annotation_gui_gcp/lib/views/image_view.py
index ec20e7543..11d1688a5 100644
--- a/annotation_gui_gcp/lib/views/image_view.py
+++ b/annotation_gui_gcp/lib/views/image_view.py
@@ -9,7 +9,6 @@ def point_color(point_id: str) -> str:
     return hex_color
 
 
-# pyre-fixme[11]: Annotation `WebView` is not defined as a type.
 class ImageView(WebView):
     def __init__(
         self,
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index fa96fc6fb..12af6a344 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -334,8 +334,6 @@ def load_words(self, image: str) -> np.ndarray:
 
     def save_words(self, image: str, words: np.ndarray) -> None:
         with self.io_handler.open(self._words_file(image), "wb") as f:
-            # pyre-fixme[6]: For 1st argument expected `Union[_SupportsWrite[bytes],
-            #  PathLike[str], str]` but got `IO[typing.Any]`.
             np.savez_compressed(f, words=words.astype(np.uint16))
 
     def _matches_path(self) -> str:

From 4bdfa335b0f1805fd3f72433a3ab5ae86453be2c Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Tue, 19 Nov 2024 16:37:42 -0800
Subject: [PATCH 099/235] Add depth prior to point observation

Summary: Adding a depth prior error term into opensfm which can help us get a metric-scale and scale-drift-free reconstruction

Reviewed By: YanNoun

Differential Revision: D65697460

fbshipit-source-id: 334d5a8d1657715b69d5358bedbce8a279bd1651
---
 opensfm/src/bundle/bundle_adjuster.h          |   6 +-
 .../src/bundle/error/relative_depth_error.h   |  46 ++
 opensfm/src/bundle/pybundle.pyi               | 314 +++++++++----
 opensfm/src/bundle/python/pybind.cc           |   9 +-
 opensfm/src/bundle/src/bundle_adjuster.cc     |  37 +-
 opensfm/src/map/observation.h                 |  21 +-
 opensfm/src/map/pymap.pyi                     | 431 +++++++++++-------
 opensfm/src/map/python/pybind.cc              |  11 +
 opensfm/src/sfm/src/ba_helpers.cc             |   8 +-
 opensfm/test/test_bundle.py                   |  24 +-
 10 files changed, 635 insertions(+), 272 deletions(-)
 create mode 100644 opensfm/src/bundle/error/relative_depth_error.h

diff --git a/opensfm/src/bundle/bundle_adjuster.h b/opensfm/src/bundle/bundle_adjuster.h
index b28a29e1e..da0688a98 100644
--- a/opensfm/src/bundle/bundle_adjuster.h
+++ b/opensfm/src/bundle/bundle_adjuster.h
@@ -9,12 +9,14 @@
 #include <foundation/optional.h>
 #include <geometry/camera.h>
 #include <geometry/pose.h>
+#include <map/observation.h>
 
 #include <cmath>
 #include <cstdio>
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -61,6 +63,7 @@ struct PointProjectionObservation {
   Shot *shot;
   Camera *camera;
   double std_deviation;
+  std::optional<map::Depth> depth_prior;
 };
 
 struct RelativeMotion {
@@ -200,7 +203,8 @@ class BundleAdjuster {
   void AddPointProjectionObservation(const std::string &shot,
                                      const std::string &point,
                                      const Vec2d &observation,
-                                     double std_deviation);
+                                     double std_deviation,
+                                     const std::optional<map::Depth>& depth_prior = std::nullopt);
 
   // Relative motion constraints
   void AddRelativeMotion(const RelativeMotion &rm);
diff --git a/opensfm/src/bundle/error/relative_depth_error.h b/opensfm/src/bundle/error/relative_depth_error.h
new file mode 100644
index 000000000..6f4eef122
--- /dev/null
+++ b/opensfm/src/bundle/error/relative_depth_error.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <bundle/bundle_adjuster.h>
+#include <bundle/error/error_utils.h>
+#include <ceres/sized_cost_function.h>
+#include <foundation/types.h>
+#include <geometry/functions.h>
+#include <geometry/camera_instances.h>
+
+namespace bundle {
+class RelativeDepthError {
+ public:
+  constexpr static int Size = 1;
+  RelativeDepthError(double depth, double std_deviation, bool use_rig_camera, bool is_radial_depth = true)
+      : depth_(depth),
+        scale_(1.0 / std_deviation),
+        use_rig_camera_(use_rig_camera),
+        is_radial_depth_(is_radial_depth) {}
+
+  template <typename T>
+  bool operator()(const T* const rig_instance,
+                  const T* const rig_camera, const T* const point,
+                  T* residuals) const {
+    T scale_one = T(1.0);
+    Vec3<T> point_in_camera;
+    const T* const actual_rig_camera = use_rig_camera_ ? rig_camera : nullptr;
+    WorldToCameraCoordinatesRig(&scale_one, rig_instance, actual_rig_camera,
+                                point, point_in_camera.data());
+
+    // The error is the difference between the predicted and observed depth
+    T depth_in_camera = point_in_camera[2];
+    if (is_radial_depth_) {
+      depth_in_camera = point_in_camera.norm();
+    }
+    residuals[0] = T(scale_) * (depth_in_camera - T(depth_));
+
+    return true;
+  }
+
+ protected:
+  const double depth_;
+  const double scale_;
+  const bool use_rig_camera_;
+  const bool is_radial_depth_;
+};
+}  // namespace bundle
diff --git a/opensfm/src/bundle/pybundle.pyi b/opensfm/src/bundle/pybundle.pyi
index da53f049e..3f5cff7e7 100644
--- a/opensfm/src/bundle/pybundle.pyi
+++ b/opensfm/src/bundle/pybundle.pyi
@@ -7,44 +7,89 @@
 # Tip: Be sure to run this with the build mode you use for your project, e.g.,
 # @//arvr/mode/linux/opt (or dev) in arvr.
 #
-# Ignore errors for [5] global variable types and [24] untyped generics.
-# pyre-ignore-all-errors[5,24]
+# Ignore errors for [24] untyped generics.
+# pyre-ignore-all-errors[24]
 
 import numpy
 import opensfm.pygeometry
+import opensfm.pymap
 from typing import *
-__all__  = [
-"BundleAdjuster",
-"Point",
-"RAReconstruction",
-"RARelativeMotionConstraint",
-"RAShot",
-"Reconstruction",
-"ReconstructionAlignment",
-"RelativeMotion",
-"RelativeRotation"
+
+__all__ = [
+    "BundleAdjuster",
+    "Point",
+    "RAReconstruction",
+    "RARelativeMotionConstraint",
+    "RAShot",
+    "Reconstruction",
+    "ReconstructionAlignment",
+    "RelativeMotion",
+    "RelativeRotation",
 ]
+
 class BundleAdjuster:
     def __init__(self) -> None: ...
     def add_absolute_pan(self, arg0: str, arg1: float, arg2: float) -> None: ...
-    def add_absolute_position_heatmap(self, arg0: str, arg1: str, arg2: float, arg3: float, arg4: float) -> None: ...
+    def add_absolute_position_heatmap(
+        self, arg0: str, arg1: str, arg2: float, arg3: float, arg4: float
+    ) -> None: ...
     def add_absolute_roll(self, arg0: str, arg1: float, arg2: float) -> None: ...
     def add_absolute_tilt(self, arg0: str, arg1: float, arg2: float) -> None: ...
-    def add_absolute_up_vector(self, arg0: str, arg1: numpy.ndarray, arg2: float) -> None: ...
-    def add_camera(self, arg0: str, arg1: opensfm.pygeometry.Camera, arg2: opensfm.pygeometry.Camera, arg3: bool) -> None: ...
-    def add_common_position(self, arg0: str, arg1: str, arg2: float, arg3: float) -> None: ...
-    def add_heatmap(self, arg0: str, arg1: List[float], arg2: int, arg3: float) -> None: ...
-    def add_linear_motion(self, arg0: str, arg1: str, arg2: str, arg3: float, arg4: float, arg5: float) -> None: ...
+    def add_absolute_up_vector(
+        self, arg0: str, arg1: numpy.ndarray, arg2: float
+    ) -> None: ...
+    def add_camera(
+        self,
+        arg0: str,
+        arg1: opensfm.pygeometry.Camera,
+        arg2: opensfm.pygeometry.Camera,
+        arg3: bool,
+    ) -> None: ...
+    def add_common_position(
+        self, arg0: str, arg1: str, arg2: float, arg3: float
+    ) -> None: ...
+    def add_heatmap(
+        self, arg0: str, arg1: List[float], arg2: int, arg3: float
+    ) -> None: ...
+    def add_linear_motion(
+        self, arg0: str, arg1: str, arg2: str, arg3: float, arg4: float, arg5: float
+    ) -> None: ...
     def add_point(self, arg0: str, arg1: numpy.ndarray, arg2: bool) -> None: ...
-    def add_point_prior(self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: bool) -> None: ...
-    def add_point_projection_observation(self, arg0: str, arg1: str, arg2: numpy.ndarray, arg3: float) -> None: ...
+    def add_point_prior(
+        self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: bool
+    ) -> None: ...
+    def add_point_projection_observation(
+        self,
+        shot: str,
+        point: str,
+        observation: numpy.ndarray,
+        std_deviation: float,
+        depth_prior: Optional[opensfm.pymap.Depth] = None,
+    ) -> None: ...
     def add_reconstruction(self, arg0: str, arg1: bool) -> None: ...
-    def add_reconstruction_instance(self, arg0: str, arg1: float, arg2: str) -> None: ...
+    def add_reconstruction_instance(
+        self, arg0: str, arg1: float, arg2: str
+    ) -> None: ...
     def add_relative_motion(self, arg0: RelativeMotion) -> None: ...
     def add_relative_rotation(self, arg0: RelativeRotation) -> None: ...
-    def add_rig_camera(self, arg0: str, arg1: opensfm.pygeometry.Pose, arg2: opensfm.pygeometry.Pose, arg3: bool) -> None: ...
-    def add_rig_instance(self, arg0: str, arg1: opensfm.pygeometry.Pose, arg2: Dict[str, str], arg3: Dict[str, str], arg4: bool) -> None: ...
-    def add_rig_instance_position_prior(self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: str) -> None: ...
+    def add_rig_camera(
+        self,
+        arg0: str,
+        arg1: opensfm.pygeometry.Pose,
+        arg2: opensfm.pygeometry.Pose,
+        arg3: bool,
+    ) -> None: ...
+    def add_rig_instance(
+        self,
+        arg0: str,
+        arg1: opensfm.pygeometry.Pose,
+        arg2: Dict[str, str],
+        arg3: Dict[str, str],
+        arg4: bool,
+    ) -> None: ...
+    def add_rig_instance_position_prior(
+        self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: str
+    ) -> None: ...
     def brief_report(self) -> str: ...
     def full_report(self) -> str: ...
     def get_camera(self, arg0: str) -> opensfm.pygeometry.Camera: ...
@@ -59,7 +104,17 @@ class BundleAdjuster:
     def set_compute_covariances(self, arg0: bool) -> None: ...
     def set_compute_reprojection_errors(self, arg0: bool) -> None: ...
     def set_gauge_fix_shots(self, arg0: str, arg1: str) -> None: ...
-    def set_internal_parameters_prior_sd(self, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float) -> None: ...
+    def set_internal_parameters_prior_sd(
+        self,
+        arg0: float,
+        arg1: float,
+        arg2: float,
+        arg3: float,
+        arg4: float,
+        arg5: float,
+        arg6: float,
+        arg7: float,
+    ) -> None: ...
     def set_linear_solver_type(self, arg0: str) -> None: ...
     def set_max_num_iterations(self, arg0: int) -> None: ...
     def set_num_threads(self, arg0: int) -> None: ...
@@ -67,159 +122,226 @@ class BundleAdjuster:
     def set_relative_motion_loss_function(self, arg0: str, arg1: float) -> None: ...
     def set_scale_sharing(self, arg0: str, arg1: bool) -> None: ...
     def set_use_analytic_derivatives(self, arg0: bool) -> None: ...
+
 class Point:
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @property
-    def p(self) -> numpy.ndarray:...
+    def p(self) -> numpy.ndarray: ...
     @property
-    def reprojection_errors(self) -> Dict[str, numpy.ndarray]:...
+    def reprojection_errors(self) -> Dict[str, numpy.ndarray]: ...
     @reprojection_errors.setter
-    def reprojection_errors(self, arg0: Dict[str, numpy.ndarray]) -> None:...
+    def reprojection_errors(self, arg0: Dict[str, numpy.ndarray]) -> None: ...
+
 class RAReconstruction:
     def __init__(self) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def rx(self) -> float:...
+    def rx(self) -> float: ...
     @rx.setter
-    def rx(self, arg1: float) -> None:...
+    def rx(self, arg1: float) -> None: ...
     @property
-    def ry(self) -> float:...
+    def ry(self) -> float: ...
     @ry.setter
-    def ry(self, arg1: float) -> None:...
+    def ry(self, arg1: float) -> None: ...
     @property
-    def rz(self) -> float:...
+    def rz(self) -> float: ...
     @rz.setter
-    def rz(self, arg1: float) -> None:...
+    def rz(self, arg1: float) -> None: ...
     @property
-    def scale(self) -> float:...
+    def scale(self) -> float: ...
     @scale.setter
-    def scale(self, arg1: float) -> None:...
+    def scale(self, arg1: float) -> None: ...
     @property
-    def tx(self) -> float:...
+    def tx(self) -> float: ...
     @tx.setter
-    def tx(self, arg1: float) -> None:...
+    def tx(self, arg1: float) -> None: ...
     @property
-    def ty(self) -> float:...
+    def ty(self) -> float: ...
     @ty.setter
-    def ty(self, arg1: float) -> None:...
+    def ty(self, arg1: float) -> None: ...
     @property
-    def tz(self) -> float:...
+    def tz(self) -> float: ...
     @tz.setter
-    def tz(self, arg1: float) -> None:...
+    def tz(self, arg1: float) -> None: ...
+
 class RARelativeMotionConstraint:
-    def __init__(self, arg0: str, arg1: str, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float) -> None: ...
+    def __init__(
+        self,
+        arg0: str,
+        arg1: str,
+        arg2: float,
+        arg3: float,
+        arg4: float,
+        arg5: float,
+        arg6: float,
+        arg7: float,
+    ) -> None: ...
     def set_scale_matrix(self, arg0: int, arg1: int, arg2: float) -> None: ...
     @property
-    def reconstruction(self) -> str:...
+    def reconstruction(self) -> str: ...
     @reconstruction.setter
-    def reconstruction(self, arg0: str) -> None:...
+    def reconstruction(self, arg0: str) -> None: ...
     @property
-    def rx(self) -> float:...
+    def rx(self) -> float: ...
     @rx.setter
-    def rx(self, arg1: float) -> None:...
+    def rx(self, arg1: float) -> None: ...
     @property
-    def ry(self) -> float:...
+    def ry(self) -> float: ...
     @ry.setter
-    def ry(self, arg1: float) -> None:...
+    def ry(self, arg1: float) -> None: ...
     @property
-    def rz(self) -> float:...
+    def rz(self) -> float: ...
     @rz.setter
-    def rz(self, arg1: float) -> None:...
+    def rz(self, arg1: float) -> None: ...
     @property
-    def shot(self) -> str:...
+    def shot(self) -> str: ...
     @shot.setter
-    def shot(self, arg0: str) -> None:...
+    def shot(self, arg0: str) -> None: ...
     @property
-    def tx(self) -> float:...
+    def tx(self) -> float: ...
     @tx.setter
-    def tx(self, arg1: float) -> None:...
+    def tx(self, arg1: float) -> None: ...
     @property
-    def ty(self) -> float:...
+    def ty(self) -> float: ...
     @ty.setter
-    def ty(self, arg1: float) -> None:...
+    def ty(self, arg1: float) -> None: ...
     @property
-    def tz(self) -> float:...
+    def tz(self) -> float: ...
     @tz.setter
-    def tz(self, arg1: float) -> None:...
+    def tz(self, arg1: float) -> None: ...
+
 class RAShot:
     def __init__(self) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def rx(self) -> float:...
+    def rx(self) -> float: ...
     @rx.setter
-    def rx(self, arg1: float) -> None:...
+    def rx(self, arg1: float) -> None: ...
     @property
-    def ry(self) -> float:...
+    def ry(self) -> float: ...
     @ry.setter
-    def ry(self, arg1: float) -> None:...
+    def ry(self, arg1: float) -> None: ...
     @property
-    def rz(self) -> float:...
+    def rz(self) -> float: ...
     @rz.setter
-    def rz(self, arg1: float) -> None:...
+    def rz(self, arg1: float) -> None: ...
     @property
-    def tx(self) -> float:...
+    def tx(self) -> float: ...
     @tx.setter
-    def tx(self, arg1: float) -> None:...
+    def tx(self, arg1: float) -> None: ...
     @property
-    def ty(self) -> float:...
+    def ty(self) -> float: ...
     @ty.setter
-    def ty(self, arg1: float) -> None:...
+    def ty(self, arg1: float) -> None: ...
     @property
-    def tz(self) -> float:...
+    def tz(self) -> float: ...
     @tz.setter
-    def tz(self, arg1: float) -> None:...
+    def tz(self, arg1: float) -> None: ...
+
 class Reconstruction:
     def __init__(self) -> None: ...
     def get_scale(self, arg0: str) -> float: ...
     def set_scale(self, arg0: str, arg1: float) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
+
 class ReconstructionAlignment:
     def __init__(self) -> None: ...
-    def add_absolute_position_constraint(self, arg0: str, arg1: float, arg2: float, arg3: float, arg4: float) -> None: ...
-    def add_common_camera_constraint(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: float, arg5: float) -> None: ...
-    def add_common_point_constraint(self, arg0: str, arg1: float, arg2: float, arg3: float, arg4: str, arg5: float, arg6: float, arg7: float, arg8: float) -> None: ...
-    def add_reconstruction(self, arg0: str, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: bool) -> None: ...
-    def add_relative_absolute_position_constraint(self, arg0: str, arg1: str, arg2: float, arg3: float, arg4: float, arg5: float) -> None: ...
-    def add_relative_motion_constraint(self, arg0: RARelativeMotionConstraint) -> None: ...
-    def add_shot(self, arg0: str, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: bool) -> None: ...
+    def add_absolute_position_constraint(
+        self, arg0: str, arg1: float, arg2: float, arg3: float, arg4: float
+    ) -> None: ...
+    def add_common_camera_constraint(
+        self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: float, arg5: float
+    ) -> None: ...
+    def add_common_point_constraint(
+        self,
+        arg0: str,
+        arg1: float,
+        arg2: float,
+        arg3: float,
+        arg4: str,
+        arg5: float,
+        arg6: float,
+        arg7: float,
+        arg8: float,
+    ) -> None: ...
+    def add_reconstruction(
+        self,
+        arg0: str,
+        arg1: float,
+        arg2: float,
+        arg3: float,
+        arg4: float,
+        arg5: float,
+        arg6: float,
+        arg7: float,
+        arg8: bool,
+    ) -> None: ...
+    def add_relative_absolute_position_constraint(
+        self, arg0: str, arg1: str, arg2: float, arg3: float, arg4: float, arg5: float
+    ) -> None: ...
+    def add_relative_motion_constraint(
+        self, arg0: RARelativeMotionConstraint
+    ) -> None: ...
+    def add_shot(
+        self,
+        arg0: str,
+        arg1: float,
+        arg2: float,
+        arg3: float,
+        arg4: float,
+        arg5: float,
+        arg6: float,
+        arg7: bool,
+    ) -> None: ...
     def brief_report(self) -> str: ...
     def full_report(self) -> str: ...
     def get_reconstruction(self, arg0: str) -> RAReconstruction: ...
     def get_shot(self, arg0: str) -> RAShot: ...
     def run(self) -> None: ...
+
 class RelativeMotion:
-    def __init__(self, arg0: str, arg1: str, arg2: numpy.ndarray, arg3: numpy.ndarray, arg4: float, arg5: float, arg6: bool) -> None: ...
+    def __init__(
+        self,
+        arg0: str,
+        arg1: str,
+        arg2: numpy.ndarray,
+        arg3: numpy.ndarray,
+        arg4: float,
+        arg5: float,
+        arg6: bool,
+    ) -> None: ...
     def set_scale_matrix(self, arg0: numpy.ndarray) -> None: ...
     @property
-    def rig_instance_i(self) -> str:...
+    def rig_instance_i(self) -> str: ...
     @rig_instance_i.setter
-    def rig_instance_i(self, arg0: str) -> None:...
+    def rig_instance_i(self, arg0: str) -> None: ...
     @property
-    def rig_instance_j(self) -> str:...
+    def rig_instance_j(self) -> str: ...
     @rig_instance_j.setter
-    def rig_instance_j(self, arg0: str) -> None:...
+    def rig_instance_j(self, arg0: str) -> None: ...
+
 class RelativeRotation:
     def __init__(self, arg0: str, arg1: str, arg2: numpy.ndarray) -> None: ...
     def set_scale_matrix(self, arg0: numpy.ndarray) -> None: ...
     @property
-    def r(self) -> numpy.ndarray:...
+    def r(self) -> numpy.ndarray: ...
     @r.setter
-    def r(self, arg1: numpy.ndarray) -> None:...
+    def r(self, arg1: numpy.ndarray) -> None: ...
     @property
-    def shot_i(self) -> str:...
+    def shot_i(self) -> str: ...
     @shot_i.setter
-    def shot_i(self, arg0: str) -> None:...
+    def shot_i(self, arg0: str) -> None: ...
     @property
-    def shot_j(self) -> str:...
+    def shot_j(self) -> str: ...
     @shot_j.setter
-    def shot_j(self, arg0: str) -> None:...
+    def shot_j(self, arg0: str) -> None: ...
diff --git a/opensfm/src/bundle/python/pybind.cc b/opensfm/src/bundle/python/pybind.cc
index c8c63e4cd..04f903f23 100644
--- a/opensfm/src/bundle/python/pybind.cc
+++ b/opensfm/src/bundle/python/pybind.cc
@@ -7,6 +7,7 @@
 
 PYBIND11_MODULE(pybundle, m) {
   py::module::import("opensfm.pygeometry");
+  py::module::import("opensfm.pymap");
 
   py::class_<bundle::RelativeMotion>(m, "RelativeMotion")
       .def(py::init<const std::string &, const std::string &,
@@ -40,6 +41,7 @@ PYBIND11_MODULE(pybundle, m) {
                              [](const bundle::Point &p) { return p.GetID(); })
       .def_readwrite("reprojection_errors",
                      &bundle::Point::reprojection_errors);
+
   py::class_<bundle::BundleAdjuster>(m, "BundleAdjuster")
       .def(py::init())
       .def("run", &bundle::BundleAdjuster::Run,
@@ -74,7 +76,12 @@ PYBIND11_MODULE(pybundle, m) {
       .def("add_reconstruction_instance",
            &bundle::BundleAdjuster::AddReconstructionInstance)
       .def("add_point_projection_observation",
-           &bundle::BundleAdjuster::AddPointProjectionObservation)
+           &bundle::BundleAdjuster::AddPointProjectionObservation,
+           py::arg("shot"),
+           py::arg("point"),
+           py::arg("observation"),
+           py::arg("std_deviation"),
+           py::arg("depth_prior") = std::nullopt)
       .def("add_relative_motion", &bundle::BundleAdjuster::AddRelativeMotion)
       .def("add_relative_rotation",
            &bundle::BundleAdjuster::AddRelativeRotation)
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 907a6691c..31c525168 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -5,6 +5,7 @@
 #include <bundle/error/position_functors.h>
 #include <bundle/error/prior_error.h>
 #include <bundle/error/projection_errors.h>
+#include <bundle/error/relative_depth_error.h>
 #include <bundle/error/relative_motion_errors.h>
 #include <foundation/types.h>
 
@@ -239,13 +240,15 @@ void BundleAdjuster::AddPointPrior(const std::string &point_id,
 void BundleAdjuster::AddPointProjectionObservation(const std::string &shot,
                                                    const std::string &point,
                                                    const Vec2d &observation,
-                                                   double std_deviation) {
+                                                   double std_deviation,
+                                                   const std::optional<map::Depth>& depth_prior) {
   PointProjectionObservation o;
   o.shot = &shots_.at(shot);
   o.camera = &cameras_.at(o.shot->GetCamera()->GetID());
   o.point = &points_.at(point);
   o.coordinates = observation;
   o.std_deviation = std_deviation;
+  o.depth_prior = depth_prior;
   point_projection_observations_.push_back(o);
 }
 
@@ -493,6 +496,34 @@ struct AddProjectionError {
   }
 };
 
+struct AddRelativeDepthError {
+  template <class T>
+  static void Apply(const PointProjectionObservation &obs,
+                    ceres::LossFunction *loss, ceres::Problem *problem) {
+    constexpr static int ShotSize = 6;
+    constexpr static int PointSize = 3;
+
+    if (!obs.depth_prior.has_value()) {
+      return;
+    }
+    const auto& depth = obs.depth_prior.value();
+
+    const bool is_rig_camera_useful =
+        IsRigCameraUseful(*obs.shot->GetRigCamera());
+    ceres::CostFunction *cost_function = nullptr;
+
+    cost_function =
+        new ceres::AutoDiffCostFunction<RelativeDepthError, RelativeDepthError::Size, ShotSize, ShotSize, PointSize>(
+          new RelativeDepthError(depth.value, depth.std_deviation, is_rig_camera_useful, depth.is_radial)
+        );
+
+    problem->AddResidualBlock(cost_function, loss,
+                              obs.shot->GetRigInstance()->GetValueData().data(),
+                              obs.shot->GetRigCamera()->GetValueData().data(),
+                              obs.point->GetValueData().data());
+  }
+};
+
 struct ComputeResidualError {
   template <class T>
   static void Apply(bool use_analytical,
@@ -771,6 +802,10 @@ void BundleAdjuster::Run() {
         observation.camera->GetValue().GetProjectionType();
     geometry::Dispatch<AddProjectionError>(
         projection_type, use_analytic_, observation, projection_loss, &problem);
+
+    // Add relative depth error blocks
+    geometry::Dispatch<AddRelativeDepthError>(
+        projection_type, observation, projection_loss, &problem);
   }
 
   // Add relative motion errors
diff --git a/opensfm/src/map/observation.h b/opensfm/src/map/observation.h
index c9a48fe9f..b1f9a4be6 100644
--- a/opensfm/src/map/observation.h
+++ b/opensfm/src/map/observation.h
@@ -3,19 +3,33 @@
 #include <map/defines.h>
 
 #include <Eigen/Dense>
+#include <optional>
 
 namespace map {
+
+struct Depth {
+  double value;
+  bool is_radial;
+  double std_deviation;
+
+  Depth() = default;
+  Depth(double value_, bool is_radial_, double std_deviation_):
+    value(value_), is_radial(is_radial_), std_deviation(std_deviation_) {}
+};
+
 struct Observation {
   Observation() = default;
   Observation(double x, double y, double s, int r, int g, int b, int feature,
               int segmentation = NO_SEMANTIC_VALUE,
-              int instance = NO_SEMANTIC_VALUE)
+              int instance = NO_SEMANTIC_VALUE,
+              const std::optional<Depth>& depth = std::nullopt)
       : point(x, y),
         scale(s),
         color(r, g, b),
         feature_id(feature),
         segmentation_id(segmentation),
-        instance_id(instance) {}
+        instance_id(instance),
+        depth_prior(depth) {}
   bool operator==(const Observation& k) const {
     return point == k.point && scale == k.scale && color == k.color &&
            feature_id == k.feature_id && segmentation_id == k.segmentation_id &&
@@ -31,6 +45,9 @@ struct Observation {
   // Optional data : semantics
   int segmentation_id;
   int instance_id;
+
+  // Optional data : depth prior
+  std::optional<Depth> depth_prior;
   static constexpr int NO_SEMANTIC_VALUE = -1;
 };
 }  // namespace map
diff --git a/opensfm/src/map/pymap.pyi b/opensfm/src/map/pymap.pyi
index 9af9c042f..f5f09dcf1 100644
--- a/opensfm/src/map/pymap.pyi
+++ b/opensfm/src/map/pymap.pyi
@@ -7,44 +7,47 @@
 # Tip: Be sure to run this with the build mode you use for your project, e.g.,
 # @//arvr/mode/linux/opt (or dev) in arvr.
 #
-# Ignore errors for [5] global variable types and [24] untyped generics.
-# pyre-ignore-all-errors[5,24]
+# Ignore errors for [24] untyped generics.
+# pyre-ignore-all-errors[24]
 
 import numpy
 import opensfm.pygeo
 import opensfm.pygeometry
 from typing import *
-__all__  = [
-"BiasView",
-"CameraView",
-"ErrorType",
-"GroundControlPoint",
-"GroundControlPointObservation",
-"GroundControlPointRole",
-"Landmark",
-"LandmarkView",
-"Map",
-"Observation",
-"PanoShotView",
-"RigCamera",
-"RigCameraView",
-"RigInstance",
-"RigInstanceView",
-"Shot",
-"ShotMeasurementDouble",
-"ShotMeasurementInt",
-"ShotMeasurementString",
-"ShotMeasurementVec3d",
-"ShotMeasurements",
-"ShotMesh",
-"ShotView",
-"TracksManager",
-"Angular",
-"METRICS_ONLY",
-"Normalized",
-"OPTIMIZATION",
-"Pixel"
+
+__all__ = [
+    "BiasView",
+    "CameraView",
+    "Depth",
+    "ErrorType",
+    "GroundControlPoint",
+    "GroundControlPointObservation",
+    "GroundControlPointRole",
+    "Landmark",
+    "LandmarkView",
+    "Map",
+    "Observation",
+    "PanoShotView",
+    "RigCamera",
+    "RigCameraView",
+    "RigInstance",
+    "RigInstanceView",
+    "Shot",
+    "ShotMeasurementDouble",
+    "ShotMeasurementInt",
+    "ShotMeasurementString",
+    "ShotMeasurementVec3d",
+    "ShotMeasurements",
+    "ShotMesh",
+    "ShotView",
+    "TracksManager",
+    "Angular",
+    "METRICS_ONLY",
+    "Normalized",
+    "OPTIMIZATION",
+    "Pixel",
 ]
+
 class BiasView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> opensfm.pygeometry.Similarity: ...
@@ -55,6 +58,7 @@ class BiasView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class CameraView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> opensfm.pygeometry.Camera: ...
@@ -65,85 +69,126 @@ class CameraView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
+class Depth:
+    def __init__(self, value: float, is_radial: bool, std_deviation: float) -> None: ...
+    @property
+    def is_radial(self) -> bool: ...
+    @is_radial.setter
+    def is_radial(self, arg0: bool) -> None: ...
+    @property
+    def std_deviation(self) -> float: ...
+    @std_deviation.setter
+    def std_deviation(self, arg0: float) -> None: ...
+    @property
+    def value(self) -> float: ...
+    @value.setter
+    def value(self, arg0: float) -> None: ...
+
 class ErrorType:
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __setstate__(self, state: int) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
     Pixel: "ErrorType"
     Normalized: "ErrorType"
     Angular: "ErrorType"
     __members__: Dict[str, "ErrorType"]
-    @property
-    def name(self) -> str: ...
+    __entries: "dict"
+
 class GroundControlPoint:
     def __init__(self) -> None: ...
     def add_observation(self, arg0: GroundControlPointObservation) -> None: ...
     @property
-    def has_altitude(self) -> bool:...
+    def has_altitude(self) -> bool: ...
     @has_altitude.setter
-    def has_altitude(self, arg0: bool) -> None:...
+    def has_altitude(self, arg0: bool) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def lla(self) -> Dict[str, float]:...
+    def lla(self) -> Dict[str, float]: ...
     @lla.setter
-    def lla(self, arg0: Dict[str, float]) -> None:...
+    def lla(self, arg0: Dict[str, float]) -> None: ...
     @property
-    def lla_vec(self) -> numpy.ndarray:...
+    def lla_vec(self) -> numpy.ndarray: ...
     @lla_vec.setter
-    def lla_vec(self, arg1: float, arg2: float, arg3: float) -> None:...
+    def lla_vec(self, arg1: float, arg2: float, arg3: float) -> None: ...
     @property
-    def observations(self) -> List[GroundControlPointObservation]:...
+    def observations(self) -> List[GroundControlPointObservation]: ...
     @observations.setter
-    def observations(self, arg1: List[GroundControlPointObservation]) -> None:...
+    def observations(self, arg1: List[GroundControlPointObservation]) -> None: ...
     @property
-    def role(self) -> GroundControlPointRole:...
+    def role(self) -> GroundControlPointRole: ...
     @role.setter
-    def role(self, arg0: GroundControlPointRole) -> None:...
+    def role(self, arg0: GroundControlPointRole) -> None: ...
     @property
-    def survey_point_id(self) -> int:...
+    def survey_point_id(self) -> int: ...
     @survey_point_id.setter
-    def survey_point_id(self, arg0: int) -> None:...
+    def survey_point_id(self, arg0: int) -> None: ...
+
 class GroundControlPointObservation:
     @overload
     def __init__(self) -> None: ...
     @overload
     def __init__(self, arg0: str, arg1: numpy.ndarray) -> None: ...
     @property
-    def projection(self) -> numpy.ndarray:...
+    def projection(self) -> numpy.ndarray: ...
     @projection.setter
-    def projection(self, arg0: numpy.ndarray) -> None:...
+    def projection(self, arg0: numpy.ndarray) -> None: ...
     @property
-    def shot_id(self) -> str:...
+    def shot_id(self) -> str: ...
     @shot_id.setter
-    def shot_id(self, arg0: str) -> None:...
+    def shot_id(self, arg0: str) -> None: ...
     @property
-    def uid(self) -> int:...
+    def uid(self) -> int: ...
     @uid.setter
-    def uid(self, arg0: int) -> None:...
+    def uid(self, arg0: int) -> None: ...
+
 class GroundControlPointRole:
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __setstate__(self, state: int) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
     OPTIMIZATION: "GroundControlPointRole"
     METRICS_ONLY: "GroundControlPointRole"
     __members__: Dict[str, "GroundControlPointRole"]
-    @property
-    def name(self) -> str: ...
+    __entries: "dict"
+
 class Landmark:
     def __init__(self, arg0: str, arg1: numpy.ndarray) -> None: ...
     def get_observations(self) -> Dict[Shot, int]: ...
     def number_of_observations(self) -> int: ...
     @property
-    def color(self) -> numpy.ndarray:...
+    def color(self) -> numpy.ndarray: ...
     @color.setter
-    def color(self, arg1: numpy.ndarray) -> None:...
+    def color(self, arg1: numpy.ndarray) -> None: ...
     @property
-    def coordinates(self) -> numpy.ndarray:...
+    def coordinates(self) -> numpy.ndarray: ...
     @coordinates.setter
-    def coordinates(self, arg1: numpy.ndarray) -> None:...
+    def coordinates(self, arg1: numpy.ndarray) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @property
-    def reprojection_errors(self) -> Dict[str, numpy.ndarray]:...
+    def reprojection_errors(self) -> Dict[str, numpy.ndarray]: ...
     @reprojection_errors.setter
-    def reprojection_errors(self, arg1: Dict[str, numpy.ndarray]) -> None:...
+    def reprojection_errors(self, arg1: Dict[str, numpy.ndarray]) -> None: ...
+
 class LandmarkView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> Landmark: ...
@@ -154,24 +199,39 @@ class LandmarkView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class Map:
     def __init__(self) -> None: ...
     @overload
-    def add_observation(self, shot: Shot, landmark: Landmark, observation: Observation) -> None: ...
+    def add_observation(
+        self, shot: Shot, landmark: Landmark, observation: Observation
+    ) -> None: ...
     @overload
-    def add_observation(self, shot_Id: str, landmark_id: str, observation: Observation) -> None: ...
+    def add_observation(
+        self, shot_Id: str, landmark_id: str, observation: Observation
+    ) -> None: ...
     def clean_landmarks_below_min_observations(self, arg0: int) -> None: ...
     def clear_observations_and_landmarks(self) -> None: ...
-    def compute_reprojection_errors(self, arg0: TracksManager, arg1: ErrorType) -> Dict[str, Dict[str, numpy.ndarray]]: ...
-    def create_camera(self, camera: opensfm.pygeometry.Camera) -> opensfm.pygeometry.Camera: ...
-    def create_landmark(self, lm_id: str, global_position: numpy.ndarray) -> Landmark: ...
-    def create_pano_shot(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: opensfm.pygeometry.Pose) -> Shot: ...
+    def compute_reprojection_errors(
+        self, arg0: TracksManager, arg1: ErrorType
+    ) -> Dict[str, Dict[str, numpy.ndarray]]: ...
+    def create_camera(
+        self, camera: opensfm.pygeometry.Camera
+    ) -> opensfm.pygeometry.Camera: ...
+    def create_landmark(
+        self, lm_id: str, global_position: numpy.ndarray
+    ) -> Landmark: ...
+    def create_pano_shot(
+        self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: opensfm.pygeometry.Pose
+    ) -> Shot: ...
     def create_rig_camera(self, arg0: RigCamera) -> RigCamera: ...
     def create_rig_instance(self, arg0: str) -> RigInstance: ...
     @overload
     def create_shot(self, arg0: str, arg1: str, arg2: str, arg3: str) -> Shot: ...
     @overload
-    def create_shot(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: opensfm.pygeometry.Pose) -> Shot: ...
+    def create_shot(
+        self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: opensfm.pygeometry.Pose
+    ) -> Shot: ...
     @staticmethod
     def deep_copy(arg0: Map, arg1: bool) -> Map: ...
     def get_bias(self, arg0: str) -> opensfm.pygeometry.Similarity: ...
@@ -187,7 +247,9 @@ class Map:
     def get_reference(self) -> opensfm.pygeo.TopocentricConverter: ...
     def get_shot(self, arg0: str) -> Shot: ...
     def get_shots(self) -> ShotView: ...
-    def get_valid_observations(self, arg0: TracksManager) -> Dict[str, Dict[str, Observation]]: ...
+    def get_valid_observations(
+        self, arg0: TracksManager
+    ) -> Dict[str, Dict[str, Observation]]: ...
     def has_landmark(self, arg0: str) -> bool: ...
     @overload
     def remove_landmark(self, arg0: Landmark) -> None: ...
@@ -203,34 +265,51 @@ class Map:
     def update_pano_shot(self, arg0: Shot) -> Shot: ...
     def update_rig_instance(self, arg0: RigInstance) -> RigInstance: ...
     def update_shot(self, arg0: Shot) -> Shot: ...
+
 class Observation:
-    def __init__(self, x: float, y: float, s: float, r: int, g: int, b: int, feature: int, segmentation: int = -1, instance: int = -1) -> None: ...
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        s: float,
+        r: int,
+        g: int,
+        b: int,
+        feature: int,
+        segmentation: int = -1,
+        instance: int = -1,
+    ) -> None: ...
     def copy(self) -> Observation: ...
     @property
-    def color(self) -> numpy.ndarray:...
+    def color(self) -> numpy.ndarray: ...
     @color.setter
-    def color(self, arg0: numpy.ndarray) -> None:...
+    def color(self, arg0: numpy.ndarray) -> None: ...
+    @property
+    def depth_prior(self) -> Optional[Depth]: ...
+    @depth_prior.setter
+    def depth_prior(self, arg0: Optional[Depth]) -> None: ...
     @property
-    def id(self) -> int:...
+    def id(self) -> int: ...
     @id.setter
-    def id(self, arg0: int) -> None:...
+    def id(self, arg0: int) -> None: ...
     @property
-    def instance(self) -> int:...
+    def instance(self) -> int: ...
     @instance.setter
-    def instance(self, arg0: int) -> None:...
+    def instance(self, arg0: int) -> None: ...
     @property
-    def point(self) -> numpy.ndarray:...
+    def point(self) -> numpy.ndarray: ...
     @point.setter
-    def point(self, arg0: numpy.ndarray) -> None:...
+    def point(self, arg0: numpy.ndarray) -> None: ...
     @property
-    def scale(self) -> float:...
+    def scale(self) -> float: ...
     @scale.setter
-    def scale(self, arg0: float) -> None:...
+    def scale(self, arg0: float) -> None: ...
     @property
-    def segmentation(self) -> int:...
+    def segmentation(self) -> int: ...
     @segmentation.setter
-    def segmentation(self, arg0: int) -> None:...
+    def segmentation(self, arg0: int) -> None: ...
     NO_SEMANTIC_VALUE = -1
+
 class PanoShotView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> Shot: ...
@@ -241,6 +320,7 @@ class PanoShotView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class RigCamera:
     def __getstate__(self) -> tuple: ...
     @overload
@@ -249,13 +329,14 @@ class RigCamera:
     def __init__(self, arg0: opensfm.pygeometry.Pose, arg1: str) -> None: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def pose(self) -> opensfm.pygeometry.Pose:...
+    def pose(self) -> opensfm.pygeometry.Pose: ...
     @pose.setter
-    def pose(self, arg0: opensfm.pygeometry.Pose) -> None:...
+    def pose(self, arg0: opensfm.pygeometry.Pose) -> None: ...
+
 class RigCameraView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> RigCamera: ...
@@ -266,29 +347,35 @@ class RigCameraView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class RigInstance:
     def __init__(self, arg0: str) -> None: ...
     def add_shot(self, arg0: RigCamera, arg1: Shot) -> None: ...
     def keys(self) -> Set[str]: ...
     def remove_shot(self, arg0: str) -> None: ...
-    def update_instance_pose_with_shot(self, arg0: str, arg1: opensfm.pygeometry.Pose) -> None: ...
-    def update_rig_camera_pose(self, arg0: str, arg1: opensfm.pygeometry.Pose) -> None: ...
+    def update_instance_pose_with_shot(
+        self, arg0: str, arg1: opensfm.pygeometry.Pose
+    ) -> None: ...
+    def update_rig_camera_pose(
+        self, arg0: str, arg1: opensfm.pygeometry.Pose
+    ) -> None: ...
     @property
-    def camera_ids(self) -> Dict[str, str]:...
+    def camera_ids(self) -> Dict[str, str]: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def pose(self) -> opensfm.pygeometry.Pose:...
+    def pose(self) -> opensfm.pygeometry.Pose: ...
     @pose.setter
-    def pose(self, arg1: opensfm.pygeometry.Pose) -> None:...
+    def pose(self, arg1: opensfm.pygeometry.Pose) -> None: ...
     @property
-    def rig_camera_ids(self) -> Dict[str, str]:...
+    def rig_camera_ids(self) -> Dict[str, str]: ...
     @property
-    def rig_cameras(self) -> Dict[str, RigCamera]:...
+    def rig_cameras(self) -> Dict[str, RigCamera]: ...
     @property
-    def shots(self) -> Dict[str, Shot]:...
+    def shots(self) -> Dict[str, Shot]: ...
+
 class RigInstanceView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> RigInstance: ...
@@ -299,8 +386,11 @@ class RigInstanceView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class Shot:
-    def __init__(self, arg0: str, arg1: opensfm.pygeometry.Camera, arg2: opensfm.pygeometry.Pose) -> None: ...
+    def __init__(
+        self, arg0: str, arg1: opensfm.pygeometry.Camera, arg2: opensfm.pygeometry.Pose
+    ) -> None: ...
     def bearing(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
     def bearing_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
     def get_landmark_observation(self, arg0: Landmark) -> Observation: ...
@@ -312,85 +402,90 @@ class Shot:
     def remove_observation(self, arg0: int) -> None: ...
     def set_rig(self, arg0: RigInstance, arg1: RigCamera) -> None: ...
     @property
-    def camera(self) -> opensfm.pygeometry.Camera:...
+    def camera(self) -> opensfm.pygeometry.Camera: ...
     @property
-    def covariance(self) -> numpy.ndarray:...
+    def covariance(self) -> numpy.ndarray: ...
     @covariance.setter
-    def covariance(self, arg1: numpy.ndarray) -> None:...
+    def covariance(self, arg1: numpy.ndarray) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @property
-    def merge_cc(self) -> int:...
+    def merge_cc(self) -> int: ...
     @merge_cc.setter
-    def merge_cc(self, arg0: int) -> None:...
+    def merge_cc(self, arg0: int) -> None: ...
     @property
-    def mesh(self) -> ShotMesh:...
+    def mesh(self) -> ShotMesh: ...
     @mesh.setter
-    def mesh(self, arg0: ShotMesh) -> None:...
+    def mesh(self, arg0: ShotMesh) -> None: ...
     @property
-    def metadata(self) -> ShotMeasurements:...
+    def metadata(self) -> ShotMeasurements: ...
     @metadata.setter
-    def metadata(self, arg1: ShotMeasurements) -> None:...
+    def metadata(self, arg1: ShotMeasurements) -> None: ...
     @property
-    def pose(self) -> opensfm.pygeometry.Pose:...
+    def pose(self) -> opensfm.pygeometry.Pose: ...
     @pose.setter
-    def pose(self, arg1: opensfm.pygeometry.Pose) -> None:...
+    def pose(self, arg1: opensfm.pygeometry.Pose) -> None: ...
     @property
-    def rig_camera(self) -> RigCamera:...
+    def rig_camera(self) -> RigCamera: ...
     @property
-    def rig_camera_id(self) -> str:...
+    def rig_camera_id(self) -> str: ...
     @property
-    def rig_instance(self) -> RigInstance:...
+    def rig_instance(self) -> RigInstance: ...
     @property
-    def rig_instance_id(self) -> str:...
+    def rig_instance_id(self) -> str: ...
     @property
-    def scale(self) -> float:...
+    def scale(self) -> float: ...
     @scale.setter
-    def scale(self, arg0: float) -> None:...
+    def scale(self, arg0: float) -> None: ...
+
 class ShotMeasurementDouble:
     def __getstate__(self) -> tuple: ...
     def __init__(self) -> None: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     def reset(self) -> None: ...
     @property
-    def has_value(self) -> bool:...
+    def has_value(self) -> bool: ...
     @property
-    def value(self) -> float:...
+    def value(self) -> float: ...
     @value.setter
-    def value(self, arg1: float) -> None:...
+    def value(self, arg1: float) -> None: ...
+
 class ShotMeasurementInt:
     def __getstate__(self) -> tuple: ...
     def __init__(self) -> None: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     def reset(self) -> None: ...
     @property
-    def has_value(self) -> bool:...
+    def has_value(self) -> bool: ...
     @property
-    def value(self) -> int:...
+    def value(self) -> int: ...
     @value.setter
-    def value(self, arg1: int) -> None:...
+    def value(self, arg1: int) -> None: ...
+
 class ShotMeasurementString:
     def __getstate__(self) -> tuple: ...
     def __init__(self) -> None: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     def reset(self) -> None: ...
     @property
-    def has_value(self) -> bool:...
+    def has_value(self) -> bool: ...
     @property
-    def value(self) -> str:...
+    def value(self) -> str: ...
     @value.setter
-    def value(self, arg1: str) -> None:...
+    def value(self, arg1: str) -> None: ...
+
 class ShotMeasurementVec3d:
     def __getstate__(self) -> tuple: ...
     def __init__(self) -> None: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     def reset(self) -> None: ...
     @property
-    def has_value(self) -> bool:...
+    def has_value(self) -> bool: ...
     @property
-    def value(self) -> numpy.ndarray:...
+    def value(self) -> numpy.ndarray: ...
     @value.setter
-    def value(self, arg1: numpy.ndarray) -> None:...
+    def value(self, arg1: numpy.ndarray) -> None: ...
+
 class ShotMeasurements:
     def __copy__(self) -> ShotMeasurements: ...
     def __getstate__(self) -> tuple: ...
@@ -398,58 +493,60 @@ class ShotMeasurements:
     def __setstate__(self, arg0: tuple) -> None: ...
     def set(self, arg0: ShotMeasurements) -> None: ...
     @property
-    def attributes(self) -> Dict[str, str]:...
+    def attributes(self) -> Dict[str, str]: ...
     @attributes.setter
-    def attributes(self, arg1: Dict[str, str]) -> None:...
+    def attributes(self, arg1: Dict[str, str]) -> None: ...
     @property
-    def capture_time(self) -> ShotMeasurementDouble:...
+    def capture_time(self) -> ShotMeasurementDouble: ...
     @capture_time.setter
-    def capture_time(self, arg0: ShotMeasurementDouble) -> None:...
+    def capture_time(self, arg0: ShotMeasurementDouble) -> None: ...
     @property
-    def compass_accuracy(self) -> ShotMeasurementDouble:...
+    def compass_accuracy(self) -> ShotMeasurementDouble: ...
     @compass_accuracy.setter
-    def compass_accuracy(self, arg0: ShotMeasurementDouble) -> None:...
+    def compass_accuracy(self, arg0: ShotMeasurementDouble) -> None: ...
     @property
-    def compass_angle(self) -> ShotMeasurementDouble:...
+    def compass_angle(self) -> ShotMeasurementDouble: ...
     @compass_angle.setter
-    def compass_angle(self, arg0: ShotMeasurementDouble) -> None:...
+    def compass_angle(self, arg0: ShotMeasurementDouble) -> None: ...
     @property
-    def gps_accuracy(self) -> ShotMeasurementDouble:...
+    def gps_accuracy(self) -> ShotMeasurementDouble: ...
     @gps_accuracy.setter
-    def gps_accuracy(self, arg0: ShotMeasurementDouble) -> None:...
+    def gps_accuracy(self, arg0: ShotMeasurementDouble) -> None: ...
     @property
-    def gps_position(self) -> ShotMeasurementVec3d:...
+    def gps_position(self) -> ShotMeasurementVec3d: ...
     @gps_position.setter
-    def gps_position(self, arg0: ShotMeasurementVec3d) -> None:...
+    def gps_position(self, arg0: ShotMeasurementVec3d) -> None: ...
     @property
-    def gravity_down(self) -> ShotMeasurementVec3d:...
+    def gravity_down(self) -> ShotMeasurementVec3d: ...
     @gravity_down.setter
-    def gravity_down(self, arg0: ShotMeasurementVec3d) -> None:...
+    def gravity_down(self, arg0: ShotMeasurementVec3d) -> None: ...
     @property
-    def opk_accuracy(self) -> ShotMeasurementDouble:...
+    def opk_accuracy(self) -> ShotMeasurementDouble: ...
     @opk_accuracy.setter
-    def opk_accuracy(self, arg0: ShotMeasurementDouble) -> None:...
+    def opk_accuracy(self, arg0: ShotMeasurementDouble) -> None: ...
     @property
-    def opk_angles(self) -> ShotMeasurementVec3d:...
+    def opk_angles(self) -> ShotMeasurementVec3d: ...
     @opk_angles.setter
-    def opk_angles(self, arg0: ShotMeasurementVec3d) -> None:...
+    def opk_angles(self, arg0: ShotMeasurementVec3d) -> None: ...
     @property
-    def orientation(self) -> ShotMeasurementInt:...
+    def orientation(self) -> ShotMeasurementInt: ...
     @orientation.setter
-    def orientation(self, arg0: ShotMeasurementInt) -> None:...
+    def orientation(self, arg0: ShotMeasurementInt) -> None: ...
     @property
-    def sequence_key(self) -> ShotMeasurementString:...
+    def sequence_key(self) -> ShotMeasurementString: ...
     @sequence_key.setter
-    def sequence_key(self, arg0: ShotMeasurementString) -> None:...
+    def sequence_key(self, arg0: ShotMeasurementString) -> None: ...
+
 class ShotMesh:
     @property
-    def faces(self) -> numpy.ndarray:...
+    def faces(self) -> numpy.ndarray: ...
     @faces.setter
-    def faces(self, arg1: numpy.ndarray) -> None:...
+    def faces(self, arg1: numpy.ndarray) -> None: ...
     @property
-    def vertices(self) -> numpy.ndarray:...
+    def vertices(self) -> numpy.ndarray: ...
     @vertices.setter
-    def vertices(self, arg1: numpy.ndarray) -> None:...
+    def vertices(self, arg1: numpy.ndarray) -> None: ...
+
 class ShotView:
     def __contains__(self, arg0: str) -> bool: ...
     def __getitem__(self, arg0: str) -> Shot: ...
@@ -460,13 +557,20 @@ class ShotView:
     def items(self) -> Iterator: ...
     def keys(self) -> Iterator: ...
     def values(self) -> Iterator: ...
+
 class TracksManager:
     def __init__(self) -> None: ...
     def add_observation(self, arg0: str, arg1: str, arg2: Observation) -> None: ...
     def as_string(self) -> str: ...
-    def construct_sub_tracks_manager(self, arg0: List[str], arg1: List[str]) -> TracksManager: ...
-    def get_all_common_observations(self, arg0: str, arg1: str) -> List[Tuple[str, Observation, Observation]]: ...
-    def get_all_pairs_connectivity(self, shots: List[str] = [], tracks: List[str] = []) -> Dict[Tuple[str, str], int]: ...
+    def construct_sub_tracks_manager(
+        self, arg0: List[str], arg1: List[str]
+    ) -> TracksManager: ...
+    def get_all_common_observations(
+        self, arg0: str, arg1: str
+    ) -> List[Tuple[str, Observation, Observation]]: ...
+    def get_all_pairs_connectivity(
+        self, shots: List[str] = [], tracks: List[str] = []
+    ) -> Dict[Tuple[str, str], int]: ...
     def get_observation(self, arg0: str, arg1: str) -> Observation: ...
     def get_shot_ids(self) -> List[str]: ...
     def get_shot_observations(self, arg0: str) -> Dict[str, Observation]: ...
@@ -482,8 +586,9 @@ class TracksManager:
     def num_tracks(self) -> int: ...
     def remove_observation(self, arg0: str, arg1: str) -> None: ...
     def write_to_file(self, arg0: str) -> None: ...
-Angular = ...
-METRICS_ONLY = ...
-Normalized = ...
-OPTIMIZATION = ...
-Pixel = ...
\ No newline at end of file
+
+Angular: "ErrorType"
+METRICS_ONLY: "GroundControlPointRole"
+Normalized: "ErrorType"
+OPTIMIZATION: "GroundControlPointRole"
+Pixel: "ErrorType"
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index 207fa4066..fcc0209ec 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -64,6 +64,16 @@ PYBIND11_MODULE(pymap, m) {
       .value("Angular", map::Map::Angular)
       .export_values();
 
+  py::class_<map::Depth>(m, "Depth")
+      .def(py::init<double, bool, double>(),
+           py::arg("value"),
+           py::arg("is_radial"),
+           py::arg("std_deviation"))
+      .def_readwrite("value",
+                     &map::Depth::value)
+      .def_readwrite("is_radial", &map::Depth::is_radial)
+      .def_readwrite("std_deviation", &map::Depth::std_deviation);
+
   py::class_<map::Observation>(m, "Observation")
       .def(py::init<double, double, double, int, int, int, int, int, int>(),
            py::arg("x"), py::arg("y"), py::arg("s"), py::arg("r"), py::arg("g"),
@@ -76,6 +86,7 @@ PYBIND11_MODULE(pymap, m) {
       .def_readwrite("color", &map::Observation::color)
       .def_readwrite("segmentation", &map::Observation::segmentation_id)
       .def_readwrite("instance", &map::Observation::instance_id)
+      .def_readwrite("depth_prior", &map::Observation::depth_prior)
       .def_readonly_static("NO_SEMANTIC_VALUE",
                            &map::Observation::NO_SEMANTIC_VALUE)
       .def(
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 82d550e9f..a92819bd8 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -236,7 +236,7 @@ py::tuple BAHelpers::BundleLocal(
       }
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_, obs.point,
-                                       obs.scale);
+                                       obs.scale, obs.depth_prior);
       ++added_reprojections;
     }
   }
@@ -246,7 +246,7 @@ py::tuple BAHelpers::BundleLocal(
       if (points.count(lm) > 0) {
         const auto& obs = lm_obs.second;
         ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_,
-                                         obs.point, obs.scale);
+                                         obs.point, obs.scale, obs.depth_prior);
         ++added_reprojections;
       }
     }
@@ -533,7 +533,7 @@ py::dict BAHelpers::BundleShotPoses(
     for (const auto& lm_obs : shot.GetLandmarkObservations()) {
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot.id_, lm_obs.first->id_, obs.point,
-                                       obs.scale);
+                                       obs.scale, obs.depth_prior);
     }
   }
 
@@ -711,7 +711,7 @@ py::dict BAHelpers::Bundle(
     for (const auto& lm_obs : shot.GetLandmarkObservations()) {
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot.id_, lm_obs.first->id_, obs.point,
-                                       obs.scale);
+                                       obs.scale, obs.depth_prior);
       ++added_reprojections;
     }
   }
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index d3d499560..8e795a82b 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -227,12 +227,28 @@ def test_pair_with_points_priors(bundle_adjuster: pybundle.BundleAdjuster) -> No
     )
 
     std_dev = np.array([1, 1, 1])
-    sa.add_point_projection_observation("1", "p1", np.array([0, 0]), 1)
-    sa.add_point_projection_observation("2", "p1", np.array([-0.5, 0]), 1)
+    sa.add_point_projection_observation(
+        shot="1", 
+        point="p1",
+        observation=np.array([0, 0]),
+        std_deviation=1)
+    sa.add_point_projection_observation(
+        shot="2",
+        point="p1",
+        observation=np.array([-0.5, 0]),
+        std_deviation=1)
     sa.add_point_prior("p1", np.array([-0.5, 2, 2]), std_dev, True)
 
-    sa.add_point_projection_observation("2", "p2", np.array([0, 0]), 1)
-    sa.add_point_projection_observation("1", "p2", np.array([0.5, 0]), 1)
+    sa.add_point_projection_observation(
+        shot="2",
+        point="p2",
+        observation=np.array([0, 0]),
+        std_deviation=1)
+    sa.add_point_projection_observation(
+        shot="1",
+        point="p2",
+        observation=np.array([0.5, 0]),
+        std_deviation=1)
     sa.add_point_prior("p2", np.array([1.5, 2, 2]), std_dev, True)
 
     sa.run()

From 9fb05967245ab69aa61749c2d8ad0bc1ae5e2c41 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Wed, 20 Nov 2024 15:23:43 -0800
Subject: [PATCH 100/235] hook up opensfm.reconstructor and depth_anything_v2

Summary:
This diff adds a depth prior to several "observation/feature" data structs. These fields are populated by the depth value read from respective pixels of the Depth-Anything-V2-estimated depth maps.

These depth priors are eventually used in OpenSfM as an additional constraint in BA. It can produce a map with absolute scale. It can also be helpful for scale drift.

Reviewed By: YanNoun

Differential Revision: D66050326

fbshipit-source-id: 4fd32a11cc5424a30b683934ee24f770b98e54b2
---
 opensfm/actions/create_tracks.py          |  5 +++-
 opensfm/config.py                         |  8 +++++++
 opensfm/features.py                       |  3 +++
 opensfm/src/bundle/src/bundle_adjuster.cc |  3 +++
 opensfm/tracking.py                       | 28 +++++++++++++++++++++--
 5 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/opensfm/actions/create_tracks.py b/opensfm/actions/create_tracks.py
index 1a0db6e4f..86fac805b 100644
--- a/opensfm/actions/create_tracks.py
+++ b/opensfm/actions/create_tracks.py
@@ -10,7 +10,7 @@ def run_dataset(data: DataSetBase) -> None:
     """Link matches pair-wise matches into tracks."""
 
     start = timer()
-    features, colors, segmentations, instances = tracking.load_features(
+    features, colors, segmentations, instances, depths = tracking.load_features(
         data, data.images()
     )
     features_end = timer()
@@ -23,6 +23,9 @@ def run_dataset(data: DataSetBase) -> None:
         instances,
         matches,
         data.config["min_track_length"],
+        depths,
+        data.config["depth_is_radial"],
+        data.config["depth_std_deviation_m_default"],
     )
     tracks_end = timer()
     data.save_tracks_manager(tracks_manager)
diff --git a/opensfm/config.py b/opensfm/config.py
index d19591333..4b2e5e4d9 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -217,6 +217,14 @@ class OpenSfMConfig:
     ##################################
     # Minimum number of features/images per track
     min_track_length: int = 2
+    # Whether use depth prior during BA
+    use_depth_prior: bool = False
+    # Depth prior default std deviation
+    depth_std_deviation_m_default: float = 1.0
+    # Whether depth is radial (distance to camera center) or Z value
+    depth_is_radial: bool = False
+    # Whether depth is stored as inverted depth
+    depth_is_inverted: bool = False
 
     ##################################
     # Params for bundle adjustment
diff --git a/opensfm/features.py b/opensfm/features.py
index 15af8700f..735494e46 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -51,6 +51,7 @@ class FeaturesData:
     descriptors: Optional[np.ndarray]
     colors: np.ndarray
     semantic: Optional[SemanticData]
+    depths: np.ndarray | None  # New field. This field is not serialized yet
 
     FEATURES_VERSION: int = 3
     FEATURES_HEADER: str = "OPENSFM_FEATURES_VERSION"
@@ -61,11 +62,13 @@ def __init__(
         descriptors: Optional[np.ndarray],
         colors: np.ndarray,
         semantic: Optional[SemanticData],
+        depths: np.ndarray | None = None,
     ):
         self.points = points
         self.descriptors = descriptors
         self.colors = colors
         self.semantic = semantic
+        self.depths = depths
 
     def get_segmentation(self) -> Optional[np.ndarray]:
         semantic = self.semantic
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 31c525168..1e6575f95 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -507,6 +507,9 @@ struct AddRelativeDepthError {
       return;
     }
     const auto& depth = obs.depth_prior.value();
+    if (!ceres::isfinite(depth.value)) {
+      throw std::runtime_error(obs.shot->GetID() + " has non-finite depth prior");
+    }
 
     const bool is_rig_camera_useful =
         IsRigCameraUseful(*obs.shot->GetRigCamera());
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index eb897855d..6c16eafaa 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -20,12 +20,14 @@ def load_features(
     t.Dict[str, np.ndarray],
     t.Dict[str, np.ndarray],
     t.Dict[str, np.ndarray],
+    t.Dict[str, np.ndarray],
 ]:
     logging.info("reading features")
     features = {}
     colors = {}
     segmentations = {}
     instances = {}
+    depths = {}
     for im in images:
         features_data = dataset.load_features(im)
 
@@ -41,7 +43,11 @@ def load_features(
             if semantic_data.has_instances():
                 instances[im] = semantic_data.instances
 
-    return features, colors, segmentations, instances
+        depth_data = features_data.depths
+        if depth_data is not None:
+            depths[im] = depth_data
+
+    return features, colors, segmentations, instances, depths
 
 
 def load_matches(
@@ -66,6 +72,9 @@ def create_tracks_manager(
     instances: t.Dict[str, np.ndarray],
     matches: t.Dict[t.Tuple[str, str], t.List[t.Tuple[int, int]]],
     min_length: int,
+    depths: t.Dict[str, np.ndarray],
+    depth_is_radial: bool = True,
+    depth_std_deviation: float = 1.0,
 ) -> TracksManager:
     """Link matches into tracks."""
     logger.debug("Merging features onto tracks")
@@ -83,10 +92,11 @@ def create_tracks_manager(
             sets[p] = [i]
 
     tracks = [t for t in sets.values() if _good_track(t, min_length)]
-    logger.debug("Good tracks: {}".format(len(tracks)))
 
     NO_VALUE = pymap.Observation.NO_SEMANTIC_VALUE
     tracks_manager = pymap.TracksManager()
+    num_observations = 0
+    num_depth_priors = 0
     for track_id, track in enumerate(tracks):
         for image, featureid in track:
             if image not in features:
@@ -104,7 +114,21 @@ def create_tracks_manager(
                 #  `Union[ndarray[typing.Any, typing.Any], int]`.
                 x, y, s, int(r), int(g), int(b), featureid, segmentation, instance
             )
+            if image in depths:
+                depth_value = depths[image][featureid]
+                if not np.isnan(depth_value) and not np.isinf(depth_value):
+                    std = max(depth_std_deviation * depth_value, depth_std_deviation)  # pyre-ignore
+                    obs.depth_prior = pymap.Depth(
+                        value=depth_value,   # pyre-ignore
+                        std_deviation=std,
+                        is_radial=depth_is_radial,
+                    )
+                    num_depth_priors += 1
             tracks_manager.add_observation(image, str(track_id), obs)
+            num_observations += 1
+    logger.info(
+        f"{len(tracks)} tracks, {num_observations} observations,"
+        f" {num_depth_priors} depth priors added to TracksManager")
     return tracks_manager
 
 

From b72eb60ea132f02f98bd2b6d025234950cddb5c0 Mon Sep 17 00:00:00 2001
From: Michael Waechter <nightwatch@meta.com>
Date: Wed, 20 Nov 2024 19:31:43 -0800
Subject: [PATCH 101/235] Follow-up of D66050326

Summary: TSIA

Differential Revision: D66276788

fbshipit-source-id: 0d2594a69c45f80c956ccad202c92cb033df82ff
---
 opensfm/config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 4b2e5e4d9..47b26c5a6 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -217,7 +217,7 @@ class OpenSfMConfig:
     ##################################
     # Minimum number of features/images per track
     min_track_length: int = 2
-    # Whether use depth prior during BA
+    # Whether to use depth prior during BA
     use_depth_prior: bool = False
     # Depth prior default std deviation
     depth_std_deviation_m_default: float = 1.0

From 8851196b51802cf13b7bdf50b1b43bf3608b9b55 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Tue, 18 Feb 2025 19:37:01 -0800
Subject: [PATCH 102/235] Add logging to opensfm.reconstructor

Summary: Some useful logs to help debug

Reviewed By: hemanthkorrapati

Differential Revision: D69820525

fbshipit-source-id: 08be619cd5ccd5b53b8d61fbfa8f17845106b520
---
 opensfm/reconstruction.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 1c07b9f62..3f59e2319 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1604,6 +1604,7 @@ def incremental_reconstruction(
 
     remaining_images = set(images)
     gcp = data.load_ground_control_points()
+    logger.info(f"Loaded {len(gcp)} ground control points.")
     common_tracks = tracking.all_common_tracks_with_features(tracks_manager)
     reconstructions = []
     pairs = compute_image_pairs(common_tracks, data)

From 9bb07a42bc1b4ac8babdc89381dc37891d124daa Mon Sep 17 00:00:00 2001
From: Yilei Yang <yilei@meta.com>
Date: Wed, 2 Apr 2025 16:48:49 -0700
Subject: [PATCH 103/235] Migrate (str Enum) classes to StrEnum310.

Summary:
This preserves these enum's __format__ behavior when upgrading from 3.10 to 3.12.

See [our wiki](https://www.internalfb.com/wiki/Python/Upgrades/3.12/#str-enum-classes-inherit) for more information.

This diff was generated by searching usages, filtering out directories that have been on 3.12, and:

```
buck run fbcode//python/libcst:libcst -- codemod py310_str_enum.Py310StrEnumCommand [FILES...]
pyautotargets [FILES...]
```

Then manually reverted unrelated build dependency changes (`autodeps[12]` could gain a `--restrict_to_dep=//python/migrations/py310:py310` flag, that would be extremely useful for LSCs.)

Reviewed By: itamaro

Differential Revision: D72268822

fbshipit-source-id: 14d025fcf29aa27ea5f542504607af1b80fd87ff
---
 opensfm/reconstruction.py | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 3f59e2319..919e1b5f4 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -2,7 +2,6 @@
 """Incremental reconstruction pipeline"""
 
 import datetime
-import enum
 import logging
 import math
 from abc import ABC, abstractmethod
@@ -29,12 +28,13 @@
 from opensfm.align import align_reconstruction, apply_similarity
 from opensfm.context import current_memory_usage, parallel_map
 from opensfm.dataset_base import DataSetBase
+from python.migrations.py310 import StrEnum310
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-class ReconstructionAlgorithm(str, enum.Enum):
+class ReconstructionAlgorithm(StrEnum310):
     INCREMENTAL = "incremental"
     TRIANGULATION = "triangulation"
 
@@ -51,15 +51,20 @@ def _get_camera_from_bundle(
 def log_bundle_stats(bundle_type: str, bundle_report: Dict[str, Any]) -> None:
     times = bundle_report["wall_times"]
     time_secs = times["run"] + times["setup"] + times["teardown"]
-    num_images, num_points, num_reprojections = bundle_report["num_images"], bundle_report["num_points"], bundle_report["num_reprojections"]
+    num_images, num_points, num_reprojections = (
+        bundle_report["num_images"],
+        bundle_report["num_points"],
+        bundle_report["num_reprojections"],
+    )
 
     msg = f"Ran {bundle_type} bundle in {time_secs:.2f} secs."
-    if num_points > 0 :
+    if num_points > 0:
         msg += f"with {num_images}/{num_points}/{num_reprojections} ({num_reprojections/num_points:.2f}) "
         msg += "shots/points/proj. (avg. length)"
 
     logger.info(msg)
 
+
 def bundle(
     reconstruction: types.Reconstruction,
     camera_priors: Dict[str, pygeometry.Camera],
@@ -596,9 +601,9 @@ def reconstruction_from_relative_pose(
 
     retriangulate(tracks_manager, reconstruction, data.config)
     if len(reconstruction.points) < min_inliers:
-        report[
-            "decision"
-        ] = "Re-triangulation after initial motion did not generate enough points"
+        report["decision"] = (
+            "Re-triangulation after initial motion did not generate enough points"
+        )
         logger.info(report["decision"])
         return None, report
 
@@ -1299,7 +1304,7 @@ def merge_reconstructions(
     reconstructions_merged = []
     num_merge = 0
 
-    for (i, j) in combinations(ids_reconstructions, 2):
+    for i, j in combinations(ids_reconstructions, 2):
         if (i in remaining_reconstruction) and (j in remaining_reconstruction):
             r = merge_two_reconstructions(
                 reconstructions[i], reconstructions[j], config

From 64b57d3b73ddfaf720944743e75327f76b69c879 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Fri, 4 Apr 2025 11:59:46 -0700
Subject: [PATCH 104/235] Do not triangulate when the origin overlap

Summary:
When two cameras have the same origin, triangulation is ill-posed, so we skip it.

meta-only:

In f716010762, opensfm throws a lot of ceres error about residual being nan.

```
Error in evaluating the ResidualBlock.
There are two possible reasons. Either the CostFunction did not evaluate and fill all
residual and jacobians that were requested or there was a non-finite value (nan/infinite)
generated during the or jacobian computation.
Residual Block size: 4 parameter blocks x 2 residuals
For each parameter block, the value of the parameters are printed in the first column
and the value of the jacobian under the corresponding residual. If a ParameterBlock was
held constant then the corresponding jacobian is printed as 'Not Computed'. If an entry
of the Jacobian/residual array was requested but was not written to by user code, it is
indicated by 'Uninitialized'. This is an error. Residuals or Jacobian values evaluating
to Inf or NaN is also an error.
Residuals:             -nan         -nan
Parameter Block 0, size: 8

   -0.100745 | Not Computed  Not Computed
   0.0387447 | Not Computed  Not Computed
 -0.00785474 | Not Computed  Not Computed
 0.000935679 | Not Computed  Not Computed
    0.370036 | Not Computed  Not Computed
     1.00776 | Not Computed  Not Computed
 -0.00029014 | Not Computed  Not Computed
-0.000430234 | Not Computed  Not Computed
Parameter Block 1, size: 6

    -1.17687 |         -nan         -nan
    -1.15541 |         -nan         -nan
     1.17687 |         -nan         -nan
          -0 |         -nan         -nan
           0 |         -nan         -nan
           0 |         -nan         -nan
Parameter Block 2, size: 6

           0 | Not Computed  Not Computed
     -1.5708 | Not Computed  Not Computed
           0 | Not Computed  Not Computed
          -0 | Not Computed  Not Computed
           0 | Not Computed  Not Computed
           0 | Not Computed  Not Computed
Parameter Block 3, size: 3

           0 |         -nan         -nan
           0 |         -nan         -nan
           0 |         -nan         -nan
```

This is because the data used in this experiment is in rigs. Each rig has two cameras, facing back to back, sharing identical origin (camera center).

When there is a track that has observations in both images in the same rig, there is a problem. The point will be triangulated at [0,0,0] because that's the only place that can fulfill the two bearing vectors. Currently that is labeled as a valid solution.

With the ceres errors, BAs are effectively not run and the map is simply an unoptimized result of the resections

{F1976773050}

This diff avoids triangulating when the camera centers are the same point, thus avoiding the ceres nan errors.

Differential Revision: D72404151

fbshipit-source-id: 856f2cda3c92cbeda29085a991d37947fd3b2663
---
 opensfm/reconstruction.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 919e1b5f4..52398dba9 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1022,6 +1022,13 @@ def triangulate(
             ids.append(shot_id)
 
         if len(os) >= 2:
+            
+            # Check if all the origins are at the same point. In such a case,
+            # the triangulation will degenerate to pure rotation and the
+            # triangulated point will always be invalid or at [0, 0, 0].
+            if all(np.allclose(os[i], os[0]) for i in range(1, len(os))):
+                return
+
             thresholds = len(os) * [reproj_threshold]
             min_ray_angle_radians = np.radians(min_ray_angle_degrees)
             valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
@@ -1035,6 +1042,12 @@ def triangulate(
                 X = pygeometry.point_refinement(
                     np.array(os), np.array(bs), X, iterations
                 )
+                if np.allclose(X, [0, 0, 0]):
+                    logger.warning(
+                        f"Detected potentially problematic triangulated point: "
+                        f"{X.tolist()} {os=} {bs=} {ids=}. It can be caused by "
+                        "identical origin points (pure rotation)."
+                    )
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
                     self.tracks_handler.store_inliers_observation(track, shot_id)

From 4386bf362dd2e394c144340af13bfdf6da06ba12 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 105/235] Add test case for triangulation with coincident
 camera origins

Summary: Just adding a test for the problem fixed in the previous diff. When we triangulate using cameras with coincident cameras, we expect triangulation to fail.

Reviewed By: YanNoun

Differential Revision: D72550226

fbshipit-source-id: 0c9d1bac64bdf5cb39289fd1a558430fa651bb91
---
 opensfm/test/test_triangulation.py | 49 ++++++++++++++++++++++++++++--
 1 file changed, 46 insertions(+), 3 deletions(-)

diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index ee9f8ceaf..21d2d623f 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -31,8 +31,8 @@ def test_track_triangulator_spherical() -> None:
                 },
                 "im2": {
                     "camera": "theta",
-                    "rotation": [0, 0, 0.0],
-                    "translation": [-1, 0, 0.0],
+                    "rotation": [0.0, 0.0, 0.0],
+                    "translation": [-1.0, 0.0, 0.0],
                 },
             },
             "points": {},
@@ -42,13 +42,56 @@ def test_track_triangulator_spherical() -> None:
     triangulator = reconstruction.TrackTriangulator(
         rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
     )
-    triangulator.triangulate("1", 0.01, 2.0, 10)
+    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, iterations=10)
     assert "1" in rec.points
     p = rec.points["1"].coordinates
     assert np.allclose(p, [0, 0, 1.3763819204711])
     assert len(rec.points["1"].get_observations()) == 2
 
 
+def test_track_triangulator_coincident_camera_origins() -> None:
+    """Test triangulating tracks when two cameras have the same origin.
+    
+    Triangulation should fail and no points should be added to the reconstruction.
+    """
+    tracks_manager = pymap.TracksManager()
+    tracks_manager.add_observation("im1", "1", pymap.Observation(0, 0, 1.0, 0, 0, 0, 0))
+    tracks_manager.add_observation(
+        "im2", "1", pymap.Observation(-0.1, 0, 1.0, 0, 0, 0, 1)
+    )
+
+    rec = io.reconstruction_from_json(
+        {
+            "cameras": {
+                "theta": {
+                    "projection_type": "spherical",
+                    "width": 800,
+                    "height": 400,
+                }
+            },
+            "shots": {
+                "im1": {
+                    "camera": "theta",
+                    "rotation": [0.0, 0.0, 0.0],
+                    "translation": [0.0, 0.0, 0.0],
+                },
+                "im2": {
+                    "camera": "theta",
+                    "rotation": [0.0, 0.0, 0.0],
+                    "translation": [0.0, 0.0, 0.0],
+                },
+            },
+            "points": {},
+        }
+    )
+
+    triangulator = reconstruction.TrackTriangulator(
+        rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
+    )
+    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, iterations=10)
+    assert not rec.points
+
+
 def unit_vector(x: object) -> np.ndarray:
     # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     return np.array(x) / np.linalg.norm(x)

From 243874bb4a59b4636c4c10b5032f78950871d65c Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 106/235] Add tests to cpp triangulation

Summary: These functions were tested only through the python wrappers in `test_triangulation.py`. Here we are adding c++ tests so that we can easierly modify the functions in the future.

Reviewed By: YanNoun

Differential Revision: D72550230

fbshipit-source-id: 2433f808edbee01cdbfa70621f71213276699638
---
 opensfm/src/geometry/CMakeLists.txt           |   1 +
 opensfm/src/geometry/src/triangulation.cc     |  18 +-
 .../src/geometry/test/triangulation_test.cc   | 217 ++++++++++++++++++
 opensfm/src/geometry/triangulation.h          |  11 +-
 4 files changed, 231 insertions(+), 16 deletions(-)
 create mode 100644 opensfm/src/geometry/test/triangulation_test.cc

diff --git a/opensfm/src/geometry/CMakeLists.txt b/opensfm/src/geometry/CMakeLists.txt
index e6dda2c26..32864dddd 100644
--- a/opensfm/src/geometry/CMakeLists.txt
+++ b/opensfm/src/geometry/CMakeLists.txt
@@ -32,6 +32,7 @@ if (OPENSFM_BUILD_TESTS)
         test/camera_functions_test.cc
         test/covariance_test.cc
         test/point_test.cc
+        test/triangulation_test.cc
         )
     add_executable(geometry_test ${GEOMETRY_TEST_FILES})
     target_include_directories(geometry_test PRIVATE ${CMAKE_SOURCE_DIR})
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index be15dfd4b..81e38656e 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -132,28 +132,28 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
   return std::make_pair(true, X.head<3>());
 }
 
-Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>
+Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
 EpipolarAngleTwoBearingsMany(
-    const Eigen::Matrix<float, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<float, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3f &rotation, const Eigen::Vector3f &translation) {
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
+    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation) {
   const auto translation_normalized = translation.normalized();
   const auto bearings2_world = bearings2 * rotation.transpose();
 
   const auto count1 = bearings1.rows();
-  Eigen::Matrix<float, Eigen::Dynamic, 3> epi1(count1, 3);
+  Eigen::Matrix<double, Eigen::Dynamic, 3> epi1(count1, 3);
   for (int i = 0; i < count1; ++i) {
-    const Vec3f bearing = bearings1.row(i);
+    const Vec3d bearing = bearings1.row(i);
     epi1.row(i) = translation_normalized.cross(bearing).normalized();
   }
   const auto count2 = bearings2.rows();
-  Eigen::Matrix<float, Eigen::Dynamic, 3> epi2(count2, 3);
+  Eigen::Matrix<double, Eigen::Dynamic, 3> epi2(count2, 3);
   for (int i = 0; i < count2; ++i) {
-    const Vec3f bearing = bearings2_world.row(i);
+    const Vec3d bearing = bearings2_world.row(i);
     epi2.row(i) = translation_normalized.cross(bearing).normalized();
   }
 
-  Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> symmetric_epi =
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> symmetric_epi =
       (((epi1 * bearings2_world.transpose()).array().abs() +
         (bearings1 * epi2.transpose()).array().abs()) /
        2.0);
diff --git a/opensfm/src/geometry/test/triangulation_test.cc b/opensfm/src/geometry/test/triangulation_test.cc
new file mode 100644
index 000000000..966a739f1
--- /dev/null
+++ b/opensfm/src/geometry/test/triangulation_test.cc
@@ -0,0 +1,217 @@
+#include <geometry/triangulation.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <Eigen/Dense>
+
+
+MatX3d generateNoisyBearings(const MatX3d &bearings, double maxNoise) {
+  MatX3d bearings_noisy = MatX3d::Zero(bearings.rows(), 3);
+  for (int i = 0; i < bearings.rows(); ++i) {
+    const Vec3d bearing = bearings.row(i);
+    const Vec3d noise = maxNoise * Vec3d::Random();
+    bearings_noisy.row(i) = (bearing + noise).normalized();
+  }
+  return bearings_noisy;
+}
+
+std::vector<Mat34d> generateRts(const MatX3d &centers) {
+  const int num_cameras = centers.rows();
+  std::vector<Mat34d> Rts(num_cameras);
+  for (int i = 0; i < num_cameras; ++i) {
+    const Vec3d center = centers.row(i);
+    Rts[i] << 1.0, 0.0, 0.0, -center(0),
+              0.0, 1.0, 0.0, -center(1),
+              0.0, 0.0, 1.0, -center(2);
+  }
+  return Rts;
+}
+
+void generate_triangulation_data(
+    const MatX3d &centers,
+    MatX3d &bearings,
+    MatX3d &bearings_noisy,
+    std::vector<Mat34d> &Rts,
+    Vec3d& gt_point) {
+  const int num_cameras = centers.rows();
+
+  gt_point = Vec3d(0.0, 0.0, 1.0);
+
+  bearings = MatX3d::Zero(num_cameras, 3);
+  for (int i = 0; i < num_cameras; ++i) {
+    const Vec3d center = centers.row(i);
+    bearings.row(i) = (gt_point - center).normalized();
+  }
+
+  bearings_noisy = generateNoisyBearings(bearings, 0.001);
+
+  Rts = generateRts(centers);
+}
+    
+class TwoCamsFixture : public ::testing::Test {
+ public:
+  TwoCamsFixture() {
+    centers = MatX3d::Zero(2, 3);
+    centers << 0.0, 0.0, 0.0,
+              1.0, 0.0, 0.0;
+  
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);
+  }
+  
+  Vec3d gt_point;
+  MatX3d centers;
+  MatX3d bearings;
+  MatX3d bearings_noisy;
+  std::vector<Mat34d> Rts;
+
+  const double threshold = 0.01;
+  const std::vector<double> thresholds = {0.01, 0.01};
+  const double min_angle = 2.0 * M_PI / 180.0;
+  const double max_angle = M_PI - min_angle;
+};
+
+class FiveCamsFixture : public ::testing::Test {
+ public:
+  FiveCamsFixture() {
+    const int num_cameras = 5;
+    centers = MatX3d::Zero(num_cameras, 3);
+    for (int i = 0; i < num_cameras; ++i) {
+      centers.row(i) << 0.5 * i / num_cameras, 0.1 * i / num_cameras, 0.0;
+    }
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);    
+  }
+
+  Vec3d gt_point;
+  MatX3d centers;
+  MatX3d bearings;
+  MatX3d bearings_noisy;
+  std::vector<Mat34d> Rts;
+
+  const double threshold = 0.01;
+  const std::vector<double> thresholds = {0.01, 0.01, 0.01, 0.01, 0.01};
+  const double min_angle = 2.0 * M_PI / 180.0;
+  const double max_angle = M_PI - min_angle;
+};
+
+class TwoCamsManyPointsFixture : public ::testing::Test {
+ public:
+  TwoCamsManyPointsFixture() {
+    gt_points.emplace_back(0.0, 0.0, 1.0);
+    gt_points.emplace_back(1.0, 2.0, 3.0);
+    
+    rotation_1_2 = Eigen::AngleAxisd(0.1, Vec3d::UnitY()).toRotationMatrix();
+    translation_1_2 << -1.0, 2.0, 0.2;
+
+    bearings1 = MatX3d(gt_points.size(), 3);
+    bearings2 = MatX3d(gt_points.size(), 3);
+    for (int i = 0; i < gt_points.size(); ++i) {
+      const Vec3d &gt_point = gt_points[i];
+      bearings1.row(i) = gt_point.normalized();
+      bearings2.row(i) = (rotation_1_2.transpose() * (gt_point - translation_1_2)).normalized();
+    }
+
+    bearings1_noisy = generateNoisyBearings(bearings1, 0.001);
+    bearings2_noisy = generateNoisyBearings(bearings2, 0.001);
+  }
+
+  std::vector<Vec3d> gt_points;
+  Mat3d rotation_1_2;
+  Vec3d translation_1_2;
+  MatX3d bearings1;
+  MatX3d bearings2;
+  MatX3d bearings1_noisy;
+  MatX3d bearings2_noisy;
+};
+
+
+TEST_F(TwoCamsFixture, TriangulateBearingsDLT) {
+  const auto [success, point] = geometry::TriangulateBearingsDLT(
+      Rts, bearings, threshold, min_angle);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
+      Rts, bearings_noisy, threshold, min_angle);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+TEST_F(FiveCamsFixture, TriangulateBearingsDLT) {
+  const auto [success, point] = geometry::TriangulateBearingsDLT(
+      Rts, bearings, threshold, min_angle);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
+      Rts, bearings_noisy, threshold, min_angle);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+TEST_F(TwoCamsFixture, TriangulateBearingsMidpoint) {
+  const auto [success, point] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings_noisy, thresholds, min_angle, max_angle);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+TEST_F(FiveCamsFixture, TriangulateBearingsMidpoint) {
+  const auto [success, point] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings_noisy, thresholds, min_angle, max_angle);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+
+TEST_F(TwoCamsManyPointsFixture, TriangulateTwoBearingsMidpointMany) {
+  const auto results = geometry::TriangulateTwoBearingsMidpointMany(
+      bearings1, bearings2, rotation_1_2, translation_1_2);
+
+  for (int i = 0; i < gt_points.size(); ++i) {
+    const auto [success, point] = results[i];
+    ASSERT_TRUE(success);
+    ASSERT_LT((point - gt_points[i]).norm(), 1e-6);
+  }
+
+  const auto results_noisy = geometry::TriangulateTwoBearingsMidpointMany(
+      bearings1_noisy, bearings2_noisy, rotation_1_2, translation_1_2);
+
+  for (int i = 0; i < gt_points.size(); ++i) {
+    const auto [success, point] = results_noisy[i];
+    ASSERT_TRUE(success);
+    ASSERT_LT((point - gt_points[i]).norm(), 0.01);
+  }
+}
+
+
+TEST_F(TwoCamsManyPointsFixture, EpipolarAngleTwoBearingsMany) {
+  MatXd angles = geometry::EpipolarAngleTwoBearingsMany(
+      bearings1, bearings2, rotation_1_2, translation_1_2);
+  ASSERT_EQ(angles.rows(), gt_points.size());
+  ASSERT_EQ(angles.cols(), gt_points.size());
+  for (int i = 0; i < gt_points.size(); ++i) {
+    for (int j = 0; j < gt_points.size(); ++j) {
+      if (i == j) {
+        ASSERT_LT(angles(i, j), 1e-6);
+      } else {
+        ASSERT_GT(angles(i, j), 1e-6);
+      }
+    }
+  }
+}
+
+TEST_F(TwoCamsFixture, PointRefinement) {
+  const Vec3d initial_point = gt_point + Vec3d(0.1, 0.2, 0.3);
+  const Vec3d refined = geometry::PointRefinement(centers, bearings, initial_point, 10);
+  ASSERT_LT((refined - gt_point).norm(), 1e-6);
+}
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index 325885157..b678e9a8f 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -6,9 +6,6 @@
 #include <Eigen/QR>
 #include <Eigen/SVD>
 #include <Eigen/StdVector>
-#include <fstream>
-#include <iostream>
-#include <string>
 
 double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v);
 
@@ -95,11 +92,11 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
     const std::vector<double> &threshold_list,
     double min_angle, double max_angle);
 
-Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>
+Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
 EpipolarAngleTwoBearingsMany(
-    const Eigen::Matrix<float, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<float, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3f &rotation, const Eigen::Vector3f &translation);
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
+    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
 
 Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
                       const Vec3d &point, int iterations);

From ae36d3a3262c043f701dee3f38926988ceed7560 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 107/235] Reorder triangulation functions

Summary: Just reordering the functions for the header to be more understandable. No functionality change.

Reviewed By: YanNoun

Differential Revision: D72550228

fbshipit-source-id: 9b6bdb82243c9cbcb20e294b0489df38e4c6d10c
---
 opensfm/src/geometry/src/triangulation.cc | 174 +++++++++++-----------
 opensfm/src/geometry/triangulation.h      |  70 +++++----
 2 files changed, 130 insertions(+), 114 deletions(-)

diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 81e38656e..d61fc4028 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -7,6 +7,8 @@
 #include <geometry/triangulation.h>
 #include <cmath>
 
+namespace {
+
 double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v) {
   double c = (u.dot(v)) / sqrt(u.dot(u) * v.dot(v));
   if (std::fabs(c) >= 1.0) {
@@ -16,28 +18,59 @@ double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v) {
   }
 }
 
-Eigen::Vector4d TriangulateBearingsDLTSolve(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts) {
-  const int nviews = bearings.rows();
-  assert(nviews == Rts.size());
+struct BearingErrorCost : public ceres::CostFunction {
+  constexpr static int Size = 3;
 
-  Eigen::MatrixXd A(2 * nviews, 4);
-  for (int i = 0; i < nviews; i++) {
-    A.row(2 * i) =
-        bearings(i, 0) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(0);
-    A.row(2 * i + 1) =
-        bearings(i, 1) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(1);
+  BearingErrorCost(const MatX3d &centers, const MatX3d &bearings,
+                   const Vec3d &point)
+      : centers_(centers), bearings_(bearings), point_(point) {
+    mutable_parameter_block_sizes()->push_back(Size);
+    set_num_residuals(bearings_.rows() * 3);
   }
+  bool Evaluate(double const *const *parameters, double *residuals,
+                double **jacobians) const override {
+    const double *point = parameters[0];
+    for (int i = 0; i < bearings_.rows(); ++i) {
+      const Vec3d &center = centers_.row(i);
+      const Vec3d &bearing = bearings_.row(i);
 
-  Eigen::JacobiSVD<Eigen::MatrixXd> mySVD(A, Eigen::ComputeFullV);
-  Eigen::Vector4d worldPoint;
-  worldPoint[0] = mySVD.matrixV()(0, 3);
-  worldPoint[1] = mySVD.matrixV()(1, 3);
-  worldPoint[2] = mySVD.matrixV()(2, 3);
-  worldPoint[3] = mySVD.matrixV()(3, 3);
+      /* Error only */
+      double *dummy = nullptr;
+      double projected[] = {point[0] - center(0), point[1] - center(1),
+                            point[2] - center(2)};
+      if (!jacobians) {
+        geometry::Normalize::Forward(&projected[0], dummy, &projected[0]);
+      } else {
+        constexpr int JacobianSize = Size * Size;
+        double jacobian[JacobianSize];
+        geometry::Normalize::ForwardDerivatives<double, true>(
+            &projected[0], dummy, &projected[0], &jacobian[0]);
+        double *jac_point = jacobians[0];
+        if (jac_point) {
+          for (int j = 0; j < Size; ++j) {
+            for (int k = 0; k < Size; ++k) {
+              jac_point[i * JacobianSize + j * Size + k] =
+                  jacobian[j * Size + k];
+            }
+          }
+        }
+      }
+
+      // The error is the difference between the predicted and observed position
+      for (int j = 0; j < Size; ++j) {
+        residuals[i * 3 + j] = (projected[j] - bearing[j]);
+      }
+    }
+    return true;
+  }
+
+  const MatX3d &centers_;
+  const MatX3d &bearings_;
+  const Vec3d &point_;
+};
+
+constexpr int BearingErrorCost::Size;
 
-  return worldPoint;
 }
 
 namespace geometry {
@@ -79,21 +112,28 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
   return std::make_pair(true, X.head<3>());
 }
 
-std::vector<std::pair<bool, Eigen::Vector3d>>
-TriangulateTwoBearingsMidpointMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation) {
-  std::vector<std::pair<bool, Eigen::Vector3d>> triangulated(bearings1.rows());
-  Eigen::Matrix<double, 2, 3> os, bs;
-  os.row(0) = Eigen::Vector3d::Zero();
-  os.row(1) = translation;
-  for (int i = 0; i < bearings1.rows(); ++i) {
-    bs.row(0) = bearings1.row(i);
-    bs.row(1) = rotation * bearings2.row(i).transpose();
-    triangulated[i] = TriangulateTwoBearingsMidpointSolve(os, bs);
+Eigen::Vector4d TriangulateBearingsDLTSolve(
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
+    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts) {
+  const int nviews = bearings.rows();
+  assert(nviews == Rts.size());
+
+  Eigen::MatrixXd A(2 * nviews, 4);
+  for (int i = 0; i < nviews; i++) {
+    A.row(2 * i) =
+        bearings(i, 0) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(0);
+    A.row(2 * i + 1) =
+        bearings(i, 1) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(1);
   }
-  return triangulated;
+
+  Eigen::JacobiSVD<Eigen::MatrixXd> mySVD(A, Eigen::ComputeFullV);
+  Eigen::Vector4d worldPoint;
+  worldPoint[0] = mySVD.matrixV()(0, 3);
+  worldPoint[1] = mySVD.matrixV()(1, 3);
+  worldPoint[2] = mySVD.matrixV()(2, 3);
+  worldPoint[3] = mySVD.matrixV()(3, 3);
+
+  return worldPoint;
 }
 
 std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
@@ -132,6 +172,23 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
   return std::make_pair(true, X.head<3>());
 }
 
+std::vector<std::pair<bool, Eigen::Vector3d>>
+TriangulateTwoBearingsMidpointMany(
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
+    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation) {
+  std::vector<std::pair<bool, Eigen::Vector3d>> triangulated(bearings1.rows());
+  Eigen::Matrix<double, 2, 3> os, bs;
+  os.row(0) = Eigen::Vector3d::Zero();
+  os.row(1) = translation;
+  for (int i = 0; i < bearings1.rows(); ++i) {
+    bs.row(0) = bearings1.row(i);
+    bs.row(1) = rotation * bearings2.row(i).transpose();
+    triangulated[i] = TriangulateTwoBearingsMidpointSolve(os, bs);
+  }
+  return triangulated;
+}
+
 Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
 EpipolarAngleTwoBearingsMany(
     const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
@@ -160,59 +217,6 @@ EpipolarAngleTwoBearingsMany(
   return M_PI / 2.0 - symmetric_epi.array().acos();
 }
 
-struct BearingErrorCost : public ceres::CostFunction {
-  constexpr static int Size = 3;
-
-  BearingErrorCost(const MatX3d &centers, const MatX3d &bearings,
-                   const Vec3d &point)
-      : centers_(centers), bearings_(bearings), point_(point) {
-    mutable_parameter_block_sizes()->push_back(Size);
-    set_num_residuals(bearings_.rows() * 3);
-  }
-  bool Evaluate(double const *const *parameters, double *residuals,
-                double **jacobians) const override {
-    const double *point = parameters[0];
-    for (int i = 0; i < bearings_.rows(); ++i) {
-      const Vec3d &center = centers_.row(i);
-      const Vec3d &bearing = bearings_.row(i);
-
-      /* Error only */
-      double *dummy = nullptr;
-      double projected[] = {point[0] - center(0), point[1] - center(1),
-                            point[2] - center(2)};
-      if (!jacobians) {
-        geometry::Normalize::Forward(&projected[0], dummy, &projected[0]);
-      } else {
-        constexpr int JacobianSize = Size * Size;
-        double jacobian[JacobianSize];
-        geometry::Normalize::ForwardDerivatives<double, true>(
-            &projected[0], dummy, &projected[0], &jacobian[0]);
-        double *jac_point = jacobians[0];
-        if (jac_point) {
-          for (int j = 0; j < Size; ++j) {
-            for (int k = 0; k < Size; ++k) {
-              jac_point[i * JacobianSize + j * Size + k] =
-                  jacobian[j * Size + k];
-            }
-          }
-        }
-      }
-
-      // The error is the difference between the predicted and observed position
-      for (int j = 0; j < Size; ++j) {
-        residuals[i * 3 + j] = (projected[j] - bearing[j]);
-      }
-    }
-    return true;
-  }
-
-  const MatX3d &centers_;
-  const MatX3d &bearings_;
-  const Vec3d &point_;
-};
-
-constexpr int BearingErrorCost::Size;
-
 Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
                       const Vec3d &point, int iterations) {
   using BearingCostFunction =
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index b678e9a8f..500e7c53e 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -7,12 +7,51 @@
 #include <Eigen/SVD>
 #include <Eigen/StdVector>
 
-double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v);
+namespace geometry {
+
+std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
+    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings, double threshold,
+    double min_angle);
 
 Eigen::Vector4d TriangulateBearingsDLTSolve(
     const Eigen::Matrix<double, Eigen::Dynamic, 3> &bs,
     const std::vector<Eigen::Matrix<double, 3, 4>> &Rts);
 
+std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &centers,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
+    const std::vector<double> &threshold_list,
+    double min_angle, double max_angle);
+
+template <class T>
+Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
+    const Eigen::Matrix<T, Eigen::Dynamic, 3> &centers,
+    const Eigen::Matrix<T, Eigen::Dynamic, 3> &bearings);
+
+std::vector<std::pair<bool, Eigen::Vector3d>>
+TriangulateTwoBearingsMidpointMany(
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
+    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
+
+template <class T>
+std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
+    const Eigen::Matrix<T, 2, 3> &centers,
+    const Eigen::Matrix<T, 2, 3> &bearings);
+
+Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
+EpipolarAngleTwoBearingsMany(
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
+    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
+    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
+
+Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
+                      const Vec3d &point, int iterations);
+
+
+// Template implementations
+
 // Point minimizing the squared distance to all rays
 // Closed for solution from
 //   Srikumar Ramalingam, Suresh K. Lodha and Peter Sturm
@@ -44,13 +83,6 @@ Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
          Cinv * BBtA;
 }
 
-namespace geometry {
-
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings, double threshold,
-    double min_angle);
-
 template <class T>
 std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
     const Eigen::Matrix<T, 2, 3> &centers,
@@ -78,27 +110,7 @@ std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
   const auto x1 = centers.row(0) + lambdas[0] * bearings.row(0);
   const auto x2 = centers.row(1) + lambdas[1] * bearings.row(1);
   return std::make_pair(true, (x1 + x2) / T(2.0));
-};
-
-std::vector<std::pair<bool, Eigen::Vector3d>>
-TriangulateTwoBearingsMidpointMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
-
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &centers,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
-    const std::vector<double> &threshold_list,
-    double min_angle, double max_angle);
-
-Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
-EpipolarAngleTwoBearingsMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
+}
 
-Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
-                      const Vec3d &point, int iterations);
 
 }  // namespace geometry

From 113d3cf5a9cf06139957b64dd9f23103fcfc1da6 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 108/235] Use short names for matrices and always double

Summary: Use short names for matrices and vectors in triangulation functions.

Reviewed By: YanNoun

Differential Revision: D72550227

fbshipit-source-id: f77cc7bd399039350c6e3e4356a5e1e87902f300
---
 opensfm/src/geometry/src/triangulation.cc | 76 ++++++++++++-----------
 opensfm/src/geometry/triangulation.h      | 50 ++++++++-------
 2 files changed, 67 insertions(+), 59 deletions(-)

diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index d61fc4028..ea6ea8201 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -9,7 +9,7 @@
 
 namespace {
 
-double AngleBetweenVectors(const Eigen::Vector3d &u, const Eigen::Vector3d &v) {
+double AngleBetweenVectors(const Vec3d &u, const Vec3d &v) {
   double c = (u.dot(v)) / sqrt(u.dot(u) * v.dot(v));
   if (std::fabs(c) >= 1.0) {
     return 0.0;
@@ -75,15 +75,16 @@ constexpr int BearingErrorCost::Size;
 
 namespace geometry {
 
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings, double threshold,
+std::pair<bool, Vec3d> TriangulateBearingsDLT(
+    const std::vector<Mat34d> &Rts,
+    const MatX3d &bearings,
+    double threshold,
     double min_angle) {
   const int count = Rts.size();
-  Eigen::MatrixXd world_bearings(count, 3);
+  MatXd world_bearings(count, 3);
   bool angle_ok = false;
   for (int i = 0; i < count && !angle_ok; ++i) {
-    const Eigen::Matrix<double, 3, 4> Rt = Rts[i];
+    const Mat34d &Rt = Rts[i];
     world_bearings.row(i) =
         Rt.block<3, 3>(0, 0).transpose() * bearings.row(i).transpose();
     for (int j = 0; j < i && !angle_ok; ++j) {
@@ -96,29 +97,29 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
   }
 
   if (!angle_ok) {
-    return std::make_pair(false, Eigen::Vector3d());
+    return std::make_pair(false, Vec3d());
   }
 
-  Eigen::Vector4d X = TriangulateBearingsDLTSolve(bearings, Rts);
+  Vec4d X = TriangulateBearingsDLTSolve(bearings, Rts);
   X /= X(3);
 
   for (int i = 0; i < count; ++i) {
-    const Eigen::Vector3d projected = Rts[i] * X;
+    const Vec3d projected = Rts[i] * X;
     if (AngleBetweenVectors(projected, bearings.row(i)) > threshold) {
-      return std::make_pair(false, Eigen::Vector3d());
+      return std::make_pair(false, Vec3d());
     }
   }
 
   return std::make_pair(true, X.head<3>());
 }
 
-Eigen::Vector4d TriangulateBearingsDLTSolve(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts) {
+Vec4d TriangulateBearingsDLTSolve(
+    const MatX3d &bearings,
+    const std::vector<Mat34d> &Rts) {
   const int nviews = bearings.rows();
   assert(nviews == Rts.size());
 
-  Eigen::MatrixXd A(2 * nviews, 4);
+  MatXd A(2 * nviews, 4);
   for (int i = 0; i < nviews; i++) {
     A.row(2 * i) =
         bearings(i, 0) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(0);
@@ -126,8 +127,8 @@ Eigen::Vector4d TriangulateBearingsDLTSolve(
         bearings(i, 1) * Rts[i].row(2) - bearings(i, 2) * Rts[i].row(1);
   }
 
-  Eigen::JacobiSVD<Eigen::MatrixXd> mySVD(A, Eigen::ComputeFullV);
-  Eigen::Vector4d worldPoint;
+  Eigen::JacobiSVD<MatXd> mySVD(A, Eigen::ComputeFullV);
+  Vec4d worldPoint;
   worldPoint[0] = mySVD.matrixV()(0, 3);
   worldPoint[1] = mySVD.matrixV()(1, 3);
   worldPoint[2] = mySVD.matrixV()(2, 3);
@@ -136,9 +137,9 @@ Eigen::Vector4d TriangulateBearingsDLTSolve(
   return worldPoint;
 }
 
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &centers,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
+std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
+    const MatX3d &centers,
+    const MatX3d &bearings,
     const std::vector<double> &threshold_list,
     double min_angle, double max_angle) {
   const int count = centers.rows();
@@ -154,7 +155,7 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
     }
   }
   if (!angle_ok) {
-    return std::make_pair(false, Eigen::Vector3d());
+    return std::make_pair(false, Vec3d());
   }
 
   // Triangulate
@@ -162,24 +163,25 @@ std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
 
   // Check reprojection error
   for (int i = 0; i < count; ++i) {
-    const Eigen::Vector3d projected = X - centers.row(i).transpose();
-    const Eigen::Vector3d measured = bearings.row(i);
+    const Vec3d projected = X - centers.row(i).transpose();
+    const Vec3d measured = bearings.row(i);
     if (AngleBetweenVectors(projected, measured) > threshold_list[i]) {
-      return std::make_pair(false, Eigen::Vector3d());
+      return std::make_pair(false, Vec3d());
     }
   }
 
   return std::make_pair(true, X.head<3>());
 }
 
-std::vector<std::pair<bool, Eigen::Vector3d>>
+std::vector<std::pair<bool, Vec3d>>
 TriangulateTwoBearingsMidpointMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation) {
-  std::vector<std::pair<bool, Eigen::Vector3d>> triangulated(bearings1.rows());
+    const MatX3d &bearings1,
+    const MatX3d &bearings2,
+    const Mat3d &rotation,
+    const Vec3d &translation) {
+  std::vector<std::pair<bool, Vec3d>> triangulated(bearings1.rows());
   Eigen::Matrix<double, 2, 3> os, bs;
-  os.row(0) = Eigen::Vector3d::Zero();
+  os.row(0) = Vec3d::Zero();
   os.row(1) = translation;
   for (int i = 0; i < bearings1.rows(); ++i) {
     bs.row(0) = bearings1.row(i);
@@ -189,28 +191,28 @@ TriangulateTwoBearingsMidpointMany(
   return triangulated;
 }
 
-Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
-EpipolarAngleTwoBearingsMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation) {
+MatXd EpipolarAngleTwoBearingsMany(
+    const MatX3d &bearings1,
+    const MatX3d &bearings2,
+    const Mat3d &rotation,
+    const Vec3d &translation) {
   const auto translation_normalized = translation.normalized();
   const auto bearings2_world = bearings2 * rotation.transpose();
 
   const auto count1 = bearings1.rows();
-  Eigen::Matrix<double, Eigen::Dynamic, 3> epi1(count1, 3);
+  MatX3d epi1(count1, 3);
   for (int i = 0; i < count1; ++i) {
     const Vec3d bearing = bearings1.row(i);
     epi1.row(i) = translation_normalized.cross(bearing).normalized();
   }
   const auto count2 = bearings2.rows();
-  Eigen::Matrix<double, Eigen::Dynamic, 3> epi2(count2, 3);
+  MatX3d epi2(count2, 3);
   for (int i = 0; i < count2; ++i) {
     const Vec3d bearing = bearings2_world.row(i);
     epi2.row(i) = translation_normalized.cross(bearing).normalized();
   }
 
-  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> symmetric_epi =
+  MatXd symmetric_epi =
       (((epi1 * bearings2_world.transpose()).array().abs() +
         (bearings1 * epi2.transpose()).array().abs()) /
        2.0);
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index 500e7c53e..b44e32292 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -9,45 +9,51 @@
 
 namespace geometry {
 
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsDLT(
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings, double threshold,
+std::pair<bool, Vec3d> TriangulateBearingsDLT(
+    const std::vector<Mat34d> &Rts,
+    const MatX3d &bearings,
+    double threshold,
     double min_angle);
 
-Eigen::Vector4d TriangulateBearingsDLTSolve(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bs,
-    const std::vector<Eigen::Matrix<double, 3, 4>> &Rts);
+Vec4d TriangulateBearingsDLTSolve(
+    const MatX3d &bs,
+    const std::vector<Mat34d> &Rts);
 
-std::pair<bool, Eigen::Vector3d> TriangulateBearingsMidpoint(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &centers,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings,
+std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
+    const MatX3d &centers,
+    const MatX3d &bearings,
     const std::vector<double> &threshold_list,
-    double min_angle, double max_angle);
+    double min_angle,
+    double max_angle);
 
 template <class T>
 Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
     const Eigen::Matrix<T, Eigen::Dynamic, 3> &centers,
     const Eigen::Matrix<T, Eigen::Dynamic, 3> &bearings);
 
-std::vector<std::pair<bool, Eigen::Vector3d>>
+std::vector<std::pair<bool, Vec3d>>
 TriangulateTwoBearingsMidpointMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
+    const MatX3d &bearings1,
+    const MatX3d &bearings2,
+    const Mat3d &rotation,
+    const Vec3d &translation);
 
 template <class T>
 std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
     const Eigen::Matrix<T, 2, 3> &centers,
     const Eigen::Matrix<T, 2, 3> &bearings);
 
-Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
-EpipolarAngleTwoBearingsMany(
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings1,
-    const Eigen::Matrix<double, Eigen::Dynamic, 3> &bearings2,
-    const Eigen::Matrix3d &rotation, const Eigen::Vector3d &translation);
-
-Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
-                      const Vec3d &point, int iterations);
+MatXd EpipolarAngleTwoBearingsMany(
+    const MatX3d &bearings1,
+    const MatX3d &bearings2,
+    const Mat3d &rotation,
+    const Vec3d &translation);
+
+Vec3d PointRefinement(
+    const MatX3d &centers,
+    const MatX3d &bearings,
+    const Vec3d &point,
+    int iterations);
 
 
 // Template implementations

From 1548c87c73b0c19f6c133e09af0cc71995144ddc Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 109/235] Add min_depth to triangulation

Summary:
This prevents triangulated points to be behind the bearings that are being triangulated.

As a side benefit, when the camera origins are coincident, enforcing a positive min_depth prevents the triangulation to return the origin of the cameras.

Reviewed By: YanNoun

Differential Revision: D72550225

fbshipit-source-id: 70dfc95e435ccb58fd935e63131c404f0cb47303
---
 bin/plot_inliers                              |   7 +-
 opensfm/config.py                             |   2 +
 opensfm/multiview.py                          |   2 +
 opensfm/reconstruction.py                     |  17 +-
 opensfm/src/geometry/pygeometry.pyi           | 505 +++++++++++-------
 opensfm/src/geometry/src/triangulation.cc     |  18 +-
 .../src/geometry/test/triangulation_test.cc   | 145 ++++-
 opensfm/src/geometry/triangulation.h          |   6 +-
 opensfm/src/sfm/src/ba_helpers.cc             |   3 +-
 opensfm/test/test_triangulation.py            |  41 +-
 10 files changed, 528 insertions(+), 218 deletions(-)

diff --git a/bin/plot_inliers b/bin/plot_inliers
index 3c6112e7e..19a808c9e 100755
--- a/bin/plot_inliers
+++ b/bin/plot_inliers
@@ -231,7 +231,7 @@ def reprojection_errors(reprojections, observations, scale):
     return errors, mean, std, min_norm, max_norm, corr
 
 
-def triangulate_tracks(tracks, reconstruction, tracks_manager, min_ray_angle):
+def triangulate_tracks(tracks, reconstruction, tracks_manager, min_ray_angle, min_depth):
     """ Triangulates a list of tracks.
 
     :param tracks: The array of tracks.
@@ -245,7 +245,7 @@ def triangulate_tracks(tracks, reconstruction, tracks_manager, min_ray_angle):
 
     for track in tracks:
         # Triangulate with 1 as reprojection threshold to avoid excluding tracks because of error.
-        triangulator.triangulate(str(track), 1, min_ray_angle, iterations=10)
+        triangulator.triangulate(str(track), 1, min_ray_angle, min_depth, iterations=10)
         succeeded.append(True) if str(track) in reconstruction.points else succeeded.append(False)
 
     return np.array(succeeded) if len(succeeded) else np.empty((0,), bool)
@@ -727,7 +727,8 @@ def plot_reprojected_tracks(fw, ip, index, p1, p2, tracks, rec_tracks, non_rec_t
     rp2 = reproject_tracks(ip.im2, rec_tracks[:, 0], reconstruction)
 
     min_ray_angle = data.config['triangulation_min_ray_angle']
-    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, tracks_manager, min_ray_angle)
+    min_depth = data.config['triangulation_min_depth']
+    succeeded = triangulate_tracks(non_rec_tracks[:, 0], reconstruction, tracks_manager, min_ray_angle, min_depth)
     reprojected1 = reproject_tracks(ip.im1, non_rec_tracks[succeeded, 0], reconstruction)
     reprojected2 = reproject_tracks(ip.im2, non_rec_tracks[succeeded, 0], reconstruction)
 
diff --git a/opensfm/config.py b/opensfm/config.py
index 47b26c5a6..a512e2ca1 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -203,6 +203,8 @@ class OpenSfMConfig:
     triangulation_threshold: float = 0.006
     # Minimum angle between views to accept a triangulated point
     triangulation_min_ray_angle: float = 1.0
+    # Minimum depth to accept a triangulated point
+    triangulation_min_depth: float = 0.001
     # Triangulation type : either considering all rays (FULL), or sing a RANSAC variant (ROBUST)
     triangulation_type: str = "FULL"
     # Number of LM iterations to run when refining a point
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 97b7e2b18..d1223c429 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -710,6 +710,7 @@ def triangulate_gcp(
     shots: Dict[str, pymap.Shot],
     reproj_threshold: float = 0.02,
     min_ray_angle_degrees: float = 1.0,
+    min_depth: float = 0.001,
 ) -> Optional[np.ndarray]:
     """Compute the reconstructed position of a GCP from observations."""
 
@@ -733,6 +734,7 @@ def triangulate_gcp(
             thresholds,
             np.radians(min_ray_angle_degrees),
             np.radians(180.0 - min_ray_angle_degrees),
+            min_depth,
         )
         if valid_triangulation:
             return X
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 52398dba9..90478ef23 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -909,6 +909,7 @@ def triangulate_robust(
         track: str,
         reproj_threshold: float,
         min_ray_angle_degrees: float,
+        min_depth: float,
         iterations: int,
     ) -> None:
         """Triangulate track in a RANSAC way and add point to reconstruction."""
@@ -953,6 +954,7 @@ def triangulate_robust(
                 thresholds,
                 min_ray_angle_radians,
                 max_ray_angle_radians,
+                min_depth,
             )
             X = pygeometry.point_refinement(os_t, bs_t, X, iterations)
 
@@ -970,6 +972,7 @@ def triangulate_robust(
                         len(inliers) * [reproj_threshold],
                         min_ray_angle_radians,
                         max_ray_angle_radians,
+                        min_depth,
                     )
                     new_X = pygeometry.point_refinement(
                         os[inliers], bs[inliers], X, iterations
@@ -1009,6 +1012,7 @@ def triangulate(
         track: str,
         reproj_threshold: float,
         min_ray_angle_degrees: float,
+        min_depth: float,
         iterations: int,
     ) -> None:
         """Triangulate track and add point to reconstruction."""
@@ -1037,6 +1041,7 @@ def triangulate(
                 thresholds,
                 min_ray_angle_radians,
                 np.pi - min_ray_angle_radians,
+                min_depth,
             )
             if valid_triangulation:
                 X = pygeometry.point_refinement(
@@ -1057,6 +1062,7 @@ def triangulate_dlt(
         track: str,
         reproj_threshold: float,
         min_ray_angle_degrees: float,
+        min_depth: float,
         iterations: int,
     ) -> None:
         """Triangulate track using DLT and add point to reconstruction."""
@@ -1077,6 +1083,7 @@ def triangulate_dlt(
                 np.asarray(bs),
                 reproj_threshold,
                 np.radians(min_ray_angle_degrees),
+                min_depth,
             )
             if e:
                 X = pygeometry.point_refinement(
@@ -1120,6 +1127,7 @@ def triangulate_shot_features(
     """Reconstruct as many tracks seen in shot_id as possible."""
     reproj_threshold = config["triangulation_threshold"]
     min_ray_angle = config["triangulation_min_ray_angle"]
+    min_depth = config["triangulation_min_depth"]
     refinement_iterations = config["triangulation_refinement_iterations"]
 
     triangulator = TrackTriangulator(
@@ -1137,11 +1145,11 @@ def triangulate_shot_features(
         if track not in reconstruction.points:
             if config["triangulation_type"] == "ROBUST":
                 triangulator.triangulate_robust(
-                    track, reproj_threshold, min_ray_angle, refinement_iterations
+                    track, reproj_threshold, min_ray_angle, min_depth, refinement_iterations
                 )
             elif config["triangulation_type"] == "FULL":
                 triangulator.triangulate(
-                    track, reproj_threshold, min_ray_angle, refinement_iterations
+                    track, reproj_threshold, min_ray_angle, min_depth, refinement_iterations
                 )
 
 
@@ -1157,6 +1165,7 @@ def retriangulate(
 
     threshold = config["triangulation_threshold"]
     min_ray_angle = config["triangulation_min_ray_angle"]
+    min_depth = config["triangulation_min_depth"]
     refinement_iterations = config["triangulation_refinement_iterations"]
 
     reconstruction.points = {}
@@ -1173,11 +1182,11 @@ def retriangulate(
     for track in tracks:
         if config["triangulation_type"] == "ROBUST":
             triangulator.triangulate_robust(
-                track, threshold, min_ray_angle, refinement_iterations
+                track, threshold, min_ray_angle, min_depth, refinement_iterations
             )
         elif config["triangulation_type"] == "FULL":
             triangulator.triangulate(
-                track, threshold, min_ray_angle, refinement_iterations
+                track, threshold, min_ray_angle, min_depth, refinement_iterations
             )
 
     report["num_points_after"] = len(reconstruction.points)
diff --git a/opensfm/src/geometry/pygeometry.pyi b/opensfm/src/geometry/pygeometry.pyi
index 8b34429fa..baa0d776b 100644
--- a/opensfm/src/geometry/pygeometry.pyi
+++ b/opensfm/src/geometry/pygeometry.pyi
@@ -7,170 +7,217 @@
 # Tip: Be sure to run this with the build mode you use for your project, e.g.,
 # @//arvr/mode/linux/opt (or dev) in arvr.
 #
-# Ignore errors for [5] global variable types and [24] untyped generics.
-# pyre-ignore-all-errors[5,24]
+# Ignore errors for [24] untyped generics.
+# pyre-ignore-all-errors[24]
 
 import numpy
 from typing import *
-__all__  = [
-"Camera",
-"CameraParameters",
-"Pose",
-"ProjectionType",
-"Similarity",
-"absolute_pose_n_points",
-"absolute_pose_n_points_known_rotation",
-"absolute_pose_three_points",
-"compute_camera_mapping",
-"epipolar_angle_two_bearings_many",
-"essential_five_points",
-"essential_n_points",
-"point_refinement",
-"relative_pose_from_essential",
-"relative_pose_refinement",
-"relative_rotation_n_points",
-"triangulate_bearings_dlt",
-"triangulate_bearings_midpoint",
-"triangulate_two_bearings_midpoint",
-"triangulate_two_bearings_midpoint_many",
-"BROWN",
-"DUAL",
-"FISHEYE",
-"FISHEYE62",
-"FISHEYE624",
-"FISHEYE_OPENCV",
-"PERSPECTIVE",
-"RADIAL",
-"SIMPLE_RADIAL",
-"SPHERICAL",
-"aspect_ratio",
-"cx",
-"cy",
-"focal",
-"k1",
-"k2",
-"k3",
-"k4",
-"k5",
-"k6",
-"none",
-"p1",
-"p2",
-"s0",
-"s1",
-"s2",
-"s3",
-"transition"
+
+__all__ = [
+    "Camera",
+    "CameraParameters",
+    "Pose",
+    "ProjectionType",
+    "Similarity",
+    "absolute_pose_n_points",
+    "absolute_pose_n_points_known_rotation",
+    "absolute_pose_three_points",
+    "compute_camera_mapping",
+    "epipolar_angle_two_bearings_many",
+    "essential_five_points",
+    "essential_n_points",
+    "point_refinement",
+    "relative_pose_from_essential",
+    "relative_pose_refinement",
+    "relative_rotation_n_points",
+    "triangulate_bearings_dlt",
+    "triangulate_bearings_midpoint",
+    "triangulate_two_bearings_midpoint",
+    "triangulate_two_bearings_midpoint_many",
+    "BROWN",
+    "DUAL",
+    "FISHEYE",
+    "FISHEYE62",
+    "FISHEYE624",
+    "FISHEYE_OPENCV",
+    "PERSPECTIVE",
+    "RADIAL",
+    "SIMPLE_RADIAL",
+    "SPHERICAL",
+    "aspect_ratio",
+    "cx",
+    "cy",
+    "focal",
+    "k1",
+    "k2",
+    "k3",
+    "k4",
+    "k5",
+    "k6",
+    "none",
+    "p1",
+    "p2",
+    "s0",
+    "s1",
+    "s2",
+    "s3",
+    "transition",
 ]
+
 class Camera:
     def __copy__(self) -> Camera: ...
     def __deepcopy__(self, arg0: dict) -> Camera: ...
     def __getstate__(self) -> tuple: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     @staticmethod
-    def create_brown(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: numpy.ndarray) -> Camera: ...
+    def create_brown(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: numpy.typing.NDArray
+    ) -> Camera: ...
     @staticmethod
     def create_dual(arg0: float, arg1: float, arg2: float, arg3: float) -> Camera: ...
     @staticmethod
     def create_fisheye(arg0: float, arg1: float, arg2: float) -> Camera: ...
     @staticmethod
-    def create_fisheye62(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: numpy.ndarray) -> Camera: ...
+    def create_fisheye62(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: numpy.typing.NDArray
+    ) -> Camera: ...
     @staticmethod
-    def create_fisheye624(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: numpy.ndarray) -> Camera: ...
+    def create_fisheye624(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: numpy.typing.NDArray
+    ) -> Camera: ...
     @staticmethod
-    def create_fisheye_opencv(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: numpy.ndarray) -> Camera: ...
+    def create_fisheye_opencv(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: numpy.typing.NDArray
+    ) -> Camera: ...
     @staticmethod
     def create_perspective(arg0: float, arg1: float, arg2: float) -> Camera: ...
     @staticmethod
-    def create_radial(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: numpy.ndarray) -> Camera: ...
+    def create_radial(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: numpy.typing.NDArray
+    ) -> Camera: ...
     @staticmethod
-    def create_simple_radial(arg0: float, arg1: float, arg2: numpy.ndarray, arg3: float) -> Camera: ...
+    def create_simple_radial(
+        arg0: float, arg1: float, arg2: numpy.typing.NDArray, arg3: float
+    ) -> Camera: ...
     @staticmethod
     def create_spherical() -> Camera: ...
-    def get_K(self) -> numpy.ndarray: ...
-    def get_K_in_pixel_coordinates(self, arg0: int, arg1: int) -> numpy.ndarray: ...
-    def get_parameters_map(self) -> Dict[CameraParameters, float]: ...
-    def get_parameters_types(self) -> List[CameraParameters]: ...
-    def get_parameters_values(self) -> numpy.ndarray: ...
+    def get_K(self) -> numpy.typing.NDArray: ...
+    def get_K_in_pixel_coordinates(
+        self, arg0: int, arg1: int
+    ) -> numpy.typing.NDArray: ...
+    def get_parameters_map(self) -> dict[CameraParameters, float]: ...
+    def get_parameters_types(self) -> list[CameraParameters]: ...
+    def get_parameters_values(self) -> numpy.typing.NDArray: ...
     @staticmethod
     def is_panorama(arg0: str) -> bool: ...
-    def normalized_to_pixel_coordinates(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def normalized_to_pixel_coordinates(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
     @staticmethod
-    def normalized_to_pixel_coordinates_common(arg0: numpy.ndarray, arg1: int, arg2: int) -> numpy.ndarray: ...
-    def normalized_to_pixel_coordinates_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def normalized_to_pixel_coordinates_common(
+        arg0: numpy.typing.NDArray, arg1: int, arg2: int
+    ) -> numpy.typing.NDArray: ...
+    def normalized_to_pixel_coordinates_many(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
     @staticmethod
-    def normalized_to_pixel_coordinates_many_common(arg0: numpy.ndarray, arg1: int, arg2: int) -> numpy.ndarray: ...
-    def pixel_bearing(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def pixel_bearing_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def pixel_to_normalized_coordinates(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def normalized_to_pixel_coordinates_many_common(
+        arg0: numpy.typing.NDArray, arg1: int, arg2: int
+    ) -> numpy.typing.NDArray: ...
+    def pixel_bearing(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
+    def pixel_bearing_many(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
+    def pixel_to_normalized_coordinates(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
     @staticmethod
-    def pixel_to_normalized_coordinates_common(arg0: numpy.ndarray, arg1: int, arg2: int) -> numpy.ndarray: ...
-    def pixel_to_normalized_coordinates_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def pixel_to_normalized_coordinates_common(
+        arg0: numpy.typing.NDArray, arg1: int, arg2: int
+    ) -> numpy.typing.NDArray: ...
+    def pixel_to_normalized_coordinates_many(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
     @staticmethod
-    def pixel_to_normalized_coordinates_many_common(arg0: numpy.ndarray, arg1: int, arg2: int) -> numpy.ndarray: ...
-    def project(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def project_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def pixel_to_normalized_coordinates_many_common(
+        arg0: numpy.typing.NDArray, arg1: int, arg2: int
+    ) -> numpy.typing.NDArray: ...
+    def project(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
+    def project_many(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
     def set_parameter_value(self, arg0: CameraParameters, arg1: float) -> None: ...
-    def set_parameters_values(self, arg0: numpy.ndarray) -> None: ...
+    def set_parameters_values(self, arg0: numpy.typing.NDArray) -> None: ...
     @property
-    def aspect_ratio(self) -> float:...
+    def aspect_ratio(self) -> float: ...
     @aspect_ratio.setter
-    def aspect_ratio(self, arg1: float) -> None:...
+    def aspect_ratio(self, arg1: float) -> None: ...
     @property
-    def distortion(self) -> numpy.ndarray:...
+    def distortion(self) -> numpy.typing.NDArray: ...
     @distortion.setter
-    def distortion(self, arg1: numpy.ndarray) -> None:...
+    def distortion(self, arg1: numpy.typing.NDArray) -> None: ...
     @property
-    def focal(self) -> float:...
+    def focal(self) -> float: ...
     @focal.setter
-    def focal(self, arg1: float) -> None:...
+    def focal(self, arg1: float) -> None: ...
     @property
-    def height(self) -> int:...
+    def height(self) -> int: ...
     @height.setter
-    def height(self, arg0: int) -> None:...
+    def height(self, arg0: int) -> None: ...
     @property
-    def id(self) -> str:...
+    def id(self) -> str: ...
     @id.setter
-    def id(self, arg0: str) -> None:...
+    def id(self, arg0: str) -> None: ...
     @property
-    def k1(self) -> float:...
+    def k1(self) -> float: ...
     @property
-    def k2(self) -> float:...
+    def k2(self) -> float: ...
     @property
-    def k3(self) -> float:...
+    def k3(self) -> float: ...
     @property
-    def k4(self) -> float:...
+    def k4(self) -> float: ...
     @property
-    def k5(self) -> float:...
+    def k5(self) -> float: ...
     @property
-    def k6(self) -> float:...
+    def k6(self) -> float: ...
     @property
-    def p1(self) -> float:...
+    def p1(self) -> float: ...
     @property
-    def p2(self) -> float:...
+    def p2(self) -> float: ...
     @property
-    def principal_point(self) -> numpy.ndarray:...
+    def principal_point(self) -> numpy.typing.NDArray: ...
     @principal_point.setter
-    def principal_point(self, arg1: numpy.ndarray) -> None:...
+    def principal_point(self, arg1: numpy.typing.NDArray) -> None: ...
     @property
-    def projection_type(self) -> str:...
+    def projection_type(self) -> str: ...
     @property
-    def s0(self) -> float:...
+    def s0(self) -> float: ...
     @property
-    def s1(self) -> float:...
+    def s1(self) -> float: ...
     @property
-    def s2(self) -> float:...
+    def s2(self) -> float: ...
     @property
-    def s3(self) -> float:...
+    def s3(self) -> float: ...
     @property
-    def transition(self) -> float:...
+    def transition(self) -> float: ...
     @transition.setter
-    def transition(self, arg1: float) -> None:...
+    def transition(self, arg1: float) -> None: ...
     @property
-    def width(self) -> int:...
+    def width(self) -> int: ...
     @width.setter
-    def width(self, arg0: int) -> None:...
+    def width(self, arg0: int) -> None: ...
+
 class CameraParameters:
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __setstate__(self, state: int) -> None: ...
+    def __str__(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
     focal: "CameraParameters"
     aspect_ratio: "CameraParameters"
     k1: "CameraParameters"
@@ -190,8 +237,8 @@ class CameraParameters:
     transition: "CameraParameters"
     none: "CameraParameters"
     __members__: Dict[str, "CameraParameters"]
-    @property
-    def name(self) -> str: ...
+    __entries: "dict"
+
 class Pose:
     def __copy__(self) -> Pose: ...
     def __deepcopy__(self, arg0: dict) -> Pose: ...
@@ -199,56 +246,71 @@ class Pose:
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, arg0: numpy.ndarray) -> None: ...
+    def __init__(self, arg0: numpy.typing.NDArray) -> None: ...
     @overload
-    def __init__(self, rotation: numpy.ndarray) -> None: ...
+    def __init__(self, rotation: numpy.typing.NDArray) -> None: ...
     @overload
-    def __init__(self, rotation: numpy.ndarray, translation: numpy.ndarray) -> None: ...
-    @overload
-    def __init__(self, rotation: numpy.ndarray, translation: numpy.ndarray) -> None: ...
+    def __init__(
+        self, rotation: numpy.typing.NDArray, translation: numpy.typing.NDArray
+    ) -> Union[None, None]: ...
     def __setstate__(self, arg0: tuple) -> None: ...
     def compose(self, arg0: Pose) -> Pose: ...
-    def get_R_cam_to_world(self) -> numpy.ndarray: ...
-    def get_R_cam_to_world_min(self) -> numpy.ndarray: ...
-    def get_R_world_to_cam(self) -> numpy.ndarray: ...
-    def get_R_world_to_cam_min(self) -> numpy.ndarray: ...
-    def get_Rt(self) -> numpy.ndarray: ...
-    def get_cam_to_world(self) -> numpy.ndarray: ...
-    def get_origin(self) -> numpy.ndarray: ...
-    def get_rotation_matrix(self) -> numpy.ndarray: ...
-    def get_t_cam_to_world(self) -> numpy.ndarray: ...
-    def get_t_world_to_cam(self) -> numpy.ndarray: ...
-    def get_world_to_cam(self) -> numpy.ndarray: ...
+    def get_R_cam_to_world(self) -> numpy.typing.NDArray: ...
+    def get_R_cam_to_world_min(self) -> numpy.typing.NDArray: ...
+    def get_R_world_to_cam(self) -> numpy.typing.NDArray: ...
+    def get_R_world_to_cam_min(self) -> numpy.typing.NDArray: ...
+    def get_Rt(self) -> numpy.typing.NDArray: ...
+    def get_cam_to_world(self) -> numpy.typing.NDArray: ...
+    def get_origin(self) -> numpy.typing.NDArray: ...
+    def get_rotation_matrix(self) -> numpy.typing.NDArray: ...
+    def get_t_cam_to_world(self) -> numpy.typing.NDArray: ...
+    def get_t_world_to_cam(self) -> numpy.typing.NDArray: ...
+    def get_world_to_cam(self) -> numpy.typing.NDArray: ...
     def inverse(self) -> Pose: ...
     def is_identity(self, arg0: float) -> bool: ...
     def relative_to(self, arg0: Pose) -> Pose: ...
     @overload
-    def set_from_cam_to_world(self, arg0: numpy.ndarray) -> None: ...
-    @overload
-    def set_from_cam_to_world(self, arg0: numpy.ndarray, arg1: numpy.ndarray) -> None: ...
+    def set_from_cam_to_world(self, arg0: numpy.typing.NDArray) -> None: ...
     @overload
-    def set_from_cam_to_world(self, arg0: numpy.ndarray, arg1: numpy.ndarray) -> None: ...
+    def set_from_cam_to_world(
+        self, arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+    ) -> Union[None, None]: ...
     @overload
-    def set_from_world_to_cam(self, arg0: numpy.ndarray) -> None: ...
+    def set_from_world_to_cam(self, arg0: numpy.typing.NDArray) -> None: ...
     @overload
-    def set_from_world_to_cam(self, arg0: numpy.ndarray, arg1: numpy.ndarray) -> None: ...
-    @overload
-    def set_from_world_to_cam(self, arg0: numpy.ndarray, arg1: numpy.ndarray) -> None: ...
-    def set_origin(self, arg0: numpy.ndarray) -> None: ...
-    def set_rotation_matrix(self, arg0: numpy.ndarray) -> None: ...
-    def transform(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def transform_inverse(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def transform_inverse_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
-    def transform_many(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def set_from_world_to_cam(
+        self, arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+    ) -> Union[None, None]: ...
+    def set_origin(self, arg0: numpy.typing.NDArray) -> None: ...
+    def set_rotation_matrix(self, arg0: numpy.typing.NDArray) -> None: ...
+    def transform(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
+    def transform_inverse(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
+    def transform_inverse_many(
+        self, arg0: numpy.typing.NDArray
+    ) -> numpy.typing.NDArray: ...
+    def transform_many(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
     @property
-    def rotation(self) -> numpy.ndarray:...
+    def rotation(self) -> numpy.typing.NDArray: ...
     @rotation.setter
-    def rotation(self, arg1: numpy.ndarray) -> None:...
+    def rotation(self, arg1: numpy.typing.NDArray) -> None: ...
     @property
-    def translation(self) -> numpy.ndarray:...
+    def translation(self) -> numpy.typing.NDArray: ...
     @translation.setter
-    def translation(self, arg1: numpy.ndarray) -> None:...
+    def translation(self, arg1: numpy.typing.NDArray) -> None: ...
+
 class ProjectionType:
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: int) -> None: ...
+    def __int__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __setstate__(self, state: int) -> None: ...
+    def __str__(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
     PERSPECTIVE: "ProjectionType"
     BROWN: "ProjectionType"
     FISHEYE: "ProjectionType"
@@ -260,65 +322,120 @@ class ProjectionType:
     RADIAL: "ProjectionType"
     SIMPLE_RADIAL: "ProjectionType"
     __members__: Dict[str, "ProjectionType"]
-    @property
-    def name(self) -> str: ...
+    __entries: "dict"
+
 class Similarity:
-    def __init__(self, arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: float) -> None: ...
-    def get_rotation_matrix(self) -> numpy.ndarray: ...
+    def __init__(
+        self, arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray, arg2: float
+    ) -> None: ...
+    def get_rotation_matrix(self) -> numpy.typing.NDArray: ...
     def inverse(self) -> Similarity: ...
-    def transform(self, arg0: numpy.ndarray) -> numpy.ndarray: ...
+    def transform(self, arg0: numpy.typing.NDArray) -> numpy.typing.NDArray: ...
     @property
-    def rotation(self) -> numpy.ndarray:...
+    def rotation(self) -> numpy.typing.NDArray: ...
     @rotation.setter
-    def rotation(self, arg1: numpy.ndarray) -> None:...
+    def rotation(self, arg1: numpy.typing.NDArray) -> None: ...
     @property
-    def scale(self) -> float:...
+    def scale(self) -> float: ...
     @scale.setter
-    def scale(self, arg1: float) -> None:...
+    def scale(self, arg1: float) -> None: ...
     @property
-    def translation(self) -> numpy.ndarray:...
+    def translation(self) -> numpy.typing.NDArray: ...
     @translation.setter
-    def translation(self, arg1: numpy.ndarray) -> None:...
-def absolute_pose_n_points(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
-def absolute_pose_n_points_known_rotation(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
-def absolute_pose_three_points(arg0: numpy.ndarray, arg1: numpy.ndarray) -> List[numpy.ndarray]:...
-def compute_camera_mapping(arg0: Camera, arg1: Camera, arg2: int, arg3: int) -> Tuple[numpy.ndarray, numpy.ndarray]:...
-def epipolar_angle_two_bearings_many(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: numpy.ndarray) -> numpy.ndarray:...
-def essential_five_points(arg0: numpy.ndarray, arg1: numpy.ndarray) -> List[numpy.ndarray]:...
-def essential_n_points(arg0: numpy.ndarray, arg1: numpy.ndarray) -> List[numpy.ndarray]:...
-def point_refinement(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: int) -> numpy.ndarray:...
-def relative_pose_from_essential(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray) -> numpy.ndarray:...
-def relative_pose_refinement(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: int) -> numpy.ndarray:...
-def relative_rotation_n_points(arg0: numpy.ndarray, arg1: numpy.ndarray) -> numpy.ndarray:...
-def triangulate_bearings_dlt(arg0: List[numpy.ndarray], arg1: numpy.ndarray, arg2: float, arg3: float) -> Tuple[bool, numpy.ndarray]:...
-def triangulate_bearings_midpoint(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: List[float], arg3: float, arg4: float) -> Tuple[bool, numpy.ndarray]:...
-def triangulate_two_bearings_midpoint(arg0: numpy.ndarray, arg1: numpy.ndarray) -> Tuple[bool, numpy.ndarray]:...
-def triangulate_two_bearings_midpoint_many(arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: numpy.ndarray) -> List[Tuple[bool, numpy.ndarray]]:...
-BROWN = ...
-DUAL = ...
-FISHEYE = ...
-FISHEYE62 = ...
-FISHEYE624 = ...
-FISHEYE_OPENCV = ...
-PERSPECTIVE = ...
-RADIAL = ...
-SIMPLE_RADIAL = ...
-SPHERICAL = ...
-aspect_ratio = ...
-cx = ...
-cy = ...
-focal = ...
-k1 = ...
-k2 = ...
-k3 = ...
-k4 = ...
-k5 = ...
-k6 = ...
-none = ...
-p1 = ...
-p2 = ...
-s0 = ...
-s1 = ...
-s2 = ...
-s3 = ...
-transition = ...
\ No newline at end of file
+    def translation(self, arg1: numpy.typing.NDArray) -> None: ...
+
+def absolute_pose_n_points(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> numpy.typing.NDArray: ...
+def absolute_pose_n_points_known_rotation(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> numpy.typing.NDArray: ...
+def absolute_pose_three_points(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> list[numpy.typing.NDArray]: ...
+def compute_camera_mapping(
+    arg0: Camera, arg1: Camera, arg2: int, arg3: int
+) -> tuple[numpy.typing.NDArray, numpy.typing.NDArray]: ...
+def epipolar_angle_two_bearings_many(
+    arg0: numpy.typing.NDArray,
+    arg1: numpy.typing.NDArray,
+    arg2: numpy.typing.NDArray,
+    arg3: numpy.typing.NDArray,
+) -> numpy.typing.NDArray: ...
+def essential_five_points(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> list[numpy.typing.NDArray]: ...
+def essential_n_points(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> list[numpy.typing.NDArray]: ...
+def point_refinement(
+    arg0: numpy.typing.NDArray,
+    arg1: numpy.typing.NDArray,
+    arg2: numpy.typing.NDArray,
+    arg3: int,
+) -> numpy.typing.NDArray: ...
+def relative_pose_from_essential(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray, arg2: numpy.typing.NDArray
+) -> numpy.typing.NDArray: ...
+def relative_pose_refinement(
+    arg0: numpy.typing.NDArray,
+    arg1: numpy.typing.NDArray,
+    arg2: numpy.typing.NDArray,
+    arg3: int,
+) -> numpy.typing.NDArray: ...
+def relative_rotation_n_points(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> numpy.typing.NDArray: ...
+def triangulate_bearings_dlt(
+    arg0: list[numpy.typing.NDArray],
+    arg1: numpy.typing.NDArray,
+    arg2: float,
+    arg3: float,
+    arg4: float,
+) -> tuple[bool, numpy.typing.NDArray]: ...
+def triangulate_bearings_midpoint(
+    arg0: numpy.typing.NDArray,
+    arg1: numpy.typing.NDArray,
+    arg2: list[float],
+    arg3: float,
+    arg4: float,
+    arg5: float,
+) -> tuple[bool, numpy.typing.NDArray]: ...
+def triangulate_two_bearings_midpoint(
+    arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
+) -> tuple[bool, numpy.typing.NDArray]: ...
+def triangulate_two_bearings_midpoint_many(
+    arg0: numpy.typing.NDArray,
+    arg1: numpy.typing.NDArray,
+    arg2: numpy.typing.NDArray,
+    arg3: numpy.typing.NDArray,
+) -> list[tuple[bool, numpy.typing.NDArray]]: ...
+
+BROWN: "ProjectionType"
+DUAL: "ProjectionType"
+FISHEYE: "ProjectionType"
+FISHEYE62: "ProjectionType"
+FISHEYE624: "ProjectionType"
+FISHEYE_OPENCV: "ProjectionType"
+PERSPECTIVE: "ProjectionType"
+RADIAL: "ProjectionType"
+SIMPLE_RADIAL: "ProjectionType"
+SPHERICAL: "ProjectionType"
+aspect_ratio: "CameraParameters"
+cx: "CameraParameters"
+cy: "CameraParameters"
+focal: "CameraParameters"
+k1: "CameraParameters"
+k2: "CameraParameters"
+k3: "CameraParameters"
+k4: "CameraParameters"
+k5: "CameraParameters"
+k6: "CameraParameters"
+none: "CameraParameters"
+p1: "CameraParameters"
+p2: "CameraParameters"
+s0: "CameraParameters"
+s1: "CameraParameters"
+s2: "CameraParameters"
+s3: "CameraParameters"
+transition: "CameraParameters"
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index ea6ea8201..0fdc2223d 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -79,7 +79,8 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(
     const std::vector<Mat34d> &Rts,
     const MatX3d &bearings,
     double threshold,
-    double min_angle) {
+    double min_angle,
+    double min_depth) {
   const int count = Rts.size();
   MatXd world_bearings(count, 3);
   bool angle_ok = false;
@@ -105,7 +106,11 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(
 
   for (int i = 0; i < count; ++i) {
     const Vec3d projected = Rts[i] * X;
-    if (AngleBetweenVectors(projected, bearings.row(i)) > threshold) {
+    const Vec3d measured = bearings.row(i);
+    if (AngleBetweenVectors(projected, measured) > threshold) {
+      return std::make_pair(false, Vec3d());
+    }
+    if (projected.dot(measured) < min_depth) {
       return std::make_pair(false, Vec3d());
     }
   }
@@ -141,7 +146,9 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     const MatX3d &centers,
     const MatX3d &bearings,
     const std::vector<double> &threshold_list,
-    double min_angle, double max_angle) {
+    double min_angle,
+    double max_angle,
+    double min_depth) {
   const int count = centers.rows();
 
   // Check angle between rays
@@ -168,6 +175,9 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     if (AngleBetweenVectors(projected, measured) > threshold_list[i]) {
       return std::make_pair(false, Vec3d());
     }
+    if (projected.dot(measured) < min_depth) {
+      return std::make_pair(false, Vec3d());
+    }
   }
 
   return std::make_pair(true, X.head<3>());
@@ -233,4 +243,6 @@ Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
   return refined;
 }
 
+
+
 }  // namespace geometry
diff --git a/opensfm/src/geometry/test/triangulation_test.cc b/opensfm/src/geometry/test/triangulation_test.cc
index 966a739f1..a17193d0c 100644
--- a/opensfm/src/geometry/test/triangulation_test.cc
+++ b/opensfm/src/geometry/test/triangulation_test.cc
@@ -68,6 +68,7 @@ class TwoCamsFixture : public ::testing::Test {
   const std::vector<double> thresholds = {0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
   const double max_angle = M_PI - min_angle;
+  const double min_depth = 1e-6;
 };
 
 class FiveCamsFixture : public ::testing::Test {
@@ -91,8 +92,75 @@ class FiveCamsFixture : public ::testing::Test {
   const std::vector<double> thresholds = {0.01, 0.01, 0.01, 0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
   const double max_angle = M_PI - min_angle;
+  const double min_depth = 1e-6;
 };
 
+// This fixture is designed to test a specific failure case:
+// When two cameras have the same center, but a third one has a
+// different center. This would happen for example when two images
+// are taken by the front and back cameras of a 360 camera and
+// another image with a different camera or timestamp. As long as
+// the bearings are consistent, we want triangulation to succeed
+// in that case.
+class ThreeCamsSameCenterFixture : public ::testing::Test {
+ public:
+  ThreeCamsSameCenterFixture() {
+    centers = MatX3d::Zero(3, 3);
+    centers << 0.0, 0.0, 0.0,
+              0.0, 0.0, 0.0,
+              1.0, 0.0, 0.0;
+  
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);
+  }
+  
+  Vec3d gt_point;
+  MatX3d centers;
+  MatX3d bearings;
+  MatX3d bearings_noisy;
+  std::vector<Mat34d> Rts;
+
+  const double threshold = 0.01;
+  const std::vector<double> thresholds = {0.01, 0.01, 0.01};
+  const double min_angle = 2.0 * M_PI / 180.0;
+  const double max_angle = M_PI - min_angle;
+  const double min_depth = 1e-6;
+};
+
+// This fixture is designed to test a specific failure case:
+// When two cameras have the same center, we want the triangulation
+// to fail. However, if the bearings are different, the triangulation
+// may find a solution by putting the point at the center of the
+// cameras. This is a bad solution and we want the functions to
+// return non-success in this case.
+class TwoCamsSameCenterFixture : public ::testing::Test {
+ public:
+  TwoCamsSameCenterFixture() {
+    centers = MatX3d::Zero(2, 3);
+    centers << 1.0, 0.0, 0.0,
+              1.0, 0.0, 0.0;
+  
+    bearings = MatX3d::Zero(2, 3);
+    bearings << 0.0, 0.0, 1.0,
+                1.0, 0.0, 0.0;
+
+    bearings_noisy = generateNoisyBearings(bearings, 0.001);
+
+    Rts = generateRts(centers);
+  }
+  
+  MatX3d centers;
+  MatX3d bearings;
+  MatX3d bearings_noisy;
+  std::vector<Mat34d> Rts;
+
+  const double threshold = 0.01;
+  const std::vector<double> thresholds = {0.01, 0.01};
+  const double min_angle = 2.0 * M_PI / 180.0;
+  const double max_angle = M_PI - min_angle;
+  const double min_depth = 1e-6;
+};
+
+
 class TwoCamsManyPointsFixture : public ::testing::Test {
  public:
   TwoCamsManyPointsFixture() {
@@ -126,52 +194,113 @@ class TwoCamsManyPointsFixture : public ::testing::Test {
 
 TEST_F(TwoCamsFixture, TriangulateBearingsDLT) {
   const auto [success, point] = geometry::TriangulateBearingsDLT(
-      Rts, bearings, threshold, min_angle);
+      Rts, bearings, threshold, min_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
-      Rts, bearings_noisy, threshold, min_angle);
+      Rts, bearings_noisy, threshold, min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
 TEST_F(FiveCamsFixture, TriangulateBearingsDLT) {
   const auto [success, point] = geometry::TriangulateBearingsDLT(
-      Rts, bearings, threshold, min_angle);
+      Rts, bearings, threshold, min_angle, min_depth);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
+      Rts, bearings_noisy, threshold, min_angle, min_depth);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+TEST_F(ThreeCamsSameCenterFixture, TriangulateBearingsDLT) {
+  const auto [success, point] = geometry::TriangulateBearingsDLT(
+      Rts, bearings, threshold, min_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
-      Rts, bearings_noisy, threshold, min_angle);
+      Rts, bearings_noisy, threshold, min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
+TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsDLT) {
+  const auto [success, point] = geometry::TriangulateBearingsDLT(
+      Rts, bearings, threshold, min_angle, min_depth);
+  ASSERT_FALSE(success);  // Expect failure due to coincident camera centers
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
+      Rts, bearings_noisy, threshold, min_angle, min_depth);
+  ASSERT_FALSE(success_noisy);  // Expect failure due to coincident camera centers
+
+  // Test that without the positive depth constraint, triangulation succeeds
+  // and returns the center of the cameras.
+  const double negative_min_depth = -1e-6;
+  const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle, negative_min_depth);
+  ASSERT_TRUE(success_no_depth_check);
+  const Vec3d expected_point = centers.row(0);
+  ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
+}
+
 TEST_F(TwoCamsFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle);
+      centers, bearings, thresholds, min_angle, max_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, max_angle);
+      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
 TEST_F(FiveCamsFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle);
+      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+  ASSERT_TRUE(success);
+  ASSERT_LT((point - gt_point).norm(), 1e-6);
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
+  ASSERT_TRUE(success_noisy);
+  ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
+}
+
+TEST_F(ThreeCamsSameCenterFixture, TriangulateBearingsMidpoint) {
+  const auto [success, point] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, max_angle);
+      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
+TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsMidpoint) {
+  const auto [success, point] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+  ASSERT_FALSE(success);  // Expect failure due to coincident camera centers
+
+  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+  ASSERT_FALSE(success_noisy);  // Expect failure due to coincident camera centers
+
+  // Test that without the positive depth constraint, triangulation succeeds
+  // and returns the center of the cameras.
+  const double negative_min_depth = -1e-6;
+  const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
+      centers, bearings, thresholds, min_angle, max_angle, negative_min_depth);
+  ASSERT_TRUE(success_no_depth_check);
+  const Vec3d expected_point = centers.row(0);
+  ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
+}
 
 TEST_F(TwoCamsManyPointsFixture, TriangulateTwoBearingsMidpointMany) {
   const auto results = geometry::TriangulateTwoBearingsMidpointMany(
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index b44e32292..a65a8c12e 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -13,7 +13,8 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(
     const std::vector<Mat34d> &Rts,
     const MatX3d &bearings,
     double threshold,
-    double min_angle);
+    double min_angle,
+    double min_depth);
 
 Vec4d TriangulateBearingsDLTSolve(
     const MatX3d &bs,
@@ -24,7 +25,8 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     const MatX3d &bearings,
     const std::vector<double> &threshold_list,
     double min_angle,
-    double max_angle);
+    double max_angle,
+    double min_depth);
 
 template <class T>
 Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index a92819bd8..9638b4f0d 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -327,6 +327,7 @@ bool BAHelpers::TriangulateGCP(
   constexpr auto reproj_threshold{1.0};
   constexpr auto min_ray_angle = 0.1 * M_PI / 180.0;
   constexpr auto max_ray_angle = M_PI - min_ray_angle;
+  constexpr auto min_depth = 1e-3;  // Assume GCPs 1mm+ away from the camera
   MatX3d os, bs;
   size_t added = 0;
   coordinates = Vec3d::Zero();
@@ -348,7 +349,7 @@ bool BAHelpers::TriangulateGCP(
   if (added >= 2) {
     const std::vector<double> thresholds(added, reproj_threshold);
     const auto& res = geometry::TriangulateBearingsMidpoint(
-        os, bs, thresholds, min_ray_angle, max_ray_angle);
+        os, bs, thresholds, min_ray_angle, max_ray_angle, min_depth);
     coordinates = res.second;
     return res.first;
   }
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index 21d2d623f..8e8d9ca19 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -42,7 +42,7 @@ def test_track_triangulator_spherical() -> None:
     triangulator = reconstruction.TrackTriangulator(
         rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
     )
-    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, iterations=10)
+    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, min_depth=0.001, iterations=10)
     assert "1" in rec.points
     p = rec.points["1"].coordinates
     assert np.allclose(p, [0, 0, 1.3763819204711])
@@ -88,7 +88,7 @@ def test_track_triangulator_coincident_camera_origins() -> None:
     triangulator = reconstruction.TrackTriangulator(
         rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
     )
-    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, iterations=10)
+    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, min_depth=0.0001, iterations=10)
     assert not rec.points
 
 
@@ -104,12 +104,26 @@ def test_triangulate_bearings_dlt() -> None:
     b2 = unit_vector([-1.0, 0, 1])
     max_reprojection = 0.01
     min_ray_angle = np.radians(2.0)
+    min_depth = 0.001
     res, X = pygeometry.triangulate_bearings_dlt(
-        [rt1, rt2], np.asarray([b1, b2]), max_reprojection, min_ray_angle
+        [rt1, rt2], np.asarray([b1, b2]), max_reprojection, min_ray_angle, min_depth
     )
     assert np.allclose(X, [0, 0, 1.0])
     assert res is True
 
+def test_triangulate_bearings_dlt_coincident_camera_origins() -> None:
+    rt1 = np.append(np.identity(3), [[0], [0], [0]], axis=1)
+    rt2 = np.append(np.identity(3), [[0], [0], [0]], axis=1)  # same origin
+    b1 = unit_vector([0.0, 0, 1])
+    b2 = unit_vector([-1.0, 0, 1])
+    max_reprojection = 0.01
+    min_ray_angle = np.radians(2.0)
+    min_depth = 0.001
+    res, X = pygeometry.triangulate_bearings_dlt(
+        [rt1, rt2], np.asarray([b1, b2]), max_reprojection, min_ray_angle, min_depth
+    )
+    assert res is False
+
 
 def test_triangulate_bearings_midpoint() -> None:
     o1 = np.array([0.0, 0, 0])
@@ -118,17 +132,38 @@ def test_triangulate_bearings_midpoint() -> None:
     b2 = unit_vector([-1.0, 0, 1])
     max_reprojection = 0.01
     min_ray_angle = np.radians(2.0)
+    min_depth = 0.001
     valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
         np.asarray([o1, o2]),
         np.asarray([b1, b2]),
         2 * [max_reprojection],
         min_ray_angle,
         np.pi - min_ray_angle,
+        min_depth,
     )
     assert np.allclose(X, [0, 0, 1.0])
     assert valid_triangulation is True
 
 
+def test_triangulate_bearings_midpoint_coincident_camera_origins() -> None:
+    o1 = np.array([0.0, 0, 0])
+    b1 = unit_vector([0.0, 0, 1])
+    o2 = np.array([0.0, 0, 0])  # same origin
+    b2 = unit_vector([-1.0, 0, 1])
+    max_reprojection = 0.01
+    min_ray_angle = np.radians(2.0)
+    min_depth = 0.001
+    valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
+        np.asarray([o1, o2]),
+        np.asarray([b1, b2]),
+        2 * [max_reprojection],
+        min_ray_angle,
+        np.pi - min_ray_angle,
+        min_depth,
+    )
+    assert valid_triangulation is False
+
+
 def test_triangulate_two_bearings_midpoint() -> None:
     o1 = np.array([0.0, 0, 0])
     b1 = unit_vector([0.0, 0, 1])

From b6f2322c4c67baf1cf6b4abdcc8ecd2aa5075af0 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 110/235] Remove max_angle parameter

Summary:
We had an extra max_angle parameter in the midpoint triangulation function. The passed value was always `pi-min_angle`. The DLT triangulation function did not check for max angle.

So we remove the parameter, use always `pi-min_angle` internally and add the check also in the DLT triangulation function.

Reviewed By: YanNoun

Differential Revision: D72560210

fbshipit-source-id: bd355fd5a6748f4010ab6077fd6ac28a2171325e
---
 opensfm/multiview.py                          |  1 -
 opensfm/reconstruction.py                     |  4 ----
 opensfm/src/geometry/pygeometry.pyi           |  1 -
 opensfm/src/geometry/src/triangulation.cc     |  5 ++--
 .../src/geometry/test/triangulation_test.cc   | 24 ++++++++-----------
 opensfm/src/geometry/triangulation.h          |  1 -
 opensfm/src/sfm/src/ba_helpers.cc             |  3 +--
 opensfm/test/test_triangulation.py            |  2 --
 8 files changed, 13 insertions(+), 28 deletions(-)

diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index d1223c429..046db6e93 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -733,7 +733,6 @@ def triangulate_gcp(
             np.asarray(bs),
             thresholds,
             np.radians(min_ray_angle_degrees),
-            np.radians(180.0 - min_ray_angle_degrees),
             min_depth,
         )
         if valid_triangulation:
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 90478ef23..59382fd80 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -936,7 +936,6 @@ def triangulate_robust(
 
         thresholds = len(os) * [reproj_threshold]
         min_ray_angle_radians = np.radians(min_ray_angle_degrees)
-        max_ray_angle_radians = np.pi - min_ray_angle_radians
         for i in range(ransac_tries):
             random_id = int(np.random.rand() * (len(all_combinations) - 1))
             if random_id in combinatiom_tried:
@@ -953,7 +952,6 @@ def triangulate_robust(
                 bs_t,
                 thresholds,
                 min_ray_angle_radians,
-                max_ray_angle_radians,
                 min_depth,
             )
             X = pygeometry.point_refinement(os_t, bs_t, X, iterations)
@@ -971,7 +969,6 @@ def triangulate_robust(
                         bs[inliers],
                         len(inliers) * [reproj_threshold],
                         min_ray_angle_radians,
-                        max_ray_angle_radians,
                         min_depth,
                     )
                     new_X = pygeometry.point_refinement(
@@ -1040,7 +1037,6 @@ def triangulate(
                 np.asarray(bs),
                 thresholds,
                 min_ray_angle_radians,
-                np.pi - min_ray_angle_radians,
                 min_depth,
             )
             if valid_triangulation:
diff --git a/opensfm/src/geometry/pygeometry.pyi b/opensfm/src/geometry/pygeometry.pyi
index baa0d776b..2c125ae9e 100644
--- a/opensfm/src/geometry/pygeometry.pyi
+++ b/opensfm/src/geometry/pygeometry.pyi
@@ -399,7 +399,6 @@ def triangulate_bearings_midpoint(
     arg2: list[float],
     arg3: float,
     arg4: float,
-    arg5: float,
 ) -> tuple[bool, numpy.typing.NDArray]: ...
 def triangulate_two_bearings_midpoint(
     arg0: numpy.typing.NDArray, arg1: numpy.typing.NDArray
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 0fdc2223d..1c450ae01 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -91,7 +91,7 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(
     for (int j = 0; j < i && !angle_ok; ++j) {
       const double angle =
           AngleBetweenVectors(world_bearings.row(i), world_bearings.row(j));
-      if (angle >= min_angle) {
+      if (angle >= min_angle && angle <= M_PI - min_angle) {
         angle_ok = true;
       }
     }
@@ -147,7 +147,6 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     const MatX3d &bearings,
     const std::vector<double> &threshold_list,
     double min_angle,
-    double max_angle,
     double min_depth) {
   const int count = centers.rows();
 
@@ -156,7 +155,7 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
   for (int i = 0; i < count && !angle_ok; ++i) {
     for (int j = 0; j < i && !angle_ok; ++j) {
       const auto angle = AngleBetweenVectors(bearings.row(i), bearings.row(j));
-      if (angle >= min_angle && angle <= max_angle) {
+      if (angle >= min_angle && angle <= M_PI - min_angle) {
         angle_ok = true;
       }
     }
diff --git a/opensfm/src/geometry/test/triangulation_test.cc b/opensfm/src/geometry/test/triangulation_test.cc
index a17193d0c..d0ba3677e 100644
--- a/opensfm/src/geometry/test/triangulation_test.cc
+++ b/opensfm/src/geometry/test/triangulation_test.cc
@@ -67,7 +67,6 @@ class TwoCamsFixture : public ::testing::Test {
   const double threshold = 0.01;
   const std::vector<double> thresholds = {0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
-  const double max_angle = M_PI - min_angle;
   const double min_depth = 1e-6;
 };
 
@@ -91,7 +90,6 @@ class FiveCamsFixture : public ::testing::Test {
   const double threshold = 0.01;
   const std::vector<double> thresholds = {0.01, 0.01, 0.01, 0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
-  const double max_angle = M_PI - min_angle;
   const double min_depth = 1e-6;
 };
 
@@ -122,7 +120,6 @@ class ThreeCamsSameCenterFixture : public ::testing::Test {
   const double threshold = 0.01;
   const std::vector<double> thresholds = {0.01, 0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
-  const double max_angle = M_PI - min_angle;
   const double min_depth = 1e-6;
 };
 
@@ -156,7 +153,6 @@ class TwoCamsSameCenterFixture : public ::testing::Test {
   const double threshold = 0.01;
   const std::vector<double> thresholds = {0.01, 0.01};
   const double min_angle = 2.0 * M_PI / 180.0;
-  const double max_angle = M_PI - min_angle;
   const double min_depth = 1e-6;
 };
 
@@ -241,7 +237,7 @@ TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsDLT) {
   // and returns the center of the cameras.
   const double negative_min_depth = -1e-6;
   const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, negative_min_depth);
+      centers, bearings, thresholds, min_angle, negative_min_depth);
   ASSERT_TRUE(success_no_depth_check);
   const Vec3d expected_point = centers.row(0);
   ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
@@ -249,54 +245,54 @@ TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsDLT) {
 
 TEST_F(TwoCamsFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings_noisy, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
 TEST_F(FiveCamsFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings_noisy, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
 TEST_F(ThreeCamsSameCenterFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings_noisy, thresholds, min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
 
 TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsMidpoint) {
   const auto [success, point] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_FALSE(success);  // Expect failure due to coincident camera centers
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, min_depth);
+      centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_FALSE(success_noisy);  // Expect failure due to coincident camera centers
 
   // Test that without the positive depth constraint, triangulation succeeds
   // and returns the center of the cameras.
   const double negative_min_depth = -1e-6;
   const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, max_angle, negative_min_depth);
+      centers, bearings, thresholds, min_angle, negative_min_depth);
   ASSERT_TRUE(success_no_depth_check);
   const Vec3d expected_point = centers.row(0);
   ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index a65a8c12e..c7cd30716 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -25,7 +25,6 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     const MatX3d &bearings,
     const std::vector<double> &threshold_list,
     double min_angle,
-    double max_angle,
     double min_depth);
 
 template <class T>
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 9638b4f0d..8163d00f7 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -326,7 +326,6 @@ bool BAHelpers::TriangulateGCP(
     Vec3d& coordinates) {
   constexpr auto reproj_threshold{1.0};
   constexpr auto min_ray_angle = 0.1 * M_PI / 180.0;
-  constexpr auto max_ray_angle = M_PI - min_ray_angle;
   constexpr auto min_depth = 1e-3;  // Assume GCPs 1mm+ away from the camera
   MatX3d os, bs;
   size_t added = 0;
@@ -349,7 +348,7 @@ bool BAHelpers::TriangulateGCP(
   if (added >= 2) {
     const std::vector<double> thresholds(added, reproj_threshold);
     const auto& res = geometry::TriangulateBearingsMidpoint(
-        os, bs, thresholds, min_ray_angle, max_ray_angle, min_depth);
+        os, bs, thresholds, min_ray_angle, min_depth);
     coordinates = res.second;
     return res.first;
   }
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index 8e8d9ca19..da01d8fd1 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -138,7 +138,6 @@ def test_triangulate_bearings_midpoint() -> None:
         np.asarray([b1, b2]),
         2 * [max_reprojection],
         min_ray_angle,
-        np.pi - min_ray_angle,
         min_depth,
     )
     assert np.allclose(X, [0, 0, 1.0])
@@ -158,7 +157,6 @@ def test_triangulate_bearings_midpoint_coincident_camera_origins() -> None:
         np.asarray([b1, b2]),
         2 * [max_reprojection],
         min_ray_angle,
-        np.pi - min_ray_angle,
         min_depth,
     )
     assert valid_triangulation is False

From 110da9c3f3c5d61979d97a2a6588bda9c4f52831 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Apr 2025 14:55:00 -0700
Subject: [PATCH 111/235] Remove same origin checks from reconstruction

Summary: Triangulation now accepts a min_depth parameter that prevents the triangulated point to be at the origin. This avoids the same-origin issue without explicitly preventing some of the cameras to have a common origin.

Reviewed By: YanNoun

Differential Revision: D72560466

fbshipit-source-id: b94c53643a0abb346543f9328a73c18ca26aa8b6
---
 opensfm/reconstruction.py | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 59382fd80..1b996457a 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1023,13 +1023,6 @@ def triangulate(
             ids.append(shot_id)
 
         if len(os) >= 2:
-            
-            # Check if all the origins are at the same point. In such a case,
-            # the triangulation will degenerate to pure rotation and the
-            # triangulated point will always be invalid or at [0, 0, 0].
-            if all(np.allclose(os[i], os[0]) for i in range(1, len(os))):
-                return
-
             thresholds = len(os) * [reproj_threshold]
             min_ray_angle_radians = np.radians(min_ray_angle_degrees)
             valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
@@ -1043,12 +1036,6 @@ def triangulate(
                 X = pygeometry.point_refinement(
                     np.array(os), np.array(bs), X, iterations
                 )
-                if np.allclose(X, [0, 0, 0]):
-                    logger.warning(
-                        f"Detected potentially problematic triangulated point: "
-                        f"{X.tolist()} {os=} {bs=} {ids=}. It can be caused by "
-                        "identical origin points (pure rotation)."
-                    )
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
                     self.tracks_handler.store_inliers_observation(track, shot_id)

From 24ea37df52523f6f19b298edc27f5429c3777b3c Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Thu, 10 Apr 2025 05:57:59 -0700
Subject: [PATCH 112/235] run linter on all repo

Summary:
The goal here is to activate linters for the OpenSfM folder so we do not need to manually format files and the style is kept consistent.

Follow-up changes needed to have the linter running on github.

Reviewed By: YanNoun

Differential Revision: D72635702

fbshipit-source-id: d69aaaf782c5baee7b87530252b39e2f943f93cd
---
 annotation_gui_gcp/lib/GUI.py                 |   3 +-
 annotation_gui_gcp/lib/gcp_manager.py         |   4 +-
 annotation_gui_gcp/lib/geometry.py            |   9 +-
 annotation_gui_gcp/lib/views/cad_view.py      |  23 ++--
 annotation_gui_gcp/lib/views/image_view.py    |   4 +-
 annotation_gui_gcp/lib/views/tools_view.py    |   2 +-
 annotation_gui_gcp/lib/views/web_view.py      |   2 +-
 annotation_gui_gcp/main.py                    |   8 +-
 annotation_gui_gcp/run_ba.py                  |   1 -
 bin/migrate_undistort.sh                      |  10 +-
 bin/plot_gcp.py                               |  49 ++++-----
 data/berlin/config.yaml                       |   1 -
 data/lund/config.yaml                         |   1 -
 export_pmvs.md                                |  22 ++--
 opensfm/__init__.py                           |  29 +++--
 opensfm/actions/align_submodels.py            |   5 +-
 opensfm/actions/bundle.py                     |   7 +-
 opensfm/actions/compute_depthmaps.py          |   3 +-
 opensfm/actions/compute_statistics.py         |   5 +-
 opensfm/actions/create_rig.py                 |  12 ++-
 opensfm/actions/create_submodels.py           |   4 +-
 opensfm/actions/create_tracks.py              |   3 +-
 opensfm/actions/export_bundler.py             |   6 +-
 opensfm/actions/export_colmap.py              |  10 +-
 opensfm/actions/export_geocoords.py           |  19 ++--
 opensfm/actions/export_openmvs.py             |   9 +-
 opensfm/actions/export_ply.py                 |  15 ++-
 opensfm/actions/export_pmvs.py                |   4 +-
 opensfm/actions/export_visualsfm.py           |   3 +-
 opensfm/actions/extend_reconstruction.py      |   3 +-
 opensfm/actions/extract_metadata.py           |   1 +
 opensfm/actions/match_features.py             |   3 +-
 opensfm/actions/reconstruct.py                |   7 +-
 opensfm/actions/reconstruct_from_prior.py     |   3 +-
 opensfm/align.py                              |   5 +-
 opensfm/commands/__init__.py                  |   2 +-
 opensfm/commands/align_submodels.py           |   5 +-
 opensfm/commands/bundle.py                    |   5 +-
 opensfm/commands/command.py                   |   6 +-
 opensfm/commands/command_runner.py            |   8 +-
 opensfm/commands/compute_depthmaps.py         |   5 +-
 opensfm/commands/compute_statistics.py        |   6 +-
 opensfm/commands/create_rig.py                |   4 +-
 opensfm/commands/create_submodels.py          |   5 +-
 opensfm/commands/create_tracks.py             |   5 +-
 opensfm/commands/detect_features.py           |   5 +-
 opensfm/commands/export_bundler.py            |   5 +-
 opensfm/commands/export_colmap.py             |   5 +-
 opensfm/commands/export_geocoords.py          |   5 +-
 opensfm/commands/export_openmvs.py            |   5 +-
 opensfm/commands/export_ply.py                |  15 ++-
 opensfm/commands/export_pmvs.py               |   5 +-
 opensfm/commands/export_report.py             |   6 +-
 opensfm/commands/export_visualsfm.py          |   5 +-
 opensfm/commands/extend_reconstruction.py     |   5 +-
 opensfm/commands/extract_metadata.py          |   5 +-
 opensfm/commands/match_features.py            |   5 +-
 opensfm/commands/mesh.py                      |   5 +-
 opensfm/commands/reconstruct.py               |   5 +-
 opensfm/commands/reconstruct_from_prior.py    |   5 +-
 opensfm/commands/undistort.py                 |  16 ++-
 opensfm/config.py                             |   4 +-
 opensfm/context.py                            |   2 +-
 opensfm/dataset.py                            |  21 ++--
 opensfm/dataset_base.py                       |  11 +-
 opensfm/dense.py                              |   9 +-
 opensfm/exif.py                               |   4 +-
 opensfm/feature_loading.py                    |   4 +-
 opensfm/features.py                           |  13 ++-
 opensfm/geo.py                                |  17 +--
 opensfm/geotag_from_gpx.py                    |   4 +-
 opensfm/io.py                                 |  29 ++---
 opensfm/large/metadataset.py                  |  21 ++--
 opensfm/large/tools.py                        |   5 +-
 opensfm/masking.py                            |   2 +-
 opensfm/matching.py                           |   5 +-
 opensfm/mesh.py                               |   2 +-
 opensfm/multiview.py                          |   4 +-
 opensfm/pairs_selection.py                    |  14 +--
 opensfm/reconstruction.py                     |  12 ++-
 opensfm/report.py                             |   3 +-
 opensfm/rig.py                                |   8 +-
 opensfm/sensors.py                            |   6 +-
 opensfm/src/bundle/bundle_adjuster.h          |   9 +-
 .../src/bundle/error/absolute_motion_errors.h |   6 +-
 .../src/bundle/error/relative_depth_error.h   |  10 +-
 opensfm/src/bundle/python/pybind.cc           |   7 +-
 opensfm/src/bundle/src/bundle_adjuster.cc     |  30 +++---
 opensfm/src/dense/depthmap_bind.h             |  44 ++++----
 opensfm/src/dense/openmvs_exporter.h          |   8 +-
 opensfm/src/dense/python/pybind.cc            |   7 +-
 opensfm/src/dense/src/depthmap.cc             |   4 +-
 opensfm/src/dense/test/depthmap_test.cc       |   1 +
 opensfm/src/features/src/akaze_bind.cc        |   4 +-
 opensfm/src/features/src/matching.cc          |   6 +-
 opensfm/src/foundation/python_types.h         |   7 +-
 .../src/foundation/test/union_find_test.cc    |   7 +-
 opensfm/src/geo/src/geo.cc                    |   2 +-
 opensfm/src/geometry/camera.h                 |   7 +-
 .../geometry/camera_distortions_functions.h   |  56 ++++++----
 opensfm/src/geometry/covariance.h             |   2 +-
 opensfm/src/geometry/essential.h              |   1 +
 opensfm/src/geometry/python/pybind.cc         |  28 ++---
 opensfm/src/geometry/relative_pose.h          |   9 +-
 opensfm/src/geometry/src/camera.cc            |  12 +--
 opensfm/src/geometry/src/covariance.cc        |   2 +-
 opensfm/src/geometry/src/triangulation.cc     |  50 ++++-----
 .../geometry/test/camera_functions_test.cc    |   4 +-
 opensfm/src/geometry/test/camera_test.cc      |  43 ++++----
 .../src/geometry/test/triangulation_test.cc   | 102 +++++++++---------
 opensfm/src/geometry/triangulation.h          |  47 +++-----
 opensfm/src/map/ground_control_points.h       |  18 ++--
 opensfm/src/map/observation.h                 |   4 +-
 opensfm/src/map/python/pybind.cc              |  26 +++--
 opensfm/src/map/rig.h                         |   3 +-
 .../absolute_pose_known_rotation_model.h      |   1 +
 opensfm/src/robust/absolute_pose_model.h      |   1 +
 opensfm/src/robust/essential_model.h          |   1 +
 opensfm/src/robust/relative_pose_model.h      |   1 +
 opensfm/src/robust/relative_rotation_model.h  |   1 +
 opensfm/src/sfm/retriangulation.h             |   2 +-
 opensfm/src/sfm/src/ba_helpers.cc             |  12 ++-
 opensfm/src/sfm/src/retriangulation.cc        |   2 +-
 opensfm/src/sfm/src/tracks_helpers.cc         |   2 +-
 opensfm/src/sfm/tracks_helpers.h              |   2 +-
 opensfm/stats.py                              |  48 +++++----
 opensfm/synthetic_data/synthetic_dataset.py   |   2 +-
 opensfm/synthetic_data/synthetic_metrics.py   |   6 +-
 opensfm/synthetic_data/synthetic_scene.py     |  12 +--
 opensfm/test/conftest.py                      |  22 ++--
 opensfm/test/test_bundle.py                   |  28 ++---
 opensfm/test/test_commands.py                 |   3 +-
 opensfm/test/test_dataset.py                  |   2 +-
 opensfm/test/test_datastructures.py           |  30 +++---
 opensfm/test/test_dense.py                    |   8 +-
 opensfm/test/test_geo.py                      |   5 +-
 opensfm/test/test_io.py                       |   2 +-
 opensfm/test/test_matching.py                 |  10 +-
 opensfm/test/test_multiview.py                |   8 +-
 opensfm/test/test_pairs_selection.py          |   2 +-
 opensfm/test/test_reconstruction_alignment.py |   7 +-
 opensfm/test/test_reconstruction_resect.py    |  10 +-
 .../test_reconstruction_shot_neighborhood.py  |   6 +-
 opensfm/test/test_rig.py                      |  17 ++-
 opensfm/test/test_robust.py                   |   3 +-
 opensfm/test/test_triangulation.py            |  24 +++--
 opensfm/test/test_types.py                    |  13 +--
 opensfm/test/test_undistort.py                |   2 +-
 opensfm/tracking.py                           |  22 +++-
 opensfm/transformations.py                    |  10 +-
 opensfm/types.py                              |   1 +
 opensfm/undistort.py                          |  12 ++-
 opensfm/upright.py                            |   3 +-
 opensfm/video.py                              |   7 +-
 opensfm/vlad.py                               |   4 +-
 viewer/legacy/js/three.js                     |  10 +-
 viewer/server.py                              |   8 +-
 157 files changed, 855 insertions(+), 731 deletions(-)

diff --git a/annotation_gui_gcp/lib/GUI.py b/annotation_gui_gcp/lib/GUI.py
index 2ca3822a6..1676201a1 100644
--- a/annotation_gui_gcp/lib/GUI.py
+++ b/annotation_gui_gcp/lib/GUI.py
@@ -7,11 +7,12 @@
 from collections import defaultdict
 
 import flask
+from opensfm import dataset
+
 from .views.cad_view import CADView
 from .views.cp_finder_view import ControlPointFinderView
 from .views.image_view import ImageView
 from .views.tools_view import ToolsView
-from opensfm import dataset
 
 
 class Gui:
diff --git a/annotation_gui_gcp/lib/gcp_manager.py b/annotation_gui_gcp/lib/gcp_manager.py
index f5d2858e5..3472bf21c 100644
--- a/annotation_gui_gcp/lib/gcp_manager.py
+++ b/annotation_gui_gcp/lib/gcp_manager.py
@@ -71,7 +71,7 @@ def __repr__(self):
 
 
 def observation_to_json(
-    obs: t.Union[PointMeasurement3D, PointMeasurement]
+    obs: t.Union[PointMeasurement3D, PointMeasurement],
 ) -> t.Dict[str, t.Any]:
     if isinstance(obs, PointMeasurement):
         return {
@@ -90,7 +90,7 @@ def observation_to_json(
 
 
 def observation_from_json(
-    obs: t.Dict[str, t.Any]
+    obs: t.Dict[str, t.Any],
 ) -> t.Union[PointMeasurement3D, PointMeasurement]:
     if "projection" in obs:
         return PointMeasurement(
diff --git a/annotation_gui_gcp/lib/geometry.py b/annotation_gui_gcp/lib/geometry.py
index 1df053f3e..edb9b2ddf 100644
--- a/annotation_gui_gcp/lib/geometry.py
+++ b/annotation_gui_gcp/lib/geometry.py
@@ -1,8 +1,9 @@
 # pyre-unsafe
-from opensfm import dataset
-from numpy import ndarray
 from typing import Dict, Tuple
 
+from numpy import ndarray
+from opensfm import dataset
+
 
 def get_all_track_observations(gcp_database, track_id: str) -> Dict[str, ndarray]:
     print(f"Getting all observations of track {track_id}")
@@ -12,7 +13,9 @@ def get_all_track_observations(gcp_database, track_id: str) -> Dict[str, ndarray
     return {shot_id: obs.point for shot_id, obs in track_obs.items()}
 
 
-def get_tracks_visible_in_image(gcp_database, image_key, min_len: int=5) -> Dict[str, Tuple[ndarray, int]]:
+def get_tracks_visible_in_image(
+    gcp_database, image_key, min_len: int = 5
+) -> Dict[str, Tuple[ndarray, int]]:
     print(f"Getting track observations visible in {image_key}")
     data = dataset.DataSet(gcp_database.path)
     tracks_manager = data.load_tracks_manager()
diff --git a/annotation_gui_gcp/lib/views/cad_view.py b/annotation_gui_gcp/lib/views/cad_view.py
index 5cb199246..23a6c118c 100644
--- a/annotation_gui_gcp/lib/views/cad_view.py
+++ b/annotation_gui_gcp/lib/views/cad_view.py
@@ -5,10 +5,11 @@
 from typing import Any, Dict, Tuple
 
 import rasterio
-from ..views.web_view import WebView, distinct_colors
 from flask import send_file
 from PIL import ImageColor
 
+from ..views.web_view import distinct_colors, WebView
+
 logger: logging.Logger = logging.getLogger(__name__)
 
 
@@ -31,7 +32,7 @@ def __init__(
         route_prefix,
         path_cad_file,
         is_geo_reference=False,
-    )-> None:
+    ) -> None:
         super().__init__(main_ui, web_app, route_prefix)
 
         self.main_ui = main_ui
@@ -60,7 +61,7 @@ def process_client_message(self, data: Dict[str, Any]) -> None:
         else:
             raise ValueError(f"Unknown event {event}")
 
-    def add_remove_update_point_observation(self, point_coordinates=None)->None:
+    def add_remove_update_point_observation(self, point_coordinates=None) -> None:
         gcp_manager = self.main_ui.gcp_manager
         active_gcp = self.main_ui.curr_point
         if active_gcp is None:
@@ -98,17 +99,17 @@ def add_remove_update_point_observation(self, point_coordinates=None)->None:
     def display_points(self) -> None:
         pass
 
-    def refocus(self, lat, lon)->None:
+    def refocus(self, lat, lon) -> None:
         x, y, z = self.latlon_to_xyz(lat, lon)
         self.send_sse_message(
             {"x": x, "y": y, "z": z},
             event_type="move_camera",
         )
 
-    def highlight_gcp_reprojection(self, *args, **kwargs)->None:
+    def highlight_gcp_reprojection(self, *args, **kwargs) -> None:
         pass
 
-    def populate_image_list(self, *args, **kwargs)->None:
+    def populate_image_list(self, *args, **kwargs) -> None:
         pass
 
     def latlon_to_xyz(self, lat, lon) -> Tuple[float, float, float]:
@@ -129,13 +130,13 @@ def xyz_to_latlon(self, x, y, z) -> Tuple[float, float, float]:
         lons, lats, alts = rasterio.warp.transform(self.crs, "EPSG:4326", [x], [y], [z])
         return lats[0], lons[0], alts[0]
 
-    def load_georeference_metadata(self, path_cad_model)->None:
+    def load_georeference_metadata(self, path_cad_model) -> None:
         metadata = _load_georeference_metadata(path_cad_model)
         self.scale = metadata["scale"]
         self.crs = metadata["crs"]
         self.offset = metadata["offset"]
 
-    def sync_to_client(self)->None:
+    def sync_to_client(self) -> None:
         """
         Sends all the data required to initialize or sync the CAD view
         """
@@ -152,7 +153,11 @@ def sync_to_client(self)->None:
         for point_id, coords in visible_points_coords.items():
             hex_color = distinct_colors[divmod(hash(point_id), 19)[1]]
             color = ImageColor.getrgb(hex_color)
-            data["annotations"][point_id] = {"coordinates": coords[:-1], "precision": coords[-1], "color": color}
+            data["annotations"][point_id] = {
+                "coordinates": coords[:-1],
+                "precision": coords[-1],
+                "color": color,
+            }
 
         # Add the 3D reprojections of the points
         fn_reprojections = Path(
diff --git a/annotation_gui_gcp/lib/views/image_view.py b/annotation_gui_gcp/lib/views/image_view.py
index 11d1688a5..0465eaaea 100644
--- a/annotation_gui_gcp/lib/views/image_view.py
+++ b/annotation_gui_gcp/lib/views/image_view.py
@@ -1,7 +1,7 @@
 # pyre-unsafe
-from typing import Dict, Any
+from typing import Any, Dict
 
-from .web_view import WebView, distinct_colors
+from .web_view import distinct_colors, WebView
 
 
 def point_color(point_id: str) -> str:
diff --git a/annotation_gui_gcp/lib/views/tools_view.py b/annotation_gui_gcp/lib/views/tools_view.py
index a0d5fb223..263a2fff1 100644
--- a/annotation_gui_gcp/lib/views/tools_view.py
+++ b/annotation_gui_gcp/lib/views/tools_view.py
@@ -1,5 +1,5 @@
 # pyre-unsafe
-from typing import Dict, Any
+from typing import Any, Dict
 
 from .web_view import WebView
 
diff --git a/annotation_gui_gcp/lib/views/web_view.py b/annotation_gui_gcp/lib/views/web_view.py
index b41dd41e6..0505ff62f 100644
--- a/annotation_gui_gcp/lib/views/web_view.py
+++ b/annotation_gui_gcp/lib/views/web_view.py
@@ -4,7 +4,7 @@
 import time
 from queue import Queue
 
-from flask import Response, jsonify, render_template, request
+from flask import jsonify, render_template, request, Response
 
 distinct_colors = [
     "#46f0f0",
diff --git a/annotation_gui_gcp/main.py b/annotation_gui_gcp/main.py
index ea27639b5..949a99e74 100644
--- a/annotation_gui_gcp/main.py
+++ b/annotation_gui_gcp/main.py
@@ -2,16 +2,18 @@
 import argparse
 import json
 import typing as t
-from collections import OrderedDict, defaultdict
+from collections import defaultdict, OrderedDict
 from os import PathLike
 from pathlib import Path
 from typing import Union
 
 import numpy as np
+from flask import Flask
 from mapillary.opensfm.annotation_gui_gcp.lib import GUI
-from mapillary.opensfm.annotation_gui_gcp.lib.gcp_manager import GroundControlPointManager
+from mapillary.opensfm.annotation_gui_gcp.lib.gcp_manager import (
+    GroundControlPointManager,
+)
 from mapillary.opensfm.annotation_gui_gcp.lib.image_manager import ImageManager
-from flask import Flask
 from opensfm import dataset, io
 
 
diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index 41d54ed59..9737a7688 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -739,7 +739,6 @@ def align(
     resplit = resplit_reconstruction(merged, reconstructions)
     data.save_reconstruction(resplit, fn_resplit)
     if covariance:
-
         # Re-triangulate to remove badly conditioned points
         n_points = len(merged.points)
 
diff --git a/bin/migrate_undistort.sh b/bin/migrate_undistort.sh
index 170d602a4..c17b4bf97 100755
--- a/bin/migrate_undistort.sh
+++ b/bin/migrate_undistort.sh
@@ -2,16 +2,16 @@
 
 # Migrate dataset to the new undistort folder structure.
 
-if [ $# -le 0 ] 
+if [ $# -le 0 ]
 then
-    echo "Migrate dataset to the new undistort folder structure." 
+    echo "Migrate dataset to the new undistort folder structure."
     echo
-	echo "Usage:"
+    echo "Usage:"
     echo
     echo "    $0 dataset"
     echo
-	exit 1
-fi 
+    exit 1
+fi
 
 cd $1
 
diff --git a/bin/plot_gcp.py b/bin/plot_gcp.py
index dbb278550..77a7f86ca 100644
--- a/bin/plot_gcp.py
+++ b/bin/plot_gcp.py
@@ -1,39 +1,37 @@
-"""Plot image crops around GCPs.
-"""
+"""Plot image crops around GCPs."""
 
 import argparse
 import logging
 from typing import List
 
-import numpy as np
 import matplotlib.pyplot as plt
 
+import numpy as np
+
 import opensfm.reconstruction as orec
-from opensfm import features
-from opensfm import io
-from opensfm import dataset
-from opensfm import pymap
-from opensfm import types
+from opensfm import dataset, features, io, pymap, types
 
 logger = logging.getLogger(__name__)
 
 
 def parse_args():
-    parser = argparse.ArgumentParser(
-        description=__doc__)
+    parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
-        'dataset',
-        help='dataset',
+        "dataset",
+        help="dataset",
     )
     return parser.parse_args()
 
 
 def pix_coords(x, image):
     return features.denormalized_image_coordinates(
-        np.array([[x[0], x[1]]]), image.shape[1], image.shape[0])[0]
+        np.array([[x[0], x[1]]]), image.shape[1], image.shape[0]
+    )[0]
 
 
-def gcp_to_ply(gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction):
+def gcp_to_ply(
+    gcps: List[pymap.GroundControlPoint], reconstruction: types.Reconstruction
+):
     """Export GCP position as a PLY string."""
     vertices = []
 
@@ -44,13 +42,15 @@ def gcp_to_ply(gcps: List[pymap.GroundControlPoint], reconstruction: types.Recon
             p = orec.triangulate_gcp(gcp, reconstruction.shots)
 
         if p is None:
-            logger.warning("Could not compute the 3D position of GCP '{}'"
-                           .format(gcp.id))
+            logger.warning(
+                "Could not compute the 3D position of GCP '{}'".format(gcp.id)
+            )
             continue
 
         c = 255, 0, 0
         s = "{} {} {} {} {} {}".format(
-            p.value[0], p.value[1], p.value[2], int(c[0]), int(c[1]), int(c[2]))
+            p.value[0], p.value[1], p.value[2], int(c[0]), int(c[1]), int(c[2])
+        )
         vertices.append(s)
 
     header = [
@@ -66,20 +66,20 @@ def gcp_to_ply(gcps: List[pymap.GroundControlPoint], reconstruction: types.Recon
         "end_header",
     ]
 
-    return '\n'.join(header + vertices + [''])
+    return "\n".join(header + vertices + [""])
 
 
 def main():
     args = parse_args()
     logging.basicConfig(
-        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-        level=logging.DEBUG)
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s", level=logging.DEBUG
+    )
 
     data = dataset.DataSet(args.dataset)
     reconstruction = data.load_reconstruction()[0]
     gcps = data.load_ground_control_points()
 
-    with io.open_wt(data.data_path + '/gcp.ply') as fout:
+    with io.open_wt(data.data_path + "/gcp.ply") as fout:
         fout.write(gcp_to_ply(gcps, reconstruction))
 
     for gcp in gcps:
@@ -91,8 +91,9 @@ def main():
             coordinates = orec.triangulate_gcp(gcp, reconstruction.shots)
 
         if coordinates is None:
-            logger.warning("Could not compute the 3D position of GCP '{}'"
-                           .format(gcp.id))
+            logger.warning(
+                "Could not compute the 3D position of GCP '{}'".format(gcp.id)
+            )
             continue
 
         for i, observation in enumerate(gcp.observations):
@@ -113,5 +114,5 @@ def main():
         plt.show()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/data/berlin/config.yaml b/data/berlin/config.yaml
index d4689cc5e..c9249183b 100644
--- a/data/berlin/config.yaml
+++ b/data/berlin/config.yaml
@@ -1,4 +1,3 @@
-
 # OpenSfM will use the default parameters from opensfm/config.py
 # Set here any parameter that you want to override for this dataset
 # For example:
diff --git a/data/lund/config.yaml b/data/lund/config.yaml
index 5d2e0359f..6cfded297 100644
--- a/data/lund/config.yaml
+++ b/data/lund/config.yaml
@@ -1,4 +1,3 @@
-
 # OpenSfM will use the default parameters from opensfm/config.py
 # Set here any parameter that you want to override for this dataset
 # For example:
diff --git a/export_pmvs.md b/export_pmvs.md
index 8298df3d2..e748868da 100644
--- a/export_pmvs.md
+++ b/export_pmvs.md
@@ -9,30 +9,30 @@ Download CMVS: http://www.di.ens.fr/cmvs/
 ### PMVS Installation Hints (Linux/Ubuntu)
 - Installation pointers here: http://www.di.ens.fr/cmvs/documentation.html
 
-- Type `make` in `cmvs/program/main`. Should make three binaries: 
+- Type `make` in `cmvs/program/main`. Should make three binaries:
     + `pmvs2`
     + `cmvs`
     + `genOptions`
-    
-- Most dependencies installed with apt-get: 
+
+- Most dependencies installed with apt-get:
 
     `sudo apt-get install libgsl0-dev libblas-dev libatlas-dev liblapack-dev liblapacke-dev`
 
 - Updated Graclus link: http://www.cs.utexas.edu/users/dml/Software/graclus.html
 
-#### Lapack Errors: 
+#### Lapack Errors:
 http://mdda.net/oss-blog/2014-06/building-VisualSFM-on-FC20/
 
     ERROR : ../base/numeric/mylapack.cc:6:25: fatal error: clapack/f2c.h: No such file or directory
 
 Update `../base/numeric/mylapack.cc`
-From: 
+From:
 
     extern "C" {
     #include <clapack/f2c.h>
     #include <clapack/clapack.h>
     };
-To: 
+To:
 
     extern "C" {
     //#include <clapack/f2c.h>
@@ -71,7 +71,7 @@ Add this to `../base/cmvs/bundle.cc`
 
     #include <numeric>
 
-#### Stdlib Error: 
+#### Stdlib Error:
     genOption.cc: In function ‘int main(int, char**)’:
     genOption.cc:17:12: error: ‘exit’ was not declared in this scope
 
@@ -79,7 +79,7 @@ Add this to `genOption.cc`
 
     #include <cstdlib>
 
-### PMVS Inputs 
+### PMVS Inputs
 
 These are the files that `export_pmvs` generates for PMVS from OpenSfM output. More info: http://www.di.ens.fr/pmvs/documentation.html
 
@@ -95,11 +95,11 @@ From the root OpenSfM directory, run:
 
     bin/export_pmvs <path_to_dataset>
 
-There will be an individual pmvs directory for each separate reconstruction. 
+There will be an individual pmvs directory for each separate reconstruction.
 
-To perform the PMVS point cloud reconstruction, run: 
+To perform the PMVS point cloud reconstruction, run:
 
-    ./pmvs2 <path_to_dataset>/pmvs/recon0/ pmvs_options.txt 
+    ./pmvs2 <path_to_dataset>/pmvs/recon0/ pmvs_options.txt
 
 This will generate files in `<path_to_dataset>/pmvs/recon0/models/` including a `pmvs_options.txt.ply`
 
diff --git a/opensfm/__init__.py b/opensfm/__init__.py
index 8cd78b225..80f3e9871 100644
--- a/opensfm/__init__.py
+++ b/opensfm/__init__.py
@@ -1,9 +1,22 @@
 # pyre-unsafe
-from opensfm import pybundle
-from opensfm import pydense
-from opensfm import pyfeatures
-from opensfm import pygeo
-from opensfm import pygeometry
-from opensfm import pymap
-from opensfm import pyrobust
-from opensfm import pysfm
+from opensfm import (
+    pybundle,
+    pydense,
+    pyfeatures,
+    pygeo,
+    pygeometry,
+    pymap,
+    pyrobust,
+    pysfm,
+)
+
+__all__ = [
+    "pybundle",
+    "pydense",
+    "pyfeatures",
+    "pygeo",
+    "pygeometry",
+    "pymap",
+    "pyrobust",
+    "pysfm",
+]
diff --git a/opensfm/actions/align_submodels.py b/opensfm/actions/align_submodels.py
index 28fc2a525..91ac0875b 100644
--- a/opensfm/actions/align_submodels.py
+++ b/opensfm/actions/align_submodels.py
@@ -1,11 +1,10 @@
 # pyre-unsafe
-from opensfm.large import metadataset
-from opensfm.large import tools
 from opensfm.dataset import DataSet
+from opensfm.large import metadataset, tools
 
 
 def run_dataset(data: DataSet) -> None:
-    """ Align submodel reconstructions for of MetaDataSet. """
+    """Align submodel reconstructions for of MetaDataSet."""
 
     meta_data = metadataset.MetaDataSet(data.data_path)
     reconstruction_shots = tools.load_reconstruction_shots(meta_data)
diff --git a/opensfm/actions/bundle.py b/opensfm/actions/bundle.py
index 28c08dd14..ebbc5cab2 100644
--- a/opensfm/actions/bundle.py
+++ b/opensfm/actions/bundle.py
@@ -1,10 +1,13 @@
 # pyre-unsafe
+from typing import Optional
+
 import opensfm.reconstruction as orec
 from opensfm.dataset_base import DataSetBase
-from typing import Optional
 
 
-def run_dataset(dataset: DataSetBase, input: Optional[str], output: Optional[str]) -> None:
+def run_dataset(
+    dataset: DataSetBase, input: Optional[str], output: Optional[str]
+) -> None:
     """Bundle a reconstructions.
 
     Args:
diff --git a/opensfm/actions/compute_depthmaps.py b/opensfm/actions/compute_depthmaps.py
index e7972c226..fd61a5d1c 100644
--- a/opensfm/actions/compute_depthmaps.py
+++ b/opensfm/actions/compute_depthmaps.py
@@ -1,8 +1,7 @@
 # pyre-unsafe
 import os
 
-from opensfm import dataset
-from opensfm import dense
+from opensfm import dataset, dense
 from opensfm.dataset import DataSet
 
 
diff --git a/opensfm/actions/compute_statistics.py b/opensfm/actions/compute_statistics.py
index 0b8eb057a..da0a05a07 100644
--- a/opensfm/actions/compute_statistics.py
+++ b/opensfm/actions/compute_statistics.py
@@ -2,14 +2,13 @@
 import logging
 import os
 
-from opensfm import io
-from opensfm import stats
+from opensfm import io, stats
 from opensfm.dataset import DataSet
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def run_dataset(data: DataSet, diagram_max_points: int=-1) -> None:
+def run_dataset(data: DataSet, diagram_max_points: int = -1) -> None:
     """Compute various staistics of a datasets and write them to 'stats' folder
 
     Args:
diff --git a/opensfm/actions/create_rig.py b/opensfm/actions/create_rig.py
index 50b1608fb..5d5466b73 100644
--- a/opensfm/actions/create_rig.py
+++ b/opensfm/actions/create_rig.py
@@ -1,16 +1,18 @@
 # pyre-unsafe
 import logging
+from typing import Dict, List
 
-from opensfm import pymap, rig, reconstruction_helpers as helpers, types
+from opensfm import pymap, reconstruction_helpers as helpers, rig, types
 from opensfm.dataset import DataSet, DataSetBase
 from opensfm.types import Reconstruction
-from typing import Dict, List
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def run_dataset(data: DataSet, method, definition: Dict[str, str], output_debug) -> None:
+def run_dataset(
+    data: DataSet, method, definition: Dict[str, str], output_debug
+) -> None:
     """Given a dataset that contains rigs, construct rig data files.
 
     Args:
@@ -30,7 +32,9 @@ def run_dataset(data: DataSet, method, definition: Dict[str, str], output_debug)
         data.save_reconstruction(reconstructions, "rig_instances.json")
 
 
-def _reconstruction_from_rigs_and_assignments(data: DataSetBase) -> List[Reconstruction]:
+def _reconstruction_from_rigs_and_assignments(
+    data: DataSetBase,
+) -> List[Reconstruction]:
     assignments = data.load_rig_assignments()
     rig_cameras = data.load_rig_cameras()
 
diff --git a/opensfm/actions/create_submodels.py b/opensfm/actions/create_submodels.py
index 3d98fba91..237e64d2d 100644
--- a/opensfm/actions/create_submodels.py
+++ b/opensfm/actions/create_submodels.py
@@ -4,15 +4,15 @@
 
 import numpy as np
 from opensfm.dataset import DataSet
-from opensfm.large.metadataset import MetaDataSet
 from opensfm.large import tools
+from opensfm.large.metadataset import MetaDataSet
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
 def run_dataset(data: DataSet) -> None:
-    """ Split the dataset into smaller submodels. """
+    """Split the dataset into smaller submodels."""
 
     meta_data = MetaDataSet(data.data_path)
 
diff --git a/opensfm/actions/create_tracks.py b/opensfm/actions/create_tracks.py
index 86fac805b..b3af1554e 100644
--- a/opensfm/actions/create_tracks.py
+++ b/opensfm/actions/create_tracks.py
@@ -1,8 +1,7 @@
 # pyre-unsafe
 from timeit import default_timer as timer
 
-from opensfm import io
-from opensfm import tracking
+from opensfm import io, tracking
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/opensfm/actions/export_bundler.py b/opensfm/actions/export_bundler.py
index 1535ff795..6fd72a6dd 100644
--- a/opensfm/actions/export_bundler.py
+++ b/opensfm/actions/export_bundler.py
@@ -37,7 +37,11 @@ def run_dataset(data: DataSet, list_path, bundle_path, undistorted) -> None:
 
 
 def export_bundler(
-    image_list, reconstructions, track_manager, bundle_file_path: str, list_file_path: str
+    image_list,
+    reconstructions,
+    track_manager,
+    bundle_file_path: str,
+    list_file_path: str,
 ) -> None:
     """
     Generate a reconstruction file that is consistent with Bundler's format
diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index 913c2faa9..01a4cd00e 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -43,8 +43,7 @@
 from typing import Tuple
 
 import numpy as np
-from opensfm import features
-from opensfm import matching
+from opensfm import features, matching
 from opensfm.dataset import DataSet
 
 I_3 = np.eye(3)
@@ -94,7 +93,7 @@ def run_dataset(data: DataSet, binary: bool) -> None:
 
 IS_PYTHON3: bool = int(sys.version_info[0]) >= 3
 
-MAX_IMAGE_ID = 2 ** 31 - 1
+MAX_IMAGE_ID = 2**31 - 1
 
 CREATE_CAMERAS_TABLE = """CREATE TABLE IF NOT EXISTS cameras (
     camera_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
@@ -124,9 +123,7 @@ def run_dataset(data: DataSet, binary: bool) -> None:
     prior_tz REAL,
     CONSTRAINT image_id_check CHECK(image_id >= 0 and image_id < {}),
     FOREIGN KEY(camera_id) REFERENCES cameras(camera_id))
-""".format(
-    MAX_IMAGE_ID
-)
+""".format(MAX_IMAGE_ID)
 
 CREATE_TWO_VIEW_GEOMETRIES_TABLE = """
 CREATE TABLE IF NOT EXISTS two_view_geometries (
@@ -483,7 +480,6 @@ def export_images_reconstruction(
         fout = data.io_handler.open_wt(os.path.join(path, "images.txt"))
 
     for reconstruction in reconstructions:
-
         for shot_id, shot in reconstruction.shots.items():
             colmap_camera_id = camera_map[shot.camera.id]
             colmap_shot_id = images_map[shot_id]
diff --git a/opensfm/actions/export_geocoords.py b/opensfm/actions/export_geocoords.py
index 42ab9df76..1f5980eec 100644
--- a/opensfm/actions/export_geocoords.py
+++ b/opensfm/actions/export_geocoords.py
@@ -1,14 +1,13 @@
 # pyre-unsafe
 import logging
 import os
-from opensfm import types
+from typing import List, Sequence
 
 import numpy as np
 import pyproj
-from opensfm import io
+from opensfm import io, types
 from opensfm.dataset import DataSet, UndistortedDataSet
 from opensfm.geo import TopocentricConverter
-from typing import List, Sequence
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -19,7 +18,7 @@ def run_dataset(
     transformation: bool,
     image_positions: bool,
     reconstruction: bool,
-    dense : bool,
+    dense: bool,
     output: str,
 ) -> None:
     """Export reconstructions in geographic coordinates
@@ -68,7 +67,9 @@ def run_dataset(
         _transform_dense_point_cloud(udata, t, output_path)
 
 
-def _get_transformation(reference: TopocentricConverter, projection: pyproj.Proj) -> np.ndarray:
+def _get_transformation(
+    reference: TopocentricConverter, projection: pyproj.Proj
+) -> np.ndarray:
     """Get the linear transform from reconstruction coords to geocoords."""
     p = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
     q = [_transform(point, reference, projection) for point in p]
@@ -88,11 +89,13 @@ def _write_transformation(transformation: np.ndarray, filename: str) -> None:
     """Write the 4x4 matrix transformation to a text file."""
     with io.open_wt(filename) as fout:
         for row in transformation:
-            fout.write(u" ".join(map(str, row)))
-            fout.write(u"\n")
+            fout.write(" ".join(map(str, row)))
+            fout.write("\n")
 
 
-def _transform(point: Sequence, reference: TopocentricConverter, projection: pyproj.Proj) -> List[float]:
+def _transform(
+    point: Sequence, reference: TopocentricConverter, projection: pyproj.Proj
+) -> List[float]:
     """Transform on point from local coords to a proj4 projection."""
     lat, lon, altitude = reference.to_lla(point[0], point[1], point[2])
     easting, northing = projection(lon, lat)
diff --git a/opensfm/actions/export_openmvs.py b/opensfm/actions/export_openmvs.py
index 2020913d6..22d1fee32 100644
--- a/opensfm/actions/export_openmvs.py
+++ b/opensfm/actions/export_openmvs.py
@@ -2,13 +2,12 @@
 import os
 
 import numpy as np
-from opensfm import io
-from opensfm import pydense
+from opensfm import io, pydense
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
 def run_dataset(data: DataSet, image_list) -> None:
-    """ Export reconstruction to OpenMVS format. """
+    """Export reconstruction to OpenMVS format."""
 
     udata = data.undistorted_dataset()
     reconstructions = udata.load_undistorted_reconstruction()
@@ -25,7 +24,9 @@ def run_dataset(data: DataSet, image_list) -> None:
         export(reconstructions[0], tracks_manager, udata, export_only)
 
 
-def export(reconstruction, tracks_manager, udata: UndistortedDataSet, export_only) -> None:
+def export(
+    reconstruction, tracks_manager, udata: UndistortedDataSet, export_only
+) -> None:
     exporter = pydense.OpenMVSExporter()
     for camera in reconstruction.cameras.values():
         if camera.projection_type == "perspective":
diff --git a/opensfm/actions/export_ply.py b/opensfm/actions/export_ply.py
index 69658ce4f..41c6f558d 100644
--- a/opensfm/actions/export_ply.py
+++ b/opensfm/actions/export_ply.py
@@ -3,11 +3,13 @@
 
 import numpy as np
 from opensfm import io
-from opensfm.dense import depthmap_to_ply, scale_down_image
 from opensfm.dataset import DataSet
+from opensfm.dense import depthmap_to_ply, scale_down_image
 
 
-def run_dataset(data: DataSet, no_cameras: bool, no_points: bool, depthmaps, point_num_views: bool) -> None:
+def run_dataset(
+    data: DataSet, no_cameras: bool, no_points: bool, depthmaps, point_num_views: bool
+) -> None:
     """Export reconstruction to PLY format
 
     Args:
@@ -25,7 +27,14 @@ def run_dataset(data: DataSet, no_cameras: bool, no_points: bool, depthmaps, poi
     point_num_views = point_num_views
 
     if reconstructions:
-        data.save_ply(reconstructions[0], tracks_manager, None, no_cameras, no_points, point_num_views)
+        data.save_ply(
+            reconstructions[0],
+            tracks_manager,
+            None,
+            no_cameras,
+            no_points,
+            point_num_views,
+        )
 
     if depthmaps:
         udata = data.undistorted_dataset()
diff --git a/opensfm/actions/export_pmvs.py b/opensfm/actions/export_pmvs.py
index de11b4974..fb9bb9153 100644
--- a/opensfm/actions/export_pmvs.py
+++ b/opensfm/actions/export_pmvs.py
@@ -4,9 +4,7 @@
 
 import cv2
 import numpy as np
-from opensfm import features
-from opensfm import io
-from opensfm import tracking
+from opensfm import features, io, tracking
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
diff --git a/opensfm/actions/export_visualsfm.py b/opensfm/actions/export_visualsfm.py
index 1f91b0811..60d444ce8 100644
--- a/opensfm/actions/export_visualsfm.py
+++ b/opensfm/actions/export_visualsfm.py
@@ -3,8 +3,7 @@
 import os
 import sys
 
-from opensfm import io
-from opensfm import transformations as tf
+from opensfm import io, transformations as tf
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
diff --git a/opensfm/actions/extend_reconstruction.py b/opensfm/actions/extend_reconstruction.py
index adc9ea78b..179ae5eaa 100644
--- a/opensfm/actions/extend_reconstruction.py
+++ b/opensfm/actions/extend_reconstruction.py
@@ -1,7 +1,8 @@
 # pyre-unsafe
+from typing import Optional
+
 from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
-from typing import Optional
 
 
 def run_dataset(data: DataSetBase, input: Optional[str], output: Optional[str]) -> None:
diff --git a/opensfm/actions/extract_metadata.py b/opensfm/actions/extract_metadata.py
index 6d58383d3..1fc2d8e93 100644
--- a/opensfm/actions/extract_metadata.py
+++ b/opensfm/actions/extract_metadata.py
@@ -3,6 +3,7 @@
 import logging
 from functools import partial
 from typing import Any, Dict
+
 from opensfm import exif
 from opensfm.dataset_base import DataSetBase
 
diff --git a/opensfm/actions/match_features.py b/opensfm/actions/match_features.py
index 9cd8d8433..d11e8b3c7 100644
--- a/opensfm/actions/match_features.py
+++ b/opensfm/actions/match_features.py
@@ -1,8 +1,7 @@
 # pyre-unsafe
 from timeit import default_timer as timer
 
-from opensfm import io
-from opensfm import matching
+from opensfm import io, matching
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/opensfm/actions/reconstruct.py b/opensfm/actions/reconstruct.py
index d5b30420d..766e3e060 100644
--- a/opensfm/actions/reconstruct.py
+++ b/opensfm/actions/reconstruct.py
@@ -1,10 +1,11 @@
 # pyre-unsafe
-from opensfm import io
-from opensfm import reconstruction
+from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 
 
-def run_dataset(data: DataSetBase, algorithm: reconstruction.ReconstructionAlgorithm) -> None:
+def run_dataset(
+    data: DataSetBase, algorithm: reconstruction.ReconstructionAlgorithm
+) -> None:
     """Compute the SfM reconstruction."""
 
     tracks_manager = data.load_tracks_manager()
diff --git a/opensfm/actions/reconstruct_from_prior.py b/opensfm/actions/reconstruct_from_prior.py
index e5d86232e..baf59b1b7 100644
--- a/opensfm/actions/reconstruct_from_prior.py
+++ b/opensfm/actions/reconstruct_from_prior.py
@@ -1,6 +1,5 @@
 # pyre-unsafe
-from opensfm import io
-from opensfm import reconstruction
+from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/opensfm/align.py b/opensfm/align.py
index f07aa004f..b2a14e2df 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -124,7 +124,9 @@ def alignment_constraints(
     """Gather alignment constraints to be used by checking bundle_use_gcp and bundle_use_gps."""
 
     X, Xp = [], []
-    logger.info(f"Collecting alignment constraints - bundle_use_gps:{config['bundle_use_gps']} bundle_use_gcp: {config['bundle_use_gcp']}")
+    logger.info(
+        f"Collecting alignment constraints - bundle_use_gps:{config['bundle_use_gps']} bundle_use_gcp: {config['bundle_use_gcp']}"
+    )
     # Get Ground Control Point correspondences
     if gcp and config["bundle_use_gcp"]:
         triangulated, measured = triangulate_all_gcp(reconstruction, gcp)
@@ -340,7 +342,6 @@ def set_gps_bias(
 
     per_camera_transform = {}
     for camera_id, shots_id in per_camera_shots.items():
-
         # As we re-use 'compute_reconstruction_similarity', we need to construct a 'Reconstruction'
         subrec = types.Reconstruction()
         subrec.add_camera(reconstruction.cameras[camera_id])
diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index 97a2f32fe..fb41eac10 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -16,8 +16,8 @@
     export_pmvs,
     export_report,
     export_visualsfm,
-    extract_metadata,
     extend_reconstruction,
+    extract_metadata,
     match_features,
     mesh,
     reconstruct,
diff --git a/opensfm/commands/align_submodels.py b/opensfm/commands/align_submodels.py
index 8055c45bd..d9059d0ec 100644
--- a/opensfm/commands/align_submodels.py
+++ b/opensfm/commands/align_submodels.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import align_submodels
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/bundle.py b/opensfm/commands/bundle.py
index 767d73146..b3ee44676 100644
--- a/opensfm/commands/bundle.py
+++ b/opensfm/commands/bundle.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import bundle
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/command.py b/opensfm/commands/command.py
index 2e7093e93..083874bb3 100644
--- a/opensfm/commands/command.py
+++ b/opensfm/commands/command.py
@@ -1,10 +1,12 @@
 # pyre-unsafe
-from timeit import default_timer as timer
 import argparse
+from timeit import default_timer as timer
+
 from opensfm.dataset import DataSet
 
+
 class CommandBase:
-    """ Base class for executable commands."""
+    """Base class for executable commands."""
 
     name = "Undefined command"
     help = "Undefined command help"
diff --git a/opensfm/commands/command_runner.py b/opensfm/commands/command_runner.py
index 55b556903..025e64ab4 100644
--- a/opensfm/commands/command_runner.py
+++ b/opensfm/commands/command_runner.py
@@ -1,12 +1,14 @@
 # pyre-unsafe
-from typing import Any, Callable, List
 import argparse
+from typing import Any, Callable, List
 
 from opensfm import log
 
 
-def command_runner(all_commands_types: List[Any], dataset_factory: Callable, dataset_choices: List[str]) -> None:
-    """ Main entry point for running the passed SfM commands types."""
+def command_runner(
+    all_commands_types: List[Any], dataset_factory: Callable, dataset_choices: List[str]
+) -> None:
+    """Main entry point for running the passed SfM commands types."""
     log.setup()
 
     # Create the top-level parser
diff --git a/opensfm/commands/compute_depthmaps.py b/opensfm/commands/compute_depthmaps.py
index 6265b6fd3..4abb83b75 100644
--- a/opensfm/commands/compute_depthmaps.py
+++ b/opensfm/commands/compute_depthmaps.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import compute_depthmaps
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/compute_statistics.py b/opensfm/commands/compute_statistics.py
index 8b6544a30..fdee55f68 100644
--- a/opensfm/commands/compute_statistics.py
+++ b/opensfm/commands/compute_statistics.py
@@ -1,8 +1,10 @@
 # pyre-unsafe
-from . import command
 import argparse
-from opensfm.dataset import DataSet
+
 from opensfm.actions import compute_statistics
+from opensfm.dataset import DataSet
+
+from . import command
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/create_rig.py b/opensfm/commands/create_rig.py
index 82d191156..ff8588d54 100644
--- a/opensfm/commands/create_rig.py
+++ b/opensfm/commands/create_rig.py
@@ -1,11 +1,11 @@
 # pyre-unsafe
+import argparse
 import json
 
 from opensfm.actions import create_rig
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/create_submodels.py b/opensfm/commands/create_submodels.py
index a6d301103..9c5e06c9c 100644
--- a/opensfm/commands/create_submodels.py
+++ b/opensfm/commands/create_submodels.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import create_submodels
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/create_tracks.py b/opensfm/commands/create_tracks.py
index 408c67a53..14b67ce11 100644
--- a/opensfm/commands/create_tracks.py
+++ b/opensfm/commands/create_tracks.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import create_tracks
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/detect_features.py b/opensfm/commands/detect_features.py
index 466826e52..145bfc7e9 100644
--- a/opensfm/commands/detect_features.py
+++ b/opensfm/commands/detect_features.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import detect_features
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_bundler.py b/opensfm/commands/export_bundler.py
index 83be840d3..a27c0ee51 100644
--- a/opensfm/commands/export_bundler.py
+++ b/opensfm/commands/export_bundler.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_bundler
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_colmap.py b/opensfm/commands/export_colmap.py
index 79c4b86ac..f16c2d875 100644
--- a/opensfm/commands/export_colmap.py
+++ b/opensfm/commands/export_colmap.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_colmap
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_geocoords.py b/opensfm/commands/export_geocoords.py
index 1f3b4e219..6768058b4 100644
--- a/opensfm/commands/export_geocoords.py
+++ b/opensfm/commands/export_geocoords.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_geocoords
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_openmvs.py b/opensfm/commands/export_openmvs.py
index 91dbb595e..29ba91ca3 100644
--- a/opensfm/commands/export_openmvs.py
+++ b/opensfm/commands/export_openmvs.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_openmvs
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_ply.py b/opensfm/commands/export_ply.py
index 1d3be5f00..07d86fc87 100644
--- a/opensfm/commands/export_ply.py
+++ b/opensfm/commands/export_ply.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_ply
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
@@ -11,7 +12,13 @@ class Command(command.CommandBase):
     help = "Export reconstruction to PLY format"
 
     def run_impl(self, dataset: DataSet, args: argparse.Namespace) -> None:
-        export_ply.run_dataset(dataset, args.no_cameras, args.no_points, args.depthmaps, args.point_num_views)
+        export_ply.run_dataset(
+            dataset,
+            args.no_cameras,
+            args.no_points,
+            args.depthmaps,
+            args.point_num_views,
+        )
 
     def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
@@ -33,5 +40,5 @@ def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
             "--point-num-views",
             action="store_true",
             default=False,
-            help="Export the number of observations associated with each point"
+            help="Export the number of observations associated with each point",
         )
diff --git a/opensfm/commands/export_pmvs.py b/opensfm/commands/export_pmvs.py
index 84d67c656..7d6fd3f7b 100644
--- a/opensfm/commands/export_pmvs.py
+++ b/opensfm/commands/export_pmvs.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_pmvs
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_report.py b/opensfm/commands/export_report.py
index d9f084329..71f876683 100644
--- a/opensfm/commands/export_report.py
+++ b/opensfm/commands/export_report.py
@@ -1,8 +1,10 @@
 # pyre-unsafe
-from . import command
 import argparse
-from opensfm.dataset import DataSet
+
 from opensfm.actions import export_report
+from opensfm.dataset import DataSet
+
+from . import command
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/export_visualsfm.py b/opensfm/commands/export_visualsfm.py
index 37080add9..847f2db8c 100644
--- a/opensfm/commands/export_visualsfm.py
+++ b/opensfm/commands/export_visualsfm.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import export_visualsfm
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/extend_reconstruction.py b/opensfm/commands/extend_reconstruction.py
index 6e72374e5..8e4443060 100644
--- a/opensfm/commands/extend_reconstruction.py
+++ b/opensfm/commands/extend_reconstruction.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import extend_reconstruction
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/extract_metadata.py b/opensfm/commands/extract_metadata.py
index 5bf0d62b1..1e2331745 100644
--- a/opensfm/commands/extract_metadata.py
+++ b/opensfm/commands/extract_metadata.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import extract_metadata
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/match_features.py b/opensfm/commands/match_features.py
index 74e88984f..494fcb70f 100644
--- a/opensfm/commands/match_features.py
+++ b/opensfm/commands/match_features.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import match_features
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/mesh.py b/opensfm/commands/mesh.py
index 6a407cab4..ab58e8eb6 100644
--- a/opensfm/commands/mesh.py
+++ b/opensfm/commands/mesh.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import mesh
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/reconstruct.py b/opensfm/commands/reconstruct.py
index 5dcb002f2..fb5bf4291 100644
--- a/opensfm/commands/reconstruct.py
+++ b/opensfm/commands/reconstruct.py
@@ -1,10 +1,11 @@
 # pyre-unsafe
+import argparse
+
 from opensfm import reconstruction
 from opensfm.actions import reconstruct
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/reconstruct_from_prior.py b/opensfm/commands/reconstruct_from_prior.py
index 0aa7389ef..f7281e971 100644
--- a/opensfm/commands/reconstruct_from_prior.py
+++ b/opensfm/commands/reconstruct_from_prior.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import reconstruct_from_prior
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
diff --git a/opensfm/commands/undistort.py b/opensfm/commands/undistort.py
index d7eae5d6e..0939af676 100644
--- a/opensfm/commands/undistort.py
+++ b/opensfm/commands/undistort.py
@@ -1,9 +1,10 @@
 # pyre-unsafe
+import argparse
+
 from opensfm.actions import undistort
+from opensfm.dataset import DataSet
 
 from . import command
-import argparse
-from opensfm.dataset import DataSet
 
 
 class Command(command.CommandBase):
@@ -17,14 +18,12 @@ def run_impl(self, dataset: DataSet, args: argparse.Namespace) -> None:
             args.reconstruction_index,
             args.tracks,
             args.output,
-            args.skip_images
+            args.skip_images,
         )
 
     def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
-            "--reconstruction",
-            help="reconstruction to undistort",
-            type=str
+            "--reconstruction", help="reconstruction to undistort", type=str
         )
         parser.add_argument(
             "--reconstruction-index",
@@ -37,10 +36,7 @@ def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
             help="tracks graph of the reconstruction",
         )
         parser.add_argument(
-            "--output",
-            help="output folder",
-            default="undistorted",
-            type=str
+            "--output", help="output folder", default="undistorted", type=str
         )
         parser.add_argument(
             "--skip-images",
diff --git a/opensfm/config.py b/opensfm/config.py
index a512e2ca1..04fdcb3f7 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -1,6 +1,6 @@
 # pyre-unsafe
 import os
-from dataclasses import dataclass, asdict
+from dataclasses import asdict, dataclass
 from typing import Any, Dict, IO, Union
 
 import yaml
@@ -396,7 +396,7 @@ def load_config(filepath) -> Dict[str, Any]:
 
 
 def load_config_from_fileobject(
-    f: Union[IO[bytes], IO[str], bytes, str]
+    f: Union[IO[bytes], IO[str], bytes, str],
 ) -> Dict[str, Any]:
     """Load config from a config.yaml fileobject"""
     config = default_config()
diff --git a/opensfm/context.py b/opensfm/context.py
index 00ea4074e..d62a841e8 100644
--- a/opensfm/context.py
+++ b/opensfm/context.py
@@ -11,7 +11,7 @@
 from typing import Optional
 
 import cv2
-from joblib import Parallel, delayed, parallel_backend
+from joblib import delayed, Parallel, parallel_backend
 
 
 logger: logging.Logger = logging.getLogger(__name__)
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 12af6a344..5d0b18fc4 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -5,20 +5,10 @@
 import os
 import pickle
 from io import BytesIO
-from typing import Dict, List, Tuple, Optional, IO, Any
+from typing import Any, Dict, IO, List, Optional, Tuple
 
 import numpy as np
-from opensfm import (
-    config,
-    features,
-    geo,
-    io,
-    pygeometry,
-    types,
-    pymap,
-    masking,
-    rig,
-)
+from opensfm import config, features, geo, io, masking, pygeometry, pymap, rig, types
 from opensfm.dataset_base import DataSetBase
 from PIL.PngImagePlugin import PngImageFile
 
@@ -134,8 +124,9 @@ def load_mask(self, image: str) -> Optional[np.ndarray]:
             mask = self.io_handler.imread(mask_path, grayscale=True)
             if mask is None:
                 raise IOError(
-                    "Unable to load mask for image {} "
-                    "from file {}".format(image, mask_path)
+                    "Unable to load mask for image {} " "from file {}".format(
+                        image, mask_path
+                    )
                 )
         else:
             mask = None
@@ -986,7 +977,7 @@ def save_undistorted_reconstruction(
 def invent_reference_from_gps_and_gcp(
     data: DataSetBase, images: Optional[List[str]] = None
 ) -> geo.TopocentricConverter:
-    """ Invent the reference from the weighted average of lat/lon measurements.
+    """Invent the reference from the weighted average of lat/lon measurements.
     Most of the time the altitude provided in the metadata is inaccurate, thus
     the reference altitude is set equal to 0 regardless of the altitude measurements.
     """
diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index a049344e9..931974621 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -1,17 +1,10 @@
 # pyre-unsafe
 import logging
 from abc import ABC, abstractmethod
-from typing import Dict, List, Tuple, Optional, IO, Any
+from typing import Any, Dict, IO, List, Optional, Tuple
 
 import numpy as np
-from opensfm import (
-    features,
-    geo,
-    io,
-    pygeometry,
-    types,
-    pymap,
-)
+from opensfm import features, geo, io, pygeometry, pymap, types
 
 logger: logging.Logger = logging.getLogger(__name__)
 
diff --git a/opensfm/dense.py b/opensfm/dense.py
index 14b4fc940..11ab78440 100644
--- a/opensfm/dense.py
+++ b/opensfm/dense.py
@@ -4,12 +4,7 @@
 
 import cv2
 import numpy as np
-from opensfm import io
-from opensfm import log
-from opensfm import pydense
-from opensfm import pymap
-from opensfm import tracking
-from opensfm import types
+from opensfm import io, log, pydense, pymap, tracking, types
 from opensfm.context import parallel_map
 from opensfm.dataset import UndistortedDataSet
 
@@ -430,7 +425,7 @@ def distance_between_shots(shot, other):
     o1 = shot.pose.get_origin()
     o2 = other.pose.get_origin()
     d = o2 - o1
-    return np.sqrt(np.sum(d ** 2))
+    return np.sqrt(np.sum(d**2))
 
 
 def scale_image(
diff --git a/opensfm/exif.py b/opensfm/exif.py
index 6b4e76462..5b71bfdf8 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -1,7 +1,7 @@
 # pyre-unsafe
 import datetime
 import logging
-from codecs import encode, decode
+from codecs import decode, encode
 from typing import Any, Dict, List, Optional, Tuple
 
 import exifread
@@ -11,7 +11,7 @@
 from opensfm.dataset_base import DataSetBase
 from opensfm.geo import ecef_from_lla
 from opensfm.pygeometry import Camera
-from opensfm.sensors import sensor_data, camera_calibration
+from opensfm.sensors import camera_calibration, sensor_data
 
 logger: logging.Logger = logging.getLogger(__name__)
 
diff --git a/opensfm/feature_loading.py b/opensfm/feature_loading.py
index 1f3c63a69..8c0be75eb 100644
--- a/opensfm/feature_loading.py
+++ b/opensfm/feature_loading.py
@@ -1,10 +1,10 @@
 # pyre-unsafe
 import logging
 from functools import lru_cache
-from typing import Optional, Tuple, Any
+from typing import Any, Optional, Tuple
 
 import numpy as np
-from opensfm import pygeometry, features as ft, masking
+from opensfm import features as ft, masking, pygeometry
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/opensfm/features.py b/opensfm/features.py
index 735494e46..173eeebc1 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -337,7 +337,11 @@ def denormalized_image_coordinates(
 
 def normalize_features(
     points: np.ndarray, desc: np.ndarray, colors: np.ndarray, width: int, height: int
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray,]:
+) -> Tuple[
+    np.ndarray,
+    np.ndarray,
+    np.ndarray,
+]:
     """Normalize feature coordinates and size."""
     points[:, :2] = normalized_image_coordinates(points[:, :2], width, height)
     points[:, 2:3] /= max(width, height)
@@ -385,7 +389,7 @@ def extract_features_sift(
             detector = cv2.FeatureDetector_create("SIFT")
             descriptor = cv2.DescriptorExtractor_create("SIFT")
             detector.setDouble("edgeThreshold", sift_edge_threshold)
-        
+
         points = detector.detect(image)
         logger.debug("Found {0} points in {1}s".format(len(points), time.time() - t))
         if len(points) < features_count and sift_peak_threshold > 0.0001:
@@ -611,8 +615,9 @@ def extract_features(
     elif feature_type == "ORB":
         points, desc = extract_features_orb(image_gray, config, features_count)
     else:
-        raise ValueError("Unknown feature type "
-                         + "(must be SURF, SIFT, AKAZE, HAHOG or ORB)")
+        raise ValueError(
+            "Unknown feature type (must be SURF, SIFT, AKAZE, HAHOG or ORB)"
+        )
 
     xs = points[:, 0].round().astype(int)
     ys = points[:, 1].round().astype(int)
diff --git a/opensfm/geo.py b/opensfm/geo.py
index 335dad66f..d5ee44258 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -1,7 +1,8 @@
 # pyre-unsafe
+from typing import Tuple
+
 import numpy as np
 from numpy import ndarray
-from typing import Tuple
 
 WGS84_a = 6378137.0
 WGS84_b = 6356752.314245
@@ -20,8 +21,8 @@ def ecef_from_lla(lat, lon, alt: float) -> Tuple[float, ...]:
     >>> np.allclose(lla_from_ecef(x,y,z), [lat, lon, alt])
     True
     """
-    a2 = WGS84_a ** 2
-    b2 = WGS84_b ** 2
+    a2 = WGS84_a**2
+    b2 = WGS84_b**2
     lat = np.radians(lat)
     lon = np.radians(lon)
     L = 1.0 / np.sqrt(a2 * np.cos(lat) ** 2 + b2 * np.sin(lat) ** 2)
@@ -40,15 +41,15 @@ def lla_from_ecef(x, y, z):
     """
     a = WGS84_a
     b = WGS84_b
-    ea = np.sqrt((a ** 2 - b ** 2) / a ** 2)
-    eb = np.sqrt((a ** 2 - b ** 2) / b ** 2)
-    p = np.sqrt(x ** 2 + y ** 2)
+    ea = np.sqrt((a**2 - b**2) / a**2)
+    eb = np.sqrt((a**2 - b**2) / b**2)
+    p = np.sqrt(x**2 + y**2)
     theta = np.arctan2(z * a, p * b)
     lon = np.arctan2(y, x)
     lat = np.arctan2(
-        z + eb ** 2 * b * np.sin(theta) ** 3, p - ea ** 2 * a * np.cos(theta) ** 3
+        z + eb**2 * b * np.sin(theta) ** 3, p - ea**2 * a * np.cos(theta) ** 3
     )
-    N = a / np.sqrt(1 - ea ** 2 * np.sin(lat) ** 2)
+    N = a / np.sqrt(1 - ea**2 * np.sin(lat) ** 2)
     alt = p / np.cos(lat) - N
     return np.degrees(lat), np.degrees(lon), alt
 
diff --git a/opensfm/geotag_from_gpx.py b/opensfm/geotag_from_gpx.py
index 9198b3398..3e0632ad6 100644
--- a/opensfm/geotag_from_gpx.py
+++ b/opensfm/geotag_from_gpx.py
@@ -195,8 +195,8 @@ def segment_sphere_intersection(A, B, C, r):
     CA = np.array(A) - np.array(C)
     a = AB.dot(AB)
     b = 2 * AB.dot(CA)
-    c = CA.dot(CA) - r ** 2
-    d = max(0, b ** 2 - 4 * a * c)
+    c = CA.dot(CA) - r**2
+    d = max(0, b**2 - 4 * a * c)
     return (-b + np.sqrt(d)) / (2 * a)
 
 
diff --git a/opensfm/io.py b/opensfm/io.py
index 79119e892..1ddce757c 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -5,7 +5,7 @@
 import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Union, Dict, Any, Iterable, List, IO, Tuple, TextIO, Optional
+from typing import Any, Dict, IO, Iterable, List, Optional, TextIO, Tuple, Union
 
 import cv2
 import numpy as np
@@ -655,7 +655,7 @@ def bias_to_json(bias: pygeometry.Similarity) -> Dict[str, Any]:
 
 
 def rig_cameras_to_json(
-    rig_cameras: Dict[str, pymap.RigCamera]
+    rig_cameras: Dict[str, pymap.RigCamera],
 ) -> Dict[str, Dict[str, Any]]:
     """
     Write rig cameras to a json object
@@ -1009,6 +1009,7 @@ def json_dumps(data, minify: bool = False) -> str:
     kwargs = json_dump_kwargs(minify)
     return json.dumps(data, **kwargs)
 
+
 def json_load(fp: Union[IO[str], IO[bytes]]) -> Any:
     return json.load(fp)
 
@@ -1034,9 +1035,9 @@ def ply_header(
             "property float nx",
             "property float ny",
             "property float nz",
-            "property uchar red",      
-            "property uchar green",     
-            "property uchar blue",      
+            "property uchar red",
+            "property uchar green",
+            "property uchar blue",
         ]
     else:
         header = [
@@ -1046,9 +1047,9 @@ def ply_header(
             "property float x",
             "property float y",
             "property float z",
-            "property uchar red",    
-            "property uchar green",   
-            "property uchar blue", 
+            "property uchar red",
+            "property uchar green",
+            "property uchar blue",
         ]
 
     if point_num_views:
@@ -1094,12 +1095,16 @@ def reconstruction_to_ply(
             o = shot.pose.get_origin()
             R = shot.pose.get_rotation_matrix()
             for axis in range(3):
-                c = 255 * np.eye(3)[axis]
+                c = np.eye(3)[axis] * 255
                 for depth in np.linspace(0, 2, 10):
                     p = o + depth * R[axis]
                     s = "{} {} {} {} {} {}".format(
-                        # pyre-fixme[16]: `int` has no attribute `__getitem__`.
-                        p[0], p[1], p[2], int(c[0]), int(c[1]), int(c[2])
+                        p[0],
+                        p[1],
+                        p[2],
+                        int(c[0]),
+                        int(c[1]),
+                        int(c[2]),
                     )
                     if point_num_views:
                         s += " 0"
@@ -1260,7 +1265,7 @@ def imwrite_from_fileobject(fwb, image: np.ndarray, ext: str) -> None:
 
 
 def image_size_from_fileobject(
-    fb: Union[IO[bytes], bytes, Path, str, TextIO]
+    fb: Union[IO[bytes], bytes, Path, str, TextIO],
 ) -> Tuple[int, int]:
     """Height and width of an image."""
     if isinstance(fb, TextIO):
diff --git a/opensfm/large/metadataset.py b/opensfm/large/metadataset.py
index df5a27a7b..21e9c35b8 100644
--- a/opensfm/large/metadataset.py
+++ b/opensfm/large/metadataset.py
@@ -1,13 +1,12 @@
 # pyre-unsafe
+import glob
 import os
 import os.path
 import shutil
 import sys
-import glob
 
 import numpy as np
-from opensfm import config
-from opensfm import io
+from opensfm import config, io
 from opensfm.dataset import DataSet
 
 
@@ -74,10 +73,10 @@ def _create_symlink(self, base_path, file_path):
 
         if not os.path.exists(src):
             return
-        
+
         # Symlinks on Windows require admin privileges,
         # so we use hard links instead
-        if sys.platform == 'win32':
+        if sys.platform == "win32":
             if os.path.isdir(dst):
                 shutil.rmtree(dst)
             elif os.path.isfile(dst):
@@ -88,7 +87,7 @@ def _create_symlink(self, base_path, file_path):
 
         subfolders = len(file_path.split(os.path.sep)) - 1
 
-        if sys.platform == 'win32':
+        if sys.platform == "win32":
             if os.path.isdir(src):
                 # Create directory in destination, then make hard links
                 # to files
@@ -101,7 +100,9 @@ def _create_symlink(self, base_path, file_path):
                 # Just make hard link
                 os.link(src, dst)
         else:
-            os.symlink(os.path.join(*[".."] * subfolders, os.path.relpath(src, base_path)), dst)
+            os.symlink(
+                os.path.join(*[".."] * subfolders, os.path.relpath(src, base_path)), dst
+            )
 
     def image_groups_exists(self):
         return os.path.isfile(self._image_groups_path())
@@ -117,12 +118,12 @@ def image_list_exists(self):
     def create_image_list(self, ills):
         with io.open_wt(self._image_list_path()) as csvfile:
             for image, lat, lon in ills:
-                csvfile.write(u"{}\t{}\t{}\n".format(image, lat, lon))
+                csvfile.write("{}\t{}\t{}\n".format(image, lat, lon))
 
     def images_with_gps(self):
         with io.open_rt(self._image_list_path()) as csvfile:
             for line in csvfile:
-                image, lat, lon = line.split(u"\t")
+                image, lat, lon = line.split("\t")
                 yield image, float(lat), float(lon)
 
     def save_clusters(self, images, positions, labels, centers):
@@ -181,7 +182,7 @@ def create_submodels(self, clusters):
                     src = data.image_files[image]
                     dst = os.path.join(submodel_images_path, image)
                     if not os.path.isfile(dst):
-                        if sys.platform == 'win32':
+                        if sys.platform == "win32":
                             os.link(src, dst)
                         else:
                             os.symlink(os.path.relpath(src, submodel_images_path), dst)
diff --git a/opensfm/large/tools.py b/opensfm/large/tools.py
index fff5b6536..72d1d2b2c 100644
--- a/opensfm/large/tools.py
+++ b/opensfm/large/tools.py
@@ -7,10 +7,10 @@
 
 import cv2
 import networkx as nx
-from networkx.classes.reportviews import EdgeView
 import numpy as np
 import scipy.spatial as spatial
 from networkx.algorithms import bipartite
+from networkx.classes.reportviews import EdgeView
 from opensfm import (
     align,
     context,
@@ -18,9 +18,9 @@
     geo,
     multiview,
     pybundle,
+    pymap,
     reconstruction,
     types,
-    pymap,
 )
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -203,7 +203,6 @@ def load_reconstruction(
 def add_point_constraints(ra, reconstruction_shots, reconstruction_name) -> None:
     connections = connected_reconstructions(reconstruction_shots)
     for connection in connections:
-
         i1, (r1, g1) = load_reconstruction(
             connection[0].submodel_path, connection[0].index
         )
diff --git a/opensfm/masking.py b/opensfm/masking.py
index 3a20a86f7..d33d4dcf4 100644
--- a/opensfm/masking.py
+++ b/opensfm/masking.py
@@ -1,6 +1,6 @@
 # pyre-unsafe
 import logging
-from typing import List, Tuple, Optional
+from typing import List, Optional, Tuple
 
 import cv2
 import numpy as np
diff --git a/opensfm/matching.py b/opensfm/matching.py
index a96eee3f0..c9146e24b 100644
--- a/opensfm/matching.py
+++ b/opensfm/matching.py
@@ -186,7 +186,7 @@ def match_unwrap_args(
         DataSetBase,
         Dict[str, Any],
         Optional[Dict[str, pygeometry.Pose]],
-    ]
+    ],
 ) -> Tuple[str, str, np.ndarray]:
     """Wrapper for parallel processing of pair matching.
 
@@ -241,8 +241,7 @@ def match_descriptors(
 
     symmetric = "symmetric" if overriden_config["symmetric_matching"] else "one-way"
     logger.debug(
-        "Matching {} and {}.  Matcher: {} ({}) "
-        "T-desc: {:1.3f} Matches: {}".format(
+        "Matching {} and {}.  Matcher: {} ({}) " "T-desc: {:1.3f} Matches: {}".format(
             im1,
             im2,
             matcher_type,
diff --git a/opensfm/mesh.py b/opensfm/mesh.py
index 9080a0a74..a393e4bb1 100644
--- a/opensfm/mesh.py
+++ b/opensfm/mesh.py
@@ -3,7 +3,7 @@
 # pyre-unsafe
 import itertools
 import logging
-from typing import Any, Tuple, List
+from typing import Any, List, Tuple
 
 import numpy as np
 import scipy.spatial
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 046db6e93..af3c1c116 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -586,8 +586,8 @@ def motion_from_plane_homography(
         sin_theta = (d1 - d3) * sin_term
         sin_phi = (d1 + d3) * sin_term
 
-        d1_x3_2 = (d1 * x3**2)
-        d3_x1_2 = (d3 * x1**2)
+        d1_x3_2 = d1 * x3**2
+        d3_x1_2 = d3 * x1**2
         cos_theta = (d3_x1_2 + d1_x3_2) / d2
         cos_phi = (d3_x1_2 - d1_x3_2) / d2
 
diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 2bae00157..a20d4e581 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -4,11 +4,11 @@
 import math
 from collections import defaultdict
 from itertools import combinations
-from typing import Optional, Tuple, List, Set, Dict, Iterable, Any
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
 import numpy as np
 import scipy.spatial as spatial
-from opensfm import bow, context, feature_loader, vlad, geo, geometry
+from opensfm import bow, context, feature_loader, geo, geometry, vlad
 from opensfm.dataset_base import DataSetBase
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -256,7 +256,9 @@ def produce_edges(triangles):
     except spatial.QhullError:
         # Initial simplex is flat
         # Scale the input to fit the unit cube ("QbB")
-        triangles = spatial.Delaunay(points, qhull_options="Qbb Qc Qz Q12 QbB").simplices
+        triangles = spatial.Delaunay(
+            points, qhull_options="Qbb Qc Qz Q12 QbB"
+        ).simplices
 
     for (image1, image2), (vertex1, vertex2) in produce_edges(triangles):
         pairs.add((image1, image2))
@@ -500,7 +502,7 @@ def create_parallel_matching_args(
 
 
 def match_bow_unwrap_args(
-    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]]
+    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]],
 ) -> Tuple[str, List[float], List[str]]:
     """Wrapper for parallel processing of BoW"""
     image, other_images, histograms = args
@@ -508,7 +510,7 @@ def match_bow_unwrap_args(
 
 
 def match_vlad_unwrap_args(
-    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]]
+    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]],
 ) -> Tuple[str, List[float], List[str]]:
     """Wrapper for parallel processing of VLAD"""
     image, other_images, histograms = args
@@ -723,7 +725,7 @@ def load_histograms(data: DataSetBase, images: Iterable[str]) -> Dict[str, np.nd
 
 
 def vlad_histogram_unwrap_args(
-    args: Tuple[DataSetBase, str]
+    args: Tuple[DataSetBase, str],
 ) -> Optional[Tuple[str, np.ndarray]]:
     """Helper function for multithreaded VLAD computation.
 
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 1b996457a..b215bb4ec 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1128,11 +1128,19 @@ def triangulate_shot_features(
         if track not in reconstruction.points:
             if config["triangulation_type"] == "ROBUST":
                 triangulator.triangulate_robust(
-                    track, reproj_threshold, min_ray_angle, min_depth, refinement_iterations
+                    track,
+                    reproj_threshold,
+                    min_ray_angle,
+                    min_depth,
+                    refinement_iterations,
                 )
             elif config["triangulation_type"] == "FULL":
                 triangulator.triangulate(
-                    track, reproj_threshold, min_ray_angle, min_depth, refinement_iterations
+                    track,
+                    reproj_threshold,
+                    min_ray_angle,
+                    min_depth,
+                    refinement_iterations,
                 )
 
 
diff --git a/opensfm/report.py b/opensfm/report.py
index 410f0a016..a726633ce 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -3,12 +3,12 @@
 import os
 import subprocess
 import tempfile
+from typing import Any, Dict
 
 import PIL
 from fpdf import FPDF
 from opensfm import io
 from opensfm.dataset import DataSet
-from typing import Any, Dict
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -111,7 +111,6 @@ def _make_subsection(self, title: str) -> None:
         self.pdf.set_xy(self.margin, self.pdf.get_y() + self.margin)
 
     def _make_centered_image(self, image_path: str, desired_height: float) -> None:
-
         with tempfile.TemporaryDirectory() as tmp_local_dir:
             local_image_path = os.path.join(tmp_local_dir, os.path.basename(image_path))
             with self.io_handler.open(local_image_path, "wb") as fwb:
diff --git a/opensfm/rig.py b/opensfm/rig.py
index d21380228..3f8949929 100644
--- a/opensfm/rig.py
+++ b/opensfm/rig.py
@@ -5,12 +5,12 @@
 import os
 import random
 import re
-from typing import Dict, Tuple, List, Optional, Set, Iterable, TYPE_CHECKING
+from typing import Dict, Iterable, List, Optional, Set, Tuple, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
 import scipy.spatial as spatial
-from opensfm import reconstruction as orec, actions, pygeometry, pymap, types
+from opensfm import actions, pygeometry, pymap, reconstruction as orec, types
 
 if TYPE_CHECKING:
     from opensfm.dataset import DataSet
@@ -43,7 +43,7 @@ def rig_assignments_per_image(
     assignments_per_image = {}
     for instance_id, instance in rig_assignments.items():
         instance_shots = [s[0] for s in instance]
-        for (shot_id, rig_camera_id) in instance:
+        for shot_id, rig_camera_id in instance:
             assignments_per_image[shot_id] = (
                 f"{instance_id}",
                 rig_camera_id,
@@ -116,7 +116,7 @@ def create_instances_with_patterns(
 
 
 def group_instances(
-    rig_instances: Dict[str, TRigInstance]
+    rig_instances: Dict[str, TRigInstance],
 ) -> Dict[str, List[TRigInstance]]:
     per_rig_camera_group: Dict[str, List[TRigInstance]] = {}
     for cameras in rig_instances.values():
diff --git a/opensfm/sensors.py b/opensfm/sensors.py
index 9e2cc8796..d00a289a4 100644
--- a/opensfm/sensors.py
+++ b/opensfm/sensors.py
@@ -1,9 +1,9 @@
 # pyre-unsafe
 from functools import lru_cache
 from typing import Any, Dict, List
+
 import yaml
-from opensfm import context
-from opensfm import io
+from opensfm import context, io
 
 
 @lru_cache(1)
@@ -16,7 +16,7 @@ def sensor_data() -> Dict[str, Any]:
 
 
 @lru_cache(1)
-def camera_calibration()-> List[Dict[str, Any]]:
+def camera_calibration() -> List[Dict[str, Any]]:
     with io.open_rt(context.CAMERA_CALIBRATION) as f:
         data = yaml.safe_load(f)
     return data
diff --git a/opensfm/src/bundle/bundle_adjuster.h b/opensfm/src/bundle/bundle_adjuster.h
index da0688a98..06a959b1e 100644
--- a/opensfm/src/bundle/bundle_adjuster.h
+++ b/opensfm/src/bundle/bundle_adjuster.h
@@ -200,11 +200,10 @@ class BundleAdjuster {
   void SetScaleSharing(const std::string &id, bool share);
 
   // Real bundle adjustment : point projections
-  void AddPointProjectionObservation(const std::string &shot,
-                                     const std::string &point,
-                                     const Vec2d &observation,
-                                     double std_deviation,
-                                     const std::optional<map::Depth>& depth_prior = std::nullopt);
+  void AddPointProjectionObservation(
+      const std::string &shot, const std::string &point,
+      const Vec2d &observation, double std_deviation,
+      const std::optional<map::Depth> &depth_prior = std::nullopt);
 
   // Relative motion constraints
   void AddRelativeMotion(const RelativeMotion &rm);
diff --git a/opensfm/src/bundle/error/absolute_motion_errors.h b/opensfm/src/bundle/error/absolute_motion_errors.h
index d6a072bcc..dae858b16 100644
--- a/opensfm/src/bundle/error/absolute_motion_errors.h
+++ b/opensfm/src/bundle/error/absolute_motion_errors.h
@@ -179,8 +179,10 @@ struct TranslationPriorError {
   template <typename T>
   bool operator()(const T* const rig_instance1, const T* const rig_instance2,
                   T* residuals) const {
-    const auto t1 = Eigen::Map<const Vec3<T>>(rig_instance1 + Pose::Parameter::TX);
-    const auto t2 = Eigen::Map<const Vec3<T>>(rig_instance2 + Pose::Parameter::TX);
+    const auto t1 =
+        Eigen::Map<const Vec3<T>>(rig_instance1 + Pose::Parameter::TX);
+    const auto t2 =
+        Eigen::Map<const Vec3<T>>(rig_instance2 + Pose::Parameter::TX);
     residuals[0] = log((t1 - t2).norm() / T(prior_norm_));
     return true;
   }
diff --git a/opensfm/src/bundle/error/relative_depth_error.h b/opensfm/src/bundle/error/relative_depth_error.h
index 6f4eef122..b912206b5 100644
--- a/opensfm/src/bundle/error/relative_depth_error.h
+++ b/opensfm/src/bundle/error/relative_depth_error.h
@@ -4,23 +4,23 @@
 #include <bundle/error/error_utils.h>
 #include <ceres/sized_cost_function.h>
 #include <foundation/types.h>
-#include <geometry/functions.h>
 #include <geometry/camera_instances.h>
+#include <geometry/functions.h>
 
 namespace bundle {
 class RelativeDepthError {
  public:
   constexpr static int Size = 1;
-  RelativeDepthError(double depth, double std_deviation, bool use_rig_camera, bool is_radial_depth = true)
+  RelativeDepthError(double depth, double std_deviation, bool use_rig_camera,
+                     bool is_radial_depth = true)
       : depth_(depth),
         scale_(1.0 / std_deviation),
         use_rig_camera_(use_rig_camera),
         is_radial_depth_(is_radial_depth) {}
 
   template <typename T>
-  bool operator()(const T* const rig_instance,
-                  const T* const rig_camera, const T* const point,
-                  T* residuals) const {
+  bool operator()(const T* const rig_instance, const T* const rig_camera,
+                  const T* const point, T* residuals) const {
     T scale_one = T(1.0);
     Vec3<T> point_in_camera;
     const T* const actual_rig_camera = use_rig_camera_ ? rig_camera : nullptr;
diff --git a/opensfm/src/bundle/python/pybind.cc b/opensfm/src/bundle/python/pybind.cc
index 04f903f23..3dd4a02b3 100644
--- a/opensfm/src/bundle/python/pybind.cc
+++ b/opensfm/src/bundle/python/pybind.cc
@@ -77,11 +77,8 @@ PYBIND11_MODULE(pybundle, m) {
            &bundle::BundleAdjuster::AddReconstructionInstance)
       .def("add_point_projection_observation",
            &bundle::BundleAdjuster::AddPointProjectionObservation,
-           py::arg("shot"),
-           py::arg("point"),
-           py::arg("observation"),
-           py::arg("std_deviation"),
-           py::arg("depth_prior") = std::nullopt)
+           py::arg("shot"), py::arg("point"), py::arg("observation"),
+           py::arg("std_deviation"), py::arg("depth_prior") = std::nullopt)
       .def("add_relative_motion", &bundle::BundleAdjuster::AddRelativeMotion)
       .def("add_relative_rotation",
            &bundle::BundleAdjuster::AddRelativeRotation)
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 1e6575f95..f5f24795b 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -237,11 +237,9 @@ void BundleAdjuster::AddPointPrior(const std::string &point_id,
   point_exist->second.has_altitude_prior = has_altitude_prior;
 }
 
-void BundleAdjuster::AddPointProjectionObservation(const std::string &shot,
-                                                   const std::string &point,
-                                                   const Vec2d &observation,
-                                                   double std_deviation,
-                                                   const std::optional<map::Depth>& depth_prior) {
+void BundleAdjuster::AddPointProjectionObservation(
+    const std::string &shot, const std::string &point, const Vec2d &observation,
+    double std_deviation, const std::optional<map::Depth> &depth_prior) {
   PointProjectionObservation o;
   o.shot = &shots_.at(shot);
   o.camera = &cameras_.at(o.shot->GetCamera()->GetID());
@@ -506,9 +504,10 @@ struct AddRelativeDepthError {
     if (!obs.depth_prior.has_value()) {
       return;
     }
-    const auto& depth = obs.depth_prior.value();
+    const auto &depth = obs.depth_prior.value();
     if (!ceres::isfinite(depth.value)) {
-      throw std::runtime_error(obs.shot->GetID() + " has non-finite depth prior");
+      throw std::runtime_error(obs.shot->GetID() +
+                               " has non-finite depth prior");
     }
 
     const bool is_rig_camera_useful =
@@ -516,9 +515,11 @@ struct AddRelativeDepthError {
     ceres::CostFunction *cost_function = nullptr;
 
     cost_function =
-        new ceres::AutoDiffCostFunction<RelativeDepthError, RelativeDepthError::Size, ShotSize, ShotSize, PointSize>(
-          new RelativeDepthError(depth.value, depth.std_deviation, is_rig_camera_useful, depth.is_radial)
-        );
+        new ceres::AutoDiffCostFunction<RelativeDepthError,
+                                        RelativeDepthError::Size, ShotSize,
+                                        ShotSize, PointSize>(
+            new RelativeDepthError(depth.value, depth.std_deviation,
+                                   is_rig_camera_useful, depth.is_radial));
 
     problem->AddResidualBlock(cost_function, loss,
                               obs.shot->GetRigInstance()->GetValueData().data(),
@@ -807,8 +808,8 @@ void BundleAdjuster::Run() {
         projection_type, use_analytic_, observation, projection_loss, &problem);
 
     // Add relative depth error blocks
-    geometry::Dispatch<AddRelativeDepthError>(
-        projection_type, observation, projection_loss, &problem);
+    geometry::Dispatch<AddRelativeDepthError>(projection_type, observation,
+                                              projection_loss, &problem);
   }
 
   // Add relative motion errors
@@ -1132,8 +1133,9 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
 
     std::vector<std::pair<const double *, const double *>> covariance_blocks;
     for (auto &i : shots_) {
-      covariance_blocks.emplace_back(i.second.GetRigInstance()->GetValueData().data(),
-                         i.second.GetRigInstance()->GetValueData().data());
+      covariance_blocks.emplace_back(
+          i.second.GetRigInstance()->GetValueData().data(),
+          i.second.GetRigInstance()->GetValueData().data());
     }
 
     bool worked = covariance.Compute(covariance_blocks, problem);
diff --git a/opensfm/src/dense/depthmap_bind.h b/opensfm/src/dense/depthmap_bind.h
index d24ff80a3..d2972c49e 100644
--- a/opensfm/src/dense/depthmap_bind.h
+++ b/opensfm/src/dense/depthmap_bind.h
@@ -3,14 +3,15 @@
 #include <dense/depthmap.h>
 #include <foundation/python_types.h>
 
-
 namespace dense {
 
 class DepthmapEstimatorWrapper {
  public:
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_uint8 image,
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
+               foundation::pyarray_d t, foundation::pyarray_uint8 image,
                foundation::pyarray_uint8 mask) {
-    if ((image.shape(0) != mask.shape(0)) || (image.shape(1) != mask.shape(1))){
+    if ((image.shape(0) != mask.shape(0)) ||
+        (image.shape(1) != mask.shape(1))) {
       throw std::invalid_argument("image and mask must have matching shapes.");
     }
     de_.AddView(K.data(), R.data(), t.data(), image.data(), mask.data(),
@@ -56,14 +57,14 @@ class DepthmapEstimatorWrapper {
 
   py::object ComputeReturnValues(const DepthmapEstimatorResult &result) {
     py::list retn;
-    retn.append(foundation::py_array_from_data(result.depth.ptr<float>(0),
-                                   result.depth.rows, result.depth.cols));
-    retn.append(foundation::py_array_from_data(result.plane.ptr<float>(0),
-                                   result.plane.rows, result.plane.cols, 3));
-    retn.append(foundation::py_array_from_data(result.score.ptr<float>(0),
-                                   result.score.rows, result.score.cols));
-    retn.append(foundation::py_array_from_data(result.nghbr.ptr<int>(0), result.nghbr.rows,
-                                   result.nghbr.cols));
+    retn.append(foundation::py_array_from_data(
+        result.depth.ptr<float>(0), result.depth.rows, result.depth.cols));
+    retn.append(foundation::py_array_from_data(
+        result.plane.ptr<float>(0), result.plane.rows, result.plane.cols, 3));
+    retn.append(foundation::py_array_from_data(
+        result.score.ptr<float>(0), result.score.rows, result.score.cols));
+    retn.append(foundation::py_array_from_data(
+        result.nghbr.ptr<int>(0), result.nghbr.rows, result.nghbr.cols));
     return std::move(retn);
   }
 
@@ -77,7 +78,8 @@ class DepthmapCleanerWrapper {
 
   void SetMinConsistentViews(int n) { dc_.SetMinConsistentViews(n); }
 
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_f depth) {
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
+               foundation::pyarray_d t, foundation::pyarray_f depth) {
     dc_.AddView(K.data(), R.data(), t.data(), depth.data(), depth.shape(1),
                 depth.shape(0));
   }
@@ -88,7 +90,8 @@ class DepthmapCleanerWrapper {
       py::gil_scoped_release release;
       dc_.Clean(&depth);
     }
-    return foundation::py_array_from_data(depth.ptr<float>(0), depth.rows, depth.cols);
+    return foundation::py_array_from_data(depth.ptr<float>(0), depth.rows,
+                                          depth.cols);
   }
 
  private:
@@ -99,15 +102,20 @@ class DepthmapPrunerWrapper {
  public:
   void SetSameDepthThreshold(float t) { dp_.SetSameDepthThreshold(t); }
 
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R, foundation::pyarray_d t, foundation::pyarray_f depth,
-               foundation::pyarray_f plane, foundation::pyarray_uint8 color, foundation::pyarray_uint8 label) {
-    if ((depth.shape(0) != plane.shape(0)) || (depth.shape(1) != plane.shape(1))){
+  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
+               foundation::pyarray_d t, foundation::pyarray_f depth,
+               foundation::pyarray_f plane, foundation::pyarray_uint8 color,
+               foundation::pyarray_uint8 label) {
+    if ((depth.shape(0) != plane.shape(0)) ||
+        (depth.shape(1) != plane.shape(1))) {
       throw std::invalid_argument("depth and plane must have matching shapes.");
     }
-    if ((depth.shape(0) != color.shape(0)) || (depth.shape(1) != color.shape(1))){
+    if ((depth.shape(0) != color.shape(0)) ||
+        (depth.shape(1) != color.shape(1))) {
       throw std::invalid_argument("depth and color must have matching shapes.");
     }
-    if ((depth.shape(0) != label.shape(0)) || (depth.shape(1) != label.shape(1))){
+    if ((depth.shape(0) != label.shape(0)) ||
+        (depth.shape(1) != label.shape(1))) {
       throw std::invalid_argument("depth and label must have matching shapes.");
     }
     dp_.AddView(K.data(), R.data(), t.data(), depth.data(), plane.data(),
diff --git a/opensfm/src/dense/openmvs_exporter.h b/opensfm/src/dense/openmvs_exporter.h
index ba055f76e..2ee915bb3 100644
--- a/opensfm/src/dense/openmvs_exporter.h
+++ b/opensfm/src/dense/openmvs_exporter.h
@@ -6,7 +6,8 @@ namespace dense {
 
 class OpenMVSExporter {
  public:
-  void AddCamera(const std::string &camera_id, foundation::pyarray_d K, uint32_t width, uint32_t height) {
+  void AddCamera(const std::string &camera_id, foundation::pyarray_d K,
+                 uint32_t width, uint32_t height) {
     MVS::Interface::Platform platform;
     platform.name = camera_id;
     MVS::Interface::Platform::Camera camera;
@@ -21,8 +22,9 @@ class OpenMVSExporter {
     scene_.platforms.push_back(platform);
   }
 
-  void AddShot(const std::string &path, const std::string &maskPath, const std::string &shot_id,
-               const std::string &camera_id, foundation::pyarray_d R, foundation::pyarray_d C) {
+  void AddShot(const std::string &path, const std::string &maskPath,
+               const std::string &shot_id, const std::string &camera_id,
+               foundation::pyarray_d R, foundation::pyarray_d C) {
     const double *C_data = C.data();
 
     int platform_id = platform_ids_[camera_id];
diff --git a/opensfm/src/dense/python/pybind.cc b/opensfm/src/dense/python/pybind.cc
index c85f8157f..ceba592e5 100644
--- a/opensfm/src/dense/python/pybind.cc
+++ b/opensfm/src/dense/python/pybind.cc
@@ -1,10 +1,9 @@
-#include <pybind11/eigen.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-
 #include <dense/depthmap_bind.h>
 #include <dense/openmvs_exporter.h>
 #include <foundation/python_types.h>
+#include <pybind11/eigen.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
 
 PYBIND11_MODULE(pydense, m) {
   py::class_<dense::OpenMVSExporter>(m, "OpenMVSExporter")
diff --git a/opensfm/src/dense/src/depthmap.cc b/opensfm/src/dense/src/depthmap.cc
index 57ef85b6d..3f5d41af1 100644
--- a/opensfm/src/dense/src/depthmap.cc
+++ b/opensfm/src/dense/src/depthmap.cc
@@ -126,7 +126,9 @@ cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d &K,
 }
 
 float UniformRand(float a, float b) {
-  // Note that float(RAND_MAX) cannot be exactly represented as a float. We ignore the small inaccuracy here; this is already a bad way to get random numbers.
+  // Note that float(RAND_MAX) cannot be exactly represented as a float. We
+  // ignore the small inaccuracy here; this is already a bad way to get random
+  // numbers.
   return a + (b - a) * float(rand()) / static_cast<float>(RAND_MAX);
 }
 
diff --git a/opensfm/src/dense/test/depthmap_test.cc b/opensfm/src/dense/test/depthmap_test.cc
index 27b7d8651..660c60052 100644
--- a/opensfm/src/dense/test/depthmap_test.cc
+++ b/opensfm/src/dense/test/depthmap_test.cc
@@ -1,5 +1,6 @@
 #include <dense/depthmap.h>
 #include <gtest/gtest.h>
+
 #include <opencv2/calib3d/calib3d.hpp>
 
 namespace {
diff --git a/opensfm/src/features/src/akaze_bind.cc b/opensfm/src/features/src/akaze_bind.cc
index 057d8f799..8739d0639 100644
--- a/opensfm/src/features/src/akaze_bind.cc
+++ b/opensfm/src/features/src/akaze_bind.cc
@@ -48,10 +48,10 @@ py::tuple akaze(foundation::pyarray_uint8 image, AKAZEOptions options) {
   if (options.descriptor == MLDB_UPRIGHT || options.descriptor == MLDB) {
     return py::make_tuple(
         keys_py, foundation::py_array_from_data(desc.ptr<unsigned char>(0),
-                                             desc.rows, desc.cols));
+                                                desc.rows, desc.cols));
   }
   return py::make_tuple(keys_py, foundation::py_array_from_data(
-                                  desc.ptr<float>(0), desc.rows, desc.cols));
+                                     desc.ptr<float>(0), desc.rows, desc.cols));
 }
 
 }  // namespace features
diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index 26e7e4339..33f833e9c 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -41,8 +41,10 @@ void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
   }
 
   std::vector<int> best_match(f1.rows, -1), second_best_match(f1.rows, -1);
-  std::vector<float> best_distance(f1.rows, std::numeric_limits<float>::infinity());
-  std::vector<float> second_best_distance(f1.rows, std::numeric_limits<float>::infinity());
+  std::vector<float> best_distance(f1.rows,
+                                   std::numeric_limits<float>::infinity());
+  std::vector<float> second_best_distance(
+      f1.rows, std::numeric_limits<float>::infinity());
   *matches = cv::Mat(0, 2, CV_32S);
   cv::Mat tmp_match(1, 2, CV_32S);
   for (unsigned int i = 0; i < w1.rows; ++i) {
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index 35855cc28..c9fcd28b6 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -4,6 +4,7 @@
 
 #include <iostream>
 #include <vector>
+
 #include "opencv2/core/core.hpp"
 
 namespace py = pybind11;
@@ -11,9 +12,11 @@ namespace py = pybind11;
 namespace foundation {
 
 using pyarray_f = py::array_t<float, py::array::c_style | py::array::forcecast>;
-using pyarray_d = py::array_t<double, py::array::c_style | py::array::forcecast>;
+using pyarray_d =
+    py::array_t<double, py::array::c_style | py::array::forcecast>;
 using pyarray_int = py::array_t<int, py::array::c_style | py::array::forcecast>;
-using pyarray_uint8 = py::array_t<unsigned char, py::array::c_style | py::array::forcecast>;
+using pyarray_uint8 =
+    py::array_t<unsigned char, py::array::c_style | py::array::forcecast>;
 
 template <typename T>
 py::array_t<T> py_array_from_data(const T *data, size_t shape0) {
diff --git a/opensfm/src/foundation/test/union_find_test.cc b/opensfm/src/foundation/test/union_find_test.cc
index 0b6af1e0d..481d37aff 100644
--- a/opensfm/src/foundation/test/union_find_test.cc
+++ b/opensfm/src/foundation/test/union_find_test.cc
@@ -1,14 +1,13 @@
+#include <foundation/union_find.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include <foundation/union_find.h>
-
 class UnionFindFixture : public ::testing::Test {
  public:
   UnionFindFixture() {
     for (int i = 0; i < count; ++i) {
-      elements.emplace_back(std::unique_ptr<UnionFindElement<int>>(
-        new UnionFindElement<int>(i)));
+      elements.emplace_back(
+          std::unique_ptr<UnionFindElement<int>>(new UnionFindElement<int>(i)));
     }
   }
 
diff --git a/opensfm/src/geo/src/geo.cc b/opensfm/src/geo/src/geo.cc
index c80118901..5ed9487fe 100644
--- a/opensfm/src/geo/src/geo.cc
+++ b/opensfm/src/geo/src/geo.cc
@@ -165,7 +165,7 @@ TopocentricConverter::TopocentricConverter(const double lat,
     : lat_(lat), long_(longitude), alt_(alt) {}
 
 TopocentricConverter::TopocentricConverter(const Vec3d& lla)
-    : TopocentricConverter(lla[0], lla[1], lla[2]){}
+    : TopocentricConverter(lla[0], lla[1], lla[2]) {}
 
 Vec3d TopocentricConverter::ToTopocentric(const double lat, const double lon,
                                           const double alt) const {
diff --git a/opensfm/src/geometry/camera.h b/opensfm/src/geometry/camera.h
index e38867d99..bce1affa0 100644
--- a/opensfm/src/geometry/camera.h
+++ b/opensfm/src/geometry/camera.h
@@ -100,14 +100,17 @@ class Camera {
   static Vec2d PixelToNormalizedCoordinates(const Vec2d& px_coord,
                                             const int width, const int height);
   static MatX2d PixelToNormalizedCoordinatesMany(const MatX2d& px_coord,
-                                            const int width, const int height);
+                                                 const int width,
+                                                 const int height);
 
   Vec2d NormalizedToPixelCoordinates(const Vec2d& norm_coord) const;
   MatX2d NormalizedToPixelCoordinatesMany(const MatX2d& norm_coords) const;
 
   static Vec2d NormalizedToPixelCoordinates(const Vec2d& norm_coord,
                                             const int width, const int height);
-  static MatX2d NormalizedToPixelCoordinatesMany(const MatX2d& norm_coords, const int width, const int height);
+  static MatX2d NormalizedToPixelCoordinatesMany(const MatX2d& norm_coords,
+                                                 const int width,
+                                                 const int height);
 
  private:
   ProjectionType type_{ProjectionType::NONE};
diff --git a/opensfm/src/geometry/camera_distortions_functions.h b/opensfm/src/geometry/camera_distortions_functions.h
index f0b86df1d..7abce119d 100644
--- a/opensfm/src/geometry/camera_distortions_functions.h
+++ b/opensfm/src/geometry/camera_distortions_functions.h
@@ -490,33 +490,45 @@ struct Disto62 : Functor<2, 8, 2> {
 
 /* Parameters are : k1, k2, k3, k4, k5, k6, p1, p2, s0, s1, s2, s3 */
 struct Disto624 : Functor<2, 12, 2> {
-  enum { K1 = 0, K2 = 1, K3 = 2, K4 = 3, K5 = 4, K6 = 5, P1 = 6, P2 = 7, S0 = 8, S1 = 9, S2 = 10, S3 = 11 };
+  enum {
+    K1 = 0,
+    K2 = 1,
+    K3 = 2,
+    K4 = 3,
+    K5 = 4,
+    K6 = 5,
+    P1 = 6,
+    P2 = 7,
+    S0 = 8,
+    S1 = 9,
+    S2 = 10,
+    S3 = 11
+  };
 
   template <class T>
   static void Forward(const T* point, const T* k, T* distorted) {
     const auto r2 = SquaredNorm(point);
 
     // Radial
-    const auto distortion_radial =
-        Disto62::RadialDistortion(r2, k[static_cast<int>(K1)], k[static_cast<int>(K2)],
-                                  k[static_cast<int>(K3)], k[static_cast<int>(K4)],
-                                  k[static_cast<int>(K5)], k[static_cast<int>(K6)]);
+    const auto distortion_radial = Disto62::RadialDistortion(
+        r2, k[static_cast<int>(K1)], k[static_cast<int>(K2)],
+        k[static_cast<int>(K3)], k[static_cast<int>(K4)],
+        k[static_cast<int>(K5)], k[static_cast<int>(K6)]);
 
     // Tangential
-    const auto distortion_tangential =
-        Disto62::TangentialDistortion(r2, point[0], point[1], k[static_cast<int>(P1)],
-                                      k[static_cast<int>(P2)]);
+    const auto distortion_tangential = Disto62::TangentialDistortion(
+        r2, point[0], point[1], k[static_cast<int>(P1)],
+        k[static_cast<int>(P2)]);
 
     // Thin prism
-    const auto distortion_thin_prism =
-        ThinPrismDistortion(r2,
-                            k[static_cast<int>(S0)],
-                            k[static_cast<int>(S1)],
-                            k[static_cast<int>(S2)],
-                            k[static_cast<int>(S3)]);
-
-    distorted[0] = point[0] * distortion_radial + distortion_tangential[0] + distortion_thin_prism[0];
-    distorted[1] = point[1] * distortion_radial + distortion_tangential[1] + distortion_thin_prism[1];
+    const auto distortion_thin_prism = ThinPrismDistortion(
+        r2, k[static_cast<int>(S0)], k[static_cast<int>(S1)],
+        k[static_cast<int>(S2)], k[static_cast<int>(S3)]);
+
+    distorted[0] = point[0] * distortion_radial + distortion_tangential[0] +
+                   distortion_thin_prism[0];
+    distorted[1] = point[1] * distortion_radial + distortion_tangential[1] +
+                   distortion_thin_prism[1];
   }
 
   template <class T, bool DERIV_PARAMS>
@@ -665,8 +677,8 @@ struct Disto624 : Functor<2, 12, 2> {
       const auto distortion_thin_prism =
           ThinPrismDistortion(r2, s0, s1, s2, s3);
 
-      return point * distortion_radial + distortion_tangential + distortion_thin_prism -
-             point_distorted;
+      return point * distortion_radial + distortion_tangential +
+             distortion_thin_prism - point_distorted;
     }
 
     Mat2<T> derivative(const Vec2<T>& point) const {
@@ -680,11 +692,9 @@ struct Disto624 : Functor<2, 12, 2> {
   };
 
   template <class T>
-  static Vec2<T> ThinPrismDistortion(const T& r2,
-                                     const T& s0, const T& s1,
+  static Vec2<T> ThinPrismDistortion(const T& r2, const T& s0, const T& s1,
                                      const T& s2, const T& s3) {
-    return Vec2<T>(s0 * r2 + s1 * r2 * r2,
-                   s2 * r2 + s3 * r2 * r2);
+    return Vec2<T>(s0 * r2 + s1 * r2 * r2, s2 * r2 + s3 * r2 * r2);
   }
 };
 
diff --git a/opensfm/src/geometry/covariance.h b/opensfm/src/geometry/covariance.h
index af6d747b9..4effe1c23 100644
--- a/opensfm/src/geometry/covariance.h
+++ b/opensfm/src/geometry/covariance.h
@@ -11,4 +11,4 @@ std::pair<PointJacobian, Vec2d> ComputeJacobianReprojectionError(
 std::pair<Mat3d, double> ComputePointInverseCovariance(
     const std::vector<Camera>& cameras, const std::vector<Pose>& poses,
     const std::vector<Vec2d>& observations, const Vec3d& point);
-}  // namespace geometry
+}  // namespace geometry::covariance
diff --git a/opensfm/src/geometry/essential.h b/opensfm/src/geometry/essential.h
index a45aeb565..e0933f57f 100644
--- a/opensfm/src/geometry/essential.h
+++ b/opensfm/src/geometry/essential.h
@@ -21,6 +21,7 @@
 #pragma once
 
 #include <foundation/numeric.h>
+
 #include <Eigen/Eigen>
 #include <Eigen/SVD>
 
diff --git a/opensfm/src/geometry/python/pybind.cc b/opensfm/src/geometry/python/pybind.cc
index 9412cd790..44239b6dc 100644
--- a/opensfm/src/geometry/python/pybind.cc
+++ b/opensfm/src/geometry/python/pybind.cc
@@ -77,11 +77,11 @@ PYBIND11_MODULE(pygeometry, m) {
       .def("get_parameters_types", &geometry::Camera::GetParametersTypes)
       .def("get_parameters_map", &geometry::Camera::GetParametersMap)
       .def_static("pixel_to_normalized_coordinates_common",
-           (Vec2d(*)(const Vec2d&, const int, const int)) &
-               geometry::Camera::PixelToNormalizedCoordinates)
+                  (Vec2d(*)(const Vec2d&, const int, const int)) &
+                      geometry::Camera::PixelToNormalizedCoordinates)
       .def_static("pixel_to_normalized_coordinates_many_common",
-           (MatX2d(*)(const MatX2d&, const int, const int)) &
-               geometry::Camera::PixelToNormalizedCoordinatesMany)
+                  (MatX2d(*)(const MatX2d&, const int, const int)) &
+                      geometry::Camera::PixelToNormalizedCoordinatesMany)
       .def("pixel_to_normalized_coordinates",
            (Vec2d(geometry::Camera::*)(const Vec2d&) const) &
                geometry::Camera::PixelToNormalizedCoordinates)
@@ -89,11 +89,11 @@ PYBIND11_MODULE(pygeometry, m) {
            (MatX2d(geometry::Camera::*)(const MatX2d&) const) &
                geometry::Camera::PixelToNormalizedCoordinatesMany)
       .def_static("normalized_to_pixel_coordinates_common",
-           (Vec2d(*)(const Vec2d&, const int, const int)) &
-               geometry::Camera::NormalizedToPixelCoordinates)
+                  (Vec2d(*)(const Vec2d&, const int, const int)) &
+                      geometry::Camera::NormalizedToPixelCoordinates)
       .def_static("normalized_to_pixel_coordinates_many_common",
-           (MatX2d(*)(const MatX2d&, const int, const int)) &
-               geometry::Camera::NormalizedToPixelCoordinatesMany)
+                  (MatX2d(*)(const MatX2d&, const int, const int)) &
+                      geometry::Camera::NormalizedToPixelCoordinatesMany)
       .def("normalized_to_pixel_coordinates",
            (Vec2d(geometry::Camera::*)(const Vec2d&) const) &
                geometry::Camera::NormalizedToPixelCoordinates)
@@ -321,21 +321,21 @@ PYBIND11_MODULE(pygeometry, m) {
       .def("get_cam_to_world", &geometry::Pose::CameraToWorld)
       .def("get_world_to_cam", &geometry::Pose::WorldToCamera)
       // C++11
-      .def("set_from_world_to_cam", (void (geometry::Pose::*)(const Mat4d&)) &
+      .def("set_from_world_to_cam", (void(geometry::Pose::*)(const Mat4d&)) &
                                         geometry::Pose::SetFromWorldToCamera)
       .def("set_from_world_to_cam",
-           (void (geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
+           (void(geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
                geometry::Pose::SetFromWorldToCamera)
       .def("set_from_world_to_cam",
-           (void (geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
+           (void(geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
                geometry::Pose::SetFromWorldToCamera)
-      .def("set_from_cam_to_world", (void (geometry::Pose::*)(const Mat4d&)) &
+      .def("set_from_cam_to_world", (void(geometry::Pose::*)(const Mat4d&)) &
                                         geometry::Pose::SetFromCameraToWorld)
       .def("set_from_cam_to_world",
-           (void (geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
+           (void(geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
                geometry::Pose::SetFromCameraToWorld)
       .def("set_from_cam_to_world",
-           (void (geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
+           (void(geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
                geometry::Pose::SetFromCameraToWorld)
       .def("get_origin", &geometry::Pose::GetOrigin)
       .def("set_origin", &geometry::Pose::SetOrigin)
diff --git a/opensfm/src/geometry/relative_pose.h b/opensfm/src/geometry/relative_pose.h
index 7fb759fd9..febf958da 100644
--- a/opensfm/src/geometry/relative_pose.h
+++ b/opensfm/src/geometry/relative_pose.h
@@ -3,8 +3,10 @@
 #include <ceres/rotation.h>
 #include <ceres/tiny_solver.h>
 #include <ceres/tiny_solver_autodiff_function.h>
+
 #include <Eigen/Eigen>
 #include <Eigen/SVD>
+
 #include "triangulation.h"
 
 template <class IT>
@@ -87,8 +89,11 @@ struct RelativePoseCost {
     std::srand(42);
     const int count = end_ - begin_;
     for (int i = 0; i < MAX_ERRORS; ++i) {
-      // Note that float(RAND_MAX) cannot be exactly represented as a float. We ignore the small inaccuracy here; this is already a bad way to get random numbers.
-      const int index = (float(std::rand()) / static_cast<float>(RAND_MAX)) * count;
+      // Note that float(RAND_MAX) cannot be exactly represented as a float. We
+      // ignore the small inaccuracy here; this is already a bad way to get
+      // random numbers.
+      const int index =
+          (float(std::rand()) / static_cast<float>(RAND_MAX)) * count;
       picked_errors_.push_back(begin_ + index);
     }
   }
diff --git a/opensfm/src/geometry/src/camera.cc b/opensfm/src/geometry/src/camera.cc
index 58b4a50e2..0fd656de7 100644
--- a/opensfm/src/geometry/src/camera.cc
+++ b/opensfm/src/geometry/src/camera.cc
@@ -95,9 +95,9 @@ Camera Camera::CreateFisheye62Camera(double focal, double aspect_ratio,
 
 /**
   Create a Fisheye624 camera with 15 parameters:
-  - params: f, cx, cy, (radial) k1, k2, k3, k4, k5, k6 (tangential) p1, p2 (thin prism) s0, s1, s2, s3
-  Note that in arvr, the parameters start at 0 and p1/p2 are reversed
-  See: https://fburl.com/diffusion/xnhraa2z
+  - params: f, cx, cy, (radial) k1, k2, k3, k4, k5, k6 (tangential) p1, p2 (thin
+  prism) s0, s1, s2, s3 Note that in arvr, the parameters start at 0 and p1/p2
+  are reversed See: https://fburl.com/diffusion/xnhraa2z
 */
 Camera Camera::CreateFisheye624Camera(double focal, double aspect_ratio,
                                       const Vec2d& principal_point,
@@ -117,9 +117,9 @@ Camera Camera::CreateFisheye624Camera(double focal, double aspect_ratio,
                    Camera::Parameters::Cx,    Camera::Parameters::Cy};
   camera.values_.resize(16);
   camera.values_ << distortion[0], distortion[1], distortion[2], distortion[3],
-      distortion[4], distortion[5], distortion[6], distortion[7],
-      distortion[8], distortion[9], distortion[10], distortion[11],
-      focal, aspect_ratio, principal_point[0], principal_point[1];
+      distortion[4], distortion[5], distortion[6], distortion[7], distortion[8],
+      distortion[9], distortion[10], distortion[11], focal, aspect_ratio,
+      principal_point[0], principal_point[1];
   return camera;
 }
 
diff --git a/opensfm/src/geometry/src/covariance.cc b/opensfm/src/geometry/src/covariance.cc
index b86fabf3d..b7cbdd3d1 100644
--- a/opensfm/src/geometry/src/covariance.cc
+++ b/opensfm/src/geometry/src/covariance.cc
@@ -38,4 +38,4 @@ std::pair<Mat3d, double> ComputePointInverseCovariance(
   return std::make_pair(covariance, sigma2);
 }
 
-}  // namespace geometry
+}  // namespace geometry::covariance
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 1c450ae01..d29120a3f 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -5,6 +5,7 @@
 #include <foundation/types.h>
 #include <geometry/transformations_functions.h>
 #include <geometry/triangulation.h>
+
 #include <cmath>
 
 namespace {
@@ -71,16 +72,15 @@ struct BearingErrorCost : public ceres::CostFunction {
 
 constexpr int BearingErrorCost::Size;
 
-}
+}  // namespace
 
 namespace geometry {
 
-std::pair<bool, Vec3d> TriangulateBearingsDLT(
-    const std::vector<Mat34d> &Rts,
-    const MatX3d &bearings,
-    double threshold,
-    double min_angle,
-    double min_depth) {
+std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
+                                              const MatX3d &bearings,
+                                              double threshold,
+                                              double min_angle,
+                                              double min_depth) {
   const int count = Rts.size();
   MatXd world_bearings(count, 3);
   bool angle_ok = false;
@@ -118,9 +118,8 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(
   return std::make_pair(true, X.head<3>());
 }
 
-Vec4d TriangulateBearingsDLTSolve(
-    const MatX3d &bearings,
-    const std::vector<Mat34d> &Rts) {
+Vec4d TriangulateBearingsDLTSolve(const MatX3d &bearings,
+                                  const std::vector<Mat34d> &Rts) {
   const int nviews = bearings.rows();
   assert(nviews == Rts.size());
 
@@ -143,10 +142,8 @@ Vec4d TriangulateBearingsDLTSolve(
 }
 
 std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
-    const MatX3d &centers,
-    const MatX3d &bearings,
-    const std::vector<double> &threshold_list,
-    double min_angle,
+    const MatX3d &centers, const MatX3d &bearings,
+    const std::vector<double> &threshold_list, double min_angle,
     double min_depth) {
   const int count = centers.rows();
 
@@ -182,11 +179,8 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
   return std::make_pair(true, X.head<3>());
 }
 
-std::vector<std::pair<bool, Vec3d>>
-TriangulateTwoBearingsMidpointMany(
-    const MatX3d &bearings1,
-    const MatX3d &bearings2,
-    const Mat3d &rotation,
+std::vector<std::pair<bool, Vec3d>> TriangulateTwoBearingsMidpointMany(
+    const MatX3d &bearings1, const MatX3d &bearings2, const Mat3d &rotation,
     const Vec3d &translation) {
   std::vector<std::pair<bool, Vec3d>> triangulated(bearings1.rows());
   Eigen::Matrix<double, 2, 3> os, bs;
@@ -200,11 +194,10 @@ TriangulateTwoBearingsMidpointMany(
   return triangulated;
 }
 
-MatXd EpipolarAngleTwoBearingsMany(
-    const MatX3d &bearings1,
-    const MatX3d &bearings2,
-    const Mat3d &rotation,
-    const Vec3d &translation) {
+MatXd EpipolarAngleTwoBearingsMany(const MatX3d &bearings1,
+                                   const MatX3d &bearings2,
+                                   const Mat3d &rotation,
+                                   const Vec3d &translation) {
   const auto translation_normalized = translation.normalized();
   const auto bearings2_world = bearings2 * rotation.transpose();
 
@@ -221,10 +214,9 @@ MatXd EpipolarAngleTwoBearingsMany(
     epi2.row(i) = translation_normalized.cross(bearing).normalized();
   }
 
-  MatXd symmetric_epi =
-      (((epi1 * bearings2_world.transpose()).array().abs() +
-        (bearings1 * epi2.transpose()).array().abs()) /
-       2.0);
+  MatXd symmetric_epi = (((epi1 * bearings2_world.transpose()).array().abs() +
+                          (bearings1 * epi2.transpose()).array().abs()) /
+                         2.0);
   return M_PI / 2.0 - symmetric_epi.array().acos();
 }
 
@@ -242,6 +234,4 @@ Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
   return refined;
 }
 
-
-
 }  // namespace geometry
diff --git a/opensfm/src/geometry/test/camera_functions_test.cc b/opensfm/src/geometry/test/camera_functions_test.cc
index 975ee9e9f..0384ea4f2 100644
--- a/opensfm/src/geometry/test/camera_functions_test.cc
+++ b/opensfm/src/geometry/test/camera_functions_test.cc
@@ -286,8 +286,8 @@ class CameraDerivativesFixture : public ::testing::Test {
       for (int j = 0; j < size_params; ++j) {
         ASSERT_NEAR(projection_expected[i].derivatives()(j), jacobian(i, j),
                     eps)
-          << "where (i, j) = (" << testing::PrintToString(i)
-          << ", " << testing::PrintToString(j) << ')';
+            << "where (i, j) = (" << testing::PrintToString(i) << ", "
+            << testing::PrintToString(j) << ')';
       }
       ASSERT_NEAR(projection_expected[i].value(), projected[i], eps);
     }
diff --git a/opensfm/src/geometry/test/camera_test.cc b/opensfm/src/geometry/test/camera_test.cc
index 881c19861..666a31049 100644
--- a/opensfm/src/geometry/test/camera_test.cc
+++ b/opensfm/src/geometry/test/camera_test.cc
@@ -118,18 +118,15 @@ TEST_F(CameraFixture, Fisheye624IsConsistent) {
 
 TEST_F(CameraFixture, Fisheye624MatchesReference) {
   Eigen::Matrix<double, 3, 3> points;
-  points <<
-    10.0, 0.0, 0.0,
-    0.0, 10.0, 0.0,
-    1e-6, 1e-6, 10.0;
+  points << 10.0, 0.0, 0.0,  // clang-format off
+            0.0, 10.0, 0.0,
+            1e-6, 1e-6, 10.0;  // clang-format on
 
   // This test case is constructed to result in round numbers apart from the
   // thin prism distortions.
   Eigen::Matrix<double, 3, 2> reference_pixels;
-  reference_pixels <<
-    149.42887062, 48.67088846,
-    99.4288738, 98.67088528,
-    100.0, 50.0;
+  reference_pixels << 149.42887062, 48.67088846, 99.4288738, 98.67088528, 100.0,
+      50.0;
 
   constexpr int width = 200, height = 100;
   constexpr double f = width / (2 * M_PI);
@@ -140,36 +137,38 @@ TEST_F(CameraFixture, Fisheye624MatchesReference) {
   const MatX2d reference_projected = camera.ProjectMany(points);
 
   ASSERT_TRUE(reference_pixels.isApprox(reference_projected, 1e-5))
-    << " where reference_pixels = \n" << reference_pixels << '\n'
-    << " and reference_projected = \n" << reference_projected << '\n';
+      << " where reference_pixels = \n"
+      << reference_pixels << '\n'
+      << " and reference_projected = \n"
+      << reference_projected << '\n';
 }
 
 TEST_F(CameraFixture, Fisheye624WithTanMatchesReference) {
   Eigen::Matrix<double, 3, 3> points;
-  points <<
-    10.0, 0.0, 0.0,
-    0.0, 10.0, 0.0,
-    1e-6, 1e-6, 10.0;
+  points << 10.0, 0.0, 0.0,  // clang-format off
+            0.0, 10.0, 0.0,
+            1e-6, 1e-6, 10.0;  // clang-format on
 
   // This test case is constructed to result in round numbers apart from the
   // tangential and thin prism distortions.
   Eigen::Matrix<double, 3, 2> reference_pixels;
-  reference_pixels <<
-    151.7850648, 51.02708265,
-    100.2142719, 105.7394678,
-    100.0, 50.0;
-
+  reference_pixels << 151.7850648, 51.02708265,  // clang-format off
+      100.2142719, 105.7394678, 
+      100.0, 50.0;  // clang-format on
   constexpr int width = 200, height = 100;
   constexpr double f = width / (2 * M_PI);
   Eigen::Matrix<double, 12, 1> distortion_tan_and_thin_prism;
-  distortion_tan_and_thin_prism << 0, 0, 0, 0, 0, 0, 0.03, 0.01, 0.01, -0.007, -0.03, 0.0053;
+  distortion_tan_and_thin_prism << 0, 0, 0, 0, 0, 0, 0.03, 0.01, 0.01, -0.007,
+      -0.03, 0.0053;
   const geometry::Camera camera = geometry::Camera::CreateFisheye624Camera(
       f, 1.0, {width / 2, height / 2}, distortion_tan_and_thin_prism);
   const MatX2d reference_projected = camera.ProjectMany(points);
 
   ASSERT_TRUE(reference_pixels.isApprox(reference_projected, 1e-5))
-    << " where reference_pixels = \n" << reference_pixels << '\n'
-    << " and reference_projected = \n" << reference_projected << '\n';
+      << " where reference_pixels = \n"
+      << reference_pixels << '\n'
+      << " and reference_projected = \n"
+      << reference_projected << '\n';
 }
 
 TEST_F(CameraFixture, DualIsConsistent) {
diff --git a/opensfm/src/geometry/test/triangulation_test.cc b/opensfm/src/geometry/test/triangulation_test.cc
index d0ba3677e..24dac9df3 100644
--- a/opensfm/src/geometry/test/triangulation_test.cc
+++ b/opensfm/src/geometry/test/triangulation_test.cc
@@ -4,7 +4,6 @@
 
 #include <Eigen/Dense>
 
-
 MatX3d generateNoisyBearings(const MatX3d &bearings, double maxNoise) {
   MatX3d bearings_noisy = MatX3d::Zero(bearings.rows(), 3);
   for (int i = 0; i < bearings.rows(); ++i) {
@@ -20,19 +19,16 @@ std::vector<Mat34d> generateRts(const MatX3d &centers) {
   std::vector<Mat34d> Rts(num_cameras);
   for (int i = 0; i < num_cameras; ++i) {
     const Vec3d center = centers.row(i);
-    Rts[i] << 1.0, 0.0, 0.0, -center(0),
+    Rts[i] << 1.0, 0.0, 0.0, -center(0),  // clang-format off
               0.0, 1.0, 0.0, -center(1),
-              0.0, 0.0, 1.0, -center(2);
+              0.0, 0.0, 1.0, -center(2);  // clang-format on
   }
   return Rts;
 }
 
-void generate_triangulation_data(
-    const MatX3d &centers,
-    MatX3d &bearings,
-    MatX3d &bearings_noisy,
-    std::vector<Mat34d> &Rts,
-    Vec3d& gt_point) {
+void generate_triangulation_data(const MatX3d &centers, MatX3d &bearings,
+                                 MatX3d &bearings_noisy,
+                                 std::vector<Mat34d> &Rts, Vec3d &gt_point) {
   const int num_cameras = centers.rows();
 
   gt_point = Vec3d(0.0, 0.0, 1.0);
@@ -47,17 +43,17 @@ void generate_triangulation_data(
 
   Rts = generateRts(centers);
 }
-    
+
 class TwoCamsFixture : public ::testing::Test {
  public:
   TwoCamsFixture() {
     centers = MatX3d::Zero(2, 3);
-    centers << 0.0, 0.0, 0.0,
-              1.0, 0.0, 0.0;
-  
-    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);
+    centers << 0.0, 0.0, 0.0, 1.0, 0.0, 0.0;
+
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts,
+                                gt_point);
   }
-  
+
   Vec3d gt_point;
   MatX3d centers;
   MatX3d bearings;
@@ -78,7 +74,8 @@ class FiveCamsFixture : public ::testing::Test {
     for (int i = 0; i < num_cameras; ++i) {
       centers.row(i) << 0.5 * i / num_cameras, 0.1 * i / num_cameras, 0.0;
     }
-    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);    
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts,
+                                gt_point);
   }
 
   Vec3d gt_point;
@@ -104,13 +101,14 @@ class ThreeCamsSameCenterFixture : public ::testing::Test {
  public:
   ThreeCamsSameCenterFixture() {
     centers = MatX3d::Zero(3, 3);
-    centers << 0.0, 0.0, 0.0,
-              0.0, 0.0, 0.0,
-              1.0, 0.0, 0.0;
-  
-    generate_triangulation_data(centers, bearings, bearings_noisy, Rts, gt_point);
+    centers << 0.0, 0.0, 0.0,  // clang-format off
+               0.0, 0.0, 0.0,
+               1.0, 0.0, 0.0;  // clang-format on
+
+    generate_triangulation_data(centers, bearings, bearings_noisy, Rts,
+                                gt_point);
   }
-  
+
   Vec3d gt_point;
   MatX3d centers;
   MatX3d bearings;
@@ -133,18 +131,18 @@ class TwoCamsSameCenterFixture : public ::testing::Test {
  public:
   TwoCamsSameCenterFixture() {
     centers = MatX3d::Zero(2, 3);
-    centers << 1.0, 0.0, 0.0,
-              1.0, 0.0, 0.0;
-  
+    centers << 1.0, 0.0, 0.0,  // clang-format off
+               1.0, 0.0, 0.0;  // clang-format on
+
     bearings = MatX3d::Zero(2, 3);
-    bearings << 0.0, 0.0, 1.0,
-                1.0, 0.0, 0.0;
+    bearings << 0.0, 0.0, 1.0,  // clang-format off
+                1.0, 0.0, 0.0;  // clang-format on
 
     bearings_noisy = generateNoisyBearings(bearings, 0.001);
 
     Rts = generateRts(centers);
   }
-  
+
   MatX3d centers;
   MatX3d bearings;
   MatX3d bearings_noisy;
@@ -156,13 +154,12 @@ class TwoCamsSameCenterFixture : public ::testing::Test {
   const double min_depth = 1e-6;
 };
 
-
 class TwoCamsManyPointsFixture : public ::testing::Test {
  public:
   TwoCamsManyPointsFixture() {
     gt_points.emplace_back(0.0, 0.0, 1.0);
     gt_points.emplace_back(1.0, 2.0, 3.0);
-    
+
     rotation_1_2 = Eigen::AngleAxisd(0.1, Vec3d::UnitY()).toRotationMatrix();
     translation_1_2 << -1.0, 2.0, 0.2;
 
@@ -171,7 +168,9 @@ class TwoCamsManyPointsFixture : public ::testing::Test {
     for (int i = 0; i < gt_points.size(); ++i) {
       const Vec3d &gt_point = gt_points[i];
       bearings1.row(i) = gt_point.normalized();
-      bearings2.row(i) = (rotation_1_2.transpose() * (gt_point - translation_1_2)).normalized();
+      bearings2.row(i) =
+          (rotation_1_2.transpose() * (gt_point - translation_1_2))
+              .normalized();
     }
 
     bearings1_noisy = generateNoisyBearings(bearings1, 0.001);
@@ -187,7 +186,6 @@ class TwoCamsManyPointsFixture : public ::testing::Test {
   MatX3d bearings2_noisy;
 };
 
-
 TEST_F(TwoCamsFixture, TriangulateBearingsDLT) {
   const auto [success, point] = geometry::TriangulateBearingsDLT(
       Rts, bearings, threshold, min_angle, min_depth);
@@ -231,13 +229,15 @@ TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsDLT) {
 
   const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsDLT(
       Rts, bearings_noisy, threshold, min_angle, min_depth);
-  ASSERT_FALSE(success_noisy);  // Expect failure due to coincident camera centers
+  ASSERT_FALSE(
+      success_noisy);  // Expect failure due to coincident camera centers
 
   // Test that without the positive depth constraint, triangulation succeeds
   // and returns the center of the cameras.
   const double negative_min_depth = -1e-6;
-  const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, negative_min_depth);
+  const auto [success_no_depth_check, point_no_depth_check] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings, thresholds,
+                                            min_angle, negative_min_depth);
   ASSERT_TRUE(success_no_depth_check);
   const Vec3d expected_point = centers.row(0);
   ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
@@ -249,8 +249,9 @@ TEST_F(TwoCamsFixture, TriangulateBearingsMidpoint) {
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
-  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, min_depth);
+  const auto [success_noisy, point_noisy] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings_noisy, thresholds,
+                                            min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
@@ -261,8 +262,9 @@ TEST_F(FiveCamsFixture, TriangulateBearingsMidpoint) {
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
-  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, min_depth);
+  const auto [success_noisy, point_noisy] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings_noisy, thresholds,
+                                            min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
@@ -273,8 +275,9 @@ TEST_F(ThreeCamsSameCenterFixture, TriangulateBearingsMidpoint) {
   ASSERT_TRUE(success);
   ASSERT_LT((point - gt_point).norm(), 1e-6);
 
-  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings_noisy, thresholds, min_angle, min_depth);
+  const auto [success_noisy, point_noisy] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings_noisy, thresholds,
+                                            min_angle, min_depth);
   ASSERT_TRUE(success_noisy);
   ASSERT_LT((point_noisy - gt_point).norm(), 0.01);
 }
@@ -284,15 +287,18 @@ TEST_F(TwoCamsSameCenterFixture, TriangulateBearingsMidpoint) {
       centers, bearings, thresholds, min_angle, min_depth);
   ASSERT_FALSE(success);  // Expect failure due to coincident camera centers
 
-  const auto [success_noisy, point_noisy] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, min_depth);
-  ASSERT_FALSE(success_noisy);  // Expect failure due to coincident camera centers
+  const auto [success_noisy, point_noisy] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings, thresholds,
+                                            min_angle, min_depth);
+  ASSERT_FALSE(
+      success_noisy);  // Expect failure due to coincident camera centers
 
   // Test that without the positive depth constraint, triangulation succeeds
   // and returns the center of the cameras.
   const double negative_min_depth = -1e-6;
-  const auto [success_no_depth_check, point_no_depth_check] = geometry::TriangulateBearingsMidpoint(
-      centers, bearings, thresholds, min_angle, negative_min_depth);
+  const auto [success_no_depth_check, point_no_depth_check] =
+      geometry::TriangulateBearingsMidpoint(centers, bearings, thresholds,
+                                            min_angle, negative_min_depth);
   ASSERT_TRUE(success_no_depth_check);
   const Vec3d expected_point = centers.row(0);
   ASSERT_LT((point_no_depth_check - expected_point).norm(), 1e-6);
@@ -318,7 +324,6 @@ TEST_F(TwoCamsManyPointsFixture, TriangulateTwoBearingsMidpointMany) {
   }
 }
 
-
 TEST_F(TwoCamsManyPointsFixture, EpipolarAngleTwoBearingsMany) {
   MatXd angles = geometry::EpipolarAngleTwoBearingsMany(
       bearings1, bearings2, rotation_1_2, translation_1_2);
@@ -337,6 +342,7 @@ TEST_F(TwoCamsManyPointsFixture, EpipolarAngleTwoBearingsMany) {
 
 TEST_F(TwoCamsFixture, PointRefinement) {
   const Vec3d initial_point = gt_point + Vec3d(0.1, 0.2, 0.3);
-  const Vec3d refined = geometry::PointRefinement(centers, bearings, initial_point, 10);
+  const Vec3d refined =
+      geometry::PointRefinement(centers, bearings, initial_point, 10);
   ASSERT_LT((refined - gt_point).norm(), 1e-6);
 }
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index c7cd30716..ae54c4d7f 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -9,22 +9,18 @@
 
 namespace geometry {
 
-std::pair<bool, Vec3d> TriangulateBearingsDLT(
-    const std::vector<Mat34d> &Rts,
-    const MatX3d &bearings,
-    double threshold,
-    double min_angle,
-    double min_depth);
+std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
+                                              const MatX3d &bearings,
+                                              double threshold,
+                                              double min_angle,
+                                              double min_depth);
 
-Vec4d TriangulateBearingsDLTSolve(
-    const MatX3d &bs,
-    const std::vector<Mat34d> &Rts);
+Vec4d TriangulateBearingsDLTSolve(const MatX3d &bs,
+                                  const std::vector<Mat34d> &Rts);
 
 std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
-    const MatX3d &centers,
-    const MatX3d &bearings,
-    const std::vector<double> &threshold_list,
-    double min_angle,
+    const MatX3d &centers, const MatX3d &bearings,
+    const std::vector<double> &threshold_list, double min_angle,
     double min_depth);
 
 template <class T>
@@ -32,11 +28,8 @@ Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
     const Eigen::Matrix<T, Eigen::Dynamic, 3> &centers,
     const Eigen::Matrix<T, Eigen::Dynamic, 3> &bearings);
 
-std::vector<std::pair<bool, Vec3d>>
-TriangulateTwoBearingsMidpointMany(
-    const MatX3d &bearings1,
-    const MatX3d &bearings2,
-    const Mat3d &rotation,
+std::vector<std::pair<bool, Vec3d>> TriangulateTwoBearingsMidpointMany(
+    const MatX3d &bearings1, const MatX3d &bearings2, const Mat3d &rotation,
     const Vec3d &translation);
 
 template <class T>
@@ -44,18 +37,13 @@ std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
     const Eigen::Matrix<T, 2, 3> &centers,
     const Eigen::Matrix<T, 2, 3> &bearings);
 
-MatXd EpipolarAngleTwoBearingsMany(
-    const MatX3d &bearings1,
-    const MatX3d &bearings2,
-    const Mat3d &rotation,
-    const Vec3d &translation);
-
-Vec3d PointRefinement(
-    const MatX3d &centers,
-    const MatX3d &bearings,
-    const Vec3d &point,
-    int iterations);
+MatXd EpipolarAngleTwoBearingsMany(const MatX3d &bearings1,
+                                   const MatX3d &bearings2,
+                                   const Mat3d &rotation,
+                                   const Vec3d &translation);
 
+Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
+                      const Vec3d &point, int iterations);
 
 // Template implementations
 
@@ -119,5 +107,4 @@ std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
   return std::make_pair(true, (x1 + x2) / T(2.0));
 }
 
-
 }  // namespace geometry
diff --git a/opensfm/src/map/ground_control_points.h b/opensfm/src/map/ground_control_points.h
index c14a07b6e..c8cb862bc 100644
--- a/opensfm/src/map/ground_control_points.h
+++ b/opensfm/src/map/ground_control_points.h
@@ -7,8 +7,8 @@ enum GroundControlPointRole {
   /*    A ground control point role in SfM cluster merge and bundle adjuster
 
        Attributes:
-           OPTIMIZATION: used in the optimization of map chunks and logging metrics
-           METRICS_ONLY: only used in logging metrics
+           OPTIMIZATION: used in the optimization of map chunks and logging
+  metrics METRICS_ONLY: only used in logging metrics
 
   **/
   OPTIMIZATION = 0,
@@ -36,10 +36,10 @@ struct GroundControlPoint {
          lla: latitude, longitude and altitude
          has_altitude: true if z coordinate is known
          observations: list of observations of the point on images
-         id: a unique id for this point group (survey point + image observations)
-         survey_point_id: a unique id for the point on the ground
-         role: OPTIMIZATION if gcp is used in SfM optimization, METRICS_ONLY if the
-         ground control point is used for computing map merging metrics
+         id: a unique id for this point group (survey point + image
+     observations) survey_point_id: a unique id for the point on the ground
+         role: OPTIMIZATION if gcp is used in SfM optimization, METRICS_ONLY if
+     the ground control point is used for computing map merging metrics
      */
   GroundControlPoint() = default;
   LandmarkId id_;
@@ -51,9 +51,9 @@ struct GroundControlPoint {
 
   Vec3d GetLlaVec3d() const {
     return {
-      lla_.at("latitude"),
-      lla_.at("longitude"),
-      has_altitude_ ? lla_.at("altitude") : 0.0,
+        lla_.at("latitude"),
+        lla_.at("longitude"),
+        has_altitude_ ? lla_.at("altitude") : 0.0,
     };
   }
 
diff --git a/opensfm/src/map/observation.h b/opensfm/src/map/observation.h
index b1f9a4be6..80ba6eebd 100644
--- a/opensfm/src/map/observation.h
+++ b/opensfm/src/map/observation.h
@@ -13,8 +13,8 @@ struct Depth {
   double std_deviation;
 
   Depth() = default;
-  Depth(double value_, bool is_radial_, double std_deviation_):
-    value(value_), is_radial(is_radial_), std_deviation(std_deviation_) {}
+  Depth(double value_, bool is_radial_, double std_deviation_)
+      : value(value_), is_radial(is_radial_), std_deviation(std_deviation_) {}
 };
 
 struct Observation {
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index fcc0209ec..8f96f464c 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -65,12 +65,9 @@ PYBIND11_MODULE(pymap, m) {
       .export_values();
 
   py::class_<map::Depth>(m, "Depth")
-      .def(py::init<double, bool, double>(),
-           py::arg("value"),
-           py::arg("is_radial"),
-           py::arg("std_deviation"))
-      .def_readwrite("value",
-                     &map::Depth::value)
+      .def(py::init<double, bool, double>(), py::arg("value"),
+           py::arg("is_radial"), py::arg("std_deviation"))
+      .def_readwrite("value", &map::Depth::value)
       .def_readwrite("is_radial", &map::Depth::is_radial)
       .def_readwrite("std_deviation", &map::Depth::std_deviation);
 
@@ -270,7 +267,8 @@ PYBIND11_MODULE(pymap, m) {
   py::class_<map::GroundControlPoint>(m, "GroundControlPoint")
       .def(py::init())
       .def_readwrite("id", &map::GroundControlPoint::id_)
-      .def_readwrite("survey_point_id", &map::GroundControlPoint::survey_point_id_)
+      .def_readwrite("survey_point_id",
+                     &map::GroundControlPoint::survey_point_id_)
       .def_readwrite("has_altitude", &map::GroundControlPoint::has_altitude_)
       .def_readwrite("lla", &map::GroundControlPoint::lla_)
       .def_property("lla_vec", &map::GroundControlPoint::GetLlaVec3d,
@@ -606,9 +604,9 @@ PYBIND11_MODULE(pymap, m) {
       .def("create_landmark", &map::Map::CreateLandmark, py::arg("lm_id"),
            py::arg("global_position"),
            py::return_value_policy::reference_internal)
-      .def("remove_landmark", (void (map::Map::*)(const map::Landmark *const)) &
+      .def("remove_landmark", (void(map::Map::*)(const map::Landmark *const)) &
                                   map::Map::RemoveLandmark)
-      .def("remove_landmark", (void (map::Map::*)(const map::LandmarkId &)) &
+      .def("remove_landmark", (void(map::Map::*)(const map::LandmarkId &)) &
                                   map::Map::RemoveLandmark)
       .def("has_landmark", &map::Map::HasLandmark)
       .def("get_landmark",
@@ -648,17 +646,17 @@ PYBIND11_MODULE(pymap, m) {
            py::return_value_policy::reference_internal)
       // Observation
       .def("add_observation",
-           (void (map::Map::*)(map::Shot *const, map::Landmark *const,
-                               const map::Observation &)) &
+           (void(map::Map::*)(map::Shot *const, map::Landmark *const,
+                              const map::Observation &)) &
                map::Map::AddObservation,
            py::arg("shot"), py::arg("landmark"), py::arg("observation"))
       .def("add_observation",
-           (void (map::Map::*)(const map::ShotId &, const map::LandmarkId &,
-                               const map::Observation &)) &
+           (void(map::Map::*)(const map::ShotId &, const map::LandmarkId &,
+                              const map::Observation &)) &
                map::Map::AddObservation,
            py::arg("shot_Id"), py::arg("landmark_id"), py::arg("observation"))
       .def("remove_observation",
-           (void (map::Map::*)(const map::ShotId &, const map::LandmarkId &)) &
+           (void(map::Map::*)(const map::ShotId &, const map::LandmarkId &)) &
                map::Map::RemoveObservation,
            py::arg("shot"), py::arg("landmark"))
       // Getters
diff --git a/opensfm/src/map/rig.h b/opensfm/src/map/rig.h
index c355fd2bf..4dab9ac3a 100644
--- a/opensfm/src/map/rig.h
+++ b/opensfm/src/map/rig.h
@@ -51,7 +51,8 @@ class RigInstance {
   std::unordered_map<map::ShotId, map::RigCamera*>& GetRigCameras() {
     return shots_rig_cameras_;
   }
-  const std::unordered_map<map::ShotId, map::RigCamera*>& GetRigCameras() const {
+  const std::unordered_map<map::ShotId, map::RigCamera*>& GetRigCameras()
+      const {
     return shots_rig_cameras_;
   }
   std::set<map::ShotId> GetShotIDs() const;
diff --git a/opensfm/src/robust/absolute_pose_known_rotation_model.h b/opensfm/src/robust/absolute_pose_known_rotation_model.h
index ddd088973..1b74438ac 100644
--- a/opensfm/src/robust/absolute_pose_known_rotation_model.h
+++ b/opensfm/src/robust/absolute_pose_known_rotation_model.h
@@ -2,6 +2,7 @@
 
 #include <foundation/numeric.h>
 #include <geometry/absolute_pose.h>
+
 #include "model.h"
 
 class AbsolutePoseKnownRotation
diff --git a/opensfm/src/robust/absolute_pose_model.h b/opensfm/src/robust/absolute_pose_model.h
index 7dfac5875..146c12e47 100644
--- a/opensfm/src/robust/absolute_pose_model.h
+++ b/opensfm/src/robust/absolute_pose_model.h
@@ -2,6 +2,7 @@
 
 #include <foundation/numeric.h>
 #include <geometry/absolute_pose.h>
+
 #include "model.h"
 
 class AbsolutePose : public Model<AbsolutePose, 1, 4> {
diff --git a/opensfm/src/robust/essential_model.h b/opensfm/src/robust/essential_model.h
index 08d75bc29..1b5d26b01 100644
--- a/opensfm/src/robust/essential_model.h
+++ b/opensfm/src/robust/essential_model.h
@@ -2,6 +2,7 @@
 
 #include <foundation/numeric.h>
 #include <geometry/essential.h>
+
 #include "model.h"
 
 class EpipolarSymmetric {
diff --git a/opensfm/src/robust/relative_pose_model.h b/opensfm/src/robust/relative_pose_model.h
index 160b8e314..1d0fa8c29 100644
--- a/opensfm/src/robust/relative_pose_model.h
+++ b/opensfm/src/robust/relative_pose_model.h
@@ -3,6 +3,7 @@
 #include <foundation/numeric.h>
 #include <geometry/relative_pose.h>
 #include <geometry/triangulation.h>
+
 #include "essential_model.h"
 #include "model.h"
 
diff --git a/opensfm/src/robust/relative_rotation_model.h b/opensfm/src/robust/relative_rotation_model.h
index 49270ede4..1a23236a3 100644
--- a/opensfm/src/robust/relative_rotation_model.h
+++ b/opensfm/src/robust/relative_rotation_model.h
@@ -2,6 +2,7 @@
 
 #include <foundation/numeric.h>
 #include <geometry/transform.h>
+
 #include "model.h"
 
 class RelativeRotation : public Model<RelativeRotation, 1, 1> {
diff --git a/opensfm/src/sfm/retriangulation.h b/opensfm/src/sfm/retriangulation.h
index c1e703ca2..ffa56bca0 100644
--- a/opensfm/src/sfm/retriangulation.h
+++ b/opensfm/src/sfm/retriangulation.h
@@ -5,4 +5,4 @@
 namespace sfm::retriangulation {
 void RealignMaps(const map::Map& reference, map::Map& to_align,
                  bool update_points);
-}  // namespace sfm
+}  // namespace sfm::retriangulation
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 8163d00f7..c6d6fbd00 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -209,8 +209,8 @@ py::tuple BAHelpers::BundleLocal(
     // only add averaged rig position constraints to moving instances
     if (!fix_instance && gps_count > 0) {
       LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>()
-                << ", adding average GPS prior to rig instance " << rig_instance_id
-                << ", count: " << gps_count
+                << ", adding average GPS prior to rig instance "
+                << rig_instance_id << ", count: " << gps_count
                 << ", avg pos: " << average_position.transpose()
                 << ", avg std: " << average_std
                 << ", scale group: " << gps_scale_group;
@@ -674,9 +674,11 @@ py::dict BAHelpers::Bundle(
         const auto acc = shot.GetShotMeasurements().gps_accuracy_;
         if (pos.HasValue() && acc.HasValue()) {
           if (acc.Value() <= 0) {
-            throw std::runtime_error("Shot " + shot.GetId() + " has an accuracy <= 0: "
-                                    + std::to_string(acc.Value()) + ". Try modifying "
-                                    "your input parser to filter such values.");
+            throw std::runtime_error(
+                "Shot " + shot.GetId() +
+                " has an accuracy <= 0: " + std::to_string(acc.Value()) +
+                ". Try modifying "
+                "your input parser to filter such values.");
           }
           average_position += pos.Value();
           average_std += acc.Value();
diff --git a/opensfm/src/sfm/src/retriangulation.cc b/opensfm/src/sfm/src/retriangulation.cc
index 006189b32..65ff8073a 100644
--- a/opensfm/src/sfm/src/retriangulation.cc
+++ b/opensfm/src/sfm/src/retriangulation.cc
@@ -113,4 +113,4 @@ void RealignMaps(const map::Map& map_from, map::Map& map_to,
     map_to.RemoveShot(shot_id);
   }
 }
-}  // namespace sfm
+}  // namespace sfm::retriangulation
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index 2346bcc94..8b8ffaab2 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -42,4 +42,4 @@ void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
     manager.RemoveObservation(shot_id, connection);
   }
 }
-}  // namespace sfm
+}  // namespace sfm::tracks_helpers
diff --git a/opensfm/src/sfm/tracks_helpers.h b/opensfm/src/sfm/tracks_helpers.h
index cadc91ea0..e715397f2 100644
--- a/opensfm/src/sfm/tracks_helpers.h
+++ b/opensfm/src/sfm/tracks_helpers.h
@@ -17,4 +17,4 @@ void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                     const std::vector<map::TrackId>& connections);
 void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                        const std::vector<map::TrackId>& connections);
-}  // namespace sfm
+}  // namespace sfm::tracks_helpers
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 061485b5a..678a5689f 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -6,14 +6,14 @@
 import statistics
 from collections import defaultdict
 from functools import lru_cache
-from typing import Dict, List, Tuple, Optional, Any
+from typing import Any, Dict, List, Optional, Tuple
 
 import matplotlib as mpl
 import matplotlib.cm as cm
 import matplotlib.colors as colors
 import matplotlib.pyplot as plt
 import numpy as np
-from opensfm import io, multiview, feature_loader, pymap, types, pygeometry
+from opensfm import feature_loader, io, multiview, pygeometry, pymap, types
 from opensfm.dataset import DataSet, DataSetBase
 
 RESIDUAL_PIXEL_CUTOFF = 4
@@ -225,8 +225,9 @@ def reconstruction_statistics(
 
     # observations total and average tracks lengths
     hist_agg = sorted(hist_agg.items(), key=lambda x: x[0])
-    lengths, counts = np.array([int(x[0]) for x in hist_agg]), np.array(
-        [x[1] for x in hist_agg]
+    lengths, counts = (
+        np.array([int(x[0]) for x in hist_agg]),
+        np.array([x[1] for x in hist_agg]),
     )
 
     points_count = stats["reconstructed_points_count"]
@@ -575,9 +576,11 @@ def save_residual_histogram(
     h_angular, b_angular = stats["reconstruction_statistics"][
         "reprojection_histogram_angular"
     ]
-    n, _, p_angular, = axs[
-        2
-    ].hist(b_angular[:-1], b_angular, weights=h_angular)
+    (
+        n,
+        _,
+        p_angular,
+    ) = axs[2].hist(b_angular[:-1], b_angular, weights=h_angular)
     n = n.astype("int")
     for i in range(len(p_angular)):
         p_angular[i].set_facecolor(plt.cm.viridis(n[i] / max(n)))
@@ -665,8 +668,9 @@ def save_topview(
     kernel = _get_gaussian_kernel(splatting, 2)
     kernel /= kernel[splatting, splatting]
     for point, color in zip(points, colors):
-        x, y = int((point[0] - low_x) / size_x * im_size_x), int(
-            (point[1] - low_y) / size_y * im_size_y
+        x, y = (
+            int((point[0] - low_x) / size_x * im_size_x),
+            int((point[1] - low_y) / size_y * im_size_y),
         )
         if not ((0 < x < (im_size_x - 1)) and (0 < y < (im_size_y - 1))):
             continue
@@ -677,8 +681,9 @@ def save_topview(
             size - max(y + splatting - (im_size_y - 2), 0),
         )
         h_low_x, h_low_y = max(x - splatting, 0), max(y - splatting, 0)
-        h_high_x, h_high_y = min(x + splatting + 1, im_size_x - 1), min(
-            y + splatting + 1, im_size_y - 1
+        h_high_x, h_high_y = (
+            min(x + splatting + 1, im_size_x - 1),
+            min(y + splatting + 1, im_size_y - 1),
         )
 
         for i in range(3):
@@ -702,8 +707,9 @@ def save_topview(
         c_gps = cm.get_cmap("autumn")(0 / len(reconstructions))
         for j, shot in enumerate(sorted_shots):
             o = shot.pose.get_origin()
-            x, y = int((o[0] - low_x) / size_x * im_size_x), int(
-                (o[1] - low_y) / size_y * im_size_y
+            x, y = (
+                int((o[0] - low_x) / size_x * im_size_x),
+                int((o[1] - low_y) / size_y * im_size_y),
             )
             plt.plot(
                 x,
@@ -718,8 +724,9 @@ def save_topview(
             # also display camera path using capture time
             if j < len(sorted_shots) - 1:
                 n = sorted_shots[j + 1].pose.get_origin()
-                nx, ny = int((n[0] - low_x) / size_x * im_size_x), int(
-                    (n[1] - low_y) / size_y * im_size_y
+                nx, ny = (
+                    int((n[0] - low_x) / size_x * im_size_x),
+                    int((n[1] - low_y) / size_y * im_size_y),
                 )
                 plt.plot(
                     [x, nx], [y, ny], linestyle="-", color=c_camera, linewidth=linewidth
@@ -729,8 +736,9 @@ def save_topview(
             if not shot.metadata.gps_position.has_value:
                 continue
             gps = shot.metadata.gps_position.value
-            gps_x, gps_y = int((gps[0] - low_x) / size_x * im_size_x), int(
-                (gps[1] - low_y) / size_y * im_size_y
+            gps_x, gps_y = (
+                int((gps[0] - low_x) / size_x * im_size_x),
+                int((gps[1] - low_y) / size_y * im_size_y),
             )
             plt.plot(
                 gps_x,
@@ -813,8 +821,9 @@ def save_heatmap(
                 size - max(y + splatting - (buckets_y - 2), 0),
             )
             h_low_x, h_low_y = max(x - splatting, 0), max(y - splatting, 0)
-            h_high_x, h_high_y = min(x + splatting + 1, buckets_x - 1), min(
-                y + splatting + 1, buckets_y - 1
+            h_high_x, h_high_y = (
+                min(x + splatting + 1, buckets_x - 1),
+                min(y + splatting + 1, buckets_y - 1),
             )
             camera_heatmap[h_low_y:h_high_y, h_low_x:h_high_x] += kernel[
                 k_low_y:k_high_y, k_low_x:k_high_x
@@ -852,7 +861,6 @@ def save_heatmap(
         ),
         "wb",
     ) as fwb:
-
         plt.savefig(
             fwb,
             dpi=300,
diff --git a/opensfm/synthetic_data/synthetic_dataset.py b/opensfm/synthetic_data/synthetic_dataset.py
index b52cdfcd7..bff82e6a9 100644
--- a/opensfm/synthetic_data/synthetic_dataset.py
+++ b/opensfm/synthetic_data/synthetic_dataset.py
@@ -6,7 +6,7 @@
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import numpy as np
-from opensfm import tracking, features as oft, types, pymap, pygeometry, io, geo
+from opensfm import features as oft, geo, io, pygeometry, pymap, tracking, types
 from opensfm.dataset import DataSet
 
 logger: logging.Logger = logging.getLogger(__name__)
diff --git a/opensfm/synthetic_data/synthetic_metrics.py b/opensfm/synthetic_data/synthetic_metrics.py
index 762060aa8..d51ffea0f 100644
--- a/opensfm/synthetic_data/synthetic_metrics.py
+++ b/opensfm/synthetic_data/synthetic_metrics.py
@@ -1,10 +1,10 @@
 # pyre-unsafe
-from typing import Tuple, List, Dict
+from typing import Dict, List, Tuple
 
 import cv2
 import numpy as np
 import opensfm.transformations as tf
-from opensfm import align, types, pymap, multiview
+from opensfm import align, multiview, pymap, types
 
 
 def points_errors(
@@ -142,7 +142,7 @@ def _copy_reconstruction(reconstruction: types.Reconstruction) -> types.Reconstr
 
 
 def rmse(errors: np.ndarray) -> float:
-    return np.sqrt(np.mean(errors ** 2))
+    return np.sqrt(np.mean(errors**2))
 
 
 def mad(errors: np.ndarray) -> float:
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 6dcae3206..34d4b9034 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -1,13 +1,13 @@
 # pyre-unsafe
 import functools
 import math
-from typing import Dict, Optional, List, Any, Union, Tuple, Callable
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import opensfm.synthetic_data.synthetic_dataset as sd
 import opensfm.synthetic_data.synthetic_generator as sg
 import opensfm.synthetic_data.synthetic_metrics as sm
-from opensfm import pygeometry, types, pymap, geo
+from opensfm import geo, pygeometry, pymap, types
 
 
 def get_camera(
@@ -241,19 +241,17 @@ def _set_terrain_hill_single(self, height: float, radius: float) -> None:
         wall_points, floor_points = self.wall_points, self.floor_points
         assert wall_points is not None and floor_points is not None
         wall_points[:, 2] += height * np.exp(
-            -0.5 * np.linalg.norm(wall_points[:, :2], axis=1) ** 2 / radius ** 2
+            -0.5 * np.linalg.norm(wall_points[:, :2], axis=1) ** 2 / radius**2
         )
         floor_points[:, 2] += height * np.exp(
-            -0.5 * np.linalg.norm(floor_points[:, :2], axis=1) ** 2 / radius ** 2
+            -0.5 * np.linalg.norm(floor_points[:, :2], axis=1) ** 2 / radius**2
         )
 
         for positions in self.instances_positions:
             for position in positions:
                 position[2] += height * np.exp(
                     -0.5
-                    * np.linalg.norm(
-                        (position[0] ** 2 + position[1] ** 2) / radius ** 2
-                    )
+                    * np.linalg.norm((position[0] ** 2 + position[1] ** 2) / radius**2)
                 )
 
     def _set_terrain_hill_repeated(self, height: float, radius: float) -> None:
diff --git a/opensfm/test/conftest.py b/opensfm/test/conftest.py
index 78331cd35..13c43dd19 100644
--- a/opensfm/test/conftest.py
+++ b/opensfm/test/conftest.py
@@ -5,11 +5,11 @@
 
 import numpy as np
 import pytest
-from opensfm import multiview, types, geo, pygeometry, pymap
+from opensfm import geo, multiview, pygeometry, pymap, types
 from opensfm.synthetic_data import (
+    synthetic_dataset as sd,
     synthetic_examples,
     synthetic_scene,
-    synthetic_dataset as sd,
 )
 
 
@@ -125,14 +125,16 @@ def scene_synthetic_triangulation() -> synthetic_scene.SyntheticInputData:
 
 
 @pytest.fixture(scope="module")
-def pairs_and_poses() -> Tuple[
-    Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
-    Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
-    pygeometry.Camera,
-    sd.SyntheticFeatures,
-    pymap.TracksManager,
-    types.Reconstruction,
-]:
+def pairs_and_poses() -> (
+    Tuple[
+        Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
+        Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
+        pygeometry.Camera,
+        sd.SyntheticFeatures,
+        pymap.TracksManager,
+        types.Reconstruction,
+    ]
+):
     np.random.seed(42)
     data = synthetic_examples.synthetic_cube_scene()
 
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index 8e795a82b..61240add8 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -228,27 +228,19 @@ def test_pair_with_points_priors(bundle_adjuster: pybundle.BundleAdjuster) -> No
 
     std_dev = np.array([1, 1, 1])
     sa.add_point_projection_observation(
-        shot="1", 
-        point="p1",
-        observation=np.array([0, 0]),
-        std_deviation=1)
+        shot="1", point="p1", observation=np.array([0, 0]), std_deviation=1
+    )
     sa.add_point_projection_observation(
-        shot="2",
-        point="p1",
-        observation=np.array([-0.5, 0]),
-        std_deviation=1)
+        shot="2", point="p1", observation=np.array([-0.5, 0]), std_deviation=1
+    )
     sa.add_point_prior("p1", np.array([-0.5, 2, 2]), std_dev, True)
 
     sa.add_point_projection_observation(
-        shot="2",
-        point="p2",
-        observation=np.array([0, 0]),
-        std_deviation=1)
+        shot="2", point="p2", observation=np.array([0, 0]), std_deviation=1
+    )
     sa.add_point_projection_observation(
-        shot="1",
-        point="p2",
-        observation=np.array([0.5, 0]),
-        std_deviation=1)
+        shot="1", point="p2", observation=np.array([0.5, 0]), std_deviation=1
+    )
     sa.add_point_prior("p2", np.array([1.5, 2, 2]), std_dev, True)
 
     sa.run()
@@ -687,8 +679,8 @@ def bell_heatmap(size, r, mu_x, mu_y):
             / (2 * np.pi * sigma_x * sigma_y)
             * np.exp(
                 -(
-                    (x - mu_x) ** 2 / (2 * sigma_x ** 2)
-                    + (y - mu_y) ** 2 / (2 * sigma_y ** 2)
+                    (x - mu_x) ** 2 / (2 * sigma_x**2)
+                    + (y - mu_y) ** 2 / (2 * sigma_y**2)
                 )
             )
         )
diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index ac04e8602..b2dda5770 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -2,9 +2,10 @@
 import argparse
 from os.path import join
 
-from opensfm import commands, dataset
 from mapillary.opensfm.opensfm.test import data_generation, utils
 
+from opensfm import commands, dataset
+
 
 def run_command(command, args) -> None:
     parser = argparse.ArgumentParser()
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 17db15e38..3a0500aef 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,7 +1,7 @@
 # pyre-unsafe
 import numpy as np
-from opensfm import features
 from mapillary.opensfm.opensfm.test import data_generation
+from opensfm import features
 
 
 def test_dataset_load_features_sift(tmpdir) -> None:
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index cbf5116be..a0a7ea50a 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -1,26 +1,29 @@
 # pyre-unsafe
 import copy
-from opensfm.pymap import RigCamera, RigInstance, Shot
-from opensfm.types import Reconstruction
-from typing import Tuple
 
 import random
+from typing import Tuple
 
 import numpy as np
 import pytest
-from opensfm import pygeometry
-from opensfm import pymap
-from opensfm import types
-from mapillary.opensfm.opensfm.test.utils import assert_maps_equal, assert_metadata_equal, assert_cameras_equal, assert_shots_equal
+from mapillary.opensfm.opensfm.test.utils import (
+    assert_cameras_equal,
+    assert_maps_equal,
+    assert_metadata_equal,
+    assert_shots_equal,
+)
+from opensfm import pygeometry, pymap, types
+from opensfm.pymap import RigCamera, RigInstance, Shot
+from opensfm.types import Reconstruction
 
 
 def _create_reconstruction(
-    n_cameras: int=0,
+    n_cameras: int = 0,
     n_shots_cam=None,
     n_pano_shots_cam=None,
-    n_points: int=0,
-    dist_to_shots: bool=False,
-    dist_to_pano_shots: bool=False,
+    n_points: int = 0,
+    dist_to_shots: bool = False,
+    dist_to_pano_shots: bool = False,
 ) -> types.Reconstruction:
     """Creates a reconstruction with n_cameras random cameras and
     shots, where n_shots_cam is a dictionary, containing the
@@ -250,7 +253,9 @@ def test_fisheye624_camera() -> None:
     focal = 0.6
     aspect_ratio = 0.7
     ppoint = np.array([0.51, 0.52])
-    dist = np.array([-0.1, 0.09, 0.08, 0.01, 0.02, 0.05, 0.1, 0.2, 0.01, -0.003, 0.005, -0.007])  # [k1-k6, p1, p2, s0-s3]
+    dist = np.array(
+        [-0.1, 0.09, 0.08, 0.01, 0.02, 0.05, 0.1, 0.2, 0.01, -0.003, 0.005, -0.007]
+    )  # [k1-k6, p1, p2, s0-s3]
     cam_cpp = pygeometry.Camera.create_fisheye624(focal, aspect_ratio, ppoint, dist)
     cam_cpp.width = 800
     cam_cpp.height = 600
@@ -1101,6 +1106,7 @@ def test_rec_deepcopy() -> None:
 
     assert_maps_equal(rec.map, rec2.map)
 
+
 def test_gcp() -> None:
     gcp = []
     for i in range(0, 10):
diff --git a/opensfm/test/test_dense.py b/opensfm/test/test_dense.py
index 2c7bdd28e..a53b7aba6 100644
--- a/opensfm/test/test_dense.py
+++ b/opensfm/test/test_dense.py
@@ -1,8 +1,6 @@
 # pyre-unsafe
 import numpy as np
-from opensfm import dense
-from opensfm import pygeometry
-from opensfm import types
+from opensfm import dense, pygeometry, types
 
 
 def test_angle_between_points() -> None:
@@ -33,7 +31,9 @@ def test_depthmap_to_ply() -> None:
     r = types.Reconstruction()
     r.add_camera(camera)
     shot = r.create_shot(
-        "shot1", camera.id, pygeometry.Pose(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 0.0]))
+        "shot1",
+        camera.id,
+        pygeometry.Pose(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 0.0])),
     )
 
     image = np.zeros((height, width, 3))
diff --git a/opensfm/test/test_geo.py b/opensfm/test/test_geo.py
index 65c3b12bd..d0b74f850 100644
--- a/opensfm/test/test_geo.py
+++ b/opensfm/test/test_geo.py
@@ -40,6 +40,7 @@ def test_ecef_lla_topocentric_consistency_pygeo() -> None:
     )
     assert np.allclose(lla_after, lla_before)
 
+
 def test_eq_geo() -> None:
-    assert geo.TopocentricConverter(40,30,0) == geo.TopocentricConverter(40,30,0)
-    assert geo.TopocentricConverter(40,32,0) != geo.TopocentricConverter(40,30,0)
+    assert geo.TopocentricConverter(40, 30, 0) == geo.TopocentricConverter(40, 30, 0)
+    assert geo.TopocentricConverter(40, 32, 0) != geo.TopocentricConverter(40, 30, 0)
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 39e46890d..0246ed377 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -4,8 +4,8 @@
 from io import StringIO
 
 import numpy as np
-from opensfm import io, pygeometry, types
 from mapillary.opensfm.opensfm.test import data_generation, utils
+from opensfm import io, pygeometry, types
 
 
 filename = os.path.join(
diff --git a/opensfm/test/test_matching.py b/opensfm/test/test_matching.py
index c236de723..a2d9ce962 100644
--- a/opensfm/test/test_matching.py
+++ b/opensfm/test/test_matching.py
@@ -2,15 +2,13 @@
 from typing import Any, Dict, List, Set, Tuple
 
 import numpy as np
-from opensfm import bow
-from opensfm import config
-from opensfm import matching
-from opensfm import pairs_selection
-from opensfm import pyfeatures
+from opensfm import bow, config, matching, pairs_selection, pyfeatures
 from opensfm.synthetic_data import synthetic_dataset
 
 
-def compute_words(features: np.ndarray, bag_of_words, num_words, bow_matcher_type) -> np.ndarray:
+def compute_words(
+    features: np.ndarray, bag_of_words, num_words, bow_matcher_type
+) -> np.ndarray:
     closest_words = bag_of_words.map_to_words(features, num_words, bow_matcher_type)
     if closest_words is None:
         return np.array([], dtype=np.int32)
diff --git a/opensfm/test/test_multiview.py b/opensfm/test/test_multiview.py
index 6911ad26c..81134b891 100644
--- a/opensfm/test/test_multiview.py
+++ b/opensfm/test/test_multiview.py
@@ -2,9 +2,7 @@
 import copy
 
 import numpy as np
-from opensfm import multiview
-from opensfm import pygeometry
-from opensfm import transformations as tf
+from opensfm import multiview, pygeometry, transformations as tf
 
 
 def normalized(x: np.ndarray) -> np.ndarray:
@@ -39,7 +37,6 @@ def test_motion_from_plane_homography() -> None:
 def test_essential_five_points(pairs_and_their_E) -> None:
     exact_found = 0
     for f1, f2, E, _ in pairs_and_their_E:
-
         result = pygeometry.essential_five_points(f1[0:5, :], f2[0:5, :])
 
         # run over the N solutions, looking for the exact one
@@ -87,7 +84,6 @@ def test_absolute_pose_n_points_known_rotation(shots_and_their_points) -> None:
 
 def test_essential_n_points(pairs_and_their_E) -> None:
     for f1, f2, E, _ in pairs_and_their_E:
-
         f1 /= np.linalg.norm(f1, axis=1)[:, None]
         f2 /= np.linalg.norm(f2, axis=1)[:, None]
 
@@ -103,7 +99,6 @@ def test_essential_n_points(pairs_and_their_E) -> None:
 
 def test_relative_pose_from_essential(pairs_and_their_E) -> None:
     for f1, f2, E, pose in pairs_and_their_E:
-
         result = pygeometry.relative_pose_from_essential(E, f1, f2)
 
         pose = copy.deepcopy(pose)
@@ -115,7 +110,6 @@ def test_relative_pose_from_essential(pairs_and_their_E) -> None:
 
 def test_relative_rotation(pairs_and_their_E) -> None:
     for f1, _, _, _ in pairs_and_their_E:
-
         vec_x = np.random.rand(3)
         vec_x /= np.linalg.norm(vec_x)
         vec_y = np.array([-vec_x[1], vec_x[0], 0.0])
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index 303f334ff..f2447b3fe 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -5,8 +5,8 @@
 
 import numpy as np
 import pytest
-from opensfm import commands, dataset, feature_loader, pairs_selection, geo
 from mapillary.opensfm.opensfm.test import data_generation
+from opensfm import commands, dataset, feature_loader, geo, pairs_selection
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/opensfm/test/test_reconstruction_alignment.py b/opensfm/test/test_reconstruction_alignment.py
index a077cca4a..e68fdb7cd 100644
--- a/opensfm/test/test_reconstruction_alignment.py
+++ b/opensfm/test/test_reconstruction_alignment.py
@@ -1,7 +1,6 @@
 # pyre-unsafe
 import numpy as np
-from opensfm import pybundle
-from opensfm import pygeometry
+from opensfm import pybundle, pygeometry
 
 
 def get_shot_origin(shot) -> np.ndarray:
@@ -13,7 +12,9 @@ def get_shot_origin(shot) -> np.ndarray:
 def get_reconstruction_origin(r) -> np.ndarray:
     """Compute the origin of a reconstruction."""
     s = r.scale
-    pose = pygeometry.Pose(np.array([r.rx, r.ry, r.rz]), np.array([r.tx / s, r.ty / s, r.tz / s]))
+    pose = pygeometry.Pose(
+        np.array([r.rx, r.ry, r.rz]), np.array([r.tx / s, r.ty / s, r.tz / s])
+    )
     return pose.get_origin()
 
 
diff --git a/opensfm/test/test_reconstruction_resect.py b/opensfm/test/test_reconstruction_resect.py
index f55448d1a..06e40487f 100644
--- a/opensfm/test/test_reconstruction_resect.py
+++ b/opensfm/test/test_reconstruction_resect.py
@@ -1,7 +1,9 @@
 # pyre-unsafe
+from typing import Tuple
+
 import numpy as np
 from opensfm import config, multiview, pymap, reconstruction, types
-from typing import Tuple
+
 
 def test_corresponding_tracks() -> None:
     t1 = {"1": pymap.Observation(1.0, 1.0, 1.0, 0, 0, 0, 1, 1, 1)}
@@ -65,7 +67,7 @@ def split_synthetic_reconstruction(
     cluster2 = types.Reconstruction()
     cluster1.cameras = scene.cameras
     cluster2.cameras = scene.cameras
-    for (i, shot) in zip(range(len(scene.shots)), scene.shots.values()):
+    for i, shot in zip(range(len(scene.shots)), scene.shots.values()):
         if i >= cluster_size:
             cluster2.add_shot(shot)
         if i <= cluster_size:
@@ -76,7 +78,9 @@ def split_synthetic_reconstruction(
     return cluster1, cluster2
 
 
-def move_and_scale_cluster(cluster: types.Reconstruction)->Tuple[types.Reconstruction, np.ndarray, float]:
+def move_and_scale_cluster(
+    cluster: types.Reconstruction,
+) -> Tuple[types.Reconstruction, np.ndarray, float]:
     scale = np.random.rand(1)
     translation = np.random.rand(3)
     for point in cluster.points.values():
diff --git a/opensfm/test/test_reconstruction_shot_neighborhood.py b/opensfm/test/test_reconstruction_shot_neighborhood.py
index f42f98603..d0c0c810b 100644
--- a/opensfm/test/test_reconstruction_shot_neighborhood.py
+++ b/opensfm/test/test_reconstruction_shot_neighborhood.py
@@ -1,10 +1,6 @@
 # pyre-unsafe
 import networkx as nx
-from opensfm import pygeometry
-from opensfm import pymap
-from opensfm import pysfm
-from opensfm import reconstruction
-from opensfm import types
+from opensfm import pygeometry, pymap, pysfm, reconstruction, types
 
 
 def _add_shot(rec, shot_id, cam) -> None:
diff --git a/opensfm/test/test_rig.py b/opensfm/test/test_rig.py
index 50677f3cc..08818b8de 100644
--- a/opensfm/test/test_rig.py
+++ b/opensfm/test/test_rig.py
@@ -1,5 +1,6 @@
 # pyre-unsafe
 """Test the rig module."""
+
 import numpy as np
 from opensfm import pygeometry, rig, types
 
@@ -88,10 +89,18 @@ def test_compute_relative_pose() -> None:
     rec.add_camera(camera4)
 
     # First rig instance
-    rec.create_shot("shot1", "camera1", pygeometry.Pose(np.array([0, 0, 0]), np.array([-2, -2, 0])))
-    rec.create_shot("shot2", "camera2", pygeometry.Pose(np.array([0, 0, 0]), np.array([-3, -3, 0])))
-    rec.create_shot("shot3", "camera3", pygeometry.Pose(np.array([0, 0, 0]), np.array([-1, -3, 0])))
-    rec.create_shot("shot4", "camera4", pygeometry.Pose(np.array([0, 0, 0]), np.array([-2, -4, 0])))
+    rec.create_shot(
+        "shot1", "camera1", pygeometry.Pose(np.array([0, 0, 0]), np.array([-2, -2, 0]))
+    )
+    rec.create_shot(
+        "shot2", "camera2", pygeometry.Pose(np.array([0, 0, 0]), np.array([-3, -3, 0]))
+    )
+    rec.create_shot(
+        "shot3", "camera3", pygeometry.Pose(np.array([0, 0, 0]), np.array([-1, -3, 0]))
+    )
+    rec.create_shot(
+        "shot4", "camera4", pygeometry.Pose(np.array([0, 0, 0]), np.array([-2, -4, 0]))
+    )
 
     # Second rig instance (rotated by pi/2 around Z)
     pose_instance = pygeometry.Pose(np.array([0, 0, -1.5707963]))
diff --git a/opensfm/test/test_robust.py b/opensfm/test/test_robust.py
index 1f4330b6f..9255cb663 100644
--- a/opensfm/test/test_robust.py
+++ b/opensfm/test/test_robust.py
@@ -3,7 +3,7 @@
 from typing import Tuple
 
 import numpy as np
-from opensfm import pyrobust, pygeometry
+from opensfm import pygeometry, pyrobust
 
 
 def line_data() -> Tuple[int, int, np.ndarray, int]:
@@ -267,7 +267,6 @@ def test_outliers_relative_pose_ransac(pairs_and_their_E) -> None:
 
 def test_outliers_relative_rotation_ransac(pairs_and_their_E) -> None:
     for f1, _, _, _ in pairs_and_their_E:
-
         vec_x = np.random.rand(3)
         vec_x /= np.linalg.norm(vec_x)
         vec_y = np.array([-vec_x[1], vec_x[0], 0.0])
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index da01d8fd1..01c82810b 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -1,9 +1,6 @@
 # pyre-unsafe
 import numpy as np
-from opensfm import io
-from opensfm import pygeometry
-from opensfm import pymap
-from opensfm import reconstruction
+from opensfm import io, pygeometry, pymap, reconstruction
 
 
 def test_track_triangulator_spherical() -> None:
@@ -42,7 +39,13 @@ def test_track_triangulator_spherical() -> None:
     triangulator = reconstruction.TrackTriangulator(
         rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
     )
-    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, min_depth=0.001, iterations=10)
+    triangulator.triangulate(
+        "1",
+        reproj_threshold=0.01,
+        min_ray_angle_degrees=2.0,
+        min_depth=0.001,
+        iterations=10,
+    )
     assert "1" in rec.points
     p = rec.points["1"].coordinates
     assert np.allclose(p, [0, 0, 1.3763819204711])
@@ -51,7 +54,7 @@ def test_track_triangulator_spherical() -> None:
 
 def test_track_triangulator_coincident_camera_origins() -> None:
     """Test triangulating tracks when two cameras have the same origin.
-    
+
     Triangulation should fail and no points should be added to the reconstruction.
     """
     tracks_manager = pymap.TracksManager()
@@ -88,7 +91,13 @@ def test_track_triangulator_coincident_camera_origins() -> None:
     triangulator = reconstruction.TrackTriangulator(
         rec, reconstruction.TrackHandlerTrackManager(tracks_manager, rec)
     )
-    triangulator.triangulate("1", reproj_threshold=0.01, min_ray_angle_degrees=2.0, min_depth=0.0001, iterations=10)
+    triangulator.triangulate(
+        "1",
+        reproj_threshold=0.01,
+        min_ray_angle_degrees=2.0,
+        min_depth=0.0001,
+        iterations=10,
+    )
     assert not rec.points
 
 
@@ -111,6 +120,7 @@ def test_triangulate_bearings_dlt() -> None:
     assert np.allclose(X, [0, 0, 1.0])
     assert res is True
 
+
 def test_triangulate_bearings_dlt_coincident_camera_origins() -> None:
     rt1 = np.append(np.identity(3), [[0], [0], [0]], axis=1)
     rt2 = np.append(np.identity(3), [[0], [0], [0]], axis=1)  # same origin
diff --git a/opensfm/test/test_types.py b/opensfm/test/test_types.py
index 679c2ab02..8e04e66cd 100644
--- a/opensfm/test/test_types.py
+++ b/opensfm/test/test_types.py
@@ -9,7 +9,6 @@
 
 
 def test_reconstruction_class_initialization() -> None:
-
     # Instantiate Reconstruction
     reconstruction = types.Reconstruction()
     focal = 0.9722222222222222
@@ -27,11 +26,13 @@ def test_reconstruction_class_initialization() -> None:
     metadata.orientation.value = 1
     metadata.capture_time.value = 0.0
     metadata.gps_accuracy.value = 5.0
-    metadata.gps_position.value = np.array([
-        1.0815875281451939,
-        -0.96510451436708888,
-        1.2042133903991235,
-    ])
+    metadata.gps_position.value = np.array(
+        [
+            1.0815875281451939,
+            -0.96510451436708888,
+            1.2042133903991235,
+        ]
+    )
     metadata.gravity_down.value = np.array([0.1, 0.9, 0.0])
     metadata.compass_angle.value = 270.0
     metadata.compass_accuracy.value = 15.0
diff --git a/opensfm/test/test_undistort.py b/opensfm/test/test_undistort.py
index e5e8120f6..c71714fd7 100644
--- a/opensfm/test/test_undistort.py
+++ b/opensfm/test/test_undistort.py
@@ -2,7 +2,7 @@
 import itertools
 
 import numpy as np
-from opensfm import undistort, pygeometry, types
+from opensfm import pygeometry, types, undistort
 
 
 def test_perspective_views_of_a_panorama() -> None:
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index 6c16eafaa..ca03603cf 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -6,8 +6,8 @@
 import numpy as np
 from opensfm import pymap
 from opensfm.dataset_base import DataSetBase
-from opensfm.unionfind import UnionFind
 from opensfm.pymap import TracksManager
+from opensfm.unionfind import UnionFind
 
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -108,18 +108,29 @@ def create_tracks_manager(
                 instances[image][featureid] if image in instances else NO_VALUE,
             )
             obs = pymap.Observation(
+                x,
+                y,
+                s,
+                int(r),
+                int(g),
+                int(b),
+                featureid,
                 # pyre-fixme[6]: For 8th argument expected `int` but got
                 #  `Union[ndarray[typing.Any, typing.Any], int]`.
+                segmentation,
                 # pyre-fixme[6]: For 9th argument expected `int` but got
                 #  `Union[ndarray[typing.Any, typing.Any], int]`.
-                x, y, s, int(r), int(g), int(b), featureid, segmentation, instance
+                instance,
             )
             if image in depths:
                 depth_value = depths[image][featureid]
                 if not np.isnan(depth_value) and not np.isinf(depth_value):
-                    std = max(depth_std_deviation * depth_value, depth_std_deviation)  # pyre-ignore
+                    std = max(
+                        depth_std_deviation * depth_value,  # pyre-ignore
+                        depth_std_deviation,
+                    )
                     obs.depth_prior = pymap.Depth(
-                        value=depth_value,   # pyre-ignore
+                        value=depth_value,  # pyre-ignore
                         std_deviation=std,
                         is_radial=depth_is_radial,
                     )
@@ -128,7 +139,8 @@ def create_tracks_manager(
             num_observations += 1
     logger.info(
         f"{len(tracks)} tracks, {num_observations} observations,"
-        f" {num_depth_priors} depth priors added to TracksManager")
+        f" {num_depth_priors} depth priors added to TracksManager"
+    )
     return tracks_manager
 
 
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index 14ac8e306..23fded2dc 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -188,7 +188,7 @@
 """
 
 import math
-from typing import Dict, Optional, List, Tuple
+from typing import Dict, List, Optional, Tuple
 
 import numpy
 
@@ -1893,7 +1893,13 @@ def is_same_transform(matrix0: numpy.ndarray, matrix1: numpy.ndarray) -> numpy.n
     return numpy.allclose(matrix0, matrix1)
 
 
-def _import_module(name: str, package: Optional[str]=None, warn: bool=True, prefix: str="_py_", ignore: str="_") -> Optional[bool]:
+def _import_module(
+    name: str,
+    package: Optional[str] = None,
+    warn: bool = True,
+    prefix: str = "_py_",
+    ignore: str = "_",
+) -> Optional[bool]:
     """Try import all public attributes from module into global namespace.
 
     Existing attributes with name clashes are renamed with prefix.
diff --git a/opensfm/types.py b/opensfm/types.py
index 6492e8509..3a830524a 100644
--- a/opensfm/types.py
+++ b/opensfm/types.py
@@ -1,5 +1,6 @@
 # pyre-unsafe
 """Basic types for building a reconstruction."""
+
 from typing import Dict, Optional
 
 import numpy as np
diff --git a/opensfm/undistort.py b/opensfm/undistort.py
index f7e3f0803..8c3e0fe68 100644
--- a/opensfm/undistort.py
+++ b/opensfm/undistort.py
@@ -1,18 +1,18 @@
 # pyre-unsafe
 import itertools
 import logging
-from typing import Iterator, List, Dict, Optional
+from typing import Dict, Iterator, List, Optional
 
 import cv2
 import numpy as np
 from opensfm import (
     features,
+    features_processing,
     log,
     pygeometry,
     pymap,
     transformations as tf,
     types,
-    features_processing,
 )
 from opensfm.context import parallel_map
 from opensfm.dataset import UndistortedDataSet
@@ -180,7 +180,13 @@ def undistort_image(
         return {}
 
     projection_type = shot.camera.projection_type
-    if projection_type in ["perspective", "brown", "fisheye", "fisheye_opencv", "fisheye62"]:
+    if projection_type in [
+        "perspective",
+        "brown",
+        "fisheye",
+        "fisheye_opencv",
+        "fisheye62",
+    ]:
         [undistorted_shot] = undistorted_shots
         new_camera = undistorted_shot.camera
         height, width = original.shape[:2]
diff --git a/opensfm/upright.py b/opensfm/upright.py
index c06cc409a..31ee383cd 100644
--- a/opensfm/upright.py
+++ b/opensfm/upright.py
@@ -1,7 +1,8 @@
 # pyre-unsafe
-import numpy as np
 from typing import Optional
 
+import numpy as np
+
 
 def opensfm_to_upright(
     coords: np.ndarray,
diff --git a/opensfm/video.py b/opensfm/video.py
index 9e34b6e92..8dc855ad2 100644
--- a/opensfm/video.py
+++ b/opensfm/video.py
@@ -1,14 +1,12 @@
 # pyre-unsafe
 import datetime
 import os
-from subprocess import Popen, PIPE
+from subprocess import PIPE, Popen
 from typing import List
 
 import cv2
 import dateutil.parser
-from opensfm import context
-from opensfm import geotag_from_gpx
-from opensfm import io
+from opensfm import context, geotag_from_gpx, io
 
 
 def video_orientation(video_file) -> int:
@@ -44,7 +42,6 @@ def import_video_with_gpx(
     visual: bool = False,
     image_description=None,
 ) -> List[str]:
-
     points = geotag_from_gpx.get_lat_lon_time(gpx_file)
 
     orientation = video_orientation(video_file)
diff --git a/opensfm/vlad.py b/opensfm/vlad.py
index 5c623e0f1..d09e3db22 100644
--- a/opensfm/vlad.py
+++ b/opensfm/vlad.py
@@ -1,9 +1,9 @@
 # pyre-unsafe
 from functools import lru_cache
-from typing import List, Tuple, Iterable, Dict, Optional
+from typing import Dict, Iterable, List, Optional, Tuple
 
 import numpy as np
-from opensfm import pyfeatures, feature_loader, bow
+from opensfm import bow, feature_loader, pyfeatures
 from opensfm.dataset_base import DataSetBase
 
 
diff --git a/viewer/legacy/js/three.js b/viewer/legacy/js/three.js
index eb93a6bf4..4cc98bacc 100755
--- a/viewer/legacy/js/three.js
+++ b/viewer/legacy/js/three.js
@@ -25460,7 +25460,7 @@ THREE.ShadowMapPlugin = function ( _renderer, _lights, _webglObjects, _webglObje
 				object = webglObject.object;
 				buffer = webglObject.buffer;
 
-				// culling is overriden globally for all objects
+				// culling is overridden globally for all objects
 				// while rendering depth map
 
 				// need to deal with MeshFaceMaterial somehow
@@ -28355,7 +28355,7 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
 
 	if ( newShapes.length > 1 ) {
-		var ambigious = false;
+		var ambiguous = false;
 		var toChange = [];
 
 		for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
@@ -28374,17 +28374,17 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 							hole_unassigned = false;
 							betterShapeHoles[s2Idx].push( ho );
 						} else {
-							ambigious = true;
+							ambiguous = true;
 						}
 					}
 				}
 				if ( hole_unassigned ) { betterShapeHoles[sIdx].push( ho ); }
 			}
 		}
-		// console.log("ambigious: ", ambigious);
+		// console.log("ambiguous: ", ambiguous);
 		if ( toChange.length > 0 ) {
 			// console.log("to change: ", toChange);
-			if (! ambigious)	newShapeHoles = betterShapeHoles;
+			if (! ambiguous)	newShapeHoles = betterShapeHoles;
 		}
 	}
 
diff --git a/viewer/server.py b/viewer/server.py
index 418791c79..af4d56df5 100644
--- a/viewer/server.py
+++ b/viewer/server.py
@@ -3,13 +3,7 @@
 import os
 from typing import List
 
-from flask import (
-    Flask,
-    abort,
-    jsonify,
-    Response,
-    send_file,
-)
+from flask import abort, Flask, jsonify, Response, send_file
 
 
 app = Flask(__name__, static_folder="./", static_url_path="")

From d0f893b68b438996ade6d6d6f360fa1ce1447155 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Fri, 11 Apr 2025 01:35:33 -0700
Subject: [PATCH 113/235] Back out
 "fbcode/mapillary/opensfm/opensfm/src/third_party/gtest/gmock"

Summary:
Original commit changeset: 93e60daee2c6

Original Phabricator Diff: D63973589

Reviewed By: bal-a

Differential Revision: D72844839

fbshipit-source-id: 1c6906cd7ce4150f66eb909127b1d5d47f315ab6
---
 opensfm/src/third_party/gtest/gmock/gmock.h   | 14978 ++++++++++++++++
 .../src/third_party/gtest/gmock/mock-log.h    |   160 +
 2 files changed, 15138 insertions(+)
 create mode 100644 opensfm/src/third_party/gtest/gmock/gmock.h
 create mode 100644 opensfm/src/third_party/gtest/gmock/mock-log.h

diff --git a/opensfm/src/third_party/gtest/gmock/gmock.h b/opensfm/src/third_party/gtest/gmock/gmock.h
new file mode 100644
index 000000000..70e227571
--- /dev/null
+++ b/opensfm/src/third_party/gtest/gmock/gmock.h
@@ -0,0 +1,14978 @@
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+//   ON_CALL(mock_object.Method(...))
+//     .With(...) ?
+//     .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+//   EXPECT_CALL(mock_object.Method(...))
+//     .With(...) ?
+//     .Times(...) ?
+//     .InSequence(...) *
+//     .WillOnce(...) *
+//     .WillRepeatedly(...) ?
+//     .RetiresOnSaturation() ? ;
+//
+// where all clauses are optional and WillOnce() can be repeated.
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif
+
+#include <algorithm>
+#include <string>
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include <stdio.h>
+#include <ostream>  // NOLINT
+#include <string>
+
+// This file was GENERATED by command:
+//     pump.py gmock-generated-internal-utils.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file contains template meta-programming utility classes needed
+// for implementing Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: vadimb@google.com (Vadim Berman)
+//
+// Low-level types and utilities for porting Google Mock to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Mock's public API and can be used by
+// code outside Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <iostream>
+
+// Most of the utilities needed for porting Google Mock are also
+// required for Google Test and are defined in gtest-port.h.
+//
+// Note to maintainers: to reduce code duplication, prefer adding
+// portability utilities to Google Test's gtest-port.h instead of
+// here, as Google Mock depends on Google Test.  Only add a utility
+// here if it's truly specific to Google Mock.
+#include "gtest/gtest.h"
+// Copyright 2015, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Injection point for custom user configurations.
+// The following macros can be defined:
+//
+//   Flag related macros:
+//     GMOCK_DECLARE_bool_(name)
+//     GMOCK_DECLARE_int32_(name)
+//     GMOCK_DECLARE_string_(name)
+//     GMOCK_DEFINE_bool_(name, default_val, doc)
+//     GMOCK_DEFINE_int32_(name, default_val, doc)
+//     GMOCK_DEFINE_string_(name, default_val, doc)
+//
+// ** Custom implementation starts here **
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+// To avoid conditional compilation everywhere, we make it
+// gmock-port.h's responsibility to #include the header implementing
+// tr1/tuple.  gmock-port.h does this via gtest-port.h, which is
+// guaranteed to pull in the tuple header.
+
+// For MS Visual C++, check the compiler version. At least VS 2003 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1310
+# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags.  This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+#if !defined(GMOCK_DECLARE_bool_)
+
+// Macros for declaring flags.
+#define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
+#define GMOCK_DECLARE_int32_(name) \
+    extern GTEST_API_ ::testing::internal::Int32 GMOCK_FLAG(name)
+#define GMOCK_DECLARE_string_(name) \
+    extern GTEST_API_ ::std::string GMOCK_FLAG(name)
+
+// Macros for defining flags.
+#define GMOCK_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
+#define GMOCK_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ ::testing::internal::Int32 GMOCK_FLAG(name) = (default_val)
+#define GMOCK_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
+
+#endif  // !defined(GMOCK_DECLARE_bool_)
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+namespace testing {
+
+template <typename T>
+class Matcher;
+
+namespace internal {
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+// This is used in implementing the IgnoreResult(a) action.
+class IgnoredValue {
+ public:
+  // This constructor template allows any value to be implicitly
+  // converted to IgnoredValue.  The object has no data member and
+  // doesn't try to remember anything about the argument.  We
+  // deliberately omit the 'explicit' keyword in order to allow the
+  // conversion to be implicit.
+  template <typename T>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// MatcherTuple<T>::type is a tuple type where each field is a Matcher
+// for the corresponding field in tuple type T.
+template <typename Tuple>
+struct MatcherTuple;
+
+template <>
+struct MatcherTuple< ::testing::tuple<> > {
+  typedef ::testing::tuple< > type;
+};
+
+template <typename A1>
+struct MatcherTuple< ::testing::tuple<A1> > {
+  typedef ::testing::tuple<Matcher<A1> > type;
+};
+
+template <typename A1, typename A2>
+struct MatcherTuple< ::testing::tuple<A1, A2> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
+};
+
+template <typename A1, typename A2, typename A3>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
+      Matcher<A4> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8, typename A9>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8, typename A9, typename A10>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+    A10> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
+      Matcher<A10> > type;
+};
+
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   ArgumentN:            the type of the N-th argument, where N starts with 1.
+//   ArgumentTuple:        the tuple type consisting of all parameters of F.
+//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
+//                         parameters of F.
+//   MakeResultVoid:       the function type obtained by substituting void
+//                         for the return type of F.
+//   MakeResultIgnoredValue:
+//                         the function type obtained by substituting Something
+//                         for the return type of F.
+template <typename F>
+struct Function;
+
+template <typename R>
+struct Function<R()> {
+  typedef R Result;
+  typedef ::testing::tuple<> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid();
+  typedef IgnoredValue MakeResultIgnoredValue();
+};
+
+template <typename R, typename A1>
+struct Function<R(A1)>
+    : Function<R()> {
+  typedef A1 Argument1;
+  typedef ::testing::tuple<A1> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1);
+  typedef IgnoredValue MakeResultIgnoredValue(A1);
+};
+
+template <typename R, typename A1, typename A2>
+struct Function<R(A1, A2)>
+    : Function<R(A1)> {
+  typedef A2 Argument2;
+  typedef ::testing::tuple<A1, A2> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct Function<R(A1, A2, A3)>
+    : Function<R(A1, A2)> {
+  typedef A3 Argument3;
+  typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct Function<R(A1, A2, A3, A4)>
+    : Function<R(A1, A2, A3)> {
+  typedef A4 Argument4;
+  typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct Function<R(A1, A2, A3, A4, A5)>
+    : Function<R(A1, A2, A3, A4)> {
+  typedef A5 Argument5;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct Function<R(A1, A2, A3, A4, A5, A6)>
+    : Function<R(A1, A2, A3, A4, A5)> {
+  typedef A6 Argument6;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
+    : Function<R(A1, A2, A3, A4, A5, A6)> {
+  typedef A7 Argument7;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef A8 Argument8;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
+  typedef A9 Argument9;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+      A9);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+  typedef A10 Argument10;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+      A10> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+      A9, A10);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+namespace testing {
+namespace internal {
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name);
+
+// PointeeOf<Pointer>::type is the type of a value pointed to by a
+// Pointer, which can be either a smart pointer or a raw pointer.  The
+// following default implementation is for the case where Pointer is a
+// smart pointer.
+template <typename Pointer>
+struct PointeeOf {
+  // Smart pointer classes define type element_type as the type of
+  // their pointees.
+  typedef typename Pointer::element_type type;
+};
+// This specialization is for the raw pointer case.
+template <typename T>
+struct PointeeOf<T*> { typedef T type; };  // NOLINT
+
+// GetRawPointer(p) returns the raw pointer underlying p when p is a
+// smart pointer, or returns p itself when p is already a raw pointer.
+// The following default implementation is for the smart pointer case.
+template <typename Pointer>
+inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+  return p.get();
+}
+// This overloaded version is for the raw pointer case.
+template <typename Element>
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// This comparator allows linked_ptr to be stored in sets.
+template <typename T>
+struct LinkedPtrLessThan {
+  bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
+                  const ::testing::internal::linked_ptr<T>& rhs) const {
+    return lhs.get() < rhs.get();
+  }
+};
+
+// Symbian compilation can be done with wchar_t being either a native
+// type or a typedef.  Using Google Mock with OpenC without wchar_t
+// should require the definition of _STLP_NO_WCHAR_T.
+//
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// same as unsigned short when the compiler option /Zc:wchar_t- is
+// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
+// is a native type.
+#if (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
+    (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
+// Using them is a bad practice and not portable.  So DON'T use them.
+//
+// Still, Google Mock is designed to work even if the user uses signed
+// wchar_t or unsigned wchar_t (obviously, assuming the compiler
+// supports them).
+//
+// To gcc,
+//   wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
+#ifdef __GNUC__
+// signed/unsigned wchar_t are valid types.
+# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// Non-standard integer types.
+GMOCK_DECLARE_KIND_(Int64, kInteger);
+GMOCK_DECLARE_KIND_(UInt64, kInteger);
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// Evaluates to true iff integer type T is signed.
+#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true iff arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
+struct LosslessArithmeticConvertibleImpl : public false_type {};
+
+// Converting bool to bool is lossless.
+template <>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any integer type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any floating-point type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
+    : public true_type {};  // NOLINT
+
+// Converting an integer to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting an integer to another non-bool integer is lossless iff
+// the target type's range encloses the source type's range.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
+    : public bool_constant<
+      // When converting from a smaller size to a larger size, we are
+      // fine as long as we are not converting from signed to unsigned.
+      ((sizeof(From) < sizeof(To)) &&
+       (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
+      // When converting between the same size, the signedness must match.
+      ((sizeof(From) == sizeof(To)) &&
+       (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {};  // NOLINT
+
+#undef GMOCK_IS_SIGNED_
+
+// Converting an integer to a floating-point type may be lossy, since
+// the format of a floating-point number is implementation-defined.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to an integer is lossy.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to another floating-point is lossless
+// iff the target type is at least as big as the source type.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<
+  kFloatingPoint, From, kFloatingPoint, To>
+    : public bool_constant<sizeof(From) <= sizeof(To)> {};  // NOLINT
+
+// LosslessArithmeticConvertible<From, To>::value is true iff arithmetic
+// type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template <typename From, typename To>
+struct LosslessArithmeticConvertible
+    : public LosslessArithmeticConvertibleImpl<
+  GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {};  // NOLINT
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+  // The type of a failure (either non-fatal or fatal).
+  enum FailureType {
+    kNonfatal, kFatal
+  };
+
+  virtual ~FailureReporterInterface() {}
+
+  // Reports a failure that occurred at the given source file location.
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+GTEST_API_ FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself.  We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+                   const string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
+                                        file, line, msg);
+  }
+}
+inline void Assert(bool condition, const char* file, int line) {
+  Assert(condition, file, line, "Assertion failed.");
+}
+
+// Verifies that condition is true; generates a non-fatal failure if
+// condition is false.
+inline void Expect(bool condition, const char* file, int line,
+                   const string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
+                                        file, line, msg);
+  }
+}
+inline void Expect(bool condition, const char* file, int line) {
+  Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+  kInfo = 0,
+  kWarning = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true iff a log with the given severity is visible according
+// to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity);
+
+// Prints the given message to stdout iff 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity,
+                    const string& message,
+                    int stack_frames_to_skip);
+
+// TODO(wan@google.com): group all type utilities together.
+
+// Type traits.
+
+// is_reference<T>::value is non-zero iff T is a reference type.
+template <typename T> struct is_reference : public false_type {};
+template <typename T> struct is_reference<T&> : public true_type {};
+
+// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
+template <typename T1, typename T2> struct type_equals : public false_type {};
+template <typename T> struct type_equals<T, T> : public true_type {};
+
+// remove_reference<T>::type removes the reference from type T, if any.
+template <typename T> struct remove_reference { typedef T type; };  // NOLINT
+template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
+
+// DecayArray<T>::type turns an array type U[N] to const U* and preserves
+// other types.  Useful for saving a copy of a function argument.
+template <typename T> struct DecayArray { typedef T type; };  // NOLINT
+template <typename T, size_t N> struct DecayArray<T[N]> {
+  typedef const T* type;
+};
+// Sometimes people use arrays whose size is not available at the use site
+// (e.g. extern const char kNamePrefix[]).  This specialization covers that
+// case.
+template <typename T> struct DecayArray<T[]> {
+  typedef const T* type;
+};
+
+// Disable MSVC warnings for infinite recursion, since in this case the
+// the recursion is unreachable.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4717)
+#endif
+
+// Invalid<T>() is usable as an expression of type T, but will terminate
+// the program with an assertion failure if actually run.  This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template <typename T>
+inline T Invalid() {
+  Assert(false, "", -1, "Internal error: attempt to return invalid value");
+  // This statement is unreachable, and would never terminate even if it
+  // could be reached. It is provided only to placate compiler warnings
+  // about missing return statements.
+  return Invalid<T>();
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView<RawContainer> has the
+// following members:
+//
+//   - type is a type that provides an STL-style container view to
+//     (i.e. implements the STL container concept for) RawContainer;
+//   - const_reference is a type that provides a reference to a const
+//     RawContainer;
+//   - ConstReference(raw_container) returns a const reference to an STL-style
+//     container view to raw_container, which is a RawContainer.
+//   - Copy(raw_container) returns an STL-style container view of a
+//     copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template <class RawContainer>
+class StlContainerView {
+ public:
+  typedef RawContainer type;
+  typedef const type& const_reference;
+
+  static const_reference ConstReference(const RawContainer& container) {
+    // Ensures that RawContainer is not a const type.
+    testing::StaticAssertTypeEq<RawContainer,
+        GTEST_REMOVE_CONST_(RawContainer)>();
+    return container;
+  }
+  static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template <typename Element, size_t N>
+class StlContainerView<Element[N]> {
+ public:
+  typedef GTEST_REMOVE_CONST_(Element) RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  // NativeArray<T> can represent a native array either by value or by
+  // reference (selected by a constructor argument), so 'const type'
+  // can be used to reference a const native array.  We cannot
+  // 'typedef const type& const_reference' here, as that would mean
+  // ConstReference() has to return a reference to a local variable.
+  typedef const type const_reference;
+
+  static const_reference ConstReference(const Element (&array)[N]) {
+    // Ensures that Element is not a const type.
+    testing::StaticAssertTypeEq<Element, RawElement>();
+#if GTEST_OS_SYMBIAN
+    // The Nokia Symbian compiler confuses itself in template instantiation
+    // for this call without the cast to Element*:
+    // function call '[testing::internal::NativeArray<char *>].NativeArray(
+    //     {lval} const char *[4], long, testing::internal::RelationToSource)'
+    //     does not match
+    // 'testing::internal::NativeArray<char *>::NativeArray(
+    //     char *const *, unsigned int, testing::internal::RelationToSource)'
+    // (instantiating: 'testing::internal::ContainsMatcherImpl
+    //     <const char * (&)[4]>::Matches(const char * (&)[4]) const')
+    // (instantiating: 'testing::internal::StlContainerView<char *[4]>::
+    //     ConstReference(const char * (&)[4])')
+    // (and though the N parameter type is mismatched in the above explicit
+    // conversion of it doesn't help - only the conversion of the array).
+    return type(const_cast<Element*>(&array[0]), N,
+                RelationToSourceReference());
+#else
+    return type(array, N, RelationToSourceReference());
+#endif  // GTEST_OS_SYMBIAN
+  }
+  static type Copy(const Element (&array)[N]) {
+#if GTEST_OS_SYMBIAN
+    return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
+#else
+    return type(array, N, RelationToSourceCopy());
+#endif  // GTEST_OS_SYMBIAN
+  }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template <typename ElementPointer, typename Size>
+class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
+ public:
+  typedef GTEST_REMOVE_CONST_(
+      typename internal::PointeeOf<ElementPointer>::type) RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  typedef const type const_reference;
+
+  static const_reference ConstReference(
+      const ::testing::tuple<ElementPointer, Size>& array) {
+    return type(get<0>(array), get<1>(array), RelationToSourceReference());
+  }
+  static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
+    return type(get<0>(array), get<1>(array), RelationToSourceCopy());
+  }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template <typename T> class StlContainerView<T&>;
+
+// A type transform to remove constness from the first part of a pair.
+// Pairs like that are used as the value_type of associative containers,
+// and this transform produces a similar but assignable pair.
+template <typename T>
+struct RemoveConstFromKey {
+  typedef T type;
+};
+
+// Partially specialized to remove constness from std::pair<const K, V>.
+template <typename K, typename V>
+struct RemoveConstFromKey<std::pair<const K, V> > {
+  typedef std::pair<K, V> type;
+};
+
+// Mapping from booleans to types. Similar to boost::bool_<kValue> and
+// std::integral_constant<bool, kValue>.
+template <bool kValue>
+struct BooleanConstant {};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+
+#if GTEST_LANG_CXX11  // Defined by gtest-port.h via gmock-port.h.
+#include <type_traits>
+#endif
+
+namespace testing {
+
+// To implement an action Foo, define:
+//   1. a class FooAction that implements the ActionInterface interface, and
+//   2. a factory function that creates an Action object from a
+//      const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+template <typename F1, typename F2>
+class ActionAdaptor;
+
+// BuiltInDefaultValueGetter<T, true>::Get() returns a
+// default-constructed T value.  BuiltInDefaultValueGetter<T,
+// false>::Get() crashes with an error.
+//
+// This primary template is used when kDefaultConstructible is true.
+template <typename T, bool kDefaultConstructible>
+struct BuiltInDefaultValueGetter {
+  static T Get() { return T(); }
+};
+template <typename T>
+struct BuiltInDefaultValueGetter<T, false> {
+  static T Get() {
+    Assert(false, __FILE__, __LINE__,
+           "Default action undefined for the function return type.");
+    return internal::Invalid<T>();
+    // The above statement will never be reached, but is required in
+    // order for this function to compile.
+  }
+};
+
+// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
+// for type T, which is NULL when T is a raw pointer type, 0 when T is
+// a numeric type, false when T is bool, or "" when T is string or
+// std::string.  In addition, in C++11 and above, it turns a
+// default-constructed T value if T is default constructible.  For any
+// other type T, the built-in default T value is undefined, and the
+// function will abort the process.
+template <typename T>
+class BuiltInDefaultValue {
+ public:
+#if GTEST_LANG_CXX11
+  // This function returns true iff type T has a built-in default value.
+  static bool Exists() {
+    return ::std::is_default_constructible<T>::value;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<
+        T, ::std::is_default_constructible<T>::value>::Get();
+  }
+
+#else  // GTEST_LANG_CXX11
+  // This function returns true iff type T has a built-in default value.
+  static bool Exists() {
+    return false;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<T, false>::Get();
+  }
+
+#endif  // GTEST_LANG_CXX11
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template <typename T>
+class BuiltInDefaultValue<const T> {
+ public:
+  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
+  static T Get() { return BuiltInDefaultValue<T>::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template <typename T>
+class BuiltInDefaultValue<T*> {
+ public:
+  static bool Exists() { return true; }
+  static T* Get() { return NULL; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+  template <> \
+  class BuiltInDefaultValue<type> { \
+   public: \
+    static bool Exists() { return true; } \
+    static type Get() { return value; } \
+  }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
+#if GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
+#endif  // GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
+
+#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
+
+}  // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue<T> class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type).  The usage is:
+//
+//   // Sets the default value for type T to be foo.
+//   DefaultValue<T>::Set(foo);
+template <typename T>
+class DefaultValue {
+ public:
+  // Sets the default value for type T; requires T to be
+  // copy-constructable and have a public destructor.
+  static void Set(T x) {
+    delete producer_;
+    producer_ = new FixedValueProducer(x);
+  }
+
+  // Provides a factory function to be called to generate the default value.
+  // This method can be used even if T is only move-constructible, but it is not
+  // limited to that case.
+  typedef T (*FactoryFunction)();
+  static void SetFactory(FactoryFunction factory) {
+    delete producer_;
+    producer_ = new FactoryValueProducer(factory);
+  }
+
+  // Unsets the default value for type T.
+  static void Clear() {
+    delete producer_;
+    producer_ = NULL;
+  }
+
+  // Returns true iff the user has set the default value for type T.
+  static bool IsSet() { return producer_ != NULL; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value. Requires that Exists()
+  // is true, which ensures that the return value is well-defined.
+  static T Get() {
+    return producer_ == NULL ?
+        internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();
+  }
+
+ private:
+  class ValueProducer {
+   public:
+    virtual ~ValueProducer() {}
+    virtual T Produce() = 0;
+  };
+
+  class FixedValueProducer : public ValueProducer {
+   public:
+    explicit FixedValueProducer(T value) : value_(value) {}
+    virtual T Produce() { return value_; }
+
+   private:
+    const T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+  };
+
+  class FactoryValueProducer : public ValueProducer {
+   public:
+    explicit FactoryValueProducer(FactoryFunction factory)
+        : factory_(factory) {}
+    virtual T Produce() { return factory_(); }
+
+   private:
+    const FactoryFunction factory_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+  };
+
+  static ValueProducer* producer_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template <typename T>
+class DefaultValue<T&> {
+ public:
+  // Sets the default value for type T&.
+  static void Set(T& x) {  // NOLINT
+    address_ = &x;
+  }
+
+  // Unsets the default value for type T&.
+  static void Clear() {
+    address_ = NULL;
+  }
+
+  // Returns true iff the user has set the default value for type T&.
+  static bool IsSet() { return address_ != NULL; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
+  }
+
+  // Returns the default value for type T& if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static T& Get() {
+    return address_ == NULL ?
+        internal::BuiltInDefaultValue<T&>::Get() : *address_;
+  }
+
+ private:
+  static T* address_;
+};
+
+// This specialization allows DefaultValue<void>::Get() to
+// compile.
+template <>
+class DefaultValue<void> {
+ public:
+  static bool Exists() { return true; }
+  static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template <typename T>
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = NULL;
+
+// Points to the user-set default value for type T&.
+template <typename T>
+T* DefaultValue<T&>::address_ = NULL;
+
+// Implement this interface to define an action for function type F.
+template <typename F>
+class ActionInterface {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  ActionInterface() {}
+  virtual ~ActionInterface() {}
+
+  // Performs the action.  This method is not const, as in general an
+  // action can have side effects and be stateful.  For example, a
+  // get-the-next-element-from-the-collection action will need to
+  // remember the current element.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+};
+
+// An Action<F> is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function
+// of type F is called.  The implementation of Action<T> is just a
+// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
+// Don't inherit from Action!
+//
+// You can view an object implementing ActionInterface<F> as a
+// concrete action (including its current state), and an Action<F>
+// object as a handle to it.
+template <typename F>
+class Action {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  // Constructs a null Action.  Needed for storing Action objects in
+  // STL containers.
+  Action() : impl_(NULL) {}
+
+  // Constructs an Action from its implementation.  A NULL impl is
+  // used to represent the "do-default" action.
+  explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
+
+  // Copy constructor.
+  Action(const Action& action) : impl_(action.impl_) {}
+
+  // This constructor allows us to turn an Action<Func> object into an
+  // Action<F>, as long as F's arguments can be implicitly converted
+  // to Func's and Func's return type can be implicitly converted to
+  // F's.
+  template <typename Func>
+  explicit Action(const Action<Func>& action);
+
+  // Returns true iff this is the DoDefault() action.
+  bool IsDoDefault() const { return impl_.get() == NULL; }
+
+  // Performs the action.  Note that this method is const even though
+  // the corresponding method in ActionInterface is not.  The reason
+  // is that a const Action<F> means that it cannot be re-bound to
+  // another concrete action, not that the concrete action it binds to
+  // cannot change state.  (Think of the difference between a const
+  // pointer and a pointer to const.)
+  Result Perform(const ArgumentTuple& args) const {
+    internal::Assert(
+        !IsDoDefault(), __FILE__, __LINE__,
+        "You are using DoDefault() inside a composite action like "
+        "DoAll() or WithArgs().  This is not supported for technical "
+        "reasons.  Please instead spell out the default action, or "
+        "assign the default action to an Action variable and use "
+        "the variable in various places.");
+    return impl_->Perform(args);
+  }
+
+ private:
+  template <typename F1, typename F2>
+  friend class internal::ActionAdaptor;
+
+  internal::linked_ptr<ActionInterface<F> > impl_;
+};
+
+// The PolymorphicAction class template makes it easy to implement a
+// polymorphic action (i.e. an action that can be used in mock
+// functions of than one type, e.g. Return()).
+//
+// To define a polymorphic action, a user first provides a COPYABLE
+// implementation class that has a Perform() method template:
+//
+//   class FooAction {
+//    public:
+//     template <typename Result, typename ArgumentTuple>
+//     Result Perform(const ArgumentTuple& args) const {
+//       // Processes the arguments and returns a result, using
+//       // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//     }
+//     ...
+//   };
+//
+// Then the user creates the polymorphic action using
+// MakePolymorphicAction(object) where object has type FooAction.  See
+// the definition of Return(void) and SetArgumentPointee<N>(value) for
+// complete examples.
+template <typename Impl>
+class PolymorphicAction {
+ public:
+  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new MonomorphicImpl<F>(impl_));
+  }
+
+ private:
+  template <typename F>
+  class MonomorphicImpl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      return impl_.template Perform<Result>(args);
+    }
+
+   private:
+    Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
+  };
+
+  Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
+};
+
+// Creates an Action from its implementation and returns it.  The
+// created Action object owns the implementation.
+template <typename F>
+Action<F> MakeAction(ActionInterface<F>* impl) {
+  return Action<F>(impl);
+}
+
+// Creates a polymorphic action from its implementation.  This is
+// easier to use than the PolymorphicAction<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicAction(foo);
+// vs
+//   PolymorphicAction<TypeOfFoo>(foo);
+template <typename Impl>
+inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
+  return PolymorphicAction<Impl>(impl);
+}
+
+namespace internal {
+
+// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
+// and F1 are compatible.
+template <typename F1, typename F2>
+class ActionAdaptor : public ActionInterface<F1> {
+ public:
+  typedef typename internal::Function<F1>::Result Result;
+  typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
+
+  explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
+
+  virtual Result Perform(const ArgumentTuple& args) {
+    return impl_->Perform(args);
+  }
+
+ private:
+  const internal::linked_ptr<ActionInterface<F2> > impl_;
+
+  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
+};
+
+// Helper struct to specialize ReturnAction to execute a move instead of a copy
+// on return. Useful for move-only types, but could be used on any type.
+template <typename T>
+struct ByMoveWrapper {
+  explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
+  T payload;
+};
+
+// Implements the polymorphic Return(x) action, which can be used in
+// any function that returns the type of x, regardless of the argument
+// types.
+//
+// Note: The value passed into Return must be converted into
+// Function<F>::Result when this action is cast to Action<F> rather than
+// when that action is performed. This is important in scenarios like
+//
+// MOCK_METHOD1(Method, T(U));
+// ...
+// {
+//   Foo foo;
+//   X x(&foo);
+//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
+// }
+//
+// In the example above the variable x holds reference to foo which leaves
+// scope and gets destroyed.  If copying X just copies a reference to foo,
+// that copy will be left with a hanging reference.  If conversion to T
+// makes a copy of foo, the above code is safe. To support that scenario, we
+// need to make sure that the type conversion happens inside the EXPECT_CALL
+// statement, and conversion of the result of Return to Action<T(U)> is a
+// good place for that.
+//
+template <typename R>
+class ReturnAction {
+ public:
+  // Constructs a ReturnAction object from the value to be returned.
+  // 'value' is passed by value instead of by const reference in order
+  // to allow Return("string literal") to compile.
+  explicit ReturnAction(R value) : value_(new R(internal::move(value))) {}
+
+  // This template type conversion operator allows Return(x) to be
+  // used in ANY function that returns x's type.
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename Function<F>::Result Result;
+    GTEST_COMPILE_ASSERT_(
+        !is_reference<Result>::value,
+        use_ReturnRef_instead_of_Return_to_return_a_reference);
+    return Action<F>(new Impl<R, F>(value_));
+  }
+
+ private:
+  // Implements the Return(x) action for a particular function type F.
+  template <typename R_, typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    // The implicit cast is necessary when Result has more than one
+    // single-argument constructor (e.g. Result is std::vector<int>) and R
+    // has a type conversion operator template.  In that case, value_(value)
+    // won't compile as the compiler doesn't known which constructor of
+    // Result to call.  ImplicitCast_ forces the compiler to convert R to
+    // Result without considering explicit constructors, thus resolving the
+    // ambiguity. value_ is then initialized using its copy constructor.
+    explicit Impl(const linked_ptr<R>& value)
+        : value_before_cast_(*value),
+          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+
+    virtual Result Perform(const ArgumentTuple&) { return value_; }
+
+   private:
+    GTEST_COMPILE_ASSERT_(!is_reference<Result>::value,
+                          Result_cannot_be_a_reference_type);
+    // We save the value before casting just in case it is being cast to a
+    // wrapper type.
+    R value_before_cast_;
+    Result value_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
+  // move its contents instead.
+  template <typename R_, typename F>
+  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const linked_ptr<R>& wrapper)
+        : performed_(false), wrapper_(wrapper) {}
+
+    virtual Result Perform(const ArgumentTuple&) {
+      GTEST_CHECK_(!performed_)
+          << "A ByMove() action should only be performed once.";
+      performed_ = true;
+      return internal::move(wrapper_->payload);
+    }
+
+   private:
+    bool performed_;
+    const linked_ptr<R> wrapper_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const linked_ptr<R> value_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnAction);
+};
+
+// Implements the ReturnNull() action.
+class ReturnNullAction {
+ public:
+  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
+  // this is enforced by returning nullptr, and in non-C++11 by asserting a
+  // pointer type on compile time.
+  template <typename Result, typename ArgumentTuple>
+  static Result Perform(const ArgumentTuple&) {
+#if GTEST_LANG_CXX11
+    return nullptr;
+#else
+    GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
+                          ReturnNull_can_be_used_to_return_a_pointer_only);
+    return NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+};
+
+// Implements the Return() action.
+class ReturnVoidAction {
+ public:
+  // Allows Return() to be used in any void-returning function.
+  template <typename Result, typename ArgumentTuple>
+  static void Perform(const ArgumentTuple&) {
+    CompileAssertTypesEqual<void, Result>();
+  }
+};
+
+// Implements the polymorphic ReturnRef(x) action, which can be used
+// in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefAction {
+ public:
+  // Constructs a ReturnRefAction object from the reference to be returned.
+  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRef(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRef(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(internal::is_reference<Result>::value,
+                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    return Action<F>(new Impl<F>(ref_));
+  }
+
+ private:
+  // Implements the ReturnRef(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
+
+    virtual Result Perform(const ArgumentTuple&) {
+      return ref_;
+    }
+
+   private:
+    T& ref_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  T& ref_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
+};
+
+// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
+// used in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefOfCopyAction {
+ public:
+  // Constructs a ReturnRefOfCopyAction object from the reference to
+  // be returned.
+  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRefOfCopy(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(
+        internal::is_reference<Result>::value,
+        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    return Action<F>(new Impl<F>(value_));
+  }
+
+ private:
+  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const T& value) : value_(value) {}  // NOLINT
+
+    virtual Result Perform(const ArgumentTuple&) {
+      return value_;
+    }
+
+   private:
+    T value_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const T value_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
+};
+
+// Implements the polymorphic DoDefault() action.
+class DoDefaultAction {
+ public:
+  // This template type conversion operator allows DoDefault() to be
+  // used in any function.
+  template <typename F>
+  operator Action<F>() const { return Action<F>(NULL); }
+};
+
+// Implements the Assign action to set a given pointer referent to a
+// particular value.
+template <typename T1, typename T2>
+class AssignAction {
+ public:
+  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& /* args */) const {
+    *ptr_ = value_;
+  }
+
+ private:
+  T1* const ptr_;
+  const T2 value_;
+
+  GTEST_DISALLOW_ASSIGN_(AssignAction);
+};
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetErrnoAndReturn action to simulate return from
+// various system calls and libc functions.
+template <typename T>
+class SetErrnoAndReturnAction {
+ public:
+  SetErrnoAndReturnAction(int errno_value, T result)
+      : errno_(errno_value),
+        result_(result) {}
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& /* args */) const {
+    errno = errno_;
+    return result_;
+  }
+
+ private:
+  const int errno_;
+  const T result_;
+
+  GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
+};
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetArgumentPointee<N>(x) action for any function
+// whose N-th argument (0-based) is a pointer to x's type.  The
+// template parameter kIsProto is true iff type A is ProtocolMessage,
+// proto2::Message, or a sub-class of those.
+template <size_t N, typename A, bool kIsProto>
+class SetArgumentPointeeAction {
+ public:
+  // Constructs an action that sets the variable pointed to by the
+  // N-th function argument to 'value'.
+  explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& args) const {
+    CompileAssertTypesEqual<void, Result>();
+    *::testing::get<N>(args) = value_;
+  }
+
+ private:
+  const A value_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
+};
+
+template <size_t N, typename Proto>
+class SetArgumentPointeeAction<N, Proto, true> {
+ public:
+  // Constructs an action that sets the variable pointed to by the
+  // N-th function argument to 'proto'.  Both ProtocolMessage and
+  // proto2::Message have the CopyFrom() method, so the same
+  // implementation works for both.
+  explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) {
+    proto_->CopyFrom(proto);
+  }
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& args) const {
+    CompileAssertTypesEqual<void, Result>();
+    ::testing::get<N>(args)->CopyFrom(*proto_);
+  }
+
+ private:
+  const internal::linked_ptr<Proto> proto_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
+};
+
+// Implements the InvokeWithoutArgs(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
+// Action<F> as long as f's type is compatible with F (i.e. f can be
+// assigned to a tr1::function<F>).
+template <typename FunctionImpl>
+class InvokeWithoutArgsAction {
+ public:
+  // The c'tor makes a copy of function_impl (either a function
+  // pointer or a functor).
+  explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
+      : function_impl_(function_impl) {}
+
+  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
+  // compatible with f.
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple&) { return function_impl_(); }
+
+ private:
+  FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
+};
+
+// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+class InvokeMethodWithoutArgsAction {
+ public:
+  InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
+      : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple&) const {
+    return (obj_ptr_->*method_ptr_)();
+  }
+
+ private:
+  Class* const obj_ptr_;
+  const MethodPtr method_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
+};
+
+// Implements the IgnoreResult(action) action.
+template <typename A>
+class IgnoreResultAction {
+ public:
+  explicit IgnoreResultAction(const A& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename internal::Function<F>::Result Result;
+
+    // Asserts at compile time that F returns void.
+    CompileAssertTypesEqual<void, Result>();
+
+    return Action<F>(new Impl<F>(action_));
+  }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const A& action) : action_(action) {}
+
+    virtual void Perform(const ArgumentTuple& args) {
+      // Performs the action and ignores its result.
+      action_.Perform(args);
+    }
+
+   private:
+    // Type OriginalFunction is the same as F except that its return
+    // type is IgnoredValue.
+    typedef typename internal::Function<F>::MakeResultIgnoredValue
+        OriginalFunction;
+
+    const Action<OriginalFunction> action_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const A action_;
+
+  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
+};
+
+// A ReferenceWrapper<T> object represents a reference to type T,
+// which can be either const or not.  It can be explicitly converted
+// from, and implicitly converted to, a T&.  Unlike a reference,
+// ReferenceWrapper<T> can be copied and can survive template type
+// inference.  This is used to support by-reference arguments in the
+// InvokeArgument<N>(...) action.  The idea was from "reference
+// wrappers" in tr1, which we don't have in our source tree yet.
+template <typename T>
+class ReferenceWrapper {
+ public:
+  // Constructs a ReferenceWrapper<T> object from a T&.
+  explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {}  // NOLINT
+
+  // Allows a ReferenceWrapper<T> object to be implicitly converted to
+  // a T&.
+  operator T&() const { return *pointer_; }
+ private:
+  T* pointer_;
+};
+
+// Allows the expression ByRef(x) to be printed as a reference to x.
+template <typename T>
+void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) {
+  T& value = ref;
+  UniversalPrinter<T&>::Print(value, os);
+}
+
+// Does two actions sequentially.  Used for implementing the DoAll(a1,
+// a2, ...) action.
+template <typename Action1, typename Action2>
+class DoBothAction {
+ public:
+  DoBothAction(Action1 action1, Action2 action2)
+      : action1_(action1), action2_(action2) {}
+
+  // This template type conversion operator allows DoAll(a1, ..., a_n)
+  // to be used in ANY function of compatible type.
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new Impl<F>(action1_, action2_));
+  }
+
+ private:
+  // Implements the DoAll(...) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+    typedef typename Function<F>::MakeResultVoid VoidResult;
+
+    Impl(const Action<VoidResult>& action1, const Action<F>& action2)
+        : action1_(action1), action2_(action2) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      action1_.Perform(args);
+      return action2_.Perform(args);
+    }
+
+   private:
+    const Action<VoidResult> action1_;
+    const Action<F> action2_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  Action1 action1_;
+  Action2 action2_;
+
+  GTEST_DISALLOW_ASSIGN_(DoBothAction);
+};
+
+}  // namespace internal
+
+// An Unused object can be implicitly constructed from ANY value.
+// This is handy when defining actions that ignore some or all of the
+// mock function arguments.  For example, given
+//
+//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+//   MOCK_METHOD3(Bar, double(int index, double x, double y));
+//
+// instead of
+//
+//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   double DistanceToOriginWithIndex(int index, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXEPCT_CALL(mock, Foo("abc", _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithLabel));
+//   EXEPCT_CALL(mock, Bar(5, _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithIndex));
+//
+// you could write
+//
+//   // We can declare any uninteresting argument as Unused.
+//   double DistanceToOrigin(Unused, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+typedef internal::IgnoredValue Unused;
+
+// This constructor allows us to turn an Action<From> object into an
+// Action<To>, as long as To's arguments can be implicitly converted
+// to From's and From's return type cann be implicitly converted to
+// To's.
+template <typename To>
+template <typename From>
+Action<To>::Action(const Action<From>& from)
+    : impl_(new internal::ActionAdaptor<To, From>(from)) {}
+
+// Creates an action that returns 'value'.  'value' is passed by value
+// instead of const reference - otherwise Return("string literal")
+// will trigger a compiler error about using array as initializer.
+template <typename R>
+internal::ReturnAction<R> Return(R value) {
+  return internal::ReturnAction<R>(internal::move(value));
+}
+
+// Creates an action that returns NULL.
+inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
+  return MakePolymorphicAction(internal::ReturnNullAction());
+}
+
+// Creates an action that returns from a void function.
+inline PolymorphicAction<internal::ReturnVoidAction> Return() {
+  return MakePolymorphicAction(internal::ReturnVoidAction());
+}
+
+// Creates an action that returns the reference to a variable.
+template <typename R>
+inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
+  return internal::ReturnRefAction<R>(x);
+}
+
+// Creates an action that returns the reference to a copy of the
+// argument.  The copy is created when the action is constructed and
+// lives as long as the action.
+template <typename R>
+inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
+  return internal::ReturnRefOfCopyAction<R>(x);
+}
+
+// Modifies the parent action (a Return() action) to perform a move of the
+// argument instead of a copy.
+// Return(ByMove()) actions can only be executed once and will assert this
+// invariant.
+template <typename R>
+internal::ByMoveWrapper<R> ByMove(R x) {
+  return internal::ByMoveWrapper<R>(internal::move(x));
+}
+
+// Creates an action that does the default action for the give mock function.
+inline internal::DoDefaultAction DoDefault() {
+  return internal::DoDefaultAction();
+}
+
+// Creates an action that sets the variable pointed by the N-th
+// (0-based) function argument to 'value'.
+template <size_t N, typename T>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<
+    N, T, internal::IsAProtocolMessage<T>::value> >
+SetArgPointee(const T& x) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, T, internal::IsAProtocolMessage<T>::value>(x));
+}
+
+#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
+// This overload allows SetArgPointee() to accept a string literal.
+// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish
+// this overload from the templated version and emit a compile error.
+template <size_t N>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<N, const char*, false> >
+SetArgPointee(const char* p) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, const char*, false>(p));
+}
+
+template <size_t N>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<N, const wchar_t*, false> >
+SetArgPointee(const wchar_t* p) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, const wchar_t*, false>(p));
+}
+#endif
+
+// The following version is DEPRECATED.
+template <size_t N, typename T>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<
+    N, T, internal::IsAProtocolMessage<T>::value> >
+SetArgumentPointee(const T& x) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, T, internal::IsAProtocolMessage<T>::value>(x));
+}
+
+// Creates an action that sets a pointer referent to a given value.
+template <typename T1, typename T2>
+PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Creates an action that sets errno and returns the appropriate error.
+template <typename T>
+PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
+SetErrnoAndReturn(int errval, T result) {
+  return MakePolymorphicAction(
+      internal::SetErrnoAndReturnAction<T>(errval, result));
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Various overloads for InvokeWithoutArgs().
+
+// Creates an action that invokes 'function_impl' with no argument.
+template <typename FunctionImpl>
+PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
+InvokeWithoutArgs(FunctionImpl function_impl) {
+  return MakePolymorphicAction(
+      internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
+}
+
+// Creates an action that invokes the given method on the given object
+// with no argument.
+template <class Class, typename MethodPtr>
+PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> >
+InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
+  return MakePolymorphicAction(
+      internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
+          obj_ptr, method_ptr));
+}
+
+// Creates an action that performs an_action and throws away its
+// result.  In other words, it changes the return type of an_action to
+// void.  an_action MUST NOT return void, or the code won't compile.
+template <typename A>
+inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
+  return internal::IgnoreResultAction<A>(an_action);
+}
+
+// Creates a reference wrapper for the given L-value.  If necessary,
+// you can explicitly specify the type of the reference.  For example,
+// suppose 'derived' is an object of type Derived, ByRef(derived)
+// would wrap a Derived&.  If you want to wrap a const Base& instead,
+// where Base is a base class of Derived, just write:
+//
+//   ByRef<const Base>(derived)
+template <typename T>
+inline internal::ReferenceWrapper<T> ByRef(T& l_value) {  // NOLINT
+  return internal::ReferenceWrapper<T>(l_value);
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used cardinalities.  More
+// cardinalities can be defined by the user implementing the
+// CardinalityInterface interface if necessary.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+
+namespace testing {
+
+// To implement a cardinality Foo, define:
+//   1. a class FooCardinality that implements the
+//      CardinalityInterface interface, and
+//   2. a factory function that creates a Cardinality object from a
+//      const FooCardinality*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Cardinality objects can now be copied like plain values.
+
+// The implementation of a cardinality.
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface() {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return 0; }
+  virtual int ConservativeUpperBound() const { return INT_MAX; }
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+
+// A Cardinality is a copyable and IMMUTABLE (except by assignment)
+// object that specifies how many times a mock function is expected to
+// be called.  The implementation of Cardinality is just a linked_ptr
+// to const CardinalityInterface, so copying is fairly cheap.
+// Don't inherit from Cardinality!
+class GTEST_API_ Cardinality {
+ public:
+  // Constructs a null cardinality.  Needed for storing Cardinality
+  // objects in STL containers.
+  Cardinality() {}
+
+  // Constructs a Cardinality from its implementation.
+  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
+  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  bool IsSatisfiedByCallCount(int call_count) const {
+    return impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  bool IsSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count);
+  }
+
+  // Returns true iff call_count calls will over-saturate this
+  // cardinality, i.e. exceed the maximum number of allowed calls.
+  bool IsOverSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count) &&
+        !impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Describes self to an ostream
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the given actual call count to an ostream.
+  static void DescribeActualCallCountTo(int actual_call_count,
+                                        ::std::ostream* os);
+
+ private:
+  internal::linked_ptr<const CardinalityInterface> impl_;
+};
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n);
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n);
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber();
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max);
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n);
+
+// Creates a cardinality from its implementation.
+inline Cardinality MakeCardinality(const CardinalityInterface* c) {
+  return Cardinality(c);
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+
+
+namespace testing {
+namespace internal {
+
+// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
+// function or method with the unpacked values, where F is a function
+// type that takes N arguments.
+template <typename Result, typename ArgumentTuple>
+class InvokeHelper;
+
+template <typename R>
+class InvokeHelper<R, ::testing::tuple<> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<>&) {
+           return function();
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<>&) {
+           return (obj_ptr->*method_ptr)();
+  }
+};
+
+template <typename R, typename A1>
+class InvokeHelper<R, ::testing::tuple<A1> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
+           return function(get<0>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2>
+class InvokeHelper<R, ::testing::tuple<A1, A2> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
+           return function(get<0>(args), get<1>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
+      A4>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
+      A5>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
+                            A7>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
+                            A8>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8, A9>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args), get<8>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
+                            A9>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args), get<8>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+    A10> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8, A9, A10>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args), get<8>(args), get<9>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
+                            A9, A10>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
+  }
+};
+
+// An INTERNAL macro for extracting the type of a tuple field.  It's
+// subject to change without notice - DO NOT USE IN USER CODE!
+#define GMOCK_FIELD_(Tuple, N) \
+    typename ::testing::tuple_element<N, Tuple>::type
+
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
+// type of an n-ary function whose i-th (1-based) argument type is the
+// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
+// type, and whose return type is Result.  For example,
+//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
+// is int(bool, long).
+//
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
+// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
+// For example,
+//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
+//       ::testing::make_tuple(true, 'a', 2.5))
+// returns tuple (2.5, true).
+//
+// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
+// in the range [0, 10].  Duplicates are allowed and they don't have
+// to be in an ascending or descending order.
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
+class SelectArgs {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
+      GMOCK_FIELD_(ArgumentTuple, k10));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args), get<k9>(args), get<k10>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple>
+class SelectArgs<Result, ArgumentTuple,
+                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type();
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& /* args */) {
+    return SelectedArgs();
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8, int k9>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args), get<k9>(args));
+  }
+};
+
+#undef GMOCK_FIELD_
+
+// Implements the WithArgs action.
+template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1, int k10 = -1>
+class WithArgsAction {
+ public:
+  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const InnerAction& action) : action_(action) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
+          k5, k6, k7, k8, k9, k10>::Select(args));
+    }
+
+   private:
+    typedef typename SelectArgs<Result, ArgumentTuple,
+        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
+
+    Action<InnerFunctionType> action_;
+  };
+
+  const InnerAction action_;
+
+  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
+};
+
+// A macro from the ACTION* family (defined later in this file)
+// defines an action that can be used in a mock function.  Typically,
+// these actions only care about a subset of the arguments of the mock
+// function.  For example, if such an action only uses the second
+// argument, it can be used in any mock function that takes >= 2
+// arguments where the type of the second argument is compatible.
+//
+// Therefore, the action implementation must be prepared to take more
+// arguments than it needs.  The ExcessiveArg type is used to
+// represent those excessive arguments.  In order to keep the compiler
+// error messages tractable, we define it in the testing namespace
+// instead of testing::internal.  However, this is an INTERNAL TYPE
+// and subject to change without notice, so a user MUST NOT USE THIS
+// TYPE DIRECTLY.
+struct ExcessiveArg {};
+
+// A helper class needed for implementing the ACTION* macros.
+template <typename Result, class Impl>
+class ActionHelper {
+ public:
+  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
+    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
+    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
+    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
+        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
+        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
+      A3>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
+        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
+      A4>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
+        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7, typename A8>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7, A8>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
+        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7, typename A8, typename A9>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7, A8, A9>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
+        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
+        get<9>(args));
+  }
+};
+
+}  // namespace internal
+
+// Various overloads for Invoke().
+
+// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
+// the selected arguments of the mock function to an_action and
+// performs it.  It serves as an adaptor between actions with
+// different argument lists.  C++ doesn't support default arguments for
+// function templates, so we have to overload it.
+template <int k1, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1>(action);
+}
+
+template <int k1, int k2, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2>(action);
+}
+
+template <int k1, int k2, int k3, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
+}
+
+template <int k1, int k2, int k3, int k4, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
+    typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
+      k7>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
+      k8>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, int k10, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+    k9, k10>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9, k10>(action);
+}
+
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation.
+template <typename Action1, typename Action2>
+inline internal::DoBothAction<Action1, Action2>
+DoAll(Action1 a1, Action2 a2) {
+  return internal::DoBothAction<Action1, Action2>(a1, a2);
+}
+
+template <typename Action1, typename Action2, typename Action3>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    Action3> >
+DoAll(Action1 a1, Action2 a2, Action3 a3) {
+  return DoAll(a1, DoAll(a2, a3));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, Action4> > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
+  return DoAll(a1, DoAll(a2, a3, a4));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    Action5> > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, Action6> > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    Action7> > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, Action8> > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8, typename Action9>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
+    Action9> > > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8, Action9 a9) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8, typename Action9, typename Action10>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
+    internal::DoBothAction<Action9, Action10> > > > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
+}
+
+}  // namespace testing
+
+// The ACTION* family of macros can be used in a namespace scope to
+// define custom actions easily.  The syntax:
+//
+//   ACTION(name) { statements; }
+//
+// will define an action with the given name that executes the
+// statements.  The value returned by the statements will be used as
+// the return value of the action.  Inside the statements, you can
+// refer to the K-th (0-based) argument of the mock function by
+// 'argK', and refer to its type by 'argK_type'.  For example:
+//
+//   ACTION(IncrementArg1) {
+//     arg1_type temp = arg1;
+//     return ++(*temp);
+//   }
+//
+// allows you to write
+//
+//   ...WillOnce(IncrementArg1());
+//
+// You can also refer to the entire argument tuple and its type by
+// 'args' and 'args_type', and refer to the mock function type and its
+// return type by 'function_type' and 'return_type'.
+//
+// Note that you don't need to specify the types of the mock function
+// arguments.  However rest assured that your code is still type-safe:
+// you'll get a compiler error if *arg1 doesn't support the ++
+// operator, or if the type of ++(*arg1) isn't compatible with the
+// mock function's return type, for example.
+//
+// Sometimes you'll want to parameterize the action.   For that you can use
+// another macro:
+//
+//   ACTION_P(name, param_name) { statements; }
+//
+// For example:
+//
+//   ACTION_P(Add, n) { return arg0 + n; }
+//
+// will allow you to write:
+//
+//   ...WillOnce(Add(5));
+//
+// Note that you don't need to provide the type of the parameter
+// either.  If you need to reference the type of a parameter named
+// 'foo', you can write 'foo_type'.  For example, in the body of
+// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
+// of 'n'.
+//
+// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
+// multi-parameter actions.
+//
+// For the purpose of typing, you can view
+//
+//   ACTION_Pk(Foo, p1, ..., pk) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// In particular, you can provide the template type arguments
+// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
+// although usually you can rely on the compiler to infer the types
+// for you automatically.  You can assign the result of expression
+// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
+// pk_type>.  This can be useful when composing actions.
+//
+// You can also overload actions with different numbers of parameters:
+//
+//   ACTION_P(Plus, a) { ... }
+//   ACTION_P2(Plus, a, b) { ... }
+//
+// While it's tempting to always use the ACTION* macros when defining
+// a new action, you should also consider implementing ActionInterface
+// or using MakePolymorphicAction() instead, especially if you need to
+// use the action a lot.  While these approaches require more work,
+// they give you more control on the types of the mock function
+// arguments and the action parameters, which in general leads to
+// better compiler error messages that pay off in the long run.  They
+// also allow overloading actions based on parameter types (as opposed
+// to just based on the number of parameters).
+//
+// CAVEAT:
+//
+// ACTION*() can only be used in a namespace scope.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using ACTION*() inside
+// a function.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+// An internal macro needed for implementing ACTION*().
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
+    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
+    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
+    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
+    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
+    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
+    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
+    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
+    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
+    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
+    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
+    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
+
+// Sometimes you want to give an action explicit template parameters
+// that cannot be inferred from its value parameters.  ACTION() and
+// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
+// and can be viewed as an extension to ACTION() and ACTION_P*().
+//
+// The syntax:
+//
+//   ACTION_TEMPLATE(ActionName,
+//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
+//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
+//
+// defines an action template that takes m explicit template
+// parameters and n value parameters.  name_i is the name of the i-th
+// template parameter, and kind_i specifies whether it's a typename,
+// an integral constant, or a template.  p_i is the name of the i-th
+// value parameter.
+//
+// Example:
+//
+//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
+//   // function to type T and copies it to *output.
+//   ACTION_TEMPLATE(DuplicateArg,
+//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+//                   AND_1_VALUE_PARAMS(output)) {
+//     *output = T(::testing::get<k>(args));
+//   }
+//   ...
+//     int n;
+//     EXPECT_CALL(mock, Foo(_, _))
+//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
+//
+// To create an instance of an action template, write:
+//
+//   ActionName<t1, ..., t_m>(v1, ..., v_n)
+//
+// where the ts are the template arguments and the vs are the value
+// arguments.  The value argument types are inferred by the compiler.
+// If you want to explicitly specify the value argument types, you can
+// provide additional template arguments:
+//
+//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
+//
+// where u_i is the desired type of v_i.
+//
+// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
+// number of value parameters, but not on the number of template
+// parameters.  Without the restriction, the meaning of the following
+// is unclear:
+//
+//   OverloadedAction<int, bool>(x);
+//
+// Are we using a single-template-parameter action where 'bool' refers
+// to the type of x, or are we using a two-template-parameter action
+// where the compiler is asked to infer the type of x?
+//
+// Implementation notes:
+//
+// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
+// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
+// implementing ACTION_TEMPLATE.  The main trick we use is to create
+// new macro invocations when expanding a macro.  For example, we have
+//
+//   #define ACTION_TEMPLATE(name, template_params, value_params)
+//       ... GMOCK_INTERNAL_DECL_##template_params ...
+//
+// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
+// to expand to
+//
+//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
+//
+// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
+// preprocessor will continue to expand it to
+//
+//       ... typename T ...
+//
+// This technique conforms to the C++ standard and is portable.  It
+// allows us to implement action templates using O(N) code, where N is
+// the maximum number of template/value parameters supported.  Without
+// using it, we'd have to devote O(N^2) amount of code to implement all
+// combinations of m and n.
+
+// Declares the template parameters.
+#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) kind0 name0, kind1 name1
+#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) kind0 name0, kind1 name1, kind2 name2
+#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
+    kind2 name2, kind3 name3, kind4 name4
+#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
+    kind5 name5, kind6 name6
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
+    kind4 name4, kind5 name5, kind6 name6, kind7 name7
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
+    kind8 name8
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
+    kind6 name6, kind7 name7, kind8 name8, kind9 name9
+
+// Lists the template parameters.
+#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) name0, name1
+#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) name0, name1, name2
+#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) name0, name1, name2, name3
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
+    name4
+#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
+    name2, name3, name4, name5
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) name0, name1, name2, name3, name4, name5, name6
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
+    name6, name7, name8
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
+    name3, name4, name5, name6, name7, name8, name9
+
+// Declares the types of value parameters.
+#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
+    typename p0##_type, typename p1##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
+    typename p0##_type, typename p1##_type, typename p2##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type, typename p8##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
+    typename p2##_type, typename p3##_type, typename p4##_type, \
+    typename p5##_type, typename p6##_type, typename p7##_type, \
+    typename p8##_type, typename p9##_type
+
+// Initializes the value parameters.
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
+    ()
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
+    (p0##_type gmock_p0) : p0(gmock_p0)
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1)
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2)
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3)
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4)
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5)
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6)
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7)
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8)
+#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+        p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8), p9(gmock_p9)
+
+// Declares the fields for storing the value parameters.
+#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
+    p1##_type p1;
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
+    p1##_type p1; p2##_type p2;
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
+    p1##_type p1; p2##_type p2; p3##_type p3;
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5;
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6;
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6; p7##_type p7;
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
+#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
+    p9##_type p9;
+
+// Lists the value parameters.
+#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
+#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
+#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
+#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
+    p2, p3, p4
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
+    p1, p2, p3, p4, p5
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0, p1, p2, p3, p4, p5, p6
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0, p1, p2, p3, p4, p5, p6, p7
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
+#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
+
+// Lists the value parameter types.
+#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
+    p1##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
+    p1##_type, p2##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    p0##_type, p1##_type, p2##_type, p3##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
+    p6##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
+
+// Declares the value parameters.
+#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
+    p1##_type p1
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
+    p1##_type p1, p2##_type p2
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
+    p1##_type p1, p2##_type p2, p3##_type p3
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6, p7##_type p7
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
+#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+    p9##_type p9
+
+// The suffix of the class template implementing the action template.
+#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
+#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
+#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
+#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
+#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
+#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
+#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
+#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) P8
+#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) P9
+#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) P10
+
+// The name of the class template implementing the action template.
+#define GMOCK_ACTION_CLASS_(name, value_params)\
+    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
+
+#define ACTION_TEMPLATE(name, template_params, value_params)\
+  template <GMOCK_INTERNAL_DECL_##template_params\
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
+  class GMOCK_ACTION_CLASS_(name, value_params) {\
+   public:\
+    explicit GMOCK_ACTION_CLASS_(name, value_params)\
+        GMOCK_INTERNAL_INIT_##value_params {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      GMOCK_INTERNAL_DEFN_##value_params\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(\
+          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
+    }\
+    GMOCK_INTERNAL_DEFN_##value_params\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
+  };\
+  template <GMOCK_INTERNAL_DECL_##template_params\
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
+  inline GMOCK_ACTION_CLASS_(name, value_params)<\
+      GMOCK_INTERNAL_LIST_##template_params\
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
+          GMOCK_INTERNAL_DECL_##value_params) {\
+    return GMOCK_ACTION_CLASS_(name, value_params)<\
+        GMOCK_INTERNAL_LIST_##template_params\
+        GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
+            GMOCK_INTERNAL_LIST_##value_params);\
+  }\
+  template <GMOCK_INTERNAL_DECL_##template_params\
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      GMOCK_ACTION_CLASS_(name, value_params)<\
+          GMOCK_INTERNAL_LIST_##template_params\
+          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
+              gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION(name)\
+  class name##Action {\
+   public:\
+    name##Action() {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl() {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>());\
+    }\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##Action);\
+  };\
+  inline name##Action name() {\
+    return name##Action();\
+  }\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P(name, p0)\
+  template <typename p0##_type>\
+  class name##ActionP {\
+   public:\
+    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
+    }\
+    p0##_type p0;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
+  };\
+  template <typename p0##_type>\
+  inline name##ActionP<p0##_type> name(p0##_type p0) {\
+    return name##ActionP<p0##_type>(p0);\
+  }\
+  template <typename p0##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P2(name, p0, p1)\
+  template <typename p0##_type, typename p1##_type>\
+  class name##ActionP2 {\
+   public:\
+    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+        p1(gmock_p1) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+          p1(gmock_p1) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
+  };\
+  template <typename p0##_type, typename p1##_type>\
+  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
+      p1##_type p1) {\
+    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
+  }\
+  template <typename p0##_type, typename p1##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P3(name, p0, p1, p2)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  class name##ActionP3 {\
+   public:\
+    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
+          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2) {\
+    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP3<p0##_type, p1##_type, \
+          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P4(name, p0, p1, p2, p3)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  class name##ActionP4 {\
+   public:\
+    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3) {\
+    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
+        p2, p3);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP4<p0##_type, p1##_type, p2##_type, \
+          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P5(name, p0, p1, p2, p3, p4)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  class name##ActionP5 {\
+   public:\
+    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, \
+        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
+          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4) {\
+    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type>(p0, p1, p2, p3, p4);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  class name##ActionP6 {\
+   public:\
+    name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, \
+          p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3, p4##_type p4, p5##_type p5) {\
+    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  class name##ActionP7 {\
+   public:\
+    name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
+        p6(gmock_p6) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
+          p6));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
+      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6) {\
+    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  class name##ActionP8 {\
+   public:\
+    name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, \
+        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \
+          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
+          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
+          p6, p7));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6, p7##_type p7) {\
+    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
+        p6, p7);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, \
+          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  class name##ActionP9 {\
+   public:\
+    name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7, \
+          p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+          p7(gmock_p7), p8(gmock_p8) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+      p8##_type p8;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
+          p6, p7, p8));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+    p8##_type p8;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, \
+      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
+      p8##_type p8) {\
+    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
+        p3, p4, p5, p6, p7, p8);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, p7##_type, \
+          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  class name##ActionP10 {\
+   public:\
+    name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+          p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+      p8##_type p8;\
+      p9##_type p9;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
+          p6, p7, p8, p9));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+    p8##_type p8;\
+    p9##_type p9;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+      p9##_type p9) {\
+    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
+        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, p7##_type, p8##_type, \
+          p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+namespace testing {
+
+
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Various overloads for InvokeArgument<N>().
+//
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside ByRef().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but ByRef() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
+
+namespace internal {
+namespace invoke_argument {
+
+// Appears in InvokeArgumentAdl's argument list to help avoid
+// accidental calls to user functions of the same name.
+struct AdlTag {};
+
+// InvokeArgumentAdl - a helper for InvokeArgument.
+// The basic overloads are provided here for generic functors.
+// Overloads for other custom-callables are provided in the
+// internal/custom/callback-actions.h header.
+
+template <typename R, typename F>
+R InvokeArgumentAdl(AdlTag, F f) {
+  return f();
+}
+template <typename R, typename F, typename A1>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
+  return f(a1);
+}
+template <typename R, typename F, typename A1, typename A2>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
+  return f(a1, a2);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
+  return f(a1, a2, a3);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
+  return f(a1, a2, a3, a4);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+  return f(a1, a2, a3, a4, a5);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
+  return f(a1, a2, a3, a4, a5, a6);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7) {
+  return f(a1, a2, a3, a4, a5, a6, a7);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8, A9 a9) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9, typename A10>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8, A9 a9, A10 a10) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+}
+}  // namespace invoke_argument
+}  // namespace internal
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args));
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(p0)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
+
+// Various overloads for ReturnNew<T>().
+//
+// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
+// instance of type T, constructed on the heap with constructor arguments
+// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_0_VALUE_PARAMS()) {
+  return new T();
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_1_VALUE_PARAMS(p0)) {
+  return new T(p0);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  return new T(p0, p1);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  return new T(p0, p1, p2);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  return new T(p0, p1, p2, p3);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  return new T(p0, p1, p2, p3, p4);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  return new T(p0, p1, p2, p3, p4, p5);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+// Include any custom actions added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+// This file was GENERATED by command:
+//     pump.py gmock-generated-actions.h.pump
+// DO NOT EDIT BY HAND!!!
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+// This file was GENERATED by command:
+//     pump.py gmock-generated-function-mockers.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements function mockers of various arities.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the ON_CALL() and EXPECT_CALL() macros.
+//
+// A user can use the ON_CALL() macro to specify the default action of
+// a mock method.  The syntax is:
+//
+//   ON_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matcher)
+//       .WillByDefault(action);
+//
+//  where the .With() clause is optional.
+//
+// A user can use the EXPECT_CALL() macro to specify an expectation on
+// a mock method.  The syntax is:
+//
+//   EXPECT_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matchers)
+//       .Times(cardinality)
+//       .InSequence(sequences)
+//       .After(expectations)
+//       .WillOnce(action)
+//       .WillRepeatedly(action)
+//       .RetiresOnSaturation();
+//
+// where all clauses are optional, and .InSequence()/.After()/
+// .WillOnce() can appear any number of times.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>  // NOLINT
+#endif
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used argument matchers.  More
+// matchers can be defined by the user implementing the
+// MatcherInterface<T> interface if necessary.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#include <math.h>
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+# include <initializer_list>  // NOLINT -- must be after gtest.h
+#endif
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherImpl that implements the
+//      MatcherInterface<T> interface, and
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherImpl*.
+//
+// The two-level delegation design makes it possible to allow a user
+// to write "v" instead of "Eq(v)" where a Matcher is expected, which
+// is impossible if we pass matchers by pointers.  It also eases
+// ownership management as Matcher objects can now be copied like
+// plain values.
+
+// MatchResultListener is an abstract class.  Its << operator can be
+// used by a matcher to explain why a value matches or doesn't match.
+//
+// TODO(wan@google.com): add method
+//   bool InterestedInWhy(bool result) const;
+// to indicate whether the listener is interested in why the match
+// result is 'result'.
+class MatchResultListener {
+ public:
+  // Creates a listener object with the given underlying ostream.  The
+  // listener does not own the ostream, and does not dereference it
+  // in the constructor or destructor.
+  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
+  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
+
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x) {
+    if (stream_ != NULL)
+      *stream_ << x;
+    return *this;
+  }
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream() { return stream_; }
+
+  // Returns true iff the listener is interested in an explanation of
+  // the match result.  A matcher's MatchAndExplain() method can use
+  // this information to avoid generating the explanation when no one
+  // intends to hear it.
+  bool IsInterested() const { return stream_ != NULL; }
+
+ private:
+  ::std::ostream* const stream_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
+};
+
+inline MatchResultListener::~MatchResultListener() {
+}
+
+// An instance of a subclass of this knows how to describe itself as a
+// matcher.
+class MatcherDescriberInterface {
+ public:
+  virtual ~MatcherDescriberInterface() {}
+
+  // Describes this matcher to an ostream.  The function should print
+  // a verb phrase that describes the property a value matching this
+  // matcher should have.  The subject of the verb phrase is the value
+  // being matched.  For example, the DescribeTo() method of the Gt(7)
+  // matcher prints "is greater than 7".
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.  For
+  // example, if the description of this matcher is "is greater than
+  // 7", the negated description could be "is not greater than 7".
+  // You are not required to override this when implementing
+  // MatcherInterface, but it is highly advised so that your matcher
+  // can produce good error messages.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "not (";
+    DescribeTo(os);
+    *os << ")";
+  }
+};
+
+// The implementation of a matcher.
+template <typename T>
+class MatcherInterface : public MatcherDescriberInterface {
+ public:
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener' if necessary (see the next paragraph), in
+  // the form of a non-restrictive relative clause ("which ...",
+  // "whose ...", etc) that describes x.  For example, the
+  // MatchAndExplain() method of the Pointee(...) matcher should
+  // generate an explanation like "which points to ...".
+  //
+  // Implementations of MatchAndExplain() should add an explanation of
+  // the match result *if and only if* they can provide additional
+  // information that's not already present (or not obvious) in the
+  // print-out of x and the matcher's description.  Whether the match
+  // succeeds is not a factor in deciding whether an explanation is
+  // needed, as sometimes the caller needs to print a failure message
+  // when the match succeeds (e.g. when the matcher is used inside
+  // Not()).
+  //
+  // For example, a "has at least 10 elements" matcher should explain
+  // what the actual element count is, regardless of the match result,
+  // as it is useful information to the reader; on the other hand, an
+  // "is empty" matcher probably only needs to explain what the actual
+  // size is when the match fails, as it's redundant to say that the
+  // size is 0 when the value is already known to be empty.
+  //
+  // You should override this method when defining a new matcher.
+  //
+  // It's the responsibility of the caller (Google Mock) to guarantee
+  // that 'listener' is not NULL.  This helps to simplify a matcher's
+  // implementation when it doesn't care about the performance, as it
+  // can talk to 'listener' without checking its validity first.
+  // However, in order to implement dummy listeners efficiently,
+  // listener->stream() may be NULL.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Inherits these methods from MatcherDescriberInterface:
+  //   virtual void DescribeTo(::std::ostream* os) const = 0;
+  //   virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+
+// A match result listener that stores the explanation in a string.
+class StringMatchResultListener : public MatchResultListener {
+ public:
+  StringMatchResultListener() : MatchResultListener(&ss_) {}
+
+  // Returns the explanation accumulated so far.
+  internal::string str() const { return ss_.str(); }
+
+  // Clears the explanation accumulated so far.
+  void Clear() { ss_.str(""); }
+
+ private:
+  ::std::stringstream ss_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+};
+
+namespace internal {
+
+struct AnyEq {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a == b; }
+};
+struct AnyNe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a != b; }
+};
+struct AnyLt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a < b; }
+};
+struct AnyGt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a > b; }
+};
+struct AnyLe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a <= b; }
+};
+struct AnyGe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a >= b; }
+};
+
+// A match result listener that ignores the explanation.
+class DummyMatchResultListener : public MatchResultListener {
+ public:
+  DummyMatchResultListener() : MatchResultListener(NULL) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
+};
+
+// A match result listener that forwards the explanation to a given
+// ostream.  The difference between this and MatchResultListener is
+// that the former is concrete.
+class StreamMatchResultListener : public MatchResultListener {
+ public:
+  explicit StreamMatchResultListener(::std::ostream* os)
+      : MatchResultListener(os) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
+};
+
+// An internal class for implementing Matcher<T>, which will derive
+// from it.  We put functionalities common to all Matcher<T>
+// specializations here to avoid code duplication.
+template <typename T>
+class MatcherBase {
+ public:
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    return impl_->MatchAndExplain(x, listener);
+  }
+
+  // Returns true iff this matcher matches x.
+  bool Matches(T x) const {
+    DummyMatchResultListener dummy;
+    return MatchAndExplain(x, &dummy);
+  }
+
+  // Describes this matcher to an ostream.
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the negation of this matcher to an ostream.
+  void DescribeNegationTo(::std::ostream* os) const {
+    impl_->DescribeNegationTo(os);
+  }
+
+  // Explains why x matches, or doesn't match, the matcher.
+  void ExplainMatchResultTo(T x, ::std::ostream* os) const {
+    StreamMatchResultListener listener(os);
+    MatchAndExplain(x, &listener);
+  }
+
+  // Returns the describer for this matcher object; retains ownership
+  // of the describer, which is only guaranteed to be alive when
+  // this matcher object is alive.
+  const MatcherDescriberInterface* GetDescriber() const {
+    return impl_.get();
+  }
+
+ protected:
+  MatcherBase() {}
+
+  // Constructs a matcher from its implementation.
+  explicit MatcherBase(const MatcherInterface<T>* impl)
+      : impl_(impl) {}
+
+  virtual ~MatcherBase() {}
+
+ private:
+  // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
+  // interfaces.  The former dynamically allocates a chunk of memory
+  // to hold the reference count, while the latter tracks all
+  // references using a circular linked list without allocating
+  // memory.  It has been observed that linked_ptr performs better in
+  // typical scenarios.  However, shared_ptr can out-perform
+  // linked_ptr when there are many more uses of the copy constructor
+  // than the default constructor.
+  //
+  // If performance becomes a problem, we should see if using
+  // shared_ptr helps.
+  ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
+};
+
+}  // namespace internal
+
+// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
+// object that can check whether a value of type T matches.  The
+// implementation of Matcher<T> is just a linked_ptr to const
+// MatcherInterface<T>, so copying is fairly cheap.  Don't inherit
+// from Matcher!
+template <typename T>
+class Matcher : public internal::MatcherBase<T> {
+ public:
+  // Constructs a null matcher.  Needed for storing Matcher objects in STL
+  // containers.  A default-constructed matcher is not yet initialized.  You
+  // cannot use it until a valid value has been assigned to it.
+  explicit Matcher() {}  // NOLINT
+
+  // Constructs a matcher from its implementation.
+  explicit Matcher(const MatcherInterface<T>* impl)
+      : internal::MatcherBase<T>(impl) {}
+
+  // Implicit constructor here allows people to write
+  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
+  Matcher(T value);  // NOLINT
+};
+
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a string
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const internal::string&>
+    : public internal::MatcherBase<const internal::string&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::string&>* impl)
+      : internal::MatcherBase<const internal::string&>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<internal::string>
+    : public internal::MatcherBase<internal::string> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<internal::string>* impl)
+      : internal::MatcherBase<internal::string>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+#if GTEST_HAS_STRING_PIECE_
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const StringPiece&>
+    : public internal::MatcherBase<const StringPiece&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
+      : internal::MatcherBase<const StringPiece&>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass StringPieces directly.
+  Matcher(StringPiece s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<StringPiece>
+    : public internal::MatcherBase<StringPiece> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<StringPiece>* impl)
+      : internal::MatcherBase<StringPiece>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass StringPieces directly.
+  Matcher(StringPiece s);  // NOLINT
+};
+#endif  // GTEST_HAS_STRING_PIECE_
+
+// The PolymorphicMatcher class template makes it easy to implement a
+// polymorphic matcher (i.e. a matcher that can match values of more
+// than one type, e.g. Eq(n) and NotNull()).
+//
+// To define a polymorphic matcher, a user should provide an Impl
+// class that has a DescribeTo() method and a DescribeNegationTo()
+// method, and define a member function (or member function template)
+//
+//   bool MatchAndExplain(const Value& value,
+//                        MatchResultListener* listener) const;
+//
+// See the definition of NotNull() for a complete example.
+template <class Impl>
+class PolymorphicMatcher {
+ public:
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
+
+  // Returns a mutable reference to the underlying matcher
+  // implementation object.
+  Impl& mutable_impl() { return impl_; }
+
+  // Returns an immutable reference to the underlying matcher
+  // implementation object.
+  const Impl& impl() const { return impl_; }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new MonomorphicImpl<T>(impl_));
+  }
+
+ private:
+  template <typename T>
+  class MonomorphicImpl : public MatcherInterface<T> {
+   public:
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      impl_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      impl_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return impl_.MatchAndExplain(x, listener);
+    }
+
+   private:
+    const Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
+  };
+
+  Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
+};
+
+// Creates a matcher from its implementation.  This is easier to use
+// than the Matcher<T> constructor as it doesn't require you to
+// explicitly write the template argument, e.g.
+//
+//   MakeMatcher(foo);
+// vs
+//   Matcher<const string&>(foo);
+template <typename T>
+inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
+  return Matcher<T>(impl);
+}
+
+// Creates a polymorphic matcher from its implementation.  This is
+// easier to use than the PolymorphicMatcher<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicMatcher(foo);
+// vs
+//   PolymorphicMatcher<TypeOfFoo>(foo);
+template <class Impl>
+inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
+  return PolymorphicMatcher<Impl>(impl);
+}
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// The MatcherCastImpl class template is a helper for implementing
+// MatcherCast().  We need this helper in order to partially
+// specialize the implementation of MatcherCast() (C++ allows
+// class/struct templates to be partially specialized, but not
+// function templates.).
+
+// This general version is used when MatcherCast()'s argument is a
+// polymorphic matcher (i.e. something that can be converted to a
+// Matcher but is not one yet; for example, Eq(value)) or a value (for
+// example, "hello").
+template <typename T, typename M>
+class MatcherCastImpl {
+ public:
+  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    // M can be a polymorhic matcher, in which case we want to use
+    // its conversion operator to create Matcher<T>.  Or it can be a value
+    // that should be passed to the Matcher<T>'s constructor.
+    //
+    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
+    // polymorphic matcher because it'll be ambiguous if T has an implicit
+    // constructor from M (this usually happens when T has an implicit
+    // constructor from any type).
+    //
+    // It won't work to unconditionally implict_cast
+    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
+    // a user-defined conversion from M to T if one exists (assuming M is
+    // a value).
+    return CastImpl(
+        polymorphic_matcher_or_value,
+        BooleanConstant<
+            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
+  }
+
+ private:
+  static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
+    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
+    // matcher.  It must be a value then.  Use direct initialization to create
+    // a matcher.
+    return Matcher<T>(ImplicitCast_<T>(value));
+  }
+
+  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
+                             BooleanConstant<true>) {
+    // M is implicitly convertible to Matcher<T>, which means that either
+    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
+    // from M.  In both cases using the implicit conversion will produce a
+    // matcher.
+    //
+    // Even if T has an implicit constructor from M, it won't be called because
+    // creating Matcher<T> would require a chain of two user-defined conversions
+    // (first to create T from M and then to create Matcher<T> from T).
+    return polymorphic_matcher_or_value;
+  }
+};
+
+// This more specialized version is used when MatcherCast()'s argument
+// is already a Matcher.  This only compiles when type T can be
+// statically converted to type U.
+template <typename T, typename U>
+class MatcherCastImpl<T, Matcher<U> > {
+ public:
+  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
+    return Matcher<T>(new Impl(source_matcher));
+  }
+
+ private:
+  class Impl : public MatcherInterface<T> {
+   public:
+    explicit Impl(const Matcher<U>& source_matcher)
+        : source_matcher_(source_matcher) {}
+
+    // We delegate the matching logic to the source matcher.
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      source_matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      source_matcher_.DescribeNegationTo(os);
+    }
+
+   private:
+    const Matcher<U> source_matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+};
+
+// This even more specialized version is used for efficiently casting
+// a matcher to its own type.
+template <typename T>
+class MatcherCastImpl<T, Matcher<T> > {
+ public:
+  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
+};
+
+}  // namespace internal
+
+// In order to be safe and clear, casting between different matcher
+// types is done explicitly via MatcherCast<T>(m), which takes a
+// matcher m and returns a Matcher<T>.  It compiles only when T can be
+// statically converted to the argument type of m.
+template <typename T, typename M>
+inline Matcher<T> MatcherCast(const M& matcher) {
+  return internal::MatcherCastImpl<T, M>::Cast(matcher);
+}
+
+// Implements SafeMatcherCast().
+//
+// We use an intermediate class to do the actual safe casting as Nokia's
+// Symbian compiler cannot decide between
+// template <T, M> ... (M) and
+// template <T, U> ... (const Matcher<U>&)
+// for function templates but can for member function templates.
+template <typename T>
+class SafeMatcherCastImpl {
+ public:
+  // This overload handles polymorphic matchers and values only since
+  // monomorphic matchers are handled by the next one.
+  template <typename M>
+  static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    return internal::MatcherCastImpl<T, M>::Cast(polymorphic_matcher_or_value);
+  }
+
+  // This overload handles monomorphic matchers.
+  //
+  // In general, if type T can be implicitly converted to type U, we can
+  // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
+  // contravariant): just keep a copy of the original Matcher<U>, convert the
+  // argument from type T to U, and then pass it to the underlying Matcher<U>.
+  // The only exception is when U is a reference and T is not, as the
+  // underlying Matcher<U> may be interested in the argument's address, which
+  // is not preserved in the conversion from T to U.
+  template <typename U>
+  static inline Matcher<T> Cast(const Matcher<U>& matcher) {
+    // Enforce that T can be implicitly converted to U.
+    GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
+                          T_must_be_implicitly_convertible_to_U);
+    // Enforce that we are not converting a non-reference type T to a reference
+    // type U.
+    GTEST_COMPILE_ASSERT_(
+        internal::is_reference<T>::value || !internal::is_reference<U>::value,
+        cannot_convert_non_referentce_arg_to_reference);
+    // In case both T and U are arithmetic types, enforce that the
+    // conversion is not lossy.
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
+    const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+    const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
+    GTEST_COMPILE_ASSERT_(
+        kTIsOther || kUIsOther ||
+        (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+        conversion_of_arithmetic_types_must_be_lossless);
+    return MatcherCast<T>(matcher);
+  }
+};
+
+template <typename T, typename M>
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
+  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
+}
+
+// A<T>() returns a matcher that matches any value of type T.
+template <typename T>
+Matcher<T> A();
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// If the explanation is not empty, prints it to the ostream.
+inline void PrintIfNotEmpty(const internal::string& explanation,
+                            ::std::ostream* os) {
+  if (explanation != "" && os != NULL) {
+    *os << ", " << explanation;
+  }
+}
+
+// Returns true if the given type name is easy to read by a human.
+// This is used to decide whether printing the type of a value might
+// be helpful.
+inline bool IsReadableTypeName(const string& type_name) {
+  // We consider a type name readable if it's short or doesn't contain
+  // a template or function type.
+  return (type_name.length() <= 20 ||
+          type_name.find_first_of("<(") == string::npos);
+}
+
+// Matches the value against the given matcher, prints the value and explains
+// the match result to the listener. Returns the match result.
+// 'listener' must not be NULL.
+// Value cannot be passed by const reference, because some matchers take a
+// non-const argument.
+template <typename Value, typename T>
+bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
+                          MatchResultListener* listener) {
+  if (!listener->IsInterested()) {
+    // If the listener is not interested, we do not need to construct the
+    // inner explanation.
+    return matcher.Matches(value);
+  }
+
+  StringMatchResultListener inner_listener;
+  const bool match = matcher.MatchAndExplain(value, &inner_listener);
+
+  UniversalPrint(value, listener->stream());
+#if GTEST_HAS_RTTI
+  const string& type_name = GetTypeName<Value>();
+  if (IsReadableTypeName(type_name))
+    *listener->stream() << " (of type " << type_name << ")";
+#endif
+  PrintIfNotEmpty(inner_listener.str(), listener->stream());
+
+  return match;
+}
+
+// An internal helper class for doing compile-time loop on a tuple's
+// fields.
+template <size_t N>
+class TuplePrefix {
+ public:
+  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
+  // iff the first N fields of matcher_tuple matches the first N
+  // fields of value_tuple, respectively.
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& matcher_tuple,
+                      const ValueTuple& value_tuple) {
+    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple)
+        && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
+  }
+
+  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
+  // describes failures in matching the first N fields of matchers
+  // against the first N fields of values.  If there is no failure,
+  // nothing will be streamed to os.
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
+                                     const ValueTuple& values,
+                                     ::std::ostream* os) {
+    // First, describes failures in the first N - 1 fields.
+    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
+
+    // Then describes the failure (if any) in the (N - 1)-th (0-based)
+    // field.
+    typename tuple_element<N - 1, MatcherTuple>::type matcher =
+        get<N - 1>(matchers);
+    typedef typename tuple_element<N - 1, ValueTuple>::type Value;
+    Value value = get<N - 1>(values);
+    StringMatchResultListener listener;
+    if (!matcher.MatchAndExplain(value, &listener)) {
+      // TODO(wan): include in the message the name of the parameter
+      // as used in MOCK_METHOD*() when possible.
+      *os << "  Expected arg #" << N - 1 << ": ";
+      get<N - 1>(matchers).DescribeTo(os);
+      *os << "\n           Actual: ";
+      // We remove the reference in type Value to prevent the
+      // universal printer from printing the address of value, which
+      // isn't interesting to the user most of the time.  The
+      // matcher's MatchAndExplain() method handles the case when
+      // the address is interesting.
+      internal::UniversalPrint(value, os);
+      PrintIfNotEmpty(listener.str(), os);
+      *os << "\n";
+    }
+  }
+};
+
+// The base case.
+template <>
+class TuplePrefix<0> {
+ public:
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& /* matcher_tuple */,
+                      const ValueTuple& /* value_tuple */) {
+    return true;
+  }
+
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
+                                     const ValueTuple& /* values */,
+                                     ::std::ostream* /* os */) {}
+};
+
+// TupleMatches(matcher_tuple, value_tuple) returns true iff all
+// matchers in matcher_tuple match the corresponding fields in
+// value_tuple.  It is a compiler error if matcher_tuple and
+// value_tuple have different number of fields or incompatible field
+// types.
+template <typename MatcherTuple, typename ValueTuple>
+bool TupleMatches(const MatcherTuple& matcher_tuple,
+                  const ValueTuple& value_tuple) {
+  // Makes sure that matcher_tuple and value_tuple have the same
+  // number of fields.
+  GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
+                        tuple_size<ValueTuple>::value,
+                        matcher_and_value_have_different_numbers_of_fields);
+  return TuplePrefix<tuple_size<ValueTuple>::value>::
+      Matches(matcher_tuple, value_tuple);
+}
+
+// Describes failures in matching matchers against values.  If there
+// is no failure, nothing will be streamed to os.
+template <typename MatcherTuple, typename ValueTuple>
+void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
+                                const ValueTuple& values,
+                                ::std::ostream* os) {
+  TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+      matchers, values, os);
+}
+
+// TransformTupleValues and its helper.
+//
+// TransformTupleValuesHelper hides the internal machinery that
+// TransformTupleValues uses to implement a tuple traversal.
+template <typename Tuple, typename Func, typename OutIter>
+class TransformTupleValuesHelper {
+ private:
+  typedef ::testing::tuple_size<Tuple> TupleSize;
+
+ public:
+  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
+  // Returns the final value of 'out' in case the caller needs it.
+  static OutIter Run(Func f, const Tuple& t, OutIter out) {
+    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
+  }
+
+ private:
+  template <typename Tup, size_t kRemainingSize>
+  struct IterateOverTuple {
+    OutIter operator() (Func f, const Tup& t, OutIter out) const {
+      *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
+      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
+    }
+  };
+  template <typename Tup>
+  struct IterateOverTuple<Tup, 0> {
+    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
+      return out;
+    }
+  };
+};
+
+// Successively invokes 'f(element)' on each element of the tuple 't',
+// appending each result to the 'out' iterator. Returns the final value
+// of 'out'.
+template <typename Tuple, typename Func, typename OutIter>
+OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
+  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
+}
+
+// Implements A<T>().
+template <typename T>
+class AnyMatcherImpl : public MatcherInterface<T> {
+ public:
+  virtual bool MatchAndExplain(
+      T /* x */, MatchResultListener* /* listener */) const { return true; }
+  virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    // This is mostly for completeness' safe, as it's not very useful
+    // to write Not(A<bool>()).  However we cannot completely rule out
+    // such a possibility, and it doesn't hurt to be prepared.
+    *os << "never matches";
+  }
+};
+
+// Implements _, a matcher that matches any value of any
+// type.  This is a polymorphic matcher, so we need a template type
+// conversion operator to make it appearing as a Matcher<T> for any
+// type T.
+class AnythingMatcher {
+ public:
+  template <typename T>
+  operator Matcher<T>() const { return A<T>(); }
+};
+
+// Implements a matcher that compares a given value with a
+// pre-supplied value using one of the ==, <=, <, etc, operators.  The
+// two values being compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq(5) can be
+// used to match an int, a short, a double, etc).  Therefore we use
+// a template type conversion operator in the implementation.
+//
+// The following template definition assumes that the Rhs parameter is
+// a "bare" type (i.e. neither 'const T' nor 'T&').
+template <typename D, typename Rhs, typename Op>
+class ComparisonBase {
+ public:
+  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
+  template <typename Lhs>
+  operator Matcher<Lhs>() const {
+    return MakeMatcher(new Impl<Lhs>(rhs_));
+  }
+
+ private:
+  template <typename Lhs>
+  class Impl : public MatcherInterface<Lhs> {
+   public:
+    explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
+    virtual bool MatchAndExplain(
+        Lhs lhs, MatchResultListener* /* listener */) const {
+      return Op()(lhs, rhs_);
+    }
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << D::Desc() << " ";
+      UniversalPrint(rhs_, os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << D::NegatedDesc() <<  " ";
+      UniversalPrint(rhs_, os);
+    }
+   private:
+    Rhs rhs_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+  Rhs rhs_;
+  GTEST_DISALLOW_ASSIGN_(ComparisonBase);
+};
+
+template <typename Rhs>
+class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
+ public:
+  explicit EqMatcher(const Rhs& rhs)
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
+  static const char* Desc() { return "is equal to"; }
+  static const char* NegatedDesc() { return "isn't equal to"; }
+};
+template <typename Rhs>
+class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
+ public:
+  explicit NeMatcher(const Rhs& rhs)
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
+  static const char* Desc() { return "isn't equal to"; }
+  static const char* NegatedDesc() { return "is equal to"; }
+};
+template <typename Rhs>
+class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
+ public:
+  explicit LtMatcher(const Rhs& rhs)
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
+  static const char* Desc() { return "is <"; }
+  static const char* NegatedDesc() { return "isn't <"; }
+};
+template <typename Rhs>
+class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
+ public:
+  explicit GtMatcher(const Rhs& rhs)
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
+  static const char* Desc() { return "is >"; }
+  static const char* NegatedDesc() { return "isn't >"; }
+};
+template <typename Rhs>
+class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
+ public:
+  explicit LeMatcher(const Rhs& rhs)
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
+  static const char* Desc() { return "is <="; }
+  static const char* NegatedDesc() { return "isn't <="; }
+};
+template <typename Rhs>
+class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
+ public:
+  explicit GeMatcher(const Rhs& rhs)
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
+  static const char* Desc() { return "is >="; }
+  static const char* NegatedDesc() { return "isn't >="; }
+};
+
+// Implements the polymorphic IsNull() matcher, which matches any raw or smart
+// pointer that is NULL.
+class IsNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+#if GTEST_LANG_CXX11
+    return p == nullptr;
+#else  // GTEST_LANG_CXX11
+    return GetRawPointer(p) == NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NULL";
+  }
+};
+
+// Implements the polymorphic NotNull() matcher, which matches any raw or smart
+// pointer that is not NULL.
+class NotNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+#if GTEST_LANG_CXX11
+    return p != nullptr;
+#else  // GTEST_LANG_CXX11
+    return GetRawPointer(p) != NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is NULL";
+  }
+};
+
+// Ref(variable) matches any argument that is a reference to
+// 'variable'.  This matcher is polymorphic as it can match any
+// super type of the type of 'variable'.
+//
+// The RefMatcher template class implements Ref(variable).  It can
+// only be instantiated with a reference type.  This prevents a user
+// from mistakenly using Ref(x) to match a non-reference function
+// argument.  For example, the following will righteously cause a
+// compiler error:
+//
+//   int n;
+//   Matcher<int> m1 = Ref(n);   // This won't compile.
+//   Matcher<int&> m2 = Ref(n);  // This will compile.
+template <typename T>
+class RefMatcher;
+
+template <typename T>
+class RefMatcher<T&> {
+  // Google Mock is a generic framework and thus needs to support
+  // mocking any function types, including those that take non-const
+  // reference arguments.  Therefore the template parameter T (and
+  // Super below) can be instantiated to either a const type or a
+  // non-const type.
+ public:
+  // RefMatcher() takes a T& instead of const T&, as we want the
+  // compiler to catch using Ref(const_value) as a matcher for a
+  // non-const reference.
+  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
+
+  template <typename Super>
+  operator Matcher<Super&>() const {
+    // By passing object_ (type T&) to Impl(), which expects a Super&,
+    // we make sure that Super is a super type of T.  In particular,
+    // this catches using Ref(const_value) as a matcher for a
+    // non-const reference, as you cannot implicitly convert a const
+    // reference to a non-const reference.
+    return MakeMatcher(new Impl<Super>(object_));
+  }
+
+ private:
+  template <typename Super>
+  class Impl : public MatcherInterface<Super&> {
+   public:
+    explicit Impl(Super& x) : object_(x) {}  // NOLINT
+
+    // MatchAndExplain() takes a Super& (as opposed to const Super&)
+    // in order to match the interface MatcherInterface<Super&>.
+    virtual bool MatchAndExplain(
+        Super& x, MatchResultListener* listener) const {
+      *listener << "which is located @" << static_cast<const void*>(&x);
+      return &x == &object_;
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "references the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "does not reference the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+   private:
+    const Super& object_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  T& object_;
+
+  GTEST_DISALLOW_ASSIGN_(RefMatcher);
+};
+
+// Polymorphic helper functions for narrow and wide string matchers.
+inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
+  return String::CaseInsensitiveCStringEquals(lhs, rhs);
+}
+
+inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
+                                         const wchar_t* rhs) {
+  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
+}
+
+// String comparison for narrow or wide strings that can have embedded NUL
+// characters.
+template <typename StringType>
+bool CaseInsensitiveStringEquals(const StringType& s1,
+                                 const StringType& s2) {
+  // Are the heads equal?
+  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
+    return false;
+  }
+
+  // Skip the equal heads.
+  const typename StringType::value_type nul = 0;
+  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
+
+  // Are we at the end of either s1 or s2?
+  if (i1 == StringType::npos || i2 == StringType::npos) {
+    return i1 == i2;
+  }
+
+  // Are the tails equal?
+  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
+}
+
+// String matchers.
+
+// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
+template <typename StringType>
+class StrEqualityMatcher {
+ public:
+  StrEqualityMatcher(const StringType& str, bool expect_eq,
+                     bool case_sensitive)
+      : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    if (s == NULL) {
+      return !expect_eq_;
+    }
+    return MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    const bool eq = case_sensitive_ ? s2 == string_ :
+        CaseInsensitiveStringEquals(s2, string_);
+    return expect_eq_ == eq;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    DescribeToHelper(expect_eq_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    DescribeToHelper(!expect_eq_, os);
+  }
+
+ private:
+  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
+    *os << (expect_eq ? "is " : "isn't ");
+    *os << "equal to ";
+    if (!case_sensitive_) {
+      *os << "(ignoring case) ";
+    }
+    UniversalPrint(string_, os);
+  }
+
+  const StringType string_;
+  const bool expect_eq_;
+  const bool case_sensitive_;
+
+  GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
+};
+
+// Implements the polymorphic HasSubstr(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class HasSubstrMatcher {
+ public:
+  explicit HasSubstrMatcher(const StringType& substring)
+      : substring_(substring) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.find(substring_) != StringType::npos;
+  }
+
+  // Describes what this matcher matches.
+  void DescribeTo(::std::ostream* os) const {
+    *os << "has substring ";
+    UniversalPrint(substring_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has no substring ";
+    UniversalPrint(substring_, os);
+  }
+
+ private:
+  const StringType substring_;
+
+  GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
+};
+
+// Implements the polymorphic StartsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class StartsWithMatcher {
+ public:
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
+  }
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= prefix_.length() &&
+        s2.substr(0, prefix_.length()) == prefix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "starts with ";
+    UniversalPrint(prefix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't start with ";
+    UniversalPrint(prefix_, os);
+  }
+
+ private:
+  const StringType prefix_;
+
+  GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
+};
+
+// Implements the polymorphic EndsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class EndsWithMatcher {
+ public:
+  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= suffix_.length() &&
+        s2.substr(s2.length() - suffix_.length()) == suffix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "ends with ";
+    UniversalPrint(suffix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't end with ";
+    UniversalPrint(suffix_, os);
+  }
+
+ private:
+  const StringType suffix_;
+
+  GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
+};
+
+// Implements polymorphic matchers MatchesRegex(regex) and
+// ContainsRegex(regex), which can be used as a Matcher<T> as long as
+// T can be converted to a string.
+class MatchesRegexMatcher {
+ public:
+  MatchesRegexMatcher(const RE* regex, bool full_match)
+      : regex_(regex), full_match_(full_match) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(internal::string(s), listener);
+  }
+
+  // Matches anything that can convert to internal::string.
+  //
+  // This is a template, not just a plain function with const internal::string&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <class MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const internal::string& s2(s);
+    return full_match_ ? RE::FullMatch(s2, *regex_) :
+        RE::PartialMatch(s2, *regex_);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << (full_match_ ? "matches" : "contains")
+        << " regular expression ";
+    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't " << (full_match_ ? "match" : "contain")
+        << " regular expression ";
+    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
+  }
+
+ private:
+  const internal::linked_ptr<const RE> regex_;
+  const bool full_match_;
+
+  GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
+};
+
+// Implements a matcher that compares the two fields of a 2-tuple
+// using one of the ==, <=, <, etc, operators.  The two fields being
+// compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq() can be
+// used to match a tuple<int, short>, a tuple<const long&, double>,
+// etc).  Therefore we use a template type conversion operator in the
+// implementation.
+template <typename D, typename Op>
+class PairMatchBase {
+ public:
+  template <typename T1, typename T2>
+  operator Matcher< ::testing::tuple<T1, T2> >() const {
+    return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::testing::tuple<T1, T2>&>() const {
+    return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << D::Desc();
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    virtual bool MatchAndExplain(
+        Tuple args,
+        MatchResultListener* /* listener */) const {
+      return Op()(::testing::get<0>(args), ::testing::get<1>(args));
+    }
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "are " << GetDesc;
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "aren't " << GetDesc;
+    }
+  };
+};
+
+class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
+ public:
+  static const char* Desc() { return "an equal pair"; }
+};
+class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
+ public:
+  static const char* Desc() { return "an unequal pair"; }
+};
+class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
+ public:
+  static const char* Desc() { return "a pair where the first < the second"; }
+};
+class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
+ public:
+  static const char* Desc() { return "a pair where the first > the second"; }
+};
+class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
+ public:
+  static const char* Desc() { return "a pair where the first <= the second"; }
+};
+class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
+ public:
+  static const char* Desc() { return "a pair where the first >= the second"; }
+};
+
+// Implements the Not(...) matcher for a particular argument type T.
+// We do not nest it inside the NotMatcher class template, as that
+// will prevent different instantiations of NotMatcher from sharing
+// the same NotMatcherImpl<T> class.
+template <typename T>
+class NotMatcherImpl : public MatcherInterface<T> {
+ public:
+  explicit NotMatcherImpl(const Matcher<T>& matcher)
+      : matcher_(matcher) {}
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    return !matcher_.MatchAndExplain(x, listener);
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    matcher_.DescribeNegationTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<T> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
+};
+
+// Implements the Not(m) matcher, which matches a value that doesn't
+// match matcher m.
+template <typename InnerMatcher>
+class NotMatcher {
+ public:
+  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
+
+  // This template type conversion operator allows Not(m) to be used
+  // to match any type m can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
+  }
+
+ private:
+  InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcher);
+};
+
+// Implements the AllOf(m1, m2) matcher for a particular argument type
+// T. We do not nest it inside the BothOfMatcher class template, as
+// that will prevent different instantiations of BothOfMatcher from
+// sharing the same BothOfMatcherImpl<T> class.
+template <typename T>
+class BothOfMatcherImpl : public MatcherInterface<T> {
+ public:
+  BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeTo(os);
+    *os << ") and (";
+    matcher2_.DescribeTo(os);
+    *os << ")";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeNegationTo(os);
+    *os << ") or (";
+    matcher2_.DescribeNegationTo(os);
+    *os << ")";
+  }
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    // If either matcher1_ or matcher2_ doesn't match x, we only need
+    // to explain why one of them fails.
+    StringMatchResultListener listener1;
+    if (!matcher1_.MatchAndExplain(x, &listener1)) {
+      *listener << listener1.str();
+      return false;
+    }
+
+    StringMatchResultListener listener2;
+    if (!matcher2_.MatchAndExplain(x, &listener2)) {
+      *listener << listener2.str();
+      return false;
+    }
+
+    // Otherwise we need to explain why *both* of them match.
+    const internal::string s1 = listener1.str();
+    const internal::string s2 = listener2.str();
+
+    if (s1 == "") {
+      *listener << s2;
+    } else {
+      *listener << s1;
+      if (s2 != "") {
+        *listener << ", and " << s2;
+      }
+    }
+    return true;
+  }
+
+ private:
+  const Matcher<T> matcher1_;
+  const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
+};
+
+#if GTEST_LANG_CXX11
+// MatcherList provides mechanisms for storing a variable number of matchers in
+// a list structure (ListType) and creating a combining matcher from such a
+// list.
+// The template is defined recursively using the following template paramters:
+//   * kSize is the length of the MatcherList.
+//   * Head is the type of the first matcher of the list.
+//   * Tail denotes the types of the remaining matchers of the list.
+template <int kSize, typename Head, typename... Tail>
+struct MatcherList {
+  typedef MatcherList<kSize - 1, Tail...> MatcherListTail;
+  typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType;
+
+  // BuildList stores variadic type values in a nested pair structure.
+  // Example:
+  // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return
+  // the corresponding result of type pair<int, pair<string, float>>.
+  static ListType BuildList(const Head& matcher, const Tail&... tail) {
+    return ListType(matcher, MatcherListTail::BuildList(tail...));
+  }
+
+  // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
+  // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
+  // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a
+  // constructor taking two Matcher<T>s as input.
+  template <typename T, template <typename /* T */> class CombiningMatcher>
+  static Matcher<T> CreateMatcher(const ListType& matchers) {
+    return Matcher<T>(new CombiningMatcher<T>(
+        SafeMatcherCast<T>(matchers.first),
+        MatcherListTail::template CreateMatcher<T, CombiningMatcher>(
+            matchers.second)));
+  }
+};
+
+// The following defines the base case for the recursive definition of
+// MatcherList.
+template <typename Matcher1, typename Matcher2>
+struct MatcherList<2, Matcher1, Matcher2> {
+  typedef ::std::pair<Matcher1, Matcher2> ListType;
+
+  static ListType BuildList(const Matcher1& matcher1,
+                            const Matcher2& matcher2) {
+    return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2);
+  }
+
+  template <typename T, template <typename /* T */> class CombiningMatcher>
+  static Matcher<T> CreateMatcher(const ListType& matchers) {
+    return Matcher<T>(new CombiningMatcher<T>(
+        SafeMatcherCast<T>(matchers.first),
+        SafeMatcherCast<T>(matchers.second)));
+  }
+};
+
+// VariadicMatcher is used for the variadic implementation of
+// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
+// CombiningMatcher<T> is used to recursively combine the provided matchers
+// (of type Args...).
+template <template <typename T> class CombiningMatcher, typename... Args>
+class VariadicMatcher {
+ public:
+  VariadicMatcher(const Args&... matchers)  // NOLINT
+      : matchers_(MatcherListType::BuildList(matchers...)) {}
+
+  // This template type conversion operator allows an
+  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
+  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return MatcherListType::template CreateMatcher<T, CombiningMatcher>(
+        matchers_);
+  }
+
+ private:
+  typedef MatcherList<sizeof...(Args), Args...> MatcherListType;
+
+  const typename MatcherListType::ListType matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
+};
+
+template <typename... Args>
+using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>;
+
+#endif  // GTEST_LANG_CXX11
+
+// Used for implementing the AllOf(m_1, ..., m_n) matcher, which
+// matches a value that matches all of the matchers m_1, ..., and m_n.
+template <typename Matcher1, typename Matcher2>
+class BothOfMatcher {
+ public:
+  BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  // This template type conversion operator allows a
+  // BothOfMatcher<Matcher1, Matcher2> object to match any type that
+  // both Matcher1 and Matcher2 can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
+                                               SafeMatcherCast<T>(matcher2_)));
+  }
+
+ private:
+  Matcher1 matcher1_;
+  Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
+};
+
+// Implements the AnyOf(m1, m2) matcher for a particular argument type
+// T.  We do not nest it inside the AnyOfMatcher class template, as
+// that will prevent different instantiations of AnyOfMatcher from
+// sharing the same EitherOfMatcherImpl<T> class.
+template <typename T>
+class EitherOfMatcherImpl : public MatcherInterface<T> {
+ public:
+  EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeTo(os);
+    *os << ") or (";
+    matcher2_.DescribeTo(os);
+    *os << ")";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeNegationTo(os);
+    *os << ") and (";
+    matcher2_.DescribeNegationTo(os);
+    *os << ")";
+  }
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    // If either matcher1_ or matcher2_ matches x, we just need to
+    // explain why *one* of them matches.
+    StringMatchResultListener listener1;
+    if (matcher1_.MatchAndExplain(x, &listener1)) {
+      *listener << listener1.str();
+      return true;
+    }
+
+    StringMatchResultListener listener2;
+    if (matcher2_.MatchAndExplain(x, &listener2)) {
+      *listener << listener2.str();
+      return true;
+    }
+
+    // Otherwise we need to explain why *both* of them fail.
+    const internal::string s1 = listener1.str();
+    const internal::string s2 = listener2.str();
+
+    if (s1 == "") {
+      *listener << s2;
+    } else {
+      *listener << s1;
+      if (s2 != "") {
+        *listener << ", and " << s2;
+      }
+    }
+    return false;
+  }
+
+ private:
+  const Matcher<T> matcher1_;
+  const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
+};
+
+#if GTEST_LANG_CXX11
+// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
+template <typename... Args>
+using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>;
+
+#endif  // GTEST_LANG_CXX11
+
+// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
+// matches a value that matches at least one of the matchers m_1, ...,
+// and m_n.
+template <typename Matcher1, typename Matcher2>
+class EitherOfMatcher {
+ public:
+  EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  // This template type conversion operator allows a
+  // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
+  // both Matcher1 and Matcher2 can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new EitherOfMatcherImpl<T>(
+        SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
+  }
+
+ private:
+  Matcher1 matcher1_;
+  Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
+};
+
+// Used for implementing Truly(pred), which turns a predicate into a
+// matcher.
+template <typename Predicate>
+class TrulyMatcher {
+ public:
+  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
+
+  // This method template allows Truly(pred) to be used as a matcher
+  // for type T where T is the argument type of predicate 'pred'.  The
+  // argument is passed by reference as the predicate may be
+  // interested in the address of the argument.
+  template <typename T>
+  bool MatchAndExplain(T& x,  // NOLINT
+                       MatchResultListener* /* listener */) const {
+    // Without the if-statement, MSVC sometimes warns about converting
+    // a value to bool (warning 4800).
+    //
+    // We cannot write 'return !!predicate_(x);' as that doesn't work
+    // when predicate_(x) returns a class convertible to bool but
+    // having no operator!().
+    if (predicate_(x))
+      return true;
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "satisfies the given predicate";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't satisfy the given predicate";
+  }
+
+ private:
+  Predicate predicate_;
+
+  GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
+};
+
+// Used for implementing Matches(matcher), which turns a matcher into
+// a predicate.
+template <typename M>
+class MatcherAsPredicate {
+ public:
+  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
+
+  // This template operator() allows Matches(m) to be used as a
+  // predicate on type T where m is a matcher on type T.
+  //
+  // The argument x is passed by reference instead of by value, as
+  // some matcher may be interested in its address (e.g. as in
+  // Matches(Ref(n))(x)).
+  template <typename T>
+  bool operator()(const T& x) const {
+    // We let matcher_ commit to a particular type here instead of
+    // when the MatcherAsPredicate object was constructed.  This
+    // allows us to write Matches(m) where m is a polymorphic matcher
+    // (e.g. Eq(5)).
+    //
+    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
+    // compile when matcher_ has type Matcher<const T&>; if we write
+    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
+    // when matcher_ has type Matcher<T>; if we just write
+    // matcher_.Matches(x), it won't compile when matcher_ is
+    // polymorphic, e.g. Eq(5).
+    //
+    // MatcherCast<const T&>() is necessary for making the code work
+    // in all of the above situations.
+    return MatcherCast<const T&>(matcher_).Matches(x);
+  }
+
+ private:
+  M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
+};
+
+// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
+// argument M must be a type that can be converted to a matcher.
+template <typename M>
+class PredicateFormatterFromMatcher {
+ public:
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
+
+  // This template () operator allows a PredicateFormatterFromMatcher
+  // object to act as a predicate-formatter suitable for using with
+  // Google Test's EXPECT_PRED_FORMAT1() macro.
+  template <typename T>
+  AssertionResult operator()(const char* value_text, const T& x) const {
+    // We convert matcher_ to a Matcher<const T&> *now* instead of
+    // when the PredicateFormatterFromMatcher object was constructed,
+    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
+    // know which type to instantiate it to until we actually see the
+    // type of x here.
+    //
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
+    // Matcher<const T&>(matcher_), as the latter won't compile when
+    // matcher_ has type Matcher<T> (e.g. An<int>()).
+    // We don't write MatcherCast<const T&> either, as that allows
+    // potentially unsafe downcasting of the matcher argument.
+    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
+    StringMatchResultListener listener;
+    if (MatchPrintAndExplain(x, matcher, &listener))
+      return AssertionSuccess();
+
+    ::std::stringstream ss;
+    ss << "Value of: " << value_text << "\n"
+       << "Expected: ";
+    matcher.DescribeTo(&ss);
+    ss << "\n  Actual: " << listener.str();
+    return AssertionFailure() << ss.str();
+  }
+
+ private:
+  const M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
+};
+
+// A helper function for converting a matcher to a predicate-formatter
+// without the user needing to explicitly write the type.  This is
+// used for implementing ASSERT_THAT() and EXPECT_THAT().
+// Implementation detail: 'matcher' is received by-value to force decaying.
+template <typename M>
+inline PredicateFormatterFromMatcher<M>
+MakePredicateFormatterFromMatcher(M matcher) {
+  return PredicateFormatterFromMatcher<M>(internal::move(matcher));
+}
+
+// Implements the polymorphic floating point equality matcher, which matches
+// two float values using ULP-based approximation or, optionally, a
+// user-specified epsilon.  The template is meant to be instantiated with
+// FloatType being either float or double.
+template <typename FloatType>
+class FloatingEqMatcher {
+ public:
+  // Constructor for FloatingEqMatcher.
+  // The matcher's input will be compared with expected.  The matcher treats two
+  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
+  // equality comparisons between NANs will always return false.  We specify a
+  // negative max_abs_error_ term to indicate that ULP-based approximation will
+  // be used for comparison.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
+    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
+  }
+
+  // Constructor that supports a user-specified max_abs_error that will be used
+  // for comparison instead of ULP-based approximation.  The max absolute
+  // should be non-negative.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
+                    FloatType max_abs_error)
+      : expected_(expected),
+        nan_eq_nan_(nan_eq_nan),
+        max_abs_error_(max_abs_error) {
+    GTEST_CHECK_(max_abs_error >= 0)
+        << ", where max_abs_error is" << max_abs_error;
+  }
+
+  // Implements floating point equality matcher as a Matcher<T>.
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
+        : expected_(expected),
+          nan_eq_nan_(nan_eq_nan),
+          max_abs_error_(max_abs_error) {}
+
+    virtual bool MatchAndExplain(T value,
+                                 MatchResultListener* listener) const {
+      const FloatingPoint<FloatType> actual(value), expected(expected_);
+
+      // Compares NaNs first, if nan_eq_nan_ is true.
+      if (actual.is_nan() || expected.is_nan()) {
+        if (actual.is_nan() && expected.is_nan()) {
+          return nan_eq_nan_;
+        }
+        // One is nan; the other is not nan.
+        return false;
+      }
+      if (HasMaxAbsError()) {
+        // We perform an equality check so that inf will match inf, regardless
+        // of error bounds.  If the result of value - expected_ would result in
+        // overflow or if either value is inf, the default result is infinity,
+        // which should only match if max_abs_error_ is also infinity.
+        if (value == expected_) {
+          return true;
+        }
+
+        const FloatType diff = value - expected_;
+        if (fabs(diff) <= max_abs_error_) {
+          return true;
+        }
+
+        if (listener->IsInterested()) {
+          *listener << "which is " << diff << " from " << expected_;
+        }
+        return false;
+      } else {
+        return actual.AlmostEquals(expected);
+      }
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      // os->precision() returns the previously set precision, which we
+      // store to restore the ostream to its original configuration
+      // after outputting.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "is NaN";
+        } else {
+          *os << "never matches";
+        }
+      } else {
+        *os << "is approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error <= " << max_abs_error_ << ")";
+        }
+      }
+      os->precision(old_precision);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      // As before, get original precision.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "isn't NaN";
+        } else {
+          *os << "is anything";
+        }
+      } else {
+        *os << "isn't approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error > " << max_abs_error_ << ")";
+        }
+      }
+      // Restore original precision.
+      os->precision(old_precision);
+    }
+
+   private:
+    bool HasMaxAbsError() const {
+      return max_abs_error_ >= 0;
+    }
+
+    const FloatType expected_;
+    const bool nan_eq_nan_;
+    // max_abs_error will be used for value comparison when >= 0.
+    const FloatType max_abs_error_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  // The following 3 type conversion operators allow FloatEq(expected) and
+  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
+  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
+  // (While Google's C++ coding style doesn't allow arguments passed
+  // by non-const reference, we may see them in code not conforming to
+  // the style.  Therefore Google Mock needs to support them.)
+  operator Matcher<FloatType>() const {
+    return MakeMatcher(
+        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<const FloatType&>() const {
+    return MakeMatcher(
+        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<FloatType&>() const {
+    return MakeMatcher(
+        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+ private:
+  const FloatType expected_;
+  const bool nan_eq_nan_;
+  // max_abs_error will be used for value comparison when >= 0.
+  const FloatType max_abs_error_;
+
+  GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
+};
+
+// Implements the Pointee(m) matcher for matching a pointer whose
+// pointee matches matcher m.  The pointer can be either raw or smart.
+template <typename InnerMatcher>
+class PointeeMatcher {
+ public:
+  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointee(m) to be
+  // used as a matcher for any pointer type whose pointee type is
+  // compatible with the inner matcher, where type Pointer can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointee().
+  template <typename Pointer>
+  operator Matcher<Pointer>() const {
+    return MakeMatcher(new Impl<Pointer>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename Pointer>
+  class Impl : public MatcherInterface<Pointer> {
+   public:
+    typedef typename PointeeOf<GTEST_REMOVE_CONST_(  // NOLINT
+        GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "points to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "does not point to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual bool MatchAndExplain(Pointer pointer,
+                                 MatchResultListener* listener) const {
+      if (GetRawPointer(pointer) == NULL)
+        return false;
+
+      *listener << "which points to ";
+      return MatchPrintAndExplain(*pointer, matcher_, listener);
+    }
+
+   private:
+    const Matcher<const Pointee&> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
+};
+
+// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
+// reference that matches inner_matcher when dynamic_cast<T> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+class WhenDynamicCastToMatcherBase {
+ public:
+  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
+      : matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeNegationTo(os);
+  }
+
+ protected:
+  const Matcher<To> matcher_;
+
+  static string GetToName() {
+#if GTEST_HAS_RTTI
+    return GetTypeName<To>();
+#else  // GTEST_HAS_RTTI
+    return "the target type";
+#endif  // GTEST_HAS_RTTI
+  }
+
+ private:
+  static void GetCastTypeDescription(::std::ostream* os) {
+    *os << "when dynamic_cast to " << GetToName() << ", ";
+  }
+
+  GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase);
+};
+
+// Primary template.
+// To is a pointer. Cast and forward the result.
+template <typename To>
+class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
+      : WhenDynamicCastToMatcherBase<To>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From from, MatchResultListener* listener) const {
+    // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail?
+    To to = dynamic_cast<To>(from);
+    return MatchPrintAndExplain(to, this->matcher_, listener);
+  }
+};
+
+// Specialize for references.
+// In this case we return false if the dynamic_cast fails.
+template <typename To>
+class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
+      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
+    // We don't want an std::bad_cast here, so do the cast with pointers.
+    To* to = dynamic_cast<To*>(&from);
+    if (to == NULL) {
+      *listener << "which cannot be dynamic_cast to " << this->GetToName();
+      return false;
+    }
+    return MatchPrintAndExplain(*to, this->matcher_, listener);
+  }
+};
+
+// Implements the Field() matcher for matching a field (i.e. member
+// variable) of an object.
+template <typename Class, typename FieldType>
+class FieldMatcher {
+ public:
+  FieldMatcher(FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field), matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object whose given field ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object whose given field ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename ::testing::internal::
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
+        value, listener);
+  }
+
+ private:
+  // The first argument of MatchAndExplainImpl() is needed to help
+  // Symbian's C++ compiler choose which overload to use.  Its type is
+  // true_type iff the Field() matcher is used to match a pointer.
+  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << "whose given field is ";
+    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == NULL)
+      return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a field, it must be a class/struct/union type and
+    // thus cannot be a pointer.  Therefore we pass false_type() as
+    // the first argument.
+    return MatchAndExplainImpl(false_type(), *p, listener);
+  }
+
+  const FieldType Class::*field_;
+  const Matcher<const FieldType&> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(FieldMatcher);
+};
+
+// Implements the Property() matcher for matching a property
+// (i.e. return value of a getter method) of an object.
+template <typename Class, typename PropertyType>
+class PropertyMatcher {
+ public:
+  // The property may have a reference type, so 'const PropertyType&'
+  // may cause double references and fail to compile.  That's why we
+  // need GTEST_REFERENCE_TO_CONST, which works regardless of
+  // PropertyType being a reference or not.
+  typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
+
+  PropertyMatcher(PropertyType (Class::*property)() const,
+                  const Matcher<RefToConstProperty>& matcher)
+      : property_(property), matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object whose given property ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object whose given property ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename ::testing::internal::
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
+        value, listener);
+  }
+
+ private:
+  // The first argument of MatchAndExplainImpl() is needed to help
+  // Symbian's C++ compiler choose which overload to use.  Its type is
+  // true_type iff the Property() matcher is used to match a pointer.
+  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << "whose given property is ";
+    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
+    // which takes a non-const reference as argument.
+#if defined(_PREFAST_ ) && _MSC_VER == 1800
+    // Workaround bug in VC++ 2013's /analyze parser.
+    // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
+    posix::Abort();  // To make sure it is never run.
+    return false;
+#else
+    RefToConstProperty result = (obj.*property_)();
+    return MatchPrintAndExplain(result, matcher_, listener);
+#endif
+  }
+
+  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == NULL)
+      return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a property method, it must be a class/struct/union
+    // type and thus cannot be a pointer.  Therefore we pass
+    // false_type() as the first argument.
+    return MatchAndExplainImpl(false_type(), *p, listener);
+  }
+
+  PropertyType (Class::*property_)() const;
+  const Matcher<RefToConstProperty> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
+};
+
+// Type traits specifying various features of different functors for ResultOf.
+// The default template specifies features for functor objects.
+// Functor classes have to typedef argument_type and result_type
+// to be compatible with ResultOf.
+template <typename Functor>
+struct CallableTraits {
+  typedef typename Functor::result_type ResultType;
+  typedef Functor StorageType;
+
+  static void CheckIsValid(Functor /* functor */) {}
+  template <typename T>
+  static ResultType Invoke(Functor f, T arg) { return f(arg); }
+};
+
+// Specialization for function pointers.
+template <typename ArgType, typename ResType>
+struct CallableTraits<ResType(*)(ArgType)> {
+  typedef ResType ResultType;
+  typedef ResType(*StorageType)(ArgType);
+
+  static void CheckIsValid(ResType(*f)(ArgType)) {
+    GTEST_CHECK_(f != NULL)
+        << "NULL function pointer is passed into ResultOf().";
+  }
+  template <typename T>
+  static ResType Invoke(ResType(*f)(ArgType), T arg) {
+    return (*f)(arg);
+  }
+};
+
+// Implements the ResultOf() matcher for matching a return value of a
+// unary function of an object.
+template <typename Callable>
+class ResultOfMatcher {
+ public:
+  typedef typename CallableTraits<Callable>::ResultType ResultType;
+
+  ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher)
+      : callable_(callable), matcher_(matcher) {
+    CallableTraits<Callable>::CheckIsValid(callable_);
+  }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new Impl<T>(callable_, matcher_));
+  }
+
+ private:
+  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
+
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
+        : callable_(callable), matcher_(matcher) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(T obj, MatchResultListener* listener) const {
+      *listener << "which is mapped by the given callable to ";
+      // Cannot pass the return value (for example, int) to
+      // MatchPrintAndExplain, which takes a non-const reference as argument.
+      ResultType result =
+          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
+      return MatchPrintAndExplain(result, matcher_, listener);
+    }
+
+   private:
+    // Functors often define operator() as non-const method even though
+    // they are actualy stateless. But we need to use them even when
+    // 'this' is a const pointer. It's the user's responsibility not to
+    // use stateful callables with ResultOf(), which does't guarantee
+    // how many times the callable will be invoked.
+    mutable CallableStorageType callable_;
+    const Matcher<ResultType> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };  // class Impl
+
+  const CallableStorageType callable_;
+  const Matcher<ResultType> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
+};
+
+// Implements a matcher that checks the size of an STL-style container.
+template <typename SizeMatcher>
+class SizeIsMatcher {
+ public:
+  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
+       : size_matcher_(size_matcher) {
+  }
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new Impl<Container>(size_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename ContainerView::type::size_type SizeType;
+    explicit Impl(const SizeMatcher& size_matcher)
+        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "size ";
+      size_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "size ";
+      size_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(Container container,
+                                 MatchResultListener* listener) const {
+      SizeType size = container.size();
+      StringMatchResultListener size_listener;
+      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
+      *listener
+          << "whose size " << size << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(size_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<SizeType> size_matcher_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const SizeMatcher size_matcher_;
+  GTEST_DISALLOW_ASSIGN_(SizeIsMatcher);
+};
+
+// Implements a matcher that checks the begin()..end() distance of an STL-style
+// container.
+template <typename DistanceMatcher>
+class BeginEndDistanceIsMatcher {
+ public:
+  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
+      : distance_matcher_(distance_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new Impl<Container>(distance_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename std::iterator_traits<
+        typename ContainerView::type::const_iterator>::difference_type
+        DistanceType;
+    explicit Impl(const DistanceMatcher& distance_matcher)
+        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(Container container,
+                                 MatchResultListener* listener) const {
+#if GTEST_HAS_STD_BEGIN_AND_END_
+      using std::begin;
+      using std::end;
+      DistanceType distance = std::distance(begin(container), end(container));
+#else
+      DistanceType distance = std::distance(container.begin(), container.end());
+#endif
+      StringMatchResultListener distance_listener;
+      const bool result =
+          distance_matcher_.MatchAndExplain(distance, &distance_listener);
+      *listener << "whose distance between begin() and end() " << distance
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(distance_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<DistanceType> distance_matcher_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const DistanceMatcher distance_matcher_;
+  GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher);
+};
+
+// Implements an equality matcher for any STL-style container whose elements
+// support ==. This matcher is like Eq(), but its failure explanations provide
+// more detailed information that is useful when the container is used as a set.
+// The failure message reports elements that are in one of the operands but not
+// the other. The failure messages do not report duplicate or out-of-order
+// elements in the containers (which don't properly matter to sets, but can
+// occur if the containers are vectors or lists, for example).
+//
+// Uses the container's const_iterator, value_type, operator ==,
+// begin(), and end().
+template <typename Container>
+class ContainerEqMatcher {
+ public:
+  typedef internal::StlContainerView<Container> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+
+  // We make a copy of expected in case the elements in it are modified
+  // after this matcher is created.
+  explicit ContainerEqMatcher(const Container& expected)
+      : expected_(View::Copy(expected)) {
+    // Makes sure the user doesn't instantiate this class template
+    // with a const or reference type.
+    (void)testing::StaticAssertTypeEq<Container,
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "equals ";
+    UniversalPrint(expected_, os);
+  }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal ";
+    UniversalPrint(expected_, os);
+  }
+
+  template <typename LhsContainer>
+  bool MatchAndExplain(const LhsContainer& lhs,
+                       MatchResultListener* listener) const {
+    // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
+    // that causes LhsContainer to be a const type sometimes.
+    typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+    if (lhs_stl_container == expected_)
+      return true;
+
+    ::std::ostream* const os = listener->stream();
+    if (os != NULL) {
+      // Something is different. Check for extra values first.
+      bool printed_header = false;
+      for (typename LhsStlContainer::const_iterator it =
+               lhs_stl_container.begin();
+           it != lhs_stl_container.end(); ++it) {
+        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
+            expected_.end()) {
+          if (printed_header) {
+            *os << ", ";
+          } else {
+            *os << "which has these unexpected elements: ";
+            printed_header = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+
+      // Now check for missing values.
+      bool printed_header2 = false;
+      for (typename StlContainer::const_iterator it = expected_.begin();
+           it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(
+                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
+            lhs_stl_container.end()) {
+          if (printed_header2) {
+            *os << ", ";
+          } else {
+            *os << (printed_header ? ",\nand" : "which")
+                << " doesn't have these expected elements: ";
+            printed_header2 = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+    }
+
+    return false;
+  }
+
+ private:
+  const StlContainer expected_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
+};
+
+// A comparator functor that uses the < operator to compare two values.
+struct LessComparator {
+  template <typename T, typename U>
+  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
+};
+
+// Implements WhenSortedBy(comparator, container_matcher).
+template <typename Comparator, typename ContainerMatcher>
+class WhenSortedByMatcher {
+ public:
+  WhenSortedByMatcher(const Comparator& comparator,
+                      const ContainerMatcher& matcher)
+      : comparator_(comparator), matcher_(matcher) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
+    // so that we can match associative containers.
+    typedef typename RemoveConstFromKey<
+        typename LhsStlContainer::value_type>::type LhsValue;
+
+    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
+        : comparator_(comparator), matcher_(matcher) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "(when sorted) ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "(when sorted) ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(LhsContainer lhs,
+                                 MatchResultListener* listener) const {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
+                                               lhs_stl_container.end());
+      ::std::sort(
+           sorted_container.begin(), sorted_container.end(), comparator_);
+
+      if (!listener->IsInterested()) {
+        // If the listener is not interested, we do not need to
+        // construct the inner explanation.
+        return matcher_.Matches(sorted_container);
+      }
+
+      *listener << "which is ";
+      UniversalPrint(sorted_container, listener->stream());
+      *listener << " when sorted";
+
+      StringMatchResultListener inner_listener;
+      const bool match = matcher_.MatchAndExplain(sorted_container,
+                                                  &inner_listener);
+      PrintIfNotEmpty(inner_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Comparator comparator_;
+    const Matcher<const ::std::vector<LhsValue>&> matcher_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+ private:
+  const Comparator comparator_;
+  const ContainerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher);
+};
+
+// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
+// must be able to be safely cast to Matcher<tuple<const T1&, const
+// T2&> >, where T1 and T2 are the types of elements in the LHS
+// container and the RHS container respectively.
+template <typename TupleMatcher, typename RhsContainer>
+class PointwiseMatcher {
+ public:
+  typedef internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type RhsValue;
+
+  // Like ContainerEq, we make a copy of rhs in case the elements in
+  // it are modified after this matcher is created.
+  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
+      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {
+    // Makes sure the user doesn't instantiate this class template
+    // with a const or reference type.
+    (void)testing::StaticAssertTypeEq<RhsContainer,
+        GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
+  }
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    typedef typename LhsStlContainer::value_type LhsValue;
+    // We pass the LHS value and the RHS value to the inner matcher by
+    // reference, as they may be expensive to copy.  We must use tuple
+    // instead of pair here, as a pair cannot hold references (C++ 98,
+    // 20.2.2 [lib.pairs]).
+    typedef ::testing::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
+
+    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
+        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
+        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
+          rhs_(rhs) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "contains " << rhs_.size()
+          << " values, where each value and its corresponding value in ";
+      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "doesn't contain exactly " << rhs_.size()
+          << " values, or contains a value x at some index i"
+          << " where x and the i-th value of ";
+      UniversalPrint(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(LhsContainer lhs,
+                                 MatchResultListener* listener) const {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      const size_t actual_size = lhs_stl_container.size();
+      if (actual_size != rhs_.size()) {
+        *listener << "which contains " << actual_size << " values";
+        return false;
+      }
+
+      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
+      typename RhsStlContainer::const_iterator right = rhs_.begin();
+      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
+        const InnerMatcherArg value_pair(*left, *right);
+
+        if (listener->IsInterested()) {
+          StringMatchResultListener inner_listener;
+          if (!mono_tuple_matcher_.MatchAndExplain(
+                  value_pair, &inner_listener)) {
+            *listener << "where the value pair (";
+            UniversalPrint(*left, listener->stream());
+            *listener << ", ";
+            UniversalPrint(*right, listener->stream());
+            *listener << ") at index #" << i << " don't match";
+            PrintIfNotEmpty(inner_listener.str(), listener->stream());
+            return false;
+          }
+        } else {
+          if (!mono_tuple_matcher_.Matches(value_pair))
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+   private:
+    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
+    const RhsStlContainer rhs_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const TupleMatcher tuple_matcher_;
+  const RhsStlContainer rhs_;
+
+  GTEST_DISALLOW_ASSIGN_(PointwiseMatcher);
+};
+
+// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
+template <typename Container>
+class QuantifierMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InnerMatcher>
+  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+
+  // Checks whether:
+  // * All elements in the container match, if all_elements_should_match.
+  // * Any element in the container matches, if !all_elements_should_match.
+  bool MatchAndExplainImpl(bool all_elements_should_match,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    for (typename StlContainer::const_iterator it = stl_container.begin();
+         it != stl_container.end(); ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+
+      if (matches != all_elements_should_match) {
+        *listener << "whose element #" << i
+                  << (matches ? " matches" : " doesn't match");
+        PrintIfNotEmpty(inner_listener.str(), listener->stream());
+        return !all_elements_should_match;
+      }
+    }
+    return all_elements_should_match;
+  }
+
+ protected:
+  const Matcher<const Element&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl);
+};
+
+// Implements Contains(element_matcher) for the given argument type Container.
+// Symmetric to EachMatcherImpl.
+template <typename Container>
+class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "contains at least one element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't contain any element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    return this->MatchAndExplainImpl(false, container, listener);
+  }
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
+};
+
+// Implements Each(element_matcher) for the given argument type Container.
+// Symmetric to ContainsMatcherImpl.
+template <typename Container>
+class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit EachMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "only contains elements that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "contains some element that ";
+    this->inner_matcher_.DescribeNegationTo(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    return this->MatchAndExplainImpl(true, container, listener);
+  }
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(EachMatcherImpl);
+};
+
+// Implements polymorphic Contains(element_matcher).
+template <typename M>
+class ContainsMatcher {
+ public:
+  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
+};
+
+// Implements polymorphic Each(element_matcher).
+template <typename M>
+class EachMatcher {
+ public:
+  explicit EachMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(EachMatcher);
+};
+
+// Implements Key(inner_matcher) for the given argument pair type.
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename PairType>
+class KeyMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type KeyType;
+
+  template <typename InnerMatcher>
+  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
+  }
+
+  // Returns true iff 'key_value.first' (the key) matches the inner matcher.
+  virtual bool MatchAndExplain(PairType key_value,
+                               MatchResultListener* listener) const {
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(key_value.first,
+                                                      &inner_listener);
+    const internal::string explanation = inner_listener.str();
+    if (explanation != "") {
+      *listener << "whose first field is a value " << explanation;
+    }
+    return match;
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "has a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't have a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const KeyType&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
+};
+
+// Implements polymorphic Key(matcher_for_key).
+template <typename M>
+class KeyMatcher {
+ public:
+  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
+  }
+
+ private:
+  const M matcher_for_key_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcher);
+};
+
+// Implements Pair(first_matcher, second_matcher) for the given argument pair
+// type with its two matchers. See Pair() function below.
+template <typename PairType>
+class PairMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type FirstType;
+  typedef typename RawPairType::second_type SecondType;
+
+  template <typename FirstMatcher, typename SecondMatcher>
+  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(
+            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
+        second_matcher_(
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "has a first field that ";
+    first_matcher_.DescribeTo(os);
+    *os << ", and has a second field that ";
+    second_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has a first field that ";
+    first_matcher_.DescribeNegationTo(os);
+    *os << ", or has a second field that ";
+    second_matcher_.DescribeNegationTo(os);
+  }
+
+  // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second'
+  // matches second_matcher.
+  virtual bool MatchAndExplain(PairType a_pair,
+                               MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      return first_matcher_.Matches(a_pair.first) &&
+             second_matcher_.Matches(a_pair.second);
+    }
+    StringMatchResultListener first_inner_listener;
+    if (!first_matcher_.MatchAndExplain(a_pair.first,
+                                        &first_inner_listener)) {
+      *listener << "whose first field does not match";
+      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
+      return false;
+    }
+    StringMatchResultListener second_inner_listener;
+    if (!second_matcher_.MatchAndExplain(a_pair.second,
+                                         &second_inner_listener)) {
+      *listener << "whose second field does not match";
+      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
+      return false;
+    }
+    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
+                   listener);
+    return true;
+  }
+
+ private:
+  void ExplainSuccess(const internal::string& first_explanation,
+                      const internal::string& second_explanation,
+                      MatchResultListener* listener) const {
+    *listener << "whose both fields match";
+    if (first_explanation != "") {
+      *listener << ", where the first field is a value " << first_explanation;
+    }
+    if (second_explanation != "") {
+      *listener << ", ";
+      if (first_explanation != "") {
+        *listener << "and ";
+      } else {
+        *listener << "where ";
+      }
+      *listener << "the second field is a value " << second_explanation;
+    }
+  }
+
+  const Matcher<const FirstType&> first_matcher_;
+  const Matcher<const SecondType&> second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
+};
+
+// Implements polymorphic Pair(first_matcher, second_matcher).
+template <typename FirstMatcher, typename SecondMatcher>
+class PairMatcher {
+ public:
+  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
+
+  template <typename PairType>
+  operator Matcher<PairType> () const {
+    return MakeMatcher(
+        new PairMatcherImpl<PairType>(
+            first_matcher_, second_matcher_));
+  }
+
+ private:
+  const FirstMatcher first_matcher_;
+  const SecondMatcher second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcher);
+};
+
+// Implements ElementsAre() and ElementsAreArray().
+template <typename Container>
+class ElementsAreMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  ElementsAreMatcherImpl(InputIter first, InputIter last) {
+    while (first != last) {
+      matchers_.push_back(MatcherCast<const Element&>(*first++));
+    }
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    if (count() == 0) {
+      *os << "is empty";
+    } else if (count() == 1) {
+      *os << "has 1 element that ";
+      matchers_[0].DescribeTo(os);
+    } else {
+      *os << "has " << Elements(count()) << " where\n";
+      for (size_t i = 0; i != count(); ++i) {
+        *os << "element #" << i << " ";
+        matchers_[i].DescribeTo(os);
+        if (i + 1 < count()) {
+          *os << ",\n";
+        }
+      }
+    }
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    if (count() == 0) {
+      *os << "isn't empty";
+      return;
+    }
+
+    *os << "doesn't have " << Elements(count()) << ", or\n";
+    for (size_t i = 0; i != count(); ++i) {
+      *os << "element #" << i << " ";
+      matchers_[i].DescribeNegationTo(os);
+      if (i + 1 < count()) {
+        *os << ", or\n";
+      }
+    }
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    // To work with stream-like "containers", we must only walk
+    // through the elements in one pass.
+
+    const bool listener_interested = listener->IsInterested();
+
+    // explanations[i] is the explanation of the element at index i.
+    ::std::vector<internal::string> explanations(count());
+    StlContainerReference stl_container = View::ConstReference(container);
+    typename StlContainer::const_iterator it = stl_container.begin();
+    size_t exam_pos = 0;
+    bool mismatch_found = false;  // Have we found a mismatched element yet?
+
+    // Go through the elements and matchers in pairs, until we reach
+    // the end of either the elements or the matchers, or until we find a
+    // mismatch.
+    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
+      bool match;  // Does the current element match the current matcher?
+      if (listener_interested) {
+        StringMatchResultListener s;
+        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
+        explanations[exam_pos] = s.str();
+      } else {
+        match = matchers_[exam_pos].Matches(*it);
+      }
+
+      if (!match) {
+        mismatch_found = true;
+        break;
+      }
+    }
+    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
+
+    // Find how many elements the actual container has.  We avoid
+    // calling size() s.t. this code works for stream-like "containers"
+    // that don't define size().
+    size_t actual_count = exam_pos;
+    for (; it != stl_container.end(); ++it) {
+      ++actual_count;
+    }
+
+    if (actual_count != count()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container.  Otherwise we just need to show
+      // how many elements there actually are.
+      if (listener_interested && (actual_count != 0)) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    if (mismatch_found) {
+      // The element count matches, but the exam_pos-th element doesn't match.
+      if (listener_interested) {
+        *listener << "whose element #" << exam_pos << " doesn't match";
+        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
+      }
+      return false;
+    }
+
+    // Every element matches its expectation.  We need to explain why
+    // (the obvious ones can be skipped).
+    if (listener_interested) {
+      bool reason_printed = false;
+      for (size_t i = 0; i != count(); ++i) {
+        const internal::string& s = explanations[i];
+        if (!s.empty()) {
+          if (reason_printed) {
+            *listener << ",\nand ";
+          }
+          *listener << "whose element #" << i << " matches, " << s;
+          reason_printed = true;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  static Message Elements(size_t count) {
+    return Message() << count << (count == 1 ? " element" : " elements");
+  }
+
+  size_t count() const { return matchers_.size(); }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
+};
+
+// Connectivity matrix of (elements X matchers), in element-major order.
+// Initially, there are no edges.
+// Use NextGraph() to iterate over all possible edge configurations.
+// Use Randomize() to generate a random edge configuration.
+class GTEST_API_ MatchMatrix {
+ public:
+  MatchMatrix(size_t num_elements, size_t num_matchers)
+      : num_elements_(num_elements),
+        num_matchers_(num_matchers),
+        matched_(num_elements_* num_matchers_, 0) {
+  }
+
+  size_t LhsSize() const { return num_elements_; }
+  size_t RhsSize() const { return num_matchers_; }
+  bool HasEdge(size_t ilhs, size_t irhs) const {
+    return matched_[SpaceIndex(ilhs, irhs)] == 1;
+  }
+  void SetEdge(size_t ilhs, size_t irhs, bool b) {
+    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
+  }
+
+  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
+  // adds 1 to that number; returns false if incrementing the graph left it
+  // empty.
+  bool NextGraph();
+
+  void Randomize();
+
+  string DebugString() const;
+
+ private:
+  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
+    return ilhs * num_matchers_ + irhs;
+  }
+
+  size_t num_elements_;
+  size_t num_matchers_;
+
+  // Each element is a char interpreted as bool. They are stored as a
+  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
+  // a (ilhs, irhs) matrix coordinate into an offset.
+  ::std::vector<char> matched_;
+};
+
+typedef ::std::pair<size_t, size_t> ElementMatcherPair;
+typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
+
+// Returns a maximum bipartite matching for the specified graph 'g'.
+// The matching is represented as a vector of {element, matcher} pairs.
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g);
+
+GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
+                            MatchResultListener* listener);
+
+// Untyped base class for implementing UnorderedElementsAre.  By
+// putting logic that's not specific to the element type here, we
+// reduce binary bloat and increase compilation speed.
+class GTEST_API_ UnorderedElementsAreMatcherImplBase {
+ protected:
+  // A vector of matcher describers, one for each element matcher.
+  // Does not own the describers (and thus can be used only when the
+  // element matchers are alive).
+  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
+
+  // Describes this UnorderedElementsAre matcher.
+  void DescribeToImpl(::std::ostream* os) const;
+
+  // Describes the negation of this UnorderedElementsAre matcher.
+  void DescribeNegationToImpl(::std::ostream* os) const;
+
+  bool VerifyAllElementsAndMatchersAreMatched(
+      const ::std::vector<string>& element_printouts,
+      const MatchMatrix& matrix,
+      MatchResultListener* listener) const;
+
+  MatcherDescriberVec& matcher_describers() {
+    return matcher_describers_;
+  }
+
+  static Message Elements(size_t n) {
+    return Message() << n << " element" << (n == 1 ? "" : "s");
+  }
+
+ private:
+  MatcherDescriberVec matcher_describers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase);
+};
+
+// Implements unordered ElementsAre and unordered ElementsAreArray.
+template <typename Container>
+class UnorderedElementsAreMatcherImpl
+    : public MatcherInterface<Container>,
+      public UnorderedElementsAreMatcherImplBase {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::const_iterator StlContainerConstIterator;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) {
+    for (; first != last; ++first) {
+      matchers_.push_back(MatcherCast<const Element&>(*first));
+      matcher_describers().push_back(matchers_.back().GetDescriber());
+    }
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    ::std::vector<string> element_printouts;
+    MatchMatrix matrix = AnalyzeElements(stl_container.begin(),
+                                         stl_container.end(),
+                                         &element_printouts,
+                                         listener);
+
+    const size_t actual_count = matrix.LhsSize();
+    if (actual_count == 0 && matchers_.empty()) {
+      return true;
+    }
+    if (actual_count != matchers_.size()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container. Otherwise we just need to show
+      // how many elements there actually are.
+      if (actual_count != 0 && listener->IsInterested()) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    return VerifyAllElementsAndMatchersAreMatched(element_printouts,
+                                                  matrix, listener) &&
+           FindPairing(matrix, listener);
+  }
+
+ private:
+  typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+
+  template <typename ElementIter>
+  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
+                              ::std::vector<string>* element_printouts,
+                              MatchResultListener* listener) const {
+    element_printouts->clear();
+    ::std::vector<char> did_match;
+    size_t num_elements = 0;
+    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
+      if (listener->IsInterested()) {
+        element_printouts->push_back(PrintToString(*elem_first));
+      }
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        did_match.push_back(Matches(matchers_[irhs])(*elem_first));
+      }
+    }
+
+    MatchMatrix matrix(num_elements, matchers_.size());
+    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
+    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
+      }
+    }
+    return matrix;
+  }
+
+  MatcherVec matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl);
+};
+
+// Functor for use in TransformTuple.
+// Performs MatcherCast<Target> on an input argument of any type.
+template <typename Target>
+struct CastAndAppendTransform {
+  template <typename Arg>
+  Matcher<Target> operator()(const Arg& a) const {
+    return MatcherCast<Target>(a);
+  }
+};
+
+// Implements UnorderedElementsAre.
+template <typename MatcherTuple>
+class UnorderedElementsAreMatcher {
+ public:
+  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
+      : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
+                           matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher);
+};
+
+// Implements ElementsAre.
+template <typename MatcherTuple>
+class ElementsAreMatcher {
+ public:
+  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
+                           matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher);
+};
+
+// Implements UnorderedElementsAreArray().
+template <typename T>
+class UnorderedElementsAreArrayMatcher {
+ public:
+  UnorderedElementsAreArrayMatcher() {}
+
+  template <typename Iter>
+  UnorderedElementsAreArrayMatcher(Iter first, Iter last)
+      : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(
+        new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(),
+                                                       matchers_.end()));
+  }
+
+ private:
+  ::std::vector<T> matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher);
+};
+
+// Implements ElementsAreArray().
+template <typename T>
+class ElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
+        matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreArrayMatcher);
+};
+
+// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
+// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
+// second) is a polymorphic matcher that matches a value x iff tm
+// matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+//
+// BoundSecondMatcher is copyable and assignable, as we need to put
+// instances of this class in a vector when implementing
+// UnorderedPointwise().
+template <typename Tuple2Matcher, typename Second>
+class BoundSecondMatcher {
+ public:
+  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
+      : tuple2_matcher_(tm), second_value_(second) {}
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
+  }
+
+  // We have to define this for UnorderedPointwise() to compile in
+  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
+  // which requires the elements to be assignable in C++98.  The
+  // compiler cannot generate the operator= for us, as Tuple2Matcher
+  // and Second may not be assignable.
+  //
+  // However, this should never be called, so the implementation just
+  // need to assert.
+  void operator=(const BoundSecondMatcher& /*rhs*/) {
+    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
+  }
+
+ private:
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    typedef ::testing::tuple<T, Second> ArgTuple;
+
+    Impl(const Tuple2Matcher& tm, const Second& second)
+        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
+          second_value_(second) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "and ";
+      UniversalPrint(second_value_, os);
+      *os << " ";
+      mono_tuple2_matcher_.DescribeTo(os);
+    }
+
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
+                                                  listener);
+    }
+
+   private:
+    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
+    const Second second_value_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const Tuple2Matcher tuple2_matcher_;
+  const Second second_value_;
+};
+
+// Given a 2-tuple matcher tm and a value second,
+// MatcherBindSecond(tm, second) returns a matcher that matches a
+// value x iff tm matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+template <typename Tuple2Matcher, typename Second>
+BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
+    const Tuple2Matcher& tm, const Second& second) {
+  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ string FormatMatcherDescription(bool negation,
+                                           const char* matcher_name,
+                                           const Strings& param_values);
+
+}  // namespace internal
+
+// ElementsAreArray(first, last)
+// ElementsAreArray(pointer, count)
+// ElementsAreArray(array)
+// ElementsAreArray(container)
+// ElementsAreArray({ e1, e2, ..., en })
+//
+// The ElementsAreArray() functions are like ElementsAre(...), except
+// that they are given a homogeneous sequence rather than taking each
+// element as a function argument. The sequence can be specified as an
+// array, a pointer and count, a vector, an initializer list, or an
+// STL iterator range. In each of these cases, the underlying sequence
+// can be either a sequence of values or a sequence of matchers.
+//
+// All forms of ElementsAreArray() make a copy of the input matcher sequence.
+
+template <typename Iter>
+inline internal::ElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+ElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::ElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T* pointer, size_t count) {
+  return ElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T (&array)[N]) {
+  return ElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::ElementsAreArrayMatcher<typename Container::value_type>
+ElementsAreArray(const Container& container) {
+  return ElementsAreArray(container.begin(), container.end());
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T>
+ElementsAreArray(::std::initializer_list<T> xs) {
+  return ElementsAreArray(xs.begin(), xs.end());
+}
+#endif
+
+// UnorderedElementsAreArray(first, last)
+// UnorderedElementsAreArray(pointer, count)
+// UnorderedElementsAreArray(array)
+// UnorderedElementsAreArray(container)
+// UnorderedElementsAreArray({ e1, e2, ..., en })
+//
+// The UnorderedElementsAreArray() functions are like
+// ElementsAreArray(...), but allow matching the elements in any order.
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+UnorderedElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T* pointer, size_t count) {
+  return UnorderedElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T (&array)[N]) {
+  return UnorderedElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+UnorderedElementsAreArray(const Container& container) {
+  return UnorderedElementsAreArray(container.begin(), container.end());
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(::std::initializer_list<T> xs) {
+  return UnorderedElementsAreArray(xs.begin(), xs.end());
+}
+#endif
+
+// _ is a matcher that matches anything of any type.
+//
+// This definition is fine as:
+//
+//   1. The C++ standard permits using the name _ in a namespace that
+//      is not the global namespace or ::std.
+//   2. The AnythingMatcher class has no data member or constructor,
+//      so it's OK to create global variables of this type.
+//   3. c-style has approved of using _ in this case.
+const internal::AnythingMatcher _ = {};
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
+
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> An() { return A<T>(); }
+
+// Creates a polymorphic matcher that matches anything equal to x.
+// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
+// wouldn't compile.
+template <typename T>
+inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
+
+// Constructs a Matcher<T> from a 'value' of type T.  The constructed
+// matcher matches any value that's equal to 'value'.
+template <typename T>
+Matcher<T>::Matcher(T value) { *this = Eq(value); }
+
+// Creates a monomorphic matcher that matches anything with type Lhs
+// and equal to rhs.  A user may need to use this instead of Eq(...)
+// in order to resolve an overloading ambiguity.
+//
+// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
+// or Matcher<T>(x), but more readable than the latter.
+//
+// We could define similar monomorphic matchers for other comparison
+// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
+// it yet as those are used much less than Eq() in practice.  A user
+// can always write Matcher<T>(Lt(5)) to be explicit about the type,
+// for example.
+template <typename Lhs, typename Rhs>
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
+
+// Creates a polymorphic matcher that matches anything >= x.
+template <typename Rhs>
+inline internal::GeMatcher<Rhs> Ge(Rhs x) {
+  return internal::GeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything > x.
+template <typename Rhs>
+inline internal::GtMatcher<Rhs> Gt(Rhs x) {
+  return internal::GtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything <= x.
+template <typename Rhs>
+inline internal::LeMatcher<Rhs> Le(Rhs x) {
+  return internal::LeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything < x.
+template <typename Rhs>
+inline internal::LtMatcher<Rhs> Lt(Rhs x) {
+  return internal::LtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything != x.
+template <typename Rhs>
+inline internal::NeMatcher<Rhs> Ne(Rhs x) {
+  return internal::NeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches any NULL pointer.
+inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
+  return MakePolymorphicMatcher(internal::IsNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any non-NULL pointer.
+// This is convenient as Not(NULL) doesn't compile (the compiler
+// thinks that that expression is comparing a pointer with an integer).
+inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
+  return MakePolymorphicMatcher(internal::NotNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any argument that
+// references variable x.
+template <typename T>
+inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
+  return internal::RefMatcher<T&>(x);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, false);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, true);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> DoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, false);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, true);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> FloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that points
+// to a value that matches inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointeeMatcher<InnerMatcher> Pointee(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
+}
+
+// Creates a matcher that matches a pointer or reference that matches
+// inner_matcher when dynamic_cast<To> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
+WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
+  return MakePolymorphicMatcher(
+      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
+}
+
+// Creates a matcher that matches an object whose given field matches
+// 'matcher'.  For example,
+//   Field(&Foo::number, Ge(5))
+// matches a Foo object x iff x.number >= 5.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<
+  internal::FieldMatcher<Class, FieldType> > Field(
+    FieldType Class::*field, const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::FieldMatcher<Class, FieldType>(
+          field, MatcherCast<const FieldType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Field(&Foo::bar, m)
+  // to compile where bar is an int32 and m is a matcher for int64.
+}
+
+// Creates a matcher that matches an object whose given property
+// matches 'matcher'.  For example,
+//   Property(&Foo::str, StartsWith("hi"))
+// matches a Foo object x iff x.str() starts with "hi".
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<
+  internal::PropertyMatcher<Class, PropertyType> > Property(
+    PropertyType (Class::*property)() const, const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType>(
+          property,
+          MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Property(&Foo::bar, m)
+  // to compile where bar() returns an int32 and m is a matcher for int64.
+}
+
+// Creates a matcher that matches an object iff the result of applying
+// a callable to x matches 'matcher'.
+// For example,
+//   ResultOf(f, StartsWith("hi"))
+// matches a Foo object x iff f(x) starts with "hi".
+// callable parameter can be a function, function pointer, or a functor.
+// Callable has to satisfy the following conditions:
+//   * It is required to keep no state affecting the results of
+//     the calls on it and make no assumptions about how many calls
+//     will be made. Any state it keeps must be protected from the
+//     concurrent access.
+//   * If it is a function object, it has to define type result_type.
+//     We recommend deriving your functor classes from std::unary_function.
+template <typename Callable, typename ResultOfMatcher>
+internal::ResultOfMatcher<Callable> ResultOf(
+    Callable callable, const ResultOfMatcher& matcher) {
+  return internal::ResultOfMatcher<Callable>(
+          callable,
+          MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
+              matcher));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   ResultOf(Function, m)
+  // to compile where Function() returns an int32 and m is a matcher for int64.
+}
+
+// String matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrEq(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrNe(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrCaseEq(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrCaseNe(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, false, false));
+}
+
+// Creates a matcher that matches any string, std::string, or C string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
+    HasSubstr(const internal::string& substring) {
+  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
+      substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
+    StartsWith(const internal::string& prefix) {
+  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
+      prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
+    EndsWith(const internal::string& suffix) {
+  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
+      suffix));
+}
+
+// Matches a string that fully matches regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
+}
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::string& regex) {
+  return MatchesRegex(new internal::RE(regex));
+}
+
+// Matches a string that contains regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
+}
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::string& regex) {
+  return ContainsRegex(new internal::RE(regex));
+}
+
+#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
+// Wide string matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrEq(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrNe(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrCaseEq(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrCaseNe(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, false, false));
+}
+
+// Creates a matcher that matches any wstring, std::wstring, or C wide string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
+    HasSubstr(const internal::wstring& substring) {
+  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>(
+      substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
+    StartsWith(const internal::wstring& prefix) {
+  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>(
+      prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
+    EndsWith(const internal::wstring& suffix) {
+  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>(
+      suffix));
+}
+
+#endif  // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field == the second field.
+inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field >= the second field.
+inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field > the second field.
+inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field <= the second field.
+inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field < the second field.
+inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field != the second field.
+inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
+
+// Creates a matcher that matches any value of type T that m doesn't
+// match.
+template <typename InnerMatcher>
+inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
+  return internal::NotMatcher<InnerMatcher>(m);
+}
+
+// Returns a matcher that matches anything that satisfies the given
+// predicate.  The predicate can be any unary function or functor
+// whose return type can be implicitly converted to bool.
+template <typename Predicate>
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
+Truly(Predicate pred) {
+  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
+}
+
+// Returns a matcher that matches the container size. The container must
+// support both size() and size_type which all STL-like containers provide.
+// Note that the parameter 'size' can be a value of type size_type as well as
+// matcher. For instance:
+//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
+//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
+template <typename SizeMatcher>
+inline internal::SizeIsMatcher<SizeMatcher>
+SizeIs(const SizeMatcher& size_matcher) {
+  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
+}
+
+// Returns a matcher that matches the distance between the container's begin()
+// iterator and its end() iterator, i.e. the size of the container. This matcher
+// can be used instead of SizeIs with containers such as std::forward_list which
+// do not implement size(). The container must provide const_iterator (with
+// valid iterator_traits), begin() and end().
+template <typename DistanceMatcher>
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
+BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
+  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
+}
+
+// Returns a matcher that matches an equal container.
+// This matcher behaves like Eq(), but in the event of mismatch lists the
+// values that are included in one container but not the other. (Duplicate
+// values and order differences are not explained.)
+template <typename Container>
+inline PolymorphicMatcher<internal::ContainerEqMatcher<  // NOLINT
+                            GTEST_REMOVE_CONST_(Container)> >
+    ContainerEq(const Container& rhs) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes Container to be a const type sometimes.
+  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
+  return MakePolymorphicMatcher(
+      internal::ContainerEqMatcher<RawContainer>(rhs));
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the given comparator, matches container_matcher.
+template <typename Comparator, typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
+WhenSortedBy(const Comparator& comparator,
+             const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
+      comparator, container_matcher);
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the < operator, matches container_matcher.
+template <typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
+WhenSorted(const ContainerMatcher& container_matcher) {
+  return
+      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
+          internal::LessComparator(), container_matcher);
+}
+
+// Matches an STL-style container or a native array that contains the
+// same number of elements as in rhs, where its i-th element and rhs's
+// i-th element (as a pair) satisfy the given pair matcher, for all i.
+// TupleMatcher must be able to be safely cast to Matcher<tuple<const
+// T1&, const T2&> >, where T1 and T2 are the types of elements in the
+// LHS container and the RHS container respectively.
+template <typename TupleMatcher, typename Container>
+inline internal::PointwiseMatcher<TupleMatcher,
+                                  GTEST_REMOVE_CONST_(Container)>
+Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes Container to be a const type sometimes (e.g. when
+  // rhs is a const int[])..
+  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
+  return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
+      tuple_matcher, rhs);
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Supports the Pointwise(m, {a, b, c}) syntax.
+template <typename TupleMatcher, typename T>
+inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
+    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
+  return Pointwise(tuple_matcher, std::vector<T>(rhs));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
+// container or a native array that contains the same number of
+// elements as in rhs, where in some permutation of the container, its
+// i-th element and rhs's i-th element (as a pair) satisfy the given
+// pair matcher, for all i.  Tuple2Matcher must be able to be safely
+// cast to Matcher<tuple<const T1&, const T2&> >, where T1 and T2 are
+// the types of elements in the LHS container and the RHS container
+// respectively.
+//
+// This is like Pointwise(pair_matcher, rhs), except that the element
+// order doesn't matter.
+template <typename Tuple2Matcher, typename RhsContainer>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<
+        Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_(
+                           RhsContainer)>::type::value_type> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   const RhsContainer& rhs_container) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes RhsContainer to be a const type sometimes (e.g. when
+  // rhs_container is a const int[]).
+  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
+
+  // RhsView allows the same code to handle RhsContainer being a
+  // STL-style container and it being a native C-style array.
+  typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type Second;
+  const RhsStlContainer& rhs_stl_container =
+      RhsView::ConstReference(rhs_container);
+
+  // Create a matcher for each element in rhs_container.
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
+  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
+       it != rhs_stl_container.end(); ++it) {
+    matchers.push_back(
+        internal::MatcherBindSecond(tuple2_matcher, *it));
+  }
+
+  // Delegate the work to UnorderedElementsAreArray().
+  return UnorderedElementsAreArray(matchers);
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
+template <typename Tuple2Matcher, typename T>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   std::initializer_list<T> rhs) {
+  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Matches an STL-style container or a native array that contains at
+// least one element matching the given value or matcher.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   page_ids.insert(3);
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Contains(1));
+//   EXPECT_THAT(page_ids, Contains(Gt(2)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   EXPECT_THAT(page_lengths,
+//               Contains(::std::pair<const int, size_t>(1, 100)));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+template <typename M>
+inline internal::ContainsMatcher<M> Contains(M matcher) {
+  return internal::ContainsMatcher<M>(matcher);
+}
+
+// Matches an STL-style container or a native array that contains only
+// elements matching the given value or matcher.
+//
+// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
+// the messages are different.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   // Each(m) matches an empty container, regardless of what m is.
+//   EXPECT_THAT(page_ids, Each(Eq(1)));
+//   EXPECT_THAT(page_ids, Each(Eq(77)));
+//
+//   page_ids.insert(3);
+//   EXPECT_THAT(page_ids, Each(Gt(0)));
+//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   page_lengths[2] = 200;
+//   page_lengths[3] = 300;
+//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
+//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
+template <typename M>
+inline internal::EachMatcher<M> Each(M matcher) {
+  return internal::EachMatcher<M>(matcher);
+}
+
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename M>
+inline internal::KeyMatcher<M> Key(M inner_matcher) {
+  return internal::KeyMatcher<M>(inner_matcher);
+}
+
+// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
+// matches first_matcher and whose 'second' field matches second_matcher.  For
+// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
+// to match a std::map<int, string> that contains exactly one element whose key
+// is >= 5 and whose value equals "foo".
+template <typename FirstMatcher, typename SecondMatcher>
+inline internal::PairMatcher<FirstMatcher, SecondMatcher>
+Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
+      first_matcher, second_matcher);
+}
+
+// Returns a predicate that is satisfied by anything that matches the
+// given matcher.
+template <typename M>
+inline internal::MatcherAsPredicate<M> Matches(M matcher) {
+  return internal::MatcherAsPredicate<M>(matcher);
+}
+
+// Returns true iff the value matches the matcher.
+template <typename T, typename M>
+inline bool Value(const T& value, M matcher) {
+  return testing::Matches(matcher)(value);
+}
+
+// Matches the value against the given matcher and explains the match
+// result to listener.
+template <typename T, typename M>
+inline bool ExplainMatchResult(
+    M matcher, const T& value, MatchResultListener* listener) {
+  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
+}
+
+#if GTEST_LANG_CXX11
+// Define variadic matcher versions. They are overloaded in
+// gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
+template <typename... Args>
+inline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) {
+  return internal::AllOfMatcher<Args...>(matchers...);
+}
+
+template <typename... Args>
+inline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) {
+  return internal::AnyOfMatcher<Args...>(matchers...);
+}
+
+#endif  // GTEST_LANG_CXX11
+
+// AllArgs(m) is a synonym of m.  This is useful in
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
+//
+// which is easier to read than
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
+template <typename InnerMatcher>
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
+
+// These macros allow using matchers to check values in Google Test
+// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
+// succeed iff the value matches the matcher.  If the assertion fails,
+// the value and the description of the matcher will be printed.
+#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+
+}  // namespace testing
+
+// Include any custom callback matchers added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+// Copyright 2015, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// ============================================================
+// An installation-specific extension point for gmock-matchers.h.
+// ============================================================
+//
+// Adds google3 callback support to CallableTraits.
+//
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
+
+#endif  //  GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+namespace testing {
+
+// An abstract handle of an expectation.
+class Expectation;
+
+// A set of expectation handles.
+class ExpectationSet;
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// Implements a mock function.
+template <typename F> class FunctionMocker;
+
+// Base class for expectations.
+class ExpectationBase;
+
+// Implements an expectation.
+template <typename F> class TypedExpectation;
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester;
+
+// Base class for function mockers.
+template <typename F> class FunctionMockerBase;
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+//
+// The reason we don't use more fine-grained protection is: when a
+// mock function Foo() is called, it needs to consult its expectations
+// to see which one should be picked.  If another thread is allowed to
+// call a mock function (either Foo() or a different one) at the same
+// time, it could affect the "retired" attributes of Foo()'s
+// expectations when InSequence() is used, and thus affect which
+// expectation gets picked.  Therefore, we sequence all mock function
+// calls to ensure the integrity of the mock objects' states.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Untyped base class for ActionResultHolder<R>.
+class UntypedActionResultHolderBase;
+
+// Abstract base class of FunctionMockerBase.  This is the
+// type-agnostic part of the function mocker interface.  Its pure
+// virtual methods are implemented by FunctionMockerBase.
+class GTEST_API_ UntypedFunctionMockerBase {
+ public:
+  UntypedFunctionMockerBase();
+  virtual ~UntypedFunctionMockerBase();
+
+  // Verifies that all expectations on this mock function have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  bool VerifyAndClearExpectationsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
+
+  // In all of the following Untyped* functions, it's the caller's
+  // responsibility to guarantee the correctness of the arguments'
+  // types.
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      const void* untyped_args,
+      const string& call_description) const = 0;
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action,
+      const void* untyped_args) const = 0;
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const = 0;
+
+  // Sets the mock object this mock method belongs to, and registers
+  // this information in the global mock registry.  Will be called
+  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+  // method.
+  // TODO(wan@google.com): rename to SetAndRegisterOwner().
+  void RegisterOwner(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Sets the mock object this mock method belongs to, and sets the
+  // name of the mock function.  Will be called upon each invocation
+  // of this mock function.
+  void SetOwnerAndName(const void* mock_obj, const char* name)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the mock object this mock method belongs to.  Must be
+  // called after RegisterOwner() or SetOwnerAndName() has been
+  // called.
+  const void* MockObject() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the name of this mock method.  Must be called after
+  // SetOwnerAndName() has been called.
+  const char* Name() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.  The caller is responsible for deleting the
+  // result.
+  UntypedActionResultHolderBase* UntypedInvokeWith(
+      const void* untyped_args)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+ protected:
+  typedef std::vector<const void*> UntypedOnCallSpecs;
+
+  typedef std::vector<internal::linked_ptr<ExpectationBase> >
+  UntypedExpectations;
+
+  // Returns an Expectation object that references and co-owns exp,
+  // which must be an expectation on this mock function.
+  Expectation GetHandleOf(ExpectationBase* exp);
+
+  // Address of the mock object this mock method belongs to.  Only
+  // valid after this mock method has been called or
+  // ON_CALL/EXPECT_CALL has been invoked on it.
+  const void* mock_obj_;  // Protected by g_gmock_mutex.
+
+  // Name of the function being mocked.  Only valid after this mock
+  // method has been called.
+  const char* name_;  // Protected by g_gmock_mutex.
+
+  // All default action specs for this function mocker.
+  UntypedOnCallSpecs untyped_on_call_specs_;
+
+  // All expectations for this function mocker.
+  UntypedExpectations untyped_expectations_;
+};  // class UntypedFunctionMockerBase
+
+// Untyped base class for OnCallSpec<F>.
+class UntypedOnCallSpecBase {
+ public:
+  // The arguments are the location of the ON_CALL() statement.
+  UntypedOnCallSpecBase(const char* a_file, int a_line)
+      : file_(a_file), line_(a_line), last_clause_(kNone) {}
+
+  // Where in the source file was the default action spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ protected:
+  // Gives each clause in the ON_CALL() statement a name.
+  enum Clause {
+    // Do not change the order of the enum members!  The run-time
+    // syntax checking relies on it.
+    kNone,
+    kWith,
+    kWillByDefault
+  };
+
+  // Asserts that the ON_CALL() statement has a certain property.
+  void AssertSpecProperty(bool property, const string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the ON_CALL() statement has a certain property.
+  void ExpectSpecProperty(bool property, const string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  const char* file_;
+  int line_;
+
+  // The last clause in the ON_CALL() statement as seen so far.
+  // Initially kNone and changes as the statement is parsed.
+  Clause last_clause_;
+};  // class UntypedOnCallSpecBase
+
+// This template class implements an ON_CALL spec.
+template <typename F>
+class OnCallSpec : public UntypedOnCallSpecBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  // Constructs an OnCallSpec object from the information inside
+  // the parenthesis of an ON_CALL() statement.
+  OnCallSpec(const char* a_file, int a_line,
+             const ArgumentMatcherTuple& matchers)
+      : UntypedOnCallSpecBase(a_file, a_line),
+        matchers_(matchers),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that triggers a compiler
+        // bug in Symbian's C++ compiler (cannot decide between two
+        // overloaded constructors of Matcher<const ArgumentTuple&>).
+        extra_matcher_(A<const ArgumentTuple&>()) {
+  }
+
+  // Implements the .With() clause.
+  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
+    // Makes sure this is called at most once.
+    ExpectSpecProperty(last_clause_ < kWith,
+                       ".With() cannot appear "
+                       "more than once in an ON_CALL().");
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    return *this;
+  }
+
+  // Implements the .WillByDefault() clause.
+  OnCallSpec& WillByDefault(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ < kWillByDefault,
+                       ".WillByDefault() must appear "
+                       "exactly once in an ON_CALL().");
+    last_clause_ = kWillByDefault;
+
+    ExpectSpecProperty(!action.IsDoDefault(),
+                       "DoDefault() cannot be used in ON_CALL().");
+    action_ = action;
+    return *this;
+  }
+
+  // Returns true iff the given arguments match the matchers.
+  bool Matches(const ArgumentTuple& args) const {
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns the action specified by the user.
+  const Action<F>& GetAction() const {
+    AssertSpecProperty(last_clause_ == kWillByDefault,
+                       ".WillByDefault() must appear exactly "
+                       "once in an ON_CALL().");
+    return action_;
+  }
+
+ private:
+  // The information in statement
+  //
+  //   ON_CALL(mock_object, Method(matchers))
+  //       .With(multi-argument-matcher)
+  //       .WillByDefault(action);
+  //
+  // is recorded in the data members like this:
+  //
+  //   source file that contains the statement => file_
+  //   line number of the statement            => line_
+  //   matchers                                => matchers_
+  //   multi-argument-matcher                  => extra_matcher_
+  //   action                                  => action_
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> action_;
+};  // class OnCallSpec
+
+// Possible reactions on uninteresting calls.
+enum CallReaction {
+  kAllow,
+  kWarn,
+  kFail,
+  kDefault = kWarn  // By default, warn about uninteresting calls.
+};
+
+}  // namespace internal
+
+// Utilities for manipulating mock objects.
+class GTEST_API_ Mock {
+ public:
+  // The following public methods can be called concurrently.
+
+  // Tells Google Mock to ignore mock_obj when checking for leaked
+  // mock objects.
+  static void AllowLeak(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies and clears all expectations on the given mock object.
+  // If the expectations aren't satisfied, generates one or more
+  // Google Test non-fatal failures and returns false.
+  static bool VerifyAndClearExpectations(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies all expectations on the given mock object and clears its
+  // default actions and expectations.  Returns true iff the
+  // verification was successful.
+  static bool VerifyAndClear(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+ private:
+  friend class internal::UntypedFunctionMockerBase;
+
+  // Needed for a function mocker to register itself (so that we know
+  // how to clear a mock object).
+  template <typename F>
+  friend class internal::FunctionMockerBase;
+
+  template <typename M>
+  friend class NiceMock;
+
+  template <typename M>
+  friend class NaggyMock;
+
+  template <typename M>
+  friend class StrictMock;
+
+  // Tells Google Mock to allow uninteresting calls on the given mock
+  // object.
+  static void AllowUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to warn the user about uninteresting calls on
+  // the given mock object.
+  static void WarnUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to fail uninteresting calls on the given mock
+  // object.
+  static void FailUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock the given mock object is being destroyed and
+  // its entry in the call-reaction table should be removed.
+  static void UnregisterCallReaction(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns the reaction Google Mock will have on uninteresting calls
+  // made on the given mock object.
+  static internal::CallReaction GetReactionOnUninterestingCalls(
+      const void* mock_obj)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies that all expectations on the given mock object have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Clears all ON_CALL()s set on the given mock object.
+  static void ClearDefaultActionsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Registers a mock object and a mock method it owns.
+  static void Register(
+      const void* mock_obj,
+      internal::UntypedFunctionMockerBase* mocker)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock where in the source code mock_obj is used in an
+  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+  // information helps the user identify which object it is.
+  static void RegisterUseByOnCallOrExpectCall(
+      const void* mock_obj, const char* file, int line)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Unregisters a mock method; removes the owning mock object from
+  // the registry when the last mock method associated with it has
+  // been unregistered.  This is called only in the destructor of
+  // FunctionMockerBase.
+  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+};  // class Mock
+
+// An abstract handle of an expectation.  Useful in the .After()
+// clause of EXPECT_CALL() for setting the (partial) order of
+// expectations.  The syntax:
+//
+//   Expectation e1 = EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(e1)...;
+//
+// sets two expectations where the latter can only be matched after
+// the former has been satisfied.
+//
+// Notes:
+//   - This class is copyable and has value semantics.
+//   - Constness is shallow: a const Expectation object itself cannot
+//     be modified, but the mutable methods of the ExpectationBase
+//     object it references can be called via expectation_base().
+//   - The constructors and destructor are defined out-of-line because
+//     the Symbian WINSCW compiler wants to otherwise instantiate them
+//     when it sees this class definition, at which point it doesn't have
+//     ExpectationBase available yet, leading to incorrect destruction
+//     in the linked_ptr (or compilation errors if using a checking
+//     linked_ptr).
+class GTEST_API_ Expectation {
+ public:
+  // Constructs a null object that doesn't reference any expectation.
+  Expectation();
+
+  ~Expectation();
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   Expectation e = EXPECT_CALL(...);
+  // syntax.
+  //
+  // A TypedExpectation object stores its pre-requisites as
+  // Expectation objects, and needs to call the non-const Retire()
+  // method on the ExpectationBase objects they reference.  Therefore
+  // Expectation must receive a *non-const* reference to the
+  // ExpectationBase object.
+  Expectation(internal::ExpectationBase& exp);  // NOLINT
+
+  // The compiler-generated copy ctor and operator= work exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true iff rhs references the same expectation as this object does.
+  bool operator==(const Expectation& rhs) const {
+    return expectation_base_ == rhs.expectation_base_;
+  }
+
+  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
+
+ private:
+  friend class ExpectationSet;
+  friend class Sequence;
+  friend class ::testing::internal::ExpectationBase;
+  friend class ::testing::internal::UntypedFunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::FunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::TypedExpectation;
+
+  // This comparator is needed for putting Expectation objects into a set.
+  class Less {
+   public:
+    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
+      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
+    }
+  };
+
+  typedef ::std::set<Expectation, Less> Set;
+
+  Expectation(
+      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
+
+  // Returns the expectation this object references.
+  const internal::linked_ptr<internal::ExpectationBase>&
+  expectation_base() const {
+    return expectation_base_;
+  }
+
+  // A linked_ptr that co-owns the expectation this handle references.
+  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
+};
+
+// A set of expectation handles.  Useful in the .After() clause of
+// EXPECT_CALL() for setting the (partial) order of expectations.  The
+// syntax:
+//
+//   ExpectationSet es;
+//   es += EXPECT_CALL(...)...;
+//   es += EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(es)...;
+//
+// sets three expectations where the last one can only be matched
+// after the first two have both been satisfied.
+//
+// This class is copyable and has value semantics.
+class ExpectationSet {
+ public:
+  // A bidirectional iterator that can read a const element in the set.
+  typedef Expectation::Set::const_iterator const_iterator;
+
+  // An object stored in the set.  This is an alias of Expectation.
+  typedef Expectation::Set::value_type value_type;
+
+  // Constructs an empty set.
+  ExpectationSet() {}
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   ExpectationSet es = EXPECT_CALL(...);
+  // syntax.
+  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
+    *this += Expectation(exp);
+  }
+
+  // This single-argument ctor implements implicit conversion from
+  // Expectation and thus must not be explicit.  This allows either an
+  // Expectation or an ExpectationSet to be used in .After().
+  ExpectationSet(const Expectation& e) {  // NOLINT
+    *this += e;
+  }
+
+  // The compiler-generator ctor and operator= works exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true iff rhs contains the same set of Expectation objects
+  // as this does.
+  bool operator==(const ExpectationSet& rhs) const {
+    return expectations_ == rhs.expectations_;
+  }
+
+  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
+
+  // Implements the syntax
+  //   expectation_set += EXPECT_CALL(...);
+  ExpectationSet& operator+=(const Expectation& e) {
+    expectations_.insert(e);
+    return *this;
+  }
+
+  int size() const { return static_cast<int>(expectations_.size()); }
+
+  const_iterator begin() const { return expectations_.begin(); }
+  const_iterator end() const { return expectations_.end(); }
+
+ private:
+  Expectation::Set expectations_;
+};
+
+
+// Sequence objects are used by a user to specify the relative order
+// in which the expectations should match.  They are copyable (we rely
+// on the compiler-defined copy constructor and assignment operator).
+class GTEST_API_ Sequence {
+ public:
+  // Constructs an empty sequence.
+  Sequence() : last_expectation_(new Expectation) {}
+
+  // Adds an expectation to this sequence.  The caller must ensure
+  // that no other thread is accessing this Sequence object.
+  void AddExpectation(const Expectation& expectation) const;
+
+ private:
+  // The last expectation in this sequence.  We use a linked_ptr here
+  // because Sequence objects are copyable and we want the copies to
+  // be aliases.  The linked_ptr allows the copies to co-own and share
+  // the same Expectation object.
+  internal::linked_ptr<Expectation> last_expectation_;
+};  // class Sequence
+
+// An object of this type causes all EXPECT_CALL() statements
+// encountered in its scope to be put in an anonymous sequence.  The
+// work is done in the constructor and destructor.  You should only
+// create an InSequence object on the stack.
+//
+// The sole purpose for this class is to support easy definition of
+// sequential expectations, e.g.
+//
+//   {
+//     InSequence dummy;  // The name of the object doesn't matter.
+//
+//     // The following expectations must match in the order they appear.
+//     EXPECT_CALL(a, Bar())...;
+//     EXPECT_CALL(a, Baz())...;
+//     ...
+//     EXPECT_CALL(b, Xyz())...;
+//   }
+//
+// You can create InSequence objects in multiple threads, as long as
+// they are used to affect different mock objects.  The idea is that
+// each thread can create and set up its own mocks as if it's the only
+// thread.  However, for clarity of your tests we recommend you to set
+// up mocks in the main thread unless you have a good reason not to do
+// so.
+class GTEST_API_ InSequence {
+ public:
+  InSequence();
+  ~InSequence();
+ private:
+  bool sequence_created_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
+} GTEST_ATTRIBUTE_UNUSED_;
+
+namespace internal {
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Base class for implementing expectations.
+//
+// There are two reasons for having a type-agnostic base class for
+// Expectation:
+//
+//   1. We need to store collections of expectations of different
+//   types (e.g. all pre-requisites of a particular expectation, all
+//   expectations in a sequence).  Therefore these expectation objects
+//   must share a common base class.
+//
+//   2. We can avoid binary code bloat by moving methods not depending
+//   on the template argument of Expectation to the base class.
+//
+// This class is internal and mustn't be used by user code directly.
+class GTEST_API_ ExpectationBase {
+ public:
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const string& source_text);
+
+  virtual ~ExpectationBase();
+
+  // Where in the source file was the expectation spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+  const char* source_text() const { return source_text_.c_str(); }
+  // Returns the cardinality specified in the expectation spec.
+  const Cardinality& cardinality() const { return cardinality_; }
+
+  // Describes the source file location of this expectation.
+  void DescribeLocationTo(::std::ostream* os) const {
+    *os << FormatFileLocation(file(), line()) << " ";
+  }
+
+  // Describes how many times a function call matching this
+  // expectation has occurred.
+  void DescribeCallCountTo(::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
+
+ protected:
+  friend class ::testing::Expectation;
+  friend class UntypedFunctionMockerBase;
+
+  enum Clause {
+    // Don't change the order of the enum members!
+    kNone,
+    kWith,
+    kTimes,
+    kInSequence,
+    kAfter,
+    kWillOnce,
+    kWillRepeatedly,
+    kRetiresOnSaturation
+  };
+
+  typedef std::vector<const void*> UntypedActions;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() = 0;
+
+  // Asserts that the EXPECT_CALL() statement has the given property.
+  void AssertSpecProperty(bool property, const string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the EXPECT_CALL() statement has the given property.
+  void ExpectSpecProperty(bool property, const string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  // Explicitly specifies the cardinality of this expectation.  Used
+  // by the subclasses to implement the .Times() clause.
+  void SpecifyCardinality(const Cardinality& cardinality);
+
+  // Returns true iff the user specified the cardinality explicitly
+  // using a .Times().
+  bool cardinality_specified() const { return cardinality_specified_; }
+
+  // Sets the cardinality of this expectation spec.
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
+  }
+
+  // The following group of methods should only be called after the
+  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
+  // the current thread.
+
+  // Retires all pre-requisites of this expectation.
+  void RetireAllPreRequisites()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns true iff this expectation is retired.
+  bool is_retired() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return retired_;
+  }
+
+  // Retires this expectation.
+  void Retire()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    retired_ = true;
+  }
+
+  // Returns true iff this expectation is satisfied.
+  bool IsSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSatisfiedByCallCount(call_count_);
+  }
+
+  // Returns true iff this expectation is saturated.
+  bool IsSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true iff this expectation is over-saturated.
+  bool IsOverSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsOverSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true iff all pre-requisites of this expectation are satisfied.
+  bool AllPrerequisitesAreSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Adds unsatisfied pre-requisites of this expectation to 'result'.
+  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns the number this expectation has been invoked.
+  int call_count() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return call_count_;
+  }
+
+  // Increments the number this expectation has been invoked.
+  void IncrementCallCount()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    call_count_++;
+  }
+
+  // Checks the action count (i.e. the number of WillOnce() and
+  // WillRepeatedly() clauses) against the cardinality if this hasn't
+  // been done before.  Prints a warning if there are too many or too
+  // few actions.
+  void CheckActionCountIfNotDone() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  friend class ::testing::Sequence;
+  friend class ::testing::internal::ExpectationTester;
+
+  template <typename Function>
+  friend class TypedExpectation;
+
+  // Implements the .Times() clause.
+  void UntypedTimes(const Cardinality& a_cardinality);
+
+  // This group of fields are part of the spec and won't change after
+  // an EXPECT_CALL() statement finishes.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const string source_text_;  // The EXPECT_CALL(...) source text.
+  // True iff the cardinality is specified explicitly.
+  bool cardinality_specified_;
+  Cardinality cardinality_;            // The cardinality of the expectation.
+  // The immediate pre-requisites (i.e. expectations that must be
+  // satisfied before this expectation can be matched) of this
+  // expectation.  We use linked_ptr in the set because we want an
+  // Expectation object to be co-owned by its FunctionMocker and its
+  // successors.  This allows multiple mock objects to be deleted at
+  // different times.
+  ExpectationSet immediate_prerequisites_;
+
+  // This group of fields are the current state of the expectation,
+  // and can change as the mock function is called.
+  int call_count_;  // How many times this expectation has been invoked.
+  bool retired_;    // True iff this expectation has retired.
+  UntypedActions untyped_actions_;
+  bool extra_matcher_specified_;
+  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
+  bool retires_on_saturation_;
+  Clause last_clause_;
+  mutable bool action_count_checked_;  // Under mutex_.
+  mutable Mutex mutex_;  // Protects action_count_checked_.
+
+  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
+};  // class ExpectationBase
+
+// Impements an expectation for the given function type.
+template <typename F>
+class TypedExpectation : public ExpectationBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+  typedef typename Function<F>::Result Result;
+
+  TypedExpectation(FunctionMockerBase<F>* owner,
+                   const char* a_file, int a_line, const string& a_source_text,
+                   const ArgumentMatcherTuple& m)
+      : ExpectationBase(a_file, a_line, a_source_text),
+        owner_(owner),
+        matchers_(m),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that triggers a compiler
+        // bug in Symbian's C++ compiler (cannot decide between two
+        // overloaded constructors of Matcher<const ArgumentTuple&>).
+        extra_matcher_(A<const ArgumentTuple&>()),
+        repeated_action_(DoDefault()) {}
+
+  virtual ~TypedExpectation() {
+    // Check the validity of the action count if it hasn't been done
+    // yet (for example, if the expectation was never used).
+    CheckActionCountIfNotDone();
+    for (UntypedActions::const_iterator it = untyped_actions_.begin();
+         it != untyped_actions_.end(); ++it) {
+      delete static_cast<const Action<F>*>(*it);
+    }
+  }
+
+  // Implements the .With() clause.
+  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
+    if (last_clause_ == kWith) {
+      ExpectSpecProperty(false,
+                         ".With() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWith,
+                         ".With() must be the first "
+                         "clause in an EXPECT_CALL().");
+    }
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    extra_matcher_specified_ = true;
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
+    ExpectationBase::UntypedTimes(a_cardinality);
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(int n) {
+    return Times(Exactly(n));
+  }
+
+  // Implements the .InSequence() clause.
+  TypedExpectation& InSequence(const Sequence& s) {
+    ExpectSpecProperty(last_clause_ <= kInSequence,
+                       ".InSequence() cannot appear after .After(),"
+                       " .WillOnce(), .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kInSequence;
+
+    s.AddExpectation(GetHandle());
+    return *this;
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
+    return InSequence(s1).InSequence(s2);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3) {
+    return InSequence(s1, s2).InSequence(s3);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4) {
+    return InSequence(s1, s2, s3).InSequence(s4);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4,
+                               const Sequence& s5) {
+    return InSequence(s1, s2, s3, s4).InSequence(s5);
+  }
+
+  // Implements that .After() clause.
+  TypedExpectation& After(const ExpectationSet& s) {
+    ExpectSpecProperty(last_clause_ <= kAfter,
+                       ".After() cannot appear after .WillOnce(),"
+                       " .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kAfter;
+
+    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
+      immediate_prerequisites_ += *it;
+    }
+    return *this;
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
+    return After(s1).After(s2);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3) {
+    return After(s1, s2).After(s3);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4) {
+    return After(s1, s2, s3).After(s4);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4,
+                          const ExpectationSet& s5) {
+    return After(s1, s2, s3, s4).After(s5);
+  }
+
+  // Implements the .WillOnce() clause.
+  TypedExpectation& WillOnce(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ <= kWillOnce,
+                       ".WillOnce() cannot appear after "
+                       ".WillRepeatedly() or .RetiresOnSaturation().");
+    last_clause_ = kWillOnce;
+
+    untyped_actions_.push_back(new Action<F>(action));
+    if (!cardinality_specified()) {
+      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
+    }
+    return *this;
+  }
+
+  // Implements the .WillRepeatedly() clause.
+  TypedExpectation& WillRepeatedly(const Action<F>& action) {
+    if (last_clause_ == kWillRepeatedly) {
+      ExpectSpecProperty(false,
+                         ".WillRepeatedly() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
+                         ".WillRepeatedly() cannot appear "
+                         "after .RetiresOnSaturation().");
+    }
+    last_clause_ = kWillRepeatedly;
+    repeated_action_specified_ = true;
+
+    repeated_action_ = action;
+    if (!cardinality_specified()) {
+      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
+    }
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Implements the .RetiresOnSaturation() clause.
+  TypedExpectation& RetiresOnSaturation() {
+    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
+                       ".RetiresOnSaturation() cannot appear "
+                       "more than once.");
+    last_clause_ = kRetiresOnSaturation;
+    retires_on_saturation_ = true;
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Returns the matchers for the arguments as specified inside the
+  // EXPECT_CALL() macro.
+  const ArgumentMatcherTuple& matchers() const {
+    return matchers_;
+  }
+
+  // Returns the matcher specified by the .With() clause.
+  const Matcher<const ArgumentTuple&>& extra_matcher() const {
+    return extra_matcher_;
+  }
+
+  // Returns the action specified by the .WillRepeatedly() clause.
+  const Action<F>& repeated_action() const { return repeated_action_; }
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
+ private:
+  template <typename Function>
+  friend class FunctionMockerBase;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() {
+    return owner_->GetHandleOf(this);
+  }
+
+  // The following methods will be called only after the EXPECT_CALL()
+  // statement finishes and when the current thread holds
+  // g_gmock_mutex.
+
+  // Returns true iff this expectation matches the given arguments.
+  bool Matches(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns true iff this expectation should handle the given arguments.
+  bool ShouldHandleArguments(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // In case the action count wasn't checked when the expectation
+    // was defined (e.g. if this expectation has no WillRepeatedly()
+    // or RetiresOnSaturation() clause), we check it when the
+    // expectation is used for the first time.
+    CheckActionCountIfNotDone();
+    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
+  }
+
+  // Describes the result of matching the arguments against this
+  // expectation to the given ostream.
+  void ExplainMatchResultTo(
+      const ArgumentTuple& args,
+      ::std::ostream* os) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    if (is_retired()) {
+      *os << "         Expected: the expectation is active\n"
+          << "           Actual: it is retired\n";
+    } else if (!Matches(args)) {
+      if (!TupleMatches(matchers_, args)) {
+        ExplainMatchFailureTupleTo(matchers_, args, os);
+      }
+      StringMatchResultListener listener;
+      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
+        *os << "    Expected args: ";
+        extra_matcher_.DescribeTo(os);
+        *os << "\n           Actual: don't match";
+
+        internal::PrintIfNotEmpty(listener.str(), os);
+        *os << "\n";
+      }
+    } else if (!AllPrerequisitesAreSatisfied()) {
+      *os << "         Expected: all pre-requisites are satisfied\n"
+          << "           Actual: the following immediate pre-requisites "
+          << "are not satisfied:\n";
+      ExpectationSet unsatisfied_prereqs;
+      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
+      int i = 0;
+      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
+           it != unsatisfied_prereqs.end(); ++it) {
+        it->expectation_base()->DescribeLocationTo(os);
+        *os << "pre-requisite #" << i++ << "\n";
+      }
+      *os << "                   (end of pre-requisites)\n";
+    } else {
+      // This line is here just for completeness' sake.  It will never
+      // be executed as currently the ExplainMatchResultTo() function
+      // is called only when the mock function call does NOT match the
+      // expectation.
+      *os << "The call matches the expectation.\n";
+    }
+  }
+
+  // Returns the action that should be taken for the current invocation.
+  const Action<F>& GetCurrentAction(
+      const FunctionMockerBase<F>* mocker,
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = call_count();
+    Assert(count >= 1, __FILE__, __LINE__,
+           "call_count() is <= 0 when GetCurrentAction() is "
+           "called - this should never happen.");
+
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    if (action_count > 0 && !repeated_action_specified_ &&
+        count > action_count) {
+      // If there is at least one WillOnce() and no WillRepeatedly(),
+      // we warn the user when the WillOnce() clauses ran out.
+      ::std::stringstream ss;
+      DescribeLocationTo(&ss);
+      ss << "Actions ran out in " << source_text() << "...\n"
+         << "Called " << count << " times, but only "
+         << action_count << " WillOnce()"
+         << (action_count == 1 ? " is" : "s are") << " specified - ";
+      mocker->DescribeDefaultActionTo(args, &ss);
+      Log(kWarning, ss.str(), 1);
+    }
+
+    return count <= action_count ?
+        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
+        repeated_action();
+  }
+
+  // Given the arguments of a mock function call, if the call will
+  // over-saturate this expectation, returns the default action;
+  // otherwise, returns the next action in this expectation.  Also
+  // describes *what* happened to 'what', and explains *why* Google
+  // Mock does it to 'why'.  This method is not const as it calls
+  // IncrementCallCount().  A return value of NULL means the default
+  // action.
+  const Action<F>* GetActionForArguments(
+      const FunctionMockerBase<F>* mocker,
+      const ArgumentTuple& args,
+      ::std::ostream* what,
+      ::std::ostream* why)
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    if (IsSaturated()) {
+      // We have an excessive call.
+      IncrementCallCount();
+      *what << "Mock function called more times than expected - ";
+      mocker->DescribeDefaultActionTo(args, what);
+      DescribeCallCountTo(why);
+
+      // TODO(wan@google.com): allow the user to control whether
+      // unexpected calls should fail immediately or continue using a
+      // flag --gmock_unexpected_calls_are_fatal.
+      return NULL;
+    }
+
+    IncrementCallCount();
+    RetireAllPreRequisites();
+
+    if (retires_on_saturation_ && IsSaturated()) {
+      Retire();
+    }
+
+    // Must be done after IncrementCount()!
+    *what << "Mock function call matches " << source_text() <<"...\n";
+    return &(GetCurrentAction(mocker, args));
+  }
+
+  // All the fields below won't change once the EXPECT_CALL()
+  // statement finishes.
+  FunctionMockerBase<F>* const owner_;
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> repeated_action_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+};  // class TypedExpectation
+
+// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
+// specifying the default behavior of, or expectation on, a mock
+// function.
+
+// Note: class MockSpec really belongs to the ::testing namespace.
+// However if we define it in ::testing, MSVC will complain when
+// classes in ::testing::internal declare it as a friend class
+// template.  To workaround this compiler bug, we define MockSpec in
+// ::testing::internal and import it into ::testing.
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const string& message);
+
+template <typename F>
+class MockSpec {
+ public:
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename internal::Function<F>::ArgumentMatcherTuple
+      ArgumentMatcherTuple;
+
+  // Constructs a MockSpec object, given the function mocker object
+  // that the spec is associated with.
+  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
+      : function_mocker_(function_mocker) {}
+
+  // Adds a new default action spec to the function mocker and returns
+  // the newly created spec.
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
+      const char* file, int line, const char* obj, const char* call) {
+    LogWithLocation(internal::kInfo, file, line,
+        string("ON_CALL(") + obj + ", " + call + ") invoked");
+    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
+  }
+
+  // Adds a new expectation spec to the function mocker and returns
+  // the newly created spec.
+  internal::TypedExpectation<F>& InternalExpectedAt(
+      const char* file, int line, const char* obj, const char* call) {
+    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
+    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
+  }
+
+ private:
+  template <typename Function>
+  friend class internal::FunctionMocker;
+
+  void SetMatchers(const ArgumentMatcherTuple& matchers) {
+    matchers_ = matchers;
+  }
+
+  // The function mocker that owns this spec.
+  internal::FunctionMockerBase<F>* const function_mocker_;
+  // The argument matchers specified in the spec.
+  ArgumentMatcherTuple matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(MockSpec);
+};  // class MockSpec
+
+// Wrapper type for generically holding an ordinary value or lvalue reference.
+// If T is not a reference type, it must be copyable or movable.
+// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
+// T is a move-only value type (which means that it will always be copyable
+// if the current platform does not support move semantics).
+//
+// The primary template defines handling for values, but function header
+// comments describe the contract for the whole template (including
+// specializations).
+template <typename T>
+class ReferenceOrValueWrapper {
+ public:
+  // Constructs a wrapper from the given value/reference.
+  explicit ReferenceOrValueWrapper(T value)
+      : value_(::testing::internal::move(value)) {
+  }
+
+  // Unwraps and returns the underlying value/reference, exactly as
+  // originally passed. The behavior of calling this more than once on
+  // the same object is unspecified.
+  T Unwrap() { return ::testing::internal::move(value_); }
+
+  // Provides nondestructive access to the underlying value/reference.
+  // Always returns a const reference (more precisely,
+  // const RemoveReference<T>&). The behavior of calling this after
+  // calling Unwrap on the same object is unspecified.
+  const T& Peek() const {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+// Specialization for lvalue reference types. See primary template
+// for documentation.
+template <typename T>
+class ReferenceOrValueWrapper<T&> {
+ public:
+  // Workaround for debatable pass-by-reference lint warning (c-library-team
+  // policy precludes NOLINT in this context)
+  typedef T& reference;
+  explicit ReferenceOrValueWrapper(reference ref)
+      : value_ptr_(&ref) {}
+  T& Unwrap() { return *value_ptr_; }
+  const T& Peek() const { return *value_ptr_; }
+
+ private:
+  T* value_ptr_;
+};
+
+// MSVC warns about using 'this' in base member initializer list, so
+// we need to temporarily disable the warning.  We have to do it for
+// the entire class to suppress the warning, even though it's about
+// the constructor only.
+
+#ifdef _MSC_VER
+# pragma warning(push)          // Saves the current warning state.
+# pragma warning(disable:4355)  // Temporarily disables warning 4355.
+#endif  // _MSV_VER
+
+// C++ treats the void type specially.  For example, you cannot define
+// a void-typed variable or pass a void value to a function.
+// ActionResultHolder<T> holds a value of type T, where T must be a
+// copyable type or void (T doesn't need to be default-constructable).
+// It hides the syntactic difference between void and other types, and
+// is used to unify the code for invoking both void-returning and
+// non-void-returning mock functions.
+
+// Untyped base class for ActionResultHolder<T>.
+class UntypedActionResultHolderBase {
+ public:
+  virtual ~UntypedActionResultHolderBase() {}
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
+};
+
+// This generic definition is used when T is not void.
+template <typename T>
+class ActionResultHolder : public UntypedActionResultHolderBase {
+ public:
+  // Returns the held value. Must not be called more than once.
+  T Unwrap() {
+    return result_.Unwrap();
+  }
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<T>::Print(result_.Peek(), os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    return new ActionResultHolder(Wrapper(
+        func_mocker->PerformDefaultAction(args, call_description)));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder*
+  PerformAction(const Action<F>& action,
+                const typename Function<F>::ArgumentTuple& args) {
+    return new ActionResultHolder(Wrapper(action.Perform(args)));
+  }
+
+ private:
+  typedef ReferenceOrValueWrapper<T> Wrapper;
+
+  explicit ActionResultHolder(Wrapper result)
+      : result_(::testing::internal::move(result)) {
+  }
+
+  Wrapper result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// Specialization for T = void.
+template <>
+class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+ public:
+  void Unwrap() { }
+
+  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
+
+  // Performs the given mock function's default action and returns ownership
+  // of an empty ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    func_mocker->PerformDefaultAction(args, call_description);
+    return new ActionResultHolder;
+  }
+
+  // Performs the given action and returns ownership of an empty
+  // ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action,
+      const typename Function<F>::ArgumentTuple& args) {
+    action.Perform(args);
+    return new ActionResultHolder;
+  }
+
+ private:
+  ActionResultHolder() {}
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// The base of the function mocker class for the given function type.
+// We put the methods in this class instead of its child to avoid code
+// bloat.
+template <typename F>
+class FunctionMockerBase : public UntypedFunctionMockerBase {
+ public:
+  typedef typename Function<F>::Result Result;
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  FunctionMockerBase() : current_spec_(this) {}
+
+  // The destructor verifies that all expectations on this mock
+  // function have been satisfied.  If not, it will report Google Test
+  // non-fatal failures for the violations.
+  virtual ~FunctionMockerBase()
+        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    MutexLock l(&g_gmock_mutex);
+    VerifyAndClearExpectationsLocked();
+    Mock::UnregisterLocked(this);
+    ClearDefaultActionsLocked();
+  }
+
+  // Returns the ON_CALL spec that matches this mock function with the
+  // given arguments; returns NULL if no matching ON_CALL is found.
+  // L = *
+  const OnCallSpec<F>* FindOnCallSpec(
+      const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it
+             = untyped_on_call_specs_.rbegin();
+         it != untyped_on_call_specs_.rend(); ++it) {
+      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
+      if (spec->Matches(args))
+        return spec;
+    }
+
+    return NULL;
+  }
+
+  // Performs the default action of this mock function on the given
+  // arguments and returns the result. Asserts (or throws if
+  // exceptions are enabled) with a helpful call descrption if there
+  // is no valid return value. This method doesn't depend on the
+  // mutable state of this object, and thus can be called concurrently
+  // without locking.
+  // L = *
+  Result PerformDefaultAction(const ArgumentTuple& args,
+                              const string& call_description) const {
+    const OnCallSpec<F>* const spec =
+        this->FindOnCallSpec(args);
+    if (spec != NULL) {
+      return spec->GetAction().Perform(args);
+    }
+    const string message = call_description +
+        "\n    The mock function has no default action "
+        "set, and its return type has no default value set.";
+#if GTEST_HAS_EXCEPTIONS
+    if (!DefaultValue<Result>::Exists()) {
+      throw std::runtime_error(message);
+    }
+#else
+    Assert(DefaultValue<Result>::Exists(), "", -1, message);
+#endif
+    return DefaultValue<Result>::Get();
+  }
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.  The caller is responsible for deleting the result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      const void* untyped_args,  // must point to an ArgumentTuple
+      const string& call_description) const {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformDefaultAction(this, args, call_description);
+  }
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.  The caller is responsible for deleting the
+  // result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, const void* untyped_args) const {
+    // Make a copy of the action before performing it, in case the
+    // action deletes the mock object (and thus deletes itself).
+    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformAction(action, args);
+  }
+
+  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
+  // clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // Deleting our default actions may trigger other mock objects to be
+    // deleted, for example if an action contains a reference counted smart
+    // pointer to that mock object, and that is the last reference. So if we
+    // delete our actions within the context of the global mutex we may deadlock
+    // when this method is called again. Instead, make a copy of the set of
+    // actions to delete, clear our set within the mutex, and then delete the
+    // actions outside of the mutex.
+    UntypedOnCallSpecs specs_to_delete;
+    untyped_on_call_specs_.swap(specs_to_delete);
+
+    g_gmock_mutex.Unlock();
+    for (UntypedOnCallSpecs::const_iterator it =
+             specs_to_delete.begin();
+         it != specs_to_delete.end(); ++it) {
+      delete static_cast<const OnCallSpec<F>*>(*it);
+    }
+
+    // Lock the mutex again, since the caller expects it to be locked when we
+    // return.
+    g_gmock_mutex.Lock();
+  }
+
+ protected:
+  template <typename Function>
+  friend class MockSpec;
+
+  typedef ActionResultHolder<Result> ResultHolder;
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.
+  Result InvokeWith(const ArgumentTuple& args)
+        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    scoped_ptr<ResultHolder> holder(
+        DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
+    return holder->Unwrap();
+  }
+
+  // Adds and returns a default action spec for this mock function.
+  OnCallSpec<F>& AddNewOnCallSpec(
+      const char* file, int line,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
+    untyped_on_call_specs_.push_back(on_call_spec);
+    return *on_call_spec;
+  }
+
+  // Adds and returns an expectation spec for this mock function.
+  TypedExpectation<F>& AddNewExpectation(
+      const char* file,
+      int line,
+      const string& source_text,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    TypedExpectation<F>* const expectation =
+        new TypedExpectation<F>(this, file, line, source_text, m);
+    const linked_ptr<ExpectationBase> untyped_expectation(expectation);
+    untyped_expectations_.push_back(untyped_expectation);
+
+    // Adds this expectation into the implicit sequence if there is one.
+    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
+    if (implicit_sequence != NULL) {
+      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
+    }
+
+    return *expectation;
+  }
+
+  // The current spec (either default action spec or expectation spec)
+  // being described on this function mocker.
+  MockSpec<F>& current_spec() { return current_spec_; }
+
+ private:
+  template <typename Func> friend class TypedExpectation;
+
+  // Some utilities needed for implementing UntypedInvokeWith().
+
+  // Describes what default action will be performed for the given
+  // arguments.
+  // L = *
+  void DescribeDefaultActionTo(const ArgumentTuple& args,
+                               ::std::ostream* os) const {
+    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
+
+    if (spec == NULL) {
+      *os << (internal::type_equals<Result, void>::value ?
+              "returning directly.\n" :
+              "returning default value.\n");
+    } else {
+      *os << "taking default action specified at:\n"
+          << FormatFileLocation(spec->file(), spec->line()) << "\n";
+    }
+  }
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    *os << "Uninteresting mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    *os << "    Function call: " << Name();
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  //
+  // Critical section: We must find the matching expectation and the
+  // corresponding action that needs to be taken in an ATOMIC
+  // transaction.  Otherwise another thread may call this mock
+  // method in the middle and mess up the state.
+  //
+  // However, performing the action has to be left out of the critical
+  // section.  The reason is that we have no control on what the
+  // action does (it can invoke an arbitrary user function or even a
+  // mock function) and excessive locking could cause a dead lock.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    MutexLock l(&g_gmock_mutex);
+    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
+    if (exp == NULL) {  // A match wasn't found.
+      this->FormatUnexpectedCallMessageLocked(args, what, why);
+      return NULL;
+    }
+
+    // This line must be done before calling GetActionForArguments(),
+    // which will increment the call count for *exp and thus affect
+    // its saturation status.
+    *is_excessive = exp->IsSaturated();
+    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
+    if (action != NULL && action->IsDoDefault())
+      action = NULL;  // Normalize "do default" to NULL.
+    *untyped_action = action;
+    return exp;
+  }
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the arguments, or NULL if no
+  // expectation matches them.
+  TypedExpectation<F>* FindMatchingExpectationLocked(
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    for (typename UntypedExpectations::const_reverse_iterator it =
+             untyped_expectations_.rbegin();
+         it != untyped_expectations_.rend(); ++it) {
+      TypedExpectation<F>* const exp =
+          static_cast<TypedExpectation<F>*>(it->get());
+      if (exp->ShouldHandleArguments(args)) {
+        return exp;
+      }
+    }
+    return NULL;
+  }
+
+  // Returns a message that the arguments don't match any expectation.
+  void FormatUnexpectedCallMessageLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* os,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    *os << "\nUnexpected mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    PrintTriedExpectationsLocked(args, why);
+  }
+
+  // Prints a list of expectations that have been tried against the
+  // current mock function call.
+  void PrintTriedExpectationsLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = static_cast<int>(untyped_expectations_.size());
+    *why << "Google Mock tried the following " << count << " "
+         << (count == 1 ? "expectation, but it didn't match" :
+             "expectations, but none matched")
+         << ":\n";
+    for (int i = 0; i < count; i++) {
+      TypedExpectation<F>* const expectation =
+          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
+      *why << "\n";
+      expectation->DescribeLocationTo(why);
+      if (count > 1) {
+        *why << "tried expectation #" << i << ": ";
+      }
+      *why << expectation->source_text() << "...\n";
+      expectation->ExplainMatchResultTo(args, why);
+      expectation->DescribeCallCountTo(why);
+    }
+  }
+
+  // The current spec (either default action spec or expectation spec)
+  // being described on this function mocker.
+  MockSpec<F> current_spec_;
+
+  // There is no generally useful and implementable semantics of
+  // copying a mock object, so copying a mock is usually a user error.
+  // Thus we disallow copying function mockers.  If the user really
+  // wants to copy a mock object, he should implement his own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
+};  // class FunctionMockerBase
+
+#ifdef _MSC_VER
+# pragma warning(pop)  // Restores the warning state.
+#endif  // _MSV_VER
+
+// Implements methods of FunctionMockerBase.
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures and
+// returns false if not.
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const string& msg);
+
+}  // namespace internal
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the MockSpec class template is
+// meant to be defined in the ::testing namespace.  The following line
+// is just a trick for working around a bug in MSVC 8.0, which cannot
+// handle it if we define MockSpec in ::testing.
+using internal::MockSpec;
+
+// Const(x) is a convenient function for obtaining a const reference
+// to x.  This is useful for setting expectations on an overloaded
+// const mock method, e.g.
+//
+//   class MockFoo : public FooInterface {
+//    public:
+//     MOCK_METHOD0(Bar, int());
+//     MOCK_CONST_METHOD0(Bar, int&());
+//   };
+//
+//   MockFoo foo;
+//   // Expects a call to non-const MockFoo::Bar().
+//   EXPECT_CALL(foo, Bar());
+//   // Expects a call to const MockFoo::Bar().
+//   EXPECT_CALL(Const(foo), Bar());
+template <typename T>
+inline const T& Const(const T& x) { return x; }
+
+// Constructs an Expectation object that references and co-owns exp.
+inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
+    : expectation_base_(exp.GetHandle().expectation_base()) {}
+
+}  // namespace testing
+
+// A separate macro is required to avoid compile errors when the name
+// of the method used in call is a result of macro expansion.
+// See CompilesWithMethodNameExpandedFromMacro tests in
+// internal/gmock-spec-builders_test.cc for more details.
+#define GMOCK_ON_CALL_IMPL_(obj, call) \
+    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
+                                                    #obj, #call)
+#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
+
+#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
+    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
+#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#if GTEST_HAS_STD_FUNCTION_
+# include <functional>
+#endif
+
+namespace testing {
+namespace internal {
+
+template <typename F>
+class FunctionMockerBase;
+
+// Note: class FunctionMocker really belongs to the ::testing
+// namespace.  However if we define it in ::testing, MSVC will
+// complain when classes in ::testing::internal declare it as a
+// friend class template.  To workaround this compiler bug, we define
+// FunctionMocker in ::testing::internal and import it into ::testing.
+template <typename F>
+class FunctionMocker;
+
+template <typename R>
+class FunctionMocker<R()> : public
+    internal::FunctionMockerBase<R()> {
+ public:
+  typedef R F();
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With() {
+    return this->current_spec();
+  }
+
+  R Invoke() {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple());
+  }
+};
+
+template <typename R, typename A1>
+class FunctionMocker<R(A1)> : public
+    internal::FunctionMockerBase<R(A1)> {
+ public:
+  typedef R F(A1);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1));
+  }
+};
+
+template <typename R, typename A1, typename A2>
+class FunctionMocker<R(A1, A2)> : public
+    internal::FunctionMockerBase<R(A1, A2)> {
+ public:
+  typedef R F(A1, A2);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class FunctionMocker<R(A1, A2, A3)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3)> {
+ public:
+  typedef R F(A1, A2, A3);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class FunctionMocker<R(A1, A2, A3, A4)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
+ public:
+  typedef R F(A1, A2, A3, A4);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
+      const Matcher<A9>& m9) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8, m9));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
+      const Matcher<A9>& m9, const Matcher<A10>& m10) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8, m9, m10));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
+      A10 a10) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+        a10));
+  }
+};
+
+}  // namespace internal
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the FunctionMocker class template
+// is meant to be defined in the ::testing namespace.  The following
+// line is just a trick for working around a bug in MSVC 8.0, which
+// cannot handle it if we define FunctionMocker in ::testing.
+using internal::FunctionMocker;
+
+// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
+// We define this as a variadic macro in case F contains unprotected
+// commas (the same reason that we use variadic macros in other places
+// in this file).
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_RESULT_(tn, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Result
+
+// The type of argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_ARG_(tn, N, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
+
+// The matcher type for argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MATCHER_(tn, N, ...) \
+    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
+
+// The variable for mocking the given method.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MOCKER_(arity, constness, Method) \
+    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      ) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 0), \
+        this_method_does_not_take_0_arguments); \
+    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method() constness { \
+    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(0, constness, Method).With(); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 1), \
+        this_method_does_not_take_1_argument); \
+    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
+    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 2), \
+        this_method_does_not_take_2_arguments); \
+    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
+    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 3), \
+        this_method_does_not_take_3_arguments); \
+    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
+    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 4), \
+        this_method_does_not_take_4_arguments); \
+    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
+    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 5), \
+        this_method_does_not_take_5_arguments); \
+    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
+    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 6), \
+        this_method_does_not_take_6_arguments); \
+    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
+    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 7), \
+        this_method_does_not_take_7_arguments); \
+    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
+    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 8), \
+        this_method_does_not_take_8_arguments); \
+    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
+    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
+      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 9), \
+        this_method_does_not_take_9_arguments); \
+    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
+        gmock_a9); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
+                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
+    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
+        gmock_a9); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
+      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \
+      GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 10), \
+        this_method_does_not_take_10_arguments); \
+    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
+        gmock_a10); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
+                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
+                     GMOCK_MATCHER_(tn, 10, \
+                         __VA_ARGS__) gmock_a10) constness { \
+    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
+        gmock_a10); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \
+      Method)
+
+#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
+
+#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T(m, ...) \
+    GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T(m, ...) \
+    GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T(m, ...) \
+    GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T(m, ...) \
+    GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T(m, ...) \
+    GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T(m, ...) \
+    GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T(m, ...) \
+    GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T(m, ...) \
+    GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T(m, ...) \
+    GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T(m, ...) \
+    GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T(m, ...) \
+    GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
+
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
+
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
+
+// A MockFunction<F> class has one mock method whose type is F.  It is
+// useful when you just want your test code to emit some messages and
+// have Google Mock verify the right messages are sent (and perhaps at
+// the right times).  For example, if you are exercising code:
+//
+//   Foo(1);
+//   Foo(2);
+//   Foo(3);
+//
+// and want to verify that Foo(1) and Foo(3) both invoke
+// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
+//
+// TEST(FooTest, InvokesBarCorrectly) {
+//   MyMock mock;
+//   MockFunction<void(string check_point_name)> check;
+//   {
+//     InSequence s;
+//
+//     EXPECT_CALL(mock, Bar("a"));
+//     EXPECT_CALL(check, Call("1"));
+//     EXPECT_CALL(check, Call("2"));
+//     EXPECT_CALL(mock, Bar("a"));
+//   }
+//   Foo(1);
+//   check.Call("1");
+//   Foo(2);
+//   check.Call("2");
+//   Foo(3);
+// }
+//
+// The expectation spec says that the first Bar("a") must happen
+// before check point "1", the second Bar("a") must happen after check
+// point "2", and nothing should happen between the two check
+// points. The explicit check points make it easy to tell which
+// Bar("a") is called by which call to Foo().
+//
+// MockFunction<F> can also be used to exercise code that accepts
+// std::function<F> callbacks. To do so, use AsStdFunction() method
+// to create std::function proxy forwarding to original object's Call.
+// Example:
+//
+// TEST(FooTest, RunsCallbackWithBarArgument) {
+//   MockFunction<int(string)> callback;
+//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
+//   Foo(callback.AsStdFunction());
+// }
+template <typename F>
+class MockFunction;
+
+template <typename R>
+class MockFunction<R()> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD0_T(Call, R());
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R()> AsStdFunction() {
+    return [this]() -> R {
+      return this->Call();
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0>
+class MockFunction<R(A0)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD1_T(Call, R(A0));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0)> AsStdFunction() {
+    return [this](A0 a0) -> R {
+      return this->Call(a0);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1>
+class MockFunction<R(A0, A1)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD2_T(Call, R(A0, A1));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1)> AsStdFunction() {
+    return [this](A0 a0, A1 a1) -> R {
+      return this->Call(a0, a1);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2>
+class MockFunction<R(A0, A1, A2)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD3_T(Call, R(A0, A1, A2));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2) -> R {
+      return this->Call(a0, a1, a2);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3>
+class MockFunction<R(A0, A1, A2, A3)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
+      return this->Call(a0, a1, a2, a3);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4>
+class MockFunction<R(A0, A1, A2, A3, A4)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
+      return this->Call(a0, a1, a2, a3, a4);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
+        A8 a8) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
+        A8 a8, A9 a9) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+// This file was GENERATED by command:
+//     pump.py gmock-generated-nice-strict.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Implements class templates NiceMock, NaggyMock, and StrictMock.
+//
+// Given a mock class MockFoo that is created using Google Mock,
+// NiceMock<MockFoo> is a subclass of MockFoo that allows
+// uninteresting calls (i.e. calls to mock methods that have no
+// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
+// that prints a warning when an uninteresting call occurs, and
+// StrictMock<MockFoo> is a subclass of MockFoo that treats all
+// uninteresting calls as errors.
+//
+// Currently a mock is naggy by default, so MockFoo and
+// NaggyMock<MockFoo> behave like the same.  However, we will soon
+// switch the default behavior of mocks to be nice, as that in general
+// leads to more maintainable tests.  When that happens, MockFoo will
+// stop behaving like NaggyMock<MockFoo> and start behaving like
+// NiceMock<MockFoo>.
+//
+// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
+// their respective base class, with up-to 10 arguments.  Therefore
+// you can write NiceMock<MockFoo>(5, "a") to construct a nice mock
+// where MockFoo has a constructor that accepts (int, const char*),
+// for example.
+//
+// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
+// and StrictMock<MockFoo> only works for mock methods defined using
+// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
+// If a mock method is defined in a base class of MockFoo, the "nice"
+// or "strict" modifier may not affect it, depending on the compiler.
+// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
+// supported.
+//
+// Another known limitation is that the constructors of the base mock
+// cannot have arguments passed by non-const reference, which are
+// banned by the Google C++ style guide anyway.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+
+
+namespace testing {
+
+template <class MockClass>
+class NiceMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  NiceMock() {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit NiceMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~NiceMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+};
+
+template <class MockClass>
+class NaggyMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  NaggyMock() {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit NaggyMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~NaggyMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+};
+
+template <class MockClass>
+class StrictMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  StrictMock() {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit StrictMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~StrictMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+};
+
+// The following specializations catch some (relatively more common)
+// user errors of nesting nice and strict mocks.  They do NOT catch
+// all possible errors.
+
+// These specializations are declared but not defined, as NiceMock,
+// NaggyMock, and StrictMock cannot be nested.
+
+template <typename MockClass>
+class NiceMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class NaggyMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class StrictMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<StrictMock<MockClass> >;
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+// This file was GENERATED by command:
+//     pump.py gmock-generated-matchers.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic matchers.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace testing {
+namespace internal {
+
+// The type of the i-th (0-based) field of Tuple.
+#define GMOCK_FIELD_TYPE_(Tuple, i) \
+    typename ::testing::tuple_element<i, Tuple>::type
+
+// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
+// tuple of type Tuple.  It has two members:
+//
+//   type: a tuple type whose i-th field is the ki-th field of Tuple.
+//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
+//
+// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
+//
+//   type is tuple<int, bool>, and
+//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
+
+template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1>
+class TupleFields;
+
+// This generic version is used when there are 10 selectors.
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7, int k8, int k9>
+class TupleFields {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
+      GMOCK_FIELD_TYPE_(Tuple, k9)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
+  }
+};
+
+// The following specialization is used for 0 ~ 9 selectors.
+
+template <class Tuple>
+class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<> type;
+  static type GetSelectedFields(const Tuple& /* t */) {
+    return type();
+  }
+};
+
+template <class Tuple, int k0>
+class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1>
+class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2>
+class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3>
+class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7, int k8>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
+  }
+};
+
+#undef GMOCK_FIELD_TYPE_
+
+// Implements the Args() matcher.
+template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  // ArgsTuple may have top-level const or reference modifiers.
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
+  typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
+      k6, k7, k8, k9>::type SelectedArgs;
+  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  virtual bool MatchAndExplain(ArgsTuple args,
+                               MatchResultListener* listener) const {
+    const SelectedArgs& selected_args = GetSelectedArgs(args);
+    if (!listener->IsInterested())
+      return inner_matcher_.Matches(selected_args);
+
+    PrintIndices(listener->stream());
+    *listener << "are " << PrintToString(selected_args);
+
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(selected_args,
+                                                      &inner_listener);
+    PrintIfNotEmpty(inner_listener.str(), listener->stream());
+    return match;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
+    return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
+        k9>::GetSelectedFields(args);
+  }
+
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
+    for (int i = 0; i < 10; i++) {
+      if (indices[i] < 0)
+        break;
+
+      if (i >= 1)
+        *os << ", ";
+
+      *os << "#" << indices[i];
+    }
+    *os << ") ";
+  }
+
+  const MonomorphicInnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
+};
+
+template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
+    int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
+    int k8 = -1, int k9 = -1>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
+      : inner_matcher_(inner_matcher) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
+        k6, k7, k8, k9>(inner_matcher_));
+  }
+
+ private:
+  const InnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
+};
+
+// A set of metafunctions for computing the result type of AllOf.
+// AllOf(m1, ..., mN) returns
+// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AllOf isn't defined for one argument, AllOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AllOfResult1 {
+  typedef M1 type;
+};
+
+template <typename M1, typename M2>
+struct AllOfResult2 {
+  typedef BothOfMatcher<
+      typename AllOfResult1<M1>::type,
+      typename AllOfResult1<M2>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3>
+struct AllOfResult3 {
+  typedef BothOfMatcher<
+      typename AllOfResult1<M1>::type,
+      typename AllOfResult2<M2, M3>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4>
+struct AllOfResult4 {
+  typedef BothOfMatcher<
+      typename AllOfResult2<M1, M2>::type,
+      typename AllOfResult2<M3, M4>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+struct AllOfResult5 {
+  typedef BothOfMatcher<
+      typename AllOfResult2<M1, M2>::type,
+      typename AllOfResult3<M3, M4, M5>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+struct AllOfResult6 {
+  typedef BothOfMatcher<
+      typename AllOfResult3<M1, M2, M3>::type,
+      typename AllOfResult3<M4, M5, M6>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+struct AllOfResult7 {
+  typedef BothOfMatcher<
+      typename AllOfResult3<M1, M2, M3>::type,
+      typename AllOfResult4<M4, M5, M6, M7>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+struct AllOfResult8 {
+  typedef BothOfMatcher<
+      typename AllOfResult4<M1, M2, M3, M4>::type,
+      typename AllOfResult4<M5, M6, M7, M8>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+struct AllOfResult9 {
+  typedef BothOfMatcher<
+      typename AllOfResult4<M1, M2, M3, M4>::type,
+      typename AllOfResult5<M5, M6, M7, M8, M9>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+struct AllOfResult10 {
+  typedef BothOfMatcher<
+      typename AllOfResult5<M1, M2, M3, M4, M5>::type,
+      typename AllOfResult5<M6, M7, M8, M9, M10>::type
+  > type;
+};
+
+// A set of metafunctions for computing the result type of AnyOf.
+// AnyOf(m1, ..., mN) returns
+// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AnyOfResult1 {
+  typedef M1 type;
+};
+
+template <typename M1, typename M2>
+struct AnyOfResult2 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult1<M1>::type,
+      typename AnyOfResult1<M2>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3>
+struct AnyOfResult3 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult1<M1>::type,
+      typename AnyOfResult2<M2, M3>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4>
+struct AnyOfResult4 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult2<M1, M2>::type,
+      typename AnyOfResult2<M3, M4>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+struct AnyOfResult5 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult2<M1, M2>::type,
+      typename AnyOfResult3<M3, M4, M5>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+struct AnyOfResult6 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult3<M1, M2, M3>::type,
+      typename AnyOfResult3<M4, M5, M6>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+struct AnyOfResult7 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult3<M1, M2, M3>::type,
+      typename AnyOfResult4<M4, M5, M6, M7>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+struct AnyOfResult8 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult4<M1, M2, M3, M4>::type,
+      typename AnyOfResult4<M5, M6, M7, M8>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+struct AnyOfResult9 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult4<M1, M2, M3, M4>::type,
+      typename AnyOfResult5<M5, M6, M7, M8, M9>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+struct AnyOfResult10 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
+      typename AnyOfResult5<M6, M7, M8, M9, M10>::type
+  > type;
+};
+
+}  // namespace internal
+
+// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
+// fields of it matches a_matcher.  C++ doesn't support default
+// arguments for function templates, so we have to overload it.
+template <typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher>(matcher);
+}
+
+template <int k1, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
+}
+
+template <int k1, int k2, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
+}
+
+template <int k1, int k2, int k3, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
+    typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
+      k7>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
+      k8>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, int k10, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
+    k10>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9, k10>(matcher);
+}
+
+// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
+// n elements, where the i-th element in the container must
+// match the i-th argument in the list.  Each argument of
+// ElementsAre() can be either a value or a matcher.  We support up to
+// 10 arguments.
+//
+// The use of DecayArray in the implementation allows ElementsAre()
+// to accept string literals, whose type is const char[N], but we
+// want to treat them as const char*.
+//
+// NOTE: Since ElementsAre() cares about the order of the elements, it
+// must not be used with containers whose elements's order is
+// undefined (e.g. hash_map).
+
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<> >
+ElementsAre() {
+  typedef ::testing::tuple<> Args;
+  return internal::ElementsAreMatcher<Args>(Args());
+}
+
+template <typename T1>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type> >
+ElementsAre(const T1& e1) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1));
+}
+
+template <typename T1, typename T2>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type> >
+ElementsAre(const T1& e1, const T2& e2) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2));
+}
+
+template <typename T1, typename T2, typename T3>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8, e9));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type,
+        typename internal::DecayArray<T10>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
+    const T10& e10) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type,
+      typename internal::DecayArray<T10>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8, e9, e10));
+}
+
+// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
+// that matches n elements in any order.  We support up to n=10 arguments.
+
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<> >
+UnorderedElementsAre() {
+  typedef ::testing::tuple<> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args());
+}
+
+template <typename T1>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type> >
+UnorderedElementsAre(const T1& e1) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
+}
+
+template <typename T1, typename T2>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
+}
+
+template <typename T1, typename T2, typename T3>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8, e9));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type,
+        typename internal::DecayArray<T10>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
+    const T10& e10) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type,
+      typename internal::DecayArray<T10>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8, e9, e10));
+}
+
+// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
+// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
+
+template <typename M1, typename M2>
+inline typename internal::AllOfResult2<M1, M2>::type
+AllOf(M1 m1, M2 m2) {
+  return typename internal::AllOfResult2<M1, M2>::type(
+      m1,
+      m2);
+}
+
+template <typename M1, typename M2, typename M3>
+inline typename internal::AllOfResult3<M1, M2, M3>::type
+AllOf(M1 m1, M2 m2, M3 m3) {
+  return typename internal::AllOfResult3<M1, M2, M3>::type(
+      m1,
+      ::testing::AllOf(m2, m3));
+}
+
+template <typename M1, typename M2, typename M3, typename M4>
+inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
+  return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
+      ::testing::AllOf(m1, m2),
+      ::testing::AllOf(m3, m4));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
+  return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
+      ::testing::AllOf(m1, m2),
+      ::testing::AllOf(m3, m4, m5));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
+  return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
+      ::testing::AllOf(m1, m2, m3),
+      ::testing::AllOf(m4, m5, m6));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
+  return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
+      ::testing::AllOf(m1, m2, m3),
+      ::testing::AllOf(m4, m5, m6, m7));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
+  return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
+      ::testing::AllOf(m1, m2, m3, m4),
+      ::testing::AllOf(m5, m6, m7, m8));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
+  return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
+      M9>::type(
+      ::testing::AllOf(m1, m2, m3, m4),
+      ::testing::AllOf(m5, m6, m7, m8, m9));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+    M10>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
+  return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+      M10>::type(
+      ::testing::AllOf(m1, m2, m3, m4, m5),
+      ::testing::AllOf(m6, m7, m8, m9, m10));
+}
+
+// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
+// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
+
+template <typename M1, typename M2>
+inline typename internal::AnyOfResult2<M1, M2>::type
+AnyOf(M1 m1, M2 m2) {
+  return typename internal::AnyOfResult2<M1, M2>::type(
+      m1,
+      m2);
+}
+
+template <typename M1, typename M2, typename M3>
+inline typename internal::AnyOfResult3<M1, M2, M3>::type
+AnyOf(M1 m1, M2 m2, M3 m3) {
+  return typename internal::AnyOfResult3<M1, M2, M3>::type(
+      m1,
+      ::testing::AnyOf(m2, m3));
+}
+
+template <typename M1, typename M2, typename M3, typename M4>
+inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
+  return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
+      ::testing::AnyOf(m1, m2),
+      ::testing::AnyOf(m3, m4));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
+  return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
+      ::testing::AnyOf(m1, m2),
+      ::testing::AnyOf(m3, m4, m5));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
+  return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
+      ::testing::AnyOf(m1, m2, m3),
+      ::testing::AnyOf(m4, m5, m6));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
+  return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
+      ::testing::AnyOf(m1, m2, m3),
+      ::testing::AnyOf(m4, m5, m6, m7));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
+  return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
+      ::testing::AnyOf(m1, m2, m3, m4),
+      ::testing::AnyOf(m5, m6, m7, m8));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
+  return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
+      M9>::type(
+      ::testing::AnyOf(m1, m2, m3, m4),
+      ::testing::AnyOf(m5, m6, m7, m8, m9));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+    M10>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
+  return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+      M10>::type(
+      ::testing::AnyOf(m1, m2, m3, m4, m5),
+      ::testing::AnyOf(m6, m7, m8, m9, m10));
+}
+
+}  // namespace testing
+
+
+// The MATCHER* family of macros can be used in a namespace scope to
+// define custom matchers easily.
+//
+// Basic Usage
+// ===========
+//
+// The syntax
+//
+//   MATCHER(name, description_string) { statements; }
+//
+// defines a matcher with the given name that executes the statements,
+// which must return a bool to indicate if the match succeeds.  Inside
+// the statements, you can refer to the value being matched by 'arg',
+// and refer to its type by 'arg_type'.
+//
+// The description string documents what the matcher does, and is used
+// to generate the failure message when the match fails.  Since a
+// MATCHER() is usually defined in a header file shared by multiple
+// C++ source files, we require the description to be a C-string
+// literal to avoid possible side effects.  It can be empty, in which
+// case we'll use the sequence of words in the matcher name as the
+// description.
+//
+// For example:
+//
+//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
+//
+// allows you to write
+//
+//   // Expects mock_foo.Bar(n) to be called where n is even.
+//   EXPECT_CALL(mock_foo, Bar(IsEven()));
+//
+// or,
+//
+//   // Verifies that the value of some_expression is even.
+//   EXPECT_THAT(some_expression, IsEven());
+//
+// If the above assertion fails, it will print something like:
+//
+//   Value of: some_expression
+//   Expected: is even
+//     Actual: 7
+//
+// where the description "is even" is automatically calculated from the
+// matcher name IsEven.
+//
+// Argument Type
+// =============
+//
+// Note that the type of the value being matched (arg_type) is
+// determined by the context in which you use the matcher and is
+// supplied to you by the compiler, so you don't need to worry about
+// declaring it (nor can you).  This allows the matcher to be
+// polymorphic.  For example, IsEven() can be used to match any type
+// where the value of "(arg % 2) == 0" can be implicitly converted to
+// a bool.  In the "Bar(IsEven())" example above, if method Bar()
+// takes an int, 'arg_type' will be int; if it takes an unsigned long,
+// 'arg_type' will be unsigned long; and so on.
+//
+// Parameterizing Matchers
+// =======================
+//
+// Sometimes you'll want to parameterize the matcher.  For that you
+// can use another macro:
+//
+//   MATCHER_P(name, param_name, description_string) { statements; }
+//
+// For example:
+//
+//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
+//
+// will allow you to write:
+//
+//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
+//
+// which may lead to this message (assuming n is 10):
+//
+//   Value of: Blah("a")
+//   Expected: has absolute value 10
+//     Actual: -9
+//
+// Note that both the matcher description and its parameter are
+// printed, making the message human-friendly.
+//
+// In the matcher definition body, you can write 'foo_type' to
+// reference the type of a parameter named 'foo'.  For example, in the
+// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
+// 'value_type' to refer to the type of 'value'.
+//
+// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to
+// support multi-parameter matchers.
+//
+// Describing Parameterized Matchers
+// =================================
+//
+// The last argument to MATCHER*() is a string-typed expression.  The
+// expression can reference all of the matcher's parameters and a
+// special bool-typed variable named 'negation'.  When 'negation' is
+// false, the expression should evaluate to the matcher's description;
+// otherwise it should evaluate to the description of the negation of
+// the matcher.  For example,
+//
+//   using testing::PrintToString;
+//
+//   MATCHER_P2(InClosedRange, low, hi,
+//       string(negation ? "is not" : "is") + " in range [" +
+//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
+//     return low <= arg && arg <= hi;
+//   }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: is in range [4, 6]
+//   ...
+//   Expected: is not in range [2, 4]
+//
+// If you specify "" as the description, the failure message will
+// contain the sequence of words in the matcher name followed by the
+// parameter values printed as a tuple.  For example,
+//
+//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: in closed range (4, 6)
+//   ...
+//   Expected: not (in closed range (2, 4))
+//
+// Types of Matcher Parameters
+// ===========================
+//
+// For the purpose of typing, you can view
+//
+//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooMatcherPk<p1_type, ..., pk_type>
+//   Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// When you write Foo(v1, ..., vk), the compiler infers the types of
+// the parameters v1, ..., and vk for you.  If you are not happy with
+// the result of the type inference, you can specify the types by
+// explicitly instantiating the template, as in Foo<long, bool>(5,
+// false).  As said earlier, you don't get to (or need to) specify
+// 'arg_type' as that's determined by the context in which the matcher
+// is used.  You can assign the result of expression Foo(p1, ..., pk)
+// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
+// can be useful when composing matchers.
+//
+// While you can instantiate a matcher template with reference types,
+// passing the parameters by pointer usually makes your code more
+// readable.  If, however, you still want to pass a parameter by
+// reference, be aware that in the failure message generated by the
+// matcher you will see the value of the referenced object but not its
+// address.
+//
+// Explaining Match Results
+// ========================
+//
+// Sometimes the matcher description alone isn't enough to explain why
+// the match has failed or succeeded.  For example, when expecting a
+// long string, it can be very helpful to also print the diff between
+// the expected string and the actual one.  To achieve that, you can
+// optionally stream additional information to a special variable
+// named result_listener, whose type is a pointer to class
+// MatchResultListener:
+//
+//   MATCHER_P(EqualsLongString, str, "") {
+//     if (arg == str) return true;
+//
+//     *result_listener << "the difference: "
+///                     << DiffStrings(str, arg);
+//     return false;
+//   }
+//
+// Overloading Matchers
+// ====================
+//
+// You can overload matchers with different numbers of parameters:
+//
+//   MATCHER_P(Blah, a, description_string1) { ... }
+//   MATCHER_P2(Blah, a, b, description_string2) { ... }
+//
+// Caveats
+// =======
+//
+// When defining a new matcher, you should also consider implementing
+// MatcherInterface or using MakePolymorphicMatcher().  These
+// approaches require more work than the MATCHER* macros, but also
+// give you more control on the types of the value being matched and
+// the matcher parameters, which may leads to better compiler error
+// messages when the matcher is used wrong.  They also allow
+// overloading matchers based on parameter types (as opposed to just
+// based on the number of parameters).
+//
+// MATCHER*() can only be used in a namespace scope.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using MATCHER*() inside
+// a function.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+#define MATCHER(name, description)\
+  class name##Matcher {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl()\
+           {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<>()));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>());\
+    }\
+    name##Matcher() {\
+    }\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
+  };\
+  inline name##Matcher name() {\
+    return name##Matcher();\
+  }\
+  template <typename arg_type>\
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P(name, p0, description)\
+  template <typename p0##_type>\
+  class name##MatcherP {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      explicit gmock_Impl(p0##_type gmock_p0)\
+           : p0(gmock_p0) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type>(p0)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0));\
+    }\
+    explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
+    }\
+    p0##_type p0;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
+  };\
+  template <typename p0##_type>\
+  inline name##MatcherP<p0##_type> name(p0##_type p0) {\
+    return name##MatcherP<p0##_type>(p0);\
+  }\
+  template <typename p0##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P2(name, p0, p1, description)\
+  template <typename p0##_type, typename p1##_type>\
+  class name##MatcherP2 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
+           : p0(gmock_p0), p1(gmock_p1) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1));\
+    }\
+    name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+        p1(gmock_p1) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
+  };\
+  template <typename p0##_type, typename p1##_type>\
+  inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
+      p1##_type p1) {\
+    return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
+  }\
+  template <typename p0##_type, typename p1##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP2<p0##_type, \
+      p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P3(name, p0, p1, p2, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  class name##MatcherP3 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
+                    p2)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2));\
+    }\
+    name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2) {\
+    return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP3<p0##_type, p1##_type, \
+      p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P4(name, p0, p1, p2, p3, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  class name##MatcherP4 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, \
+                    p3##_type>(p0, p1, p2, p3)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3));\
+    }\
+    name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3) {\
+    return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
+        p1, p2, p3);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  class name##MatcherP5 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type>(p0, p1, p2, p3, p4)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
+    }\
+    name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, \
+        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4) {\
+    return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type>(p0, p1, p2, p3, p4);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  class name##MatcherP6 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
+    }\
+    name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3, p4##_type p4, p5##_type p5) {\
+    return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  class name##MatcherP7 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
+                    p6)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
+    }\
+    name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
+        p6(gmock_p6) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
+      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6) {\
+    return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  class name##MatcherP8 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
+                    p3, p4, p5, p6, p7)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
+    }\
+    name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, \
+        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6, p7##_type p7) {\
+    return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
+        p6, p7);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type, \
+      p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  class name##MatcherP9 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+               p8(gmock_p8) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+      p8##_type p8;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type, \
+                    p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
+    }\
+    name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+    p8##_type p8;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, \
+      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
+      p8##_type p8) {\
+    return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
+        p3, p4, p5, p6, p7, p8);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type, p7##_type, \
+      p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  class name##MatcherP10 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+          p9##_type gmock_p9)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+               p8(gmock_p8), p9(gmock_p9) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+      p8##_type p8;\
+      p9##_type p9;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+                    p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
+    }\
+    name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+    p7##_type p7;\
+    p8##_type p8;\
+    p9##_type p9;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+      p9##_type p9) {\
+    return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
+        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type, typename p8##_type, \
+      typename p9##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some actions that depend on gmock-generated-actions.h.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+
+#include <algorithm>
+
+
+namespace testing {
+namespace internal {
+
+// Implements the Invoke(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  Invoke(f) can be used as an
+// Action<F> as long as f's type is compatible with F (i.e. f can be
+// assigned to a tr1::function<F>).
+template <typename FunctionImpl>
+class InvokeAction {
+ public:
+  // The c'tor makes a copy of function_impl (either a function
+  // pointer or a functor).
+  explicit InvokeAction(FunctionImpl function_impl)
+      : function_impl_(function_impl) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) {
+    return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
+  }
+
+ private:
+  FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeAction);
+};
+
+// Implements the Invoke(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+class InvokeMethodAction {
+ public:
+  InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
+      : method_ptr_(method_ptr), obj_ptr_(obj_ptr) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
+        obj_ptr_, method_ptr_, args);
+  }
+
+ private:
+  // The order of these members matters.  Reversing the order can trigger
+  // warning C4121 in MSVC (see
+  // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm ).
+  const MethodPtr method_ptr_;
+  Class* const obj_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
+};
+
+// An internal replacement for std::copy which mimics its behavior. This is
+// necessary because Visual Studio deprecates ::std::copy, issuing warning 4996.
+// However Visual Studio 2010 and later do not honor #pragmas which disable that
+// warning.
+template<typename InputIterator, typename OutputIterator>
+inline OutputIterator CopyElements(InputIterator first,
+                                   InputIterator last,
+                                   OutputIterator output) {
+  for (; first != last; ++first, ++output) {
+    *output = *first;
+  }
+  return output;
+}
+
+}  // namespace internal
+
+// Various overloads for Invoke().
+
+// Creates an action that invokes 'function_impl' with the mock
+// function's arguments.
+template <typename FunctionImpl>
+PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
+    FunctionImpl function_impl) {
+  return MakePolymorphicAction(
+      internal::InvokeAction<FunctionImpl>(function_impl));
+}
+
+// Creates an action that invokes the given method on the given object
+// with the mock function's arguments.
+template <class Class, typename MethodPtr>
+PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
+    Class* obj_ptr, MethodPtr method_ptr) {
+  return MakePolymorphicAction(
+      internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
+}
+
+// WithoutArgs(inner_action) can be used in a mock function with a
+// non-empty argument list to perform inner_action, which takes no
+// argument.  In other words, it adapts an action accepting no
+// argument to one that accepts (and ignores) arguments.
+template <typename InnerAction>
+inline internal::WithArgsAction<InnerAction>
+WithoutArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction>(action);
+}
+
+// WithArg<k>(an_action) creates an action that passes the k-th
+// (0-based) argument of the mock function to an_action and performs
+// it.  It adapts an action accepting one argument to one that accepts
+// multiple arguments.  For convenience, we also provide
+// WithArgs<k>(an_action) (defined below) as a synonym.
+template <int k, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k>
+WithArg(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k>(action);
+}
+
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Action ReturnArg<k>() returns the k-th argument of the mock function.
+ACTION_TEMPLATE(ReturnArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  return ::testing::get<k>(args);
+}
+
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
+// mock function to *pointer.
+ACTION_TEMPLATE(SaveArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = ::testing::get<k>(args);
+}
+
+// Action SaveArgPointee<k>(pointer) saves the value pointed to
+// by the k-th (0-based) argument of the mock function to *pointer.
+ACTION_TEMPLATE(SaveArgPointee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = *::testing::get<k>(args);
+}
+
+// Action SetArgReferee<k>(value) assigns 'value' to the variable
+// referenced by the k-th (0-based) argument of the mock function.
+ACTION_TEMPLATE(SetArgReferee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(value)) {
+  typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
+  // Ensures that argument #k is a reference.  If you get a compiler
+  // error on the next line, you are using SetArgReferee<k>(value) in
+  // a mock function whose k-th (0-based) argument is not a reference.
+  GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+                        SetArgReferee_must_be_used_with_a_reference_argument);
+  ::testing::get<k>(args) = value;
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+ACTION_TEMPLATE(SetArrayArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(first, last)) {
+  // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
+#ifdef _MSC_VER
+  internal::CopyElements(first, last, ::testing::get<k>(args));
+#else
+  ::std::copy(first, last, ::testing::get<k>(args));
+#endif
+}
+
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
+// function.
+ACTION_TEMPLATE(DeleteArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  delete ::testing::get<k>(args);
+}
+
+// This action returns the value pointed to by 'pointer'.
+ACTION_P(ReturnPointee, pointer) { return *pointer; }
+
+// Action Throw(exception) can be used in a mock function of any type
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
+
+// Suppresses the 'unreachable code' warning that VC generates in opt modes.
+# ifdef _MSC_VER
+#  pragma warning(push)          // Saves the current warning state.
+#  pragma warning(disable:4702)  // Temporarily disables warning 4702.
+# endif
+ACTION_P(Throw, exception) { throw exception; }
+# ifdef _MSC_VER
+#  pragma warning(pop)           // Restores the warning state.
+# endif
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+// Copyright 2013, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: marcus.boerger@google.com (Marcus Boerger)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some matchers that depend on gmock-generated-matchers.h.
+//
+// Note that tests are implemented in gmock-matchers_test.cc rather than
+// gmock-more-matchers-test.cc.
+
+#ifndef GMOCK_GMOCK_MORE_MATCHERS_H_
+#define GMOCK_GMOCK_MORE_MATCHERS_H_
+
+
+namespace testing {
+
+// Defines a matcher that matches an empty container. The container must
+// support both size() and empty(), which all STL-like containers provide.
+MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
+  if (arg.empty()) {
+    return true;
+  }
+  *result_listener << "whose size is " << arg.size();
+  return false;
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_GMOCK_MORE_MATCHERS_H_
+
+namespace testing {
+
+// Declares Google Mock flags that we want a user to use programmatically.
+GMOCK_DECLARE_bool_(catch_leaked_mocks);
+GMOCK_DECLARE_string_(verbose);
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses the command line for the flags
+// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
+// it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/opensfm/src/third_party/gtest/gmock/mock-log.h b/opensfm/src/third_party/gtest/gmock/mock-log.h
new file mode 100644
index 000000000..bce54ab5e
--- /dev/null
+++ b/opensfm/src/third_party/gtest/gmock/mock-log.h
@@ -0,0 +1,160 @@
+// Copyright (c) 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: Zhanyong Wan
+//
+// Defines the ScopedMockLog class (using Google C++ Mocking
+// Framework), which is convenient for testing code that uses LOG().
+//
+// NOTE(keir): This is a fork until Google Log exports the scoped mock log
+// class; see: http://code.google.com/p/google-glog/issues/detail?id=88
+
+#ifndef GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
+#define GOOGLE_CERES_INTERNAL_MOCK_LOG_H_
+
+#include <string>
+
+#include <gmock/gmock.h>
+
+#include "glog/logging.h"
+
+// Needed to make the scoped mock log tests work without modification.
+namespace ceres {
+namespace internal {
+using google::WARNING;
+}  // namespace internal
+}  // namespace ceres
+
+namespace testing {
+
+// A ScopedMockLog object intercepts LOG() messages issued during its
+// lifespan.  Using this together with Google C++ Mocking Framework,
+// it's very easy to test how a piece of code calls LOG().  The
+// typical usage:
+//
+//   TEST(FooTest, LogsCorrectly) {
+//     ScopedMockLog log;
+//
+//     // We expect the WARNING "Something bad!" exactly twice.
+//     EXPECT_CALL(log, Log(WARNING, _, "Something bad!"))
+//         .Times(2);
+//
+//     // We allow foo.cc to call LOG(INFO) any number of times.
+//     EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _))
+//         .Times(AnyNumber());
+//
+//     Foo();  // Exercises the code under test.
+//   }
+class ScopedMockLog : public google::LogSink {
+ public:
+  // When a ScopedMockLog object is constructed, it starts to
+  // intercept logs.
+  ScopedMockLog() { AddLogSink(this); }
+
+  // When the object is destructed, it stops intercepting logs.
+  virtual ~ScopedMockLog() { RemoveLogSink(this); }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity, const string& file_path,
+  //            const string& message);
+  //
+  // The second argument to Send() is the full path of the source file
+  // in which the LOG() was issued.
+  //
+  // Note, that in a multi-threaded environment, all LOG() messages from a
+  // single thread will be handled in sequence, but that cannot be guaranteed
+  // for messages from different threads. In fact, if the same or multiple
+  // expectations are matched on two threads concurrently, their actions will
+  // be executed concurrently as well and may interleave.
+  MOCK_METHOD3(Log, void(google::LogSeverity severity,
+                         const std::string& file_path,
+                         const std::string& message));
+
+ private:
+  // Implements the send() virtual function in class LogSink.
+  // Whenever a LOG() statement is executed, this function will be
+  // invoked with information presented in the LOG().
+  //
+  // The method argument list is long and carries much information a
+  // test usually doesn't care about, so we trim the list before
+  // forwarding the call to Log(), which is much easier to use in
+  // tests.
+  //
+  // We still cannot call Log() directly, as it may invoke other LOG()
+  // messages, either due to Invoke, or due to an error logged in
+  // Google C++ Mocking Framework code, which would trigger a deadlock
+  // since a lock is held during send().
+  //
+  // Hence, we save the message for WaitTillSent() which will be called after
+  // the lock on send() is released, and we'll call Log() inside
+  // WaitTillSent(). Since while a single send() call may be running at a
+  // time, multiple WaitTillSent() calls (along with the one send() call) may
+  // be running simultaneously, we ensure thread-safety of the exchange between
+  // send() and WaitTillSent(), and that for each message, LOG(), send(),
+  // WaitTillSent() and Log() are executed in the same thread.
+  virtual void send(google::LogSeverity severity,
+                    const char* full_filename,
+                    const char* base_filename, int line, const tm* tm_time,
+                    const char* message, size_t message_len) {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    message_info_.severity = severity;
+    message_info_.file_path = full_filename;
+    message_info_.message = std::string(message, message_len);
+  }
+
+  // Implements the WaitTillSent() virtual function in class LogSink.
+  // It will be executed after send() and after the global logging lock is
+  // released, so calls within it (or rather within the Log() method called
+  // within) may also issue LOG() statements.
+  //
+  // LOG(), send(), WaitTillSent() and Log() will occur in the same thread for
+  // a given log message.
+  virtual void WaitTillSent() {
+    // First, and very importantly, we save a copy of the message being
+    // processed before calling Log(), since Log() may indirectly call send()
+    // and WaitTillSent() in the same thread again.
+    MessageInfo message_info = message_info_;
+    Log(message_info.severity, message_info.file_path, message_info.message);
+  }
+
+  // All relevant information about a logged message that needs to be passed
+  // from send() to WaitTillSent().
+  struct MessageInfo {
+    google::LogSeverity severity;
+    std::string file_path;
+    std::string message;
+  };
+  MessageInfo message_info_;
+};
+
+}  // namespace testing
+
+#endif  // GOOGLE_CERES_INTERNAL_MOCK_LOG_H_

From aa521cb1a2ebec020d1f74574aa39ea267603871 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Fri, 11 Apr 2025 01:35:33 -0700
Subject: [PATCH 114/235] Back out
 "fbcode/mapillary/opensfm/opensfm/src/third_party/gtest/gtest"

Summary:
Original commit changeset: 572499517f09

Original Phabricator Diff: D63970634

Reviewed By: bal-a

Differential Revision: D72844842

fbshipit-source-id: 3cbf302694180e0d650aa30d9ec42989270863f8
---
 opensfm/src/third_party/gtest/gtest/gtest.h | 21201 ++++++++++++++++++
 1 file changed, 21201 insertions(+)
 create mode 100644 opensfm/src/third_party/gtest/gtest/gtest.h

diff --git a/opensfm/src/third_party/gtest/gtest/gtest.h b/opensfm/src/third_party/gtest/gtest/gtest.h
new file mode 100644
index 000000000..e6a9600be
--- /dev/null
+++ b/opensfm/src/third_party/gtest/gtest/gtest.h
@@ -0,0 +1,21201 @@
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_H_
+
+#include <limits>
+#include <ostream>
+#include <vector>
+
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: wan@google.com (Zhanyong Wan)
+//
+// Low-level types and utilities for porting Google Test to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Test's public API and can be used by
+// code outside Google Test.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// Environment-describing macros
+// -----------------------------
+//
+// Google Test can be used in many different environments.  Macros in
+// this section tell Google Test what kind of environment it is being
+// used in, such that Google Test can provide environment-specific
+// features and implementations.
+//
+// Google Test tries to automatically detect the properties of its
+// environment, so users usually don't need to worry about these
+// macros.  However, the automatic detection is not perfect.
+// Sometimes it's necessary for a user to define some of the following
+// macros in the build script to override Google Test's decisions.
+//
+// If the user doesn't define a macro in the list, Google Test will
+// provide a default definition.  After this header is #included, all
+// macros in this list will be defined to either 1 or 0.
+//
+// Notes to maintainers:
+//   - Each macro here is a user-tweakable knob; do not grow the list
+//     lightly.
+//   - Use #if to key off these macros.  Don't use #ifdef or "#if
+//     defined(...)", which will not work as these macros are ALWAYS
+//     defined.
+//
+//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
+//                              is/isn't available.
+//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
+//                              are enabled.
+//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::string, which is different to std::string).
+//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::wstring, which is different to std::wstring).
+//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
+//                              expressions are/aren't available.
+//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
+//                              is/isn't available.
+//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
+//                              enabled.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
+//                              is/isn't available.
+//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
+//                              compiler supports Microsoft's "Structured
+//                              Exception Handling".
+//   GTEST_HAS_STREAM_REDIRECTION
+//                            - Define it to 1/0 to indicate whether the
+//                              platform supports I/O stream redirection using
+//                              dup() and dup2().
+//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
+//                              Test's own tr1 tuple implementation should be
+//                              used.  Unused when the user sets
+//                              GTEST_HAS_TR1_TUPLE to 0.
+//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
+//                              is building in C++11/C++98 mode.
+//   GTEST_LINKED_AS_SHARED_LIBRARY
+//                            - Define to 1 when compiling tests that use
+//                              Google Test as a shared library (known as
+//                              DLL on Windows).
+//   GTEST_CREATE_SHARED_LIBRARY
+//                            - Define to 1 when compiling Google Test itself
+//                              as a shared library.
+
+// Platform-indicating macros
+// --------------------------
+//
+// Macros indicating the platform on which Google Test is being used
+// (a macro is defined to 1 if compiled on the given platform;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+//   GTEST_OS_AIX      - IBM AIX
+//   GTEST_OS_CYGWIN   - Cygwin
+//   GTEST_OS_FREEBSD  - FreeBSD
+//   GTEST_OS_HPUX     - HP-UX
+//   GTEST_OS_LINUX    - Linux
+//     GTEST_OS_LINUX_ANDROID - Google Android
+//   GTEST_OS_MAC      - Mac OS X
+//     GTEST_OS_IOS    - iOS
+//   GTEST_OS_NACL     - Google Native Client (NaCl)
+//   GTEST_OS_OPENBSD  - OpenBSD
+//   GTEST_OS_QNX      - QNX
+//   GTEST_OS_SOLARIS  - Sun Solaris
+//   GTEST_OS_SYMBIAN  - Symbian
+//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
+//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
+//     GTEST_OS_WINDOWS_MINGW    - MinGW
+//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
+//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
+//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
+//   GTEST_OS_ZOS      - z/OS
+//
+// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
+// most stable support.  Since core members of the Google Test project
+// don't have access to other platforms, support for them may be less
+// stable.  If you notice any problems on your platform, please notify
+// googletestframework@googlegroups.com (patches for fixing them are
+// even more welcome!).
+//
+// It is possible that none of the GTEST_OS_* macros are defined.
+
+// Feature-indicating macros
+// -------------------------
+//
+// Macros indicating which Google Test features are available (a macro
+// is defined to 1 if the corresponding feature is supported;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+// These macros are public so that portable tests can be written.
+// Such tests typically surround code using a feature with an #if
+// which controls that code.  For example:
+//
+// #if GTEST_HAS_DEATH_TEST
+//   EXPECT_DEATH(DoSomethingDeadly());
+// #endif
+//
+//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
+//                            tests)
+//   GTEST_HAS_DEATH_TEST   - death tests
+//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
+//   GTEST_HAS_TYPED_TEST   - typed tests
+//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
+//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
+//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
+//                            GTEST_HAS_POSIX_RE (see above) which users can
+//                            define themselves.
+//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
+//                            the above two are mutually exclusive.
+//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
+
+// Misc public macros
+// ------------------
+//
+//   GTEST_FLAG(flag_name)  - references the variable corresponding to
+//                            the given Google Test flag.
+
+// Internal utilities
+// ------------------
+//
+// The following macros and utilities are for Google Test's INTERNAL
+// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
+//
+// Macros for basic C++ coding:
+//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
+//                              variable don't have to be used.
+//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
+//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
+//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
+//                                        suppressed (constant conditional).
+//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
+//                                        is suppressed.
+//
+// C++11 feature wrappers:
+//
+//   testing::internal::move  - portability wrapper for std::move.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                            - synchronization primitives.
+//
+// Template meta programming:
+//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
+//   IteratorTraits - partial implementation of std::iterator_traits, which
+//                    is not available in libCstd when compiled with Sun C++.
+//
+// Smart pointers:
+//   scoped_ptr     - as in TR2.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax on UNIX-like
+//                    platforms, or a reduced regular exception syntax on
+//                    other platforms, including Windows.
+//
+// Logging:
+//   GTEST_LOG_()   - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stdout and stderr capturing:
+//   CaptureStdout()     - starts capturing stdout.
+//   GetCapturedStdout() - stops capturing stdout and returns the captured
+//                         string.
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   Int32, UInt32, Int64, UInt64, TimeInMillis
+//                  - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   BoolFromGTestEnv()   - parses a bool environment variable.
+//   Int32FromGTestEnv()  - parses an Int32 environment variable.
+//   StringFromGTestEnv() - parses a string environment variable.
+
+#include <ctype.h>   // for isspace, etc
+#include <stddef.h>  // for ptrdiff_t
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifndef _WIN32_WCE
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif  // !_WIN32_WCE
+
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
+#include <algorithm>  // NOLINT
+#include <iostream>  // NOLINT
+#include <sstream>  // NOLINT
+#include <string>  // NOLINT
+#include <utility>
+#include <vector>  // NOLINT
+
+// Copyright 2015, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the GTEST_OS_* macro.
+// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+
+// Determines the platform on which Google Test is compiled.
+#ifdef __CYGWIN__
+# define GTEST_OS_CYGWIN 1
+#elif defined __SYMBIAN32__
+# define GTEST_OS_SYMBIAN 1
+#elif defined _WIN32
+# define GTEST_OS_WINDOWS 1
+# ifdef _WIN32_WCE
+#  define GTEST_OS_WINDOWS_MOBILE 1
+# elif defined(__MINGW__) || defined(__MINGW32__)
+#  define GTEST_OS_WINDOWS_MINGW 1
+# elif defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define GTEST_OS_WINDOWS_RT 1
+#  else
+    // WINAPI_FAMILY defined but no known partition matched.
+    // Default to desktop.
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  endif
+# else
+#  define GTEST_OS_WINDOWS_DESKTOP 1
+# endif  // _WIN32_WCE
+#elif defined __APPLE__
+# define GTEST_OS_MAC 1
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+# endif
+#elif defined __FreeBSD__
+# define GTEST_OS_FREEBSD 1
+#elif defined __linux__
+# define GTEST_OS_LINUX 1
+# if defined __ANDROID__
+#  define GTEST_OS_LINUX_ANDROID 1
+# endif
+#elif defined __MVS__
+# define GTEST_OS_ZOS 1
+#elif defined(__sun) && defined(__SVR4)
+# define GTEST_OS_SOLARIS 1
+#elif defined(_AIX)
+# define GTEST_OS_AIX 1
+#elif defined(__hpux)
+# define GTEST_OS_HPUX 1
+#elif defined __native_client__
+# define GTEST_OS_NACL 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
+#endif  // __CYGWIN__
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+// Copyright 2015, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Injection point for custom user configurations.
+// The following macros can be defined:
+//
+//   Flag related macros:
+//     GTEST_FLAG(flag_name)
+//     GTEST_USE_OWN_FLAGFILE_FLAG_  - Define to 0 when the system provides its
+//                                     own flagfile flag parsing.
+//     GTEST_DECLARE_bool_(name)
+//     GTEST_DECLARE_int32_(name)
+//     GTEST_DECLARE_string_(name)
+//     GTEST_DEFINE_bool_(name, default_val, doc)
+//     GTEST_DEFINE_int32_(name, default_val, doc)
+//     GTEST_DEFINE_string_(name, default_val, doc)
+//
+//   Test filtering:
+//     GTEST_TEST_FILTER_ENV_VAR_ - The name of an environment variable that
+//                                  will be used if --GTEST_FLAG(test_filter)
+//                                  is not provided.
+//
+//   Logging:
+//     GTEST_LOG_(severity)
+//     GTEST_CHECK_(condition)
+//     Functions LogToStderr() and FlushInfoLog() have to be provided too.
+//
+//   Threading:
+//     GTEST_HAS_NOTIFICATION_ - Enabled if Notification is already provided.
+//     GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Enabled if Mutex and ThreadLocal are
+//                                         already provided.
+//     Must also provide GTEST_DECLARE_STATIC_MUTEX_(mutex) and
+//     GTEST_DEFINE_STATIC_MUTEX_(mutex)
+//
+//     GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+//     GTEST_LOCK_EXCLUDED_(locks)
+//
+// ** Custom implementation starts here **
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#if !defined(GTEST_DEV_EMAIL_)
+# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+# define GTEST_FLAG_PREFIX_ "gtest_"
+# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+# define GTEST_NAME_ "Google Test"
+# define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
+#endif  // !defined(GTEST_DEV_EMAIL_)
+
+#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+
+// Determines the version of gcc that is used to compile this.
+#ifdef __GNUC__
+// 40302 means version 4.3.2.
+# define GTEST_GCC_VER_ \
+    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#endif  // __GNUC__
+
+// Macros for disabling Microsoft Visual C++ warnings.
+//
+//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
+//   /* code that triggers warnings C4800 and C4385 */
+//   GTEST_DISABLE_MSC_WARNINGS_POP_()
+#if _MSC_VER >= 1500
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+    __pragma(warning(push))                        \
+    __pragma(warning(disable: warnings))
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
+    __pragma(warning(pop))
+#else
+// Older versions of MSVC don't have __pragma.
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+#ifndef GTEST_LANG_CXX11
+// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
+// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
+// value for __cplusplus, and recent versions of clang, gcc, and
+// probably other compilers set that too in C++11 mode.
+# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
+// Compiling in at least C++11 mode.
+#  define GTEST_LANG_CXX11 1
+# else
+#  define GTEST_LANG_CXX11 0
+# endif
+#endif
+
+// Distinct from C++11 language support, some environments don't provide
+// proper C++11 library support. Notably, it's possible to build in
+// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
+// with no C++11 support.
+//
+// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
+// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
+// this date, so check for those versions by their date stamps.
+// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
+#if GTEST_LANG_CXX11 && \
+    (!defined(__GLIBCXX__) || ( \
+        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
+        /* Block list of patch releases of older branches: */ \
+        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
+        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
+        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
+        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
+# define GTEST_STDLIB_CXX11 1
+#endif
+
+// Only use C++11 library features if the library provides them.
+#if GTEST_STDLIB_CXX11
+# define GTEST_HAS_STD_BEGIN_AND_END_ 1
+# define GTEST_HAS_STD_FORWARD_LIST_ 1
+# define GTEST_HAS_STD_FUNCTION_ 1
+# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
+# define GTEST_HAS_STD_MOVE_ 1
+# define GTEST_HAS_STD_UNIQUE_PTR_ 1
+# define GTEST_HAS_STD_SHARED_PTR_ 1
+#endif
+
+// C++11 specifies that <tuple> provides std::tuple.
+// Some platforms still might not have it, however.
+#if GTEST_LANG_CXX11
+# define GTEST_HAS_STD_TUPLE_ 1
+# if defined(__clang__)
+// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
+#  if defined(__has_include) && !__has_include(<tuple>)
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# elif defined(_MSC_VER)
+// Inspired by boost/config/stdlib/dinkumware.hpp
+#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# elif defined(__GLIBCXX__)
+// Inspired by boost/config/stdlib/libstdcpp3.hpp,
+// http://gcc.gnu.org/gcc-4.2/changes.html and
+// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
+#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# endif
+#endif
+
+// Brings in definitions for functions used in the testing::internal::posix
+// namespace (read, write, close, chdir, isatty, stat). We do not currently
+// use them on Windows Mobile.
+#if GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS_MOBILE
+#  include <direct.h>
+#  include <io.h>
+# endif
+// In order to avoid having to include <windows.h>, use forward declaration
+// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
+// This assumption is verified by
+// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
+struct _RTL_CRITICAL_SECTION;
+#else
+// This assumes that non-Windows OSes provide unistd.h. For OSes where this
+// is not the case, we need to include headers that provide the functions
+// mentioned above.
+# include <unistd.h>
+# include <strings.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
+// Defines this to true iff Google Test can use POSIX regular expressions.
+#ifndef GTEST_HAS_POSIX_RE
+# if GTEST_OS_LINUX_ANDROID
+// On Android, <regex.h> is only available starting with Gingerbread.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+# else
+#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
+# endif
+#endif
+
+#if GTEST_USES_PCRE
+// The appropriate headers have already been included.
+
+#elif GTEST_HAS_POSIX_RE
+
+// On some platforms, <regex.h> needs someone to define size_t, and
+// won't compile otherwise.  We can #include it here as we already
+// included <stdlib.h>, which is guaranteed to define size_t through
+// <stddef.h>.
+# include <regex.h>  // NOLINT
+
+# define GTEST_USES_POSIX_RE 1
+
+#elif GTEST_OS_WINDOWS
+
+// <regex.h> is not available on Windows.  Use our own simple regex
+// implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#else
+
+// <regex.h> may not be available on this platform.  Use our own
+// simple regex implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#endif  // GTEST_USES_PCRE
+
+#ifndef GTEST_HAS_EXCEPTIONS
+// The user didn't tell us whether exceptions are enabled, so we need
+// to figure it out.
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
+// macro to enable exceptions, so we'll do the same.
+// Assumes that exceptions are enabled by default.
+#  ifndef _HAS_EXCEPTIONS
+#   define _HAS_EXCEPTIONS 1
+#  endif  // _HAS_EXCEPTIONS
+#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+# elif defined(__clang__)
+// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
+// but iff cleanups are enabled after that. In Obj-C++ files, there can be
+// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
+// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
+// exceptions starting at clang r206352, but which checked for cleanups prior to
+// that. To reliably check for C++ exception availability with clang, check for
+// __EXCEPTIONS && __has_feature(cxx_exceptions).
+#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
+# elif defined(__GNUC__) && __EXCEPTIONS
+// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__SUNPRO_CC)
+// Sun Pro CC supports exceptions.  However, there is no compile-time way of
+// detecting whether they are enabled or not.  Therefore, we assume that
+// they are enabled unless the user tells us otherwise.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__IBMCPP__) && __EXCEPTIONS
+// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__HP_aCC)
+// Exception handling is in effect by default in HP aCC compiler. It has to
+// be turned of by +noeh compiler option if desired.
+#  define GTEST_HAS_EXCEPTIONS 1
+# else
+// For other compilers, we assume exceptions are disabled to be
+// conservative.
+#  define GTEST_HAS_EXCEPTIONS 0
+# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#if !defined(GTEST_HAS_STD_STRING)
+// Even though we don't use this macro any longer, we keep it in case
+// some clients still depend on it.
+# define GTEST_HAS_STD_STRING 1
+#elif !GTEST_HAS_STD_STRING
+// The user told us that ::std::string isn't available.
+# error "Google Test cannot be used where ::std::string isn't available."
+#endif  // !defined(GTEST_HAS_STD_STRING)
+
+#ifndef GTEST_HAS_GLOBAL_STRING
+// The user didn't tell us whether ::string is available, so we need
+// to figure it out.
+
+# define GTEST_HAS_GLOBAL_STRING 0
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
+//   is available.
+
+// Cygwin 1.7 and below doesn't support ::std::wstring.
+// Solaris' libc++ doesn't support it either.  Android has
+// no support for it at least as recent as Froyo (2.2).
+# define GTEST_HAS_STD_WSTRING \
+    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#ifndef GTEST_HAS_GLOBAL_WSTRING
+// The user didn't tell us whether ::wstring is available, so we need
+// to figure it out.
+# define GTEST_HAS_GLOBAL_WSTRING \
+    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Determines whether RTTI is available.
+#ifndef GTEST_HAS_RTTI
+// The user didn't tell us whether RTTI is enabled, so we need to
+// figure it out.
+
+# ifdef _MSC_VER
+
+#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
+# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
+
+#  ifdef __GXX_RTTI
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif  // __GXX_RTTI
+
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
+// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
+// both the typeid and dynamic_cast features are present.
+# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+
+#  ifdef __RTTI_ALL__
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+# else
+
+// For all other compilers, we assume RTTI is enabled.
+#  define GTEST_HAS_RTTI 1
+
+# endif  // _MSC_VER
+
+#endif  // GTEST_HAS_RTTI
+
+// It's this header's responsibility to #include <typeinfo> when RTTI
+// is enabled.
+#if GTEST_HAS_RTTI
+# include <typeinfo>
+#endif
+
+// Determines whether Google Test can use the pthreads library.
+#ifndef GTEST_HAS_PTHREAD
+// The user didn't tell us explicitly, so we make reasonable assumptions about
+// which platforms have pthreads support.
+//
+// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
+// to your compiler flags.
+# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
+    || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL)
+#endif  // GTEST_HAS_PTHREAD
+
+#if GTEST_HAS_PTHREAD
+// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
+// true.
+# include <pthread.h>  // NOLINT
+
+// For timespec and nanosleep, used below.
+# include <time.h>  // NOLINT
+#endif
+
+// Determines if hash_map/hash_set are available.
+// Only used for testing against those containers.
+#if !defined(GTEST_HAS_HASH_MAP_)
+# if _MSC_VER
+#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
+#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
+# endif  // _MSC_VER
+#endif  // !defined(GTEST_HAS_HASH_MAP_)
+
+// Determines whether Google Test can use tr1/tuple.  You can define
+// this macro to 0 to prevent Google Test from using tuple (any
+// feature depending on tuple with be disabled in this mode).
+#ifndef GTEST_HAS_TR1_TUPLE
+# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
+// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
+#  define GTEST_HAS_TR1_TUPLE 0
+# else
+// The user didn't tell us not to do it, so we assume it's OK.
+#  define GTEST_HAS_TR1_TUPLE 1
+# endif
+#endif  // GTEST_HAS_TR1_TUPLE
+
+// Determines whether Google Test's own tr1 tuple implementation
+// should be used.
+#ifndef GTEST_USE_OWN_TR1_TUPLE
+// The user didn't tell us, so we need to figure it out.
+
+// We use our own TR1 tuple if we aren't sure the user has an
+// implementation of it already.  At this time, libstdc++ 4.0.0+ and
+// MSVC 2010 are the only mainstream standard libraries that come
+// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
+// pretends to be GCC by defining __GNUC__ and friends, but cannot
+// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
+// tuple in a 323 MB Feature Pack download, which we cannot assume the
+// user has.  QNX's QCC compiler is a modified GCC but it doesn't
+// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
+// and it can be used with some compilers that define __GNUC__.
+# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
+      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
+#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
+# endif
+
+// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
+// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
+// can build with clang but need to use gcc4.2's libstdc++).
+# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
+#  define GTEST_ENV_HAS_STD_TUPLE_ 1
+# endif
+
+# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
+#  define GTEST_USE_OWN_TR1_TUPLE 0
+# else
+#  define GTEST_USE_OWN_TR1_TUPLE 1
+# endif
+
+#endif  // GTEST_USE_OWN_TR1_TUPLE
+
+// To avoid conditional compilation everywhere, we make it
+// gtest-port.h's responsibility to #include the header implementing
+// tuple.
+#if GTEST_HAS_STD_TUPLE_
+# include <tuple>  // IWYU pragma: export
+# define GTEST_TUPLE_NAMESPACE_ ::std
+#endif  // GTEST_HAS_STD_TUPLE_
+
+// We include tr1::tuple even if std::tuple is available to define printers for
+// them.
+#if GTEST_HAS_TR1_TUPLE
+# ifndef GTEST_TUPLE_NAMESPACE_
+#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
+# endif  // GTEST_TUPLE_NAMESPACE_
+
+# if GTEST_USE_OWN_TR1_TUPLE
+// This file was GENERATED by command:
+//     pump.py gtest-tuple.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2009 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+
+#include <utility>  // For ::std::pair.
+
+// The compiler used in Symbian has a bug that prevents us from declaring the
+// tuple template as a friend (it complains that tuple is redefined).  This
+// hack bypasses the bug by declaring the members that should otherwise be
+// private as public.
+// Sun Studio versions < 12 also have the above bug.
+#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
+#else
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
+    template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
+   private:
+#endif
+
+// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
+// with our own definitions. Therefore using our own tuple does not work on
+// those compilers.
+#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
+# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
+GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
+#endif
+
+// GTEST_n_TUPLE_(T) is the type of an n-tuple.
+#define GTEST_0_TUPLE_(T) tuple<>
+#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
+    void, void, void>
+#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
+    void, void, void>
+#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
+    void, void, void>
+#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
+    void, void, void>
+#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
+    void, void, void>
+#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
+    void, void, void>
+#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    void, void, void>
+#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, void, void>
+#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, T##8, void>
+#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, T##8, T##9>
+
+// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
+#define GTEST_0_TYPENAMES_(T)
+#define GTEST_1_TYPENAMES_(T) typename T##0
+#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
+#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
+#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3
+#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4
+#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5
+#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6
+#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
+#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, \
+    typename T##7, typename T##8
+#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, \
+    typename T##7, typename T##8, typename T##9
+
+// In theory, defining stuff in the ::std namespace is undefined
+// behavior.  We can do this as we are playing the role of a standard
+// library vendor.
+namespace std {
+namespace tr1 {
+
+template <typename T0 = void, typename T1 = void, typename T2 = void,
+    typename T3 = void, typename T4 = void, typename T5 = void,
+    typename T6 = void, typename T7 = void, typename T8 = void,
+    typename T9 = void>
+class tuple;
+
+// Anything in namespace gtest_internal is Google Test's INTERNAL
+// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
+namespace gtest_internal {
+
+// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
+template <typename T>
+struct ByRef { typedef const T& type; };  // NOLINT
+template <typename T>
+struct ByRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for ByRef.
+#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
+
+// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
+// is the same as tr1::add_reference<T>::type.
+template <typename T>
+struct AddRef { typedef T& type; };  // NOLINT
+template <typename T>
+struct AddRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for AddRef.
+#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
+
+// A helper for implementing get<k>().
+template <int k> class Get;
+
+// A helper for implementing tuple_element<k, T>.  kIndexValid is true
+// iff k < the number of fields in tuple type T.
+template <bool kIndexValid, int kIndex, class Tuple>
+struct TupleElement;
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
+  typedef T0 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
+  typedef T1 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
+  typedef T2 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
+  typedef T3 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
+  typedef T4 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
+  typedef T5 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
+  typedef T6 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
+  typedef T7 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
+  typedef T8 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
+  typedef T9 type;
+};
+
+}  // namespace gtest_internal
+
+template <>
+class tuple<> {
+ public:
+  tuple() {}
+  tuple(const tuple& /* t */)  {}
+  tuple& operator=(const tuple& /* t */) { return *this; }
+};
+
+template <GTEST_1_TYPENAMES_(T)>
+class GTEST_1_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
+
+  tuple(const tuple& t) : f0_(t.f0_) {}
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    return *this;
+  }
+
+  T0 f0_;
+};
+
+template <GTEST_2_TYPENAMES_(T)>
+class GTEST_2_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
+      f1_(f1) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
+  template <typename U0, typename U1>
+  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+  template <typename U0, typename U1>
+  tuple& operator=(const ::std::pair<U0, U1>& p) {
+    f0_ = p.first;
+    f1_ = p.second;
+    return *this;
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+};
+
+template <GTEST_3_TYPENAMES_(T)>
+class GTEST_3_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+};
+
+template <GTEST_4_TYPENAMES_(T)>
+class GTEST_4_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+};
+
+template <GTEST_5_TYPENAMES_(T)>
+class GTEST_5_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
+      GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_) {}
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+};
+
+template <GTEST_6_TYPENAMES_(T)>
+class GTEST_6_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_) {}
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+};
+
+template <GTEST_7_TYPENAMES_(T)>
+class GTEST_7_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+};
+
+template <GTEST_8_TYPENAMES_(T)>
+class GTEST_8_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
+      GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5), f6_(f6), f7_(f7) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+};
+
+template <GTEST_9_TYPENAMES_(T)>
+class GTEST_9_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
+      GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    f8_ = t.f8_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+  T8 f8_;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+class tuple {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
+      f9_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
+      GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
+      f9_(t.f9_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    f8_ = t.f8_;
+    f9_ = t.f9_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+  T8 f8_;
+  T9 f9_;
+};
+
+// 6.1.3.2 Tuple creation functions.
+
+// Known limitations: we don't support passing an
+// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
+// implement tie().
+
+inline tuple<> make_tuple() { return tuple<>(); }
+
+template <GTEST_1_TYPENAMES_(T)>
+inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
+  return GTEST_1_TUPLE_(T)(f0);
+}
+
+template <GTEST_2_TYPENAMES_(T)>
+inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
+  return GTEST_2_TUPLE_(T)(f0, f1);
+}
+
+template <GTEST_3_TYPENAMES_(T)>
+inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
+  return GTEST_3_TUPLE_(T)(f0, f1, f2);
+}
+
+template <GTEST_4_TYPENAMES_(T)>
+inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3) {
+  return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
+}
+
+template <GTEST_5_TYPENAMES_(T)>
+inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4) {
+  return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
+}
+
+template <GTEST_6_TYPENAMES_(T)>
+inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5) {
+  return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
+}
+
+template <GTEST_7_TYPENAMES_(T)>
+inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
+  return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
+}
+
+template <GTEST_8_TYPENAMES_(T)>
+inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
+  return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
+}
+
+template <GTEST_9_TYPENAMES_(T)>
+inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
+    const T8& f8) {
+  return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
+}
+
+template <GTEST_10_TYPENAMES_(T)>
+inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
+    const T8& f8, const T9& f9) {
+  return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
+}
+
+// 6.1.3.3 Tuple helper classes.
+
+template <typename Tuple> struct tuple_size;
+
+template <GTEST_0_TYPENAMES_(T)>
+struct tuple_size<GTEST_0_TUPLE_(T) > {
+  static const int value = 0;
+};
+
+template <GTEST_1_TYPENAMES_(T)>
+struct tuple_size<GTEST_1_TUPLE_(T) > {
+  static const int value = 1;
+};
+
+template <GTEST_2_TYPENAMES_(T)>
+struct tuple_size<GTEST_2_TUPLE_(T) > {
+  static const int value = 2;
+};
+
+template <GTEST_3_TYPENAMES_(T)>
+struct tuple_size<GTEST_3_TUPLE_(T) > {
+  static const int value = 3;
+};
+
+template <GTEST_4_TYPENAMES_(T)>
+struct tuple_size<GTEST_4_TUPLE_(T) > {
+  static const int value = 4;
+};
+
+template <GTEST_5_TYPENAMES_(T)>
+struct tuple_size<GTEST_5_TUPLE_(T) > {
+  static const int value = 5;
+};
+
+template <GTEST_6_TYPENAMES_(T)>
+struct tuple_size<GTEST_6_TUPLE_(T) > {
+  static const int value = 6;
+};
+
+template <GTEST_7_TYPENAMES_(T)>
+struct tuple_size<GTEST_7_TUPLE_(T) > {
+  static const int value = 7;
+};
+
+template <GTEST_8_TYPENAMES_(T)>
+struct tuple_size<GTEST_8_TUPLE_(T) > {
+  static const int value = 8;
+};
+
+template <GTEST_9_TYPENAMES_(T)>
+struct tuple_size<GTEST_9_TUPLE_(T) > {
+  static const int value = 9;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct tuple_size<GTEST_10_TUPLE_(T) > {
+  static const int value = 10;
+};
+
+template <int k, class Tuple>
+struct tuple_element {
+  typedef typename gtest_internal::TupleElement<
+      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
+};
+
+#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
+
+// 6.1.3.4 Element access.
+
+namespace gtest_internal {
+
+template <>
+class Get<0> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
+  Field(Tuple& t) { return t.f0_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
+  ConstField(const Tuple& t) { return t.f0_; }
+};
+
+template <>
+class Get<1> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
+  Field(Tuple& t) { return t.f1_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
+  ConstField(const Tuple& t) { return t.f1_; }
+};
+
+template <>
+class Get<2> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
+  Field(Tuple& t) { return t.f2_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
+  ConstField(const Tuple& t) { return t.f2_; }
+};
+
+template <>
+class Get<3> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
+  Field(Tuple& t) { return t.f3_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
+  ConstField(const Tuple& t) { return t.f3_; }
+};
+
+template <>
+class Get<4> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
+  Field(Tuple& t) { return t.f4_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
+  ConstField(const Tuple& t) { return t.f4_; }
+};
+
+template <>
+class Get<5> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
+  Field(Tuple& t) { return t.f5_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
+  ConstField(const Tuple& t) { return t.f5_; }
+};
+
+template <>
+class Get<6> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
+  Field(Tuple& t) { return t.f6_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
+  ConstField(const Tuple& t) { return t.f6_; }
+};
+
+template <>
+class Get<7> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
+  Field(Tuple& t) { return t.f7_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
+  ConstField(const Tuple& t) { return t.f7_; }
+};
+
+template <>
+class Get<8> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
+  Field(Tuple& t) { return t.f8_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
+  ConstField(const Tuple& t) { return t.f8_; }
+};
+
+template <>
+class Get<9> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
+  Field(Tuple& t) { return t.f9_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
+  ConstField(const Tuple& t) { return t.f9_; }
+};
+
+}  // namespace gtest_internal
+
+template <int k, GTEST_10_TYPENAMES_(T)>
+GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
+get(GTEST_10_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::Field(t);
+}
+
+template <int k, GTEST_10_TYPENAMES_(T)>
+GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
+get(const GTEST_10_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::ConstField(t);
+}
+
+// 6.1.3.5 Relational operators
+
+// We only implement == and !=, as we don't have a need for the rest yet.
+
+namespace gtest_internal {
+
+// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
+// first k fields of t1 equals the first k fields of t2.
+// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
+// k1 != k2.
+template <int kSize1, int kSize2>
+struct SameSizeTuplePrefixComparator;
+
+template <>
+struct SameSizeTuplePrefixComparator<0, 0> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
+    return true;
+  }
+};
+
+template <int k>
+struct SameSizeTuplePrefixComparator<k, k> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
+    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
+        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
+  }
+};
+
+}  // namespace gtest_internal
+
+template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
+inline bool operator==(const GTEST_10_TUPLE_(T)& t,
+                       const GTEST_10_TUPLE_(U)& u) {
+  return gtest_internal::SameSizeTuplePrefixComparator<
+      tuple_size<GTEST_10_TUPLE_(T) >::value,
+      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
+}
+
+template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
+inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
+                       const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
+
+// 6.1.4 Pairs.
+// Unimplemented.
+
+}  // namespace tr1
+}  // namespace std
+
+#undef GTEST_0_TUPLE_
+#undef GTEST_1_TUPLE_
+#undef GTEST_2_TUPLE_
+#undef GTEST_3_TUPLE_
+#undef GTEST_4_TUPLE_
+#undef GTEST_5_TUPLE_
+#undef GTEST_6_TUPLE_
+#undef GTEST_7_TUPLE_
+#undef GTEST_8_TUPLE_
+#undef GTEST_9_TUPLE_
+#undef GTEST_10_TUPLE_
+
+#undef GTEST_0_TYPENAMES_
+#undef GTEST_1_TYPENAMES_
+#undef GTEST_2_TYPENAMES_
+#undef GTEST_3_TYPENAMES_
+#undef GTEST_4_TYPENAMES_
+#undef GTEST_5_TYPENAMES_
+#undef GTEST_6_TYPENAMES_
+#undef GTEST_7_TYPENAMES_
+#undef GTEST_8_TYPENAMES_
+#undef GTEST_9_TYPENAMES_
+#undef GTEST_10_TYPENAMES_
+
+#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
+#undef GTEST_BY_REF_
+#undef GTEST_ADD_REF_
+#undef GTEST_TUPLE_ELEMENT_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+# elif GTEST_ENV_HAS_STD_TUPLE_
+#  include <tuple>
+// C++11 puts its tuple into the ::std namespace rather than
+// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
+// This causes undefined behavior, but supported compilers react in
+// the way we intend.
+namespace std {
+namespace tr1 {
+using ::std::get;
+using ::std::make_tuple;
+using ::std::tuple;
+using ::std::tuple_element;
+using ::std::tuple_size;
+}
+}
+
+# elif GTEST_OS_SYMBIAN
+
+// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
+// use STLport's tuple implementation, which unfortunately doesn't
+// work as the copy of STLport distributed with Symbian is incomplete.
+// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
+// use its own tuple implementation.
+#  ifdef BOOST_HAS_TR1_TUPLE
+#   undef BOOST_HAS_TR1_TUPLE
+#  endif  // BOOST_HAS_TR1_TUPLE
+
+// This prevents <boost/tr1/detail/config.hpp>, which defines
+// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
+#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
+#  include <tuple>  // IWYU pragma: export  // NOLINT
+
+# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
+// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
+// not conform to the TR1 spec, which requires the header to be <tuple>.
+
+#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
+// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
+// which is #included by <tr1/tuple>, to not compile when RTTI is
+// disabled.  _TR1_FUNCTIONAL is the header guard for
+// <tr1/functional>.  Hence the following #define is a hack to prevent
+// <tr1/functional> from being included.
+#   define _TR1_FUNCTIONAL 1
+#   include <tr1/tuple>
+#   undef _TR1_FUNCTIONAL  // Allows the user to #include
+                        // <tr1/functional> if he chooses to.
+#  else
+#   include <tr1/tuple>  // NOLINT
+#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
+
+# else
+// If the compiler is not GCC 4.0+, we assume the user is using a
+// spec-conforming TR1 implementation.
+#  include <tuple>  // IWYU pragma: export  // NOLINT
+# endif  // GTEST_USE_OWN_TR1_TUPLE
+
+#endif  // GTEST_HAS_TR1_TUPLE
+
+// Determines whether clone(2) is supported.
+// Usually it will only be available on Linux, excluding
+// Linux on the Itanium architecture.
+// Also see http://linux.die.net/man/2/clone.
+#ifndef GTEST_HAS_CLONE
+// The user didn't tell us, so we need to figure it out.
+
+# if GTEST_OS_LINUX && !defined(__ia64__)
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() is only available on ARM starting with Gingerbread.
+#    if defined(__arm__) && __ANDROID_API__ >= 9
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
+# else
+#  define GTEST_HAS_CLONE 0
+# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+
+#endif  // GTEST_HAS_CLONE
+
+// Determines whether to support stream redirection. This is used to test
+// output correctness and to implement death tests.
+#ifndef GTEST_HAS_STREAM_REDIRECTION
+// By default, we assume that stream redirection is supported on all
+// platforms except known mobile ones.
+# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+#  define GTEST_HAS_STREAM_REDIRECTION 0
+# else
+#  define GTEST_HAS_STREAM_REDIRECTION 1
+# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Determines whether to support death tests.
+// Google Test does not support death tests for VC 7.1 and earlier as
+// abort() in a VC 7.1 application compiled as GUI in debug config
+// pops up a dialog window that cannot be suppressed programmatically.
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+     (GTEST_OS_MAC && !GTEST_OS_IOS) || \
+     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
+     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
+     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
+# define GTEST_HAS_DEATH_TEST 1
+#endif
+
+// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
+// all the compilers we care about are adequate for supporting
+// value-parameterized tests.
+#define GTEST_HAS_PARAM_TEST 1
+
+// Determines whether to support type-driven tests.
+
+// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
+// Sun Pro CC, IBM Visual Age, and HP aCC support.
+#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
+    defined(__IBMCPP__) || defined(__HP_aCC)
+# define GTEST_HAS_TYPED_TEST 1
+# define GTEST_HAS_TYPED_TEST_P 1
+#endif
+
+// Determines whether to support Combine(). This only makes sense when
+// value-parameterized tests are enabled.  The implementation doesn't
+// work on Sun Studio since it doesn't understand templated conversion
+// operators.
+#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
+# define GTEST_HAS_COMBINE 1
+#endif
+
+// Determines whether the system compiler uses UTF-16 for encoding wide strings.
+#define GTEST_WIDE_STRING_USES_UTF16_ \
+    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
+
+// Determines whether test results can be streamed to a socket.
+#if GTEST_OS_LINUX
+# define GTEST_CAN_STREAM_RESULTS_ 1
+#endif
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#else
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct/class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED_;
+//
+// Also use it after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+#elif defined(__clang__)
+# if __has_attribute(unused)
+#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+# endif
+#endif
+#ifndef GTEST_ATTRIBUTE_UNUSED_
+# define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
+// A macro to disallow operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_ASSIGN_(type)\
+  void operator=(type const &)
+
+// A macro to disallow copy constructor and operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
+  type(type const &);\
+  GTEST_DISALLOW_ASSIGN_(type)
+
+// Tell the compiler to warn about unused return values for functions declared
+// with this macro.  The macro should be used on function declarations
+// following the argument list:
+//
+//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
+#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
+# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#else
+# define GTEST_MUST_USE_RESULT_
+#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
+
+// MS C++ compiler emits warning when a conditional expression is compile time
+// constant. In some contexts this warning is false positive and needs to be
+// suppressed. Use the following two macros in such cases:
+//
+// GTEST_INTENTIONAL_CONST_COND_PUSH_()
+// while (true) {
+// GTEST_INTENTIONAL_CONST_COND_POP_()
+// }
+# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+# define GTEST_INTENTIONAL_CONST_COND_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+// Determine whether the compiler supports Microsoft's Structured Exception
+// Handling.  This is supported by several Windows compilers but generally
+// does not exist on any other system.
+#ifndef GTEST_HAS_SEH
+// The user didn't tell us, so we need to figure it out.
+
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// These two compilers are known to support SEH.
+#  define GTEST_HAS_SEH 1
+# else
+// Assume no SEH.
+#  define GTEST_HAS_SEH 0
+# endif
+
+#define GTEST_IS_THREADSAFE \
+    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
+     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \
+     || GTEST_HAS_PTHREAD)
+
+#endif  // GTEST_HAS_SEH
+
+#ifdef _MSC_VER
+
+# if GTEST_LINKED_AS_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllimport)
+# elif GTEST_CREATE_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllexport)
+# endif
+
+#endif  // _MSC_VER
+
+#ifndef GTEST_API_
+# define GTEST_API_
+#endif
+
+#ifdef __GNUC__
+// Ask the compiler to never inline a given function.
+# define GTEST_NO_INLINE_ __attribute__((noinline))
+#else
+# define GTEST_NO_INLINE_
+#endif
+
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
+# define GTEST_HAS_CXXABI_H_ 1
+#else
+# define GTEST_HAS_CXXABI_H_ 0
+#endif
+
+// A function level attribute to disable checking for use of uninitialized
+// memory when built with MemorySanitizer.
+#if defined(__clang__)
+# if __has_feature(memory_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
+       __attribute__((no_sanitize_memory))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+# endif  // __has_feature(memory_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif  // __clang__
+
+// A function level attribute to disable AddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(address_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+       __attribute__((no_sanitize_address))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+# endif  // __has_feature(address_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable ThreadSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(thread_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
+       __attribute__((no_sanitize_thread))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+# endif  // __has_feature(thread_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif  // __clang__
+
+namespace testing {
+
+class Message;
+
+#if defined(GTEST_TUPLE_NAMESPACE_)
+// Import tuple and friends into the ::testing namespace.
+// It is part of our interface, having them in ::testing allows us to change
+// their types as needed.
+using GTEST_TUPLE_NAMESPACE_::get;
+using GTEST_TUPLE_NAMESPACE_::make_tuple;
+using GTEST_TUPLE_NAMESPACE_::tuple;
+using GTEST_TUPLE_NAMESPACE_::tuple_size;
+using GTEST_TUPLE_NAMESPACE_::tuple_element;
+#endif  // defined(GTEST_TUPLE_NAMESPACE_)
+
+namespace internal {
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
+//                         names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+#if GTEST_LANG_CXX11
+# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+#else  // !GTEST_LANG_CXX11
+template <bool>
+  struct CompileAssert {
+};
+
+# define GTEST_COMPILE_ASSERT_(expr, msg) \
+  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
+      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
+#endif  // !GTEST_LANG_CXX11
+
+// Implementation details of GTEST_COMPILE_ASSERT_:
+//
+// (In C++11, we simply use static_assert instead of the following)
+//
+// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
+//                                      // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
+//
+// This template is declared, but intentionally undefined.
+template <typename T1, typename T2>
+struct StaticAssertTypeEqHelper;
+
+template <typename T>
+struct StaticAssertTypeEqHelper<T, T> {
+  enum { value = true };
+};
+
+// Evaluates to the number of elements in 'array'.
+#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
+
+#if GTEST_HAS_GLOBAL_STRING
+typedef ::string string;
+#else
+typedef ::std::string string;
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+typedef ::wstring wstring;
+#elif GTEST_HAS_STD_WSTRING
+typedef ::std::wstring wstring;
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// A helper for suppressing warnings on constant condition.  It just
+// returns 'condition'.
+GTEST_API_ bool IsTrue(bool condition);
+
+// Defines scoped_ptr.
+
+// This implementation of scoped_ptr is PARTIAL - it only contains
+// enough stuff to satisfy Google Test's need.
+template <typename T>
+class scoped_ptr {
+ public:
+  typedef T element_type;
+
+  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
+  ~scoped_ptr() { reset(); }
+
+  T& operator*() const { return *ptr_; }
+  T* operator->() const { return ptr_; }
+  T* get() const { return ptr_; }
+
+  T* release() {
+    T* const ptr = ptr_;
+    ptr_ = NULL;
+    return ptr;
+  }
+
+  void reset(T* p = NULL) {
+    if (p != ptr_) {
+      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
+        delete ptr_;
+      }
+      ptr_ = p;
+    }
+  }
+
+  friend void swap(scoped_ptr& a, scoped_ptr& b) {
+    using std::swap;
+    swap(a.ptr_, b.ptr_);
+  }
+
+ private:
+  T* ptr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
+};
+
+// Defines RE.
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
+// Regular Expression syntax.
+class GTEST_API_ RE {
+ public:
+  // A copy constructor is required by the Standard to initialize object
+  // references from r-values.
+  RE(const RE& other) { Init(other.pattern()); }
+
+  // Constructs an RE from a string.
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+#if GTEST_HAS_GLOBAL_STRING
+
+  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // FullMatch(str, re) returns true iff regular expression re matches
+  // the entire str.
+  // PartialMatch(str, re) returns true iff regular expression re
+  // matches a substring of str (including str itself).
+  //
+  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
+  // when str contains NUL characters.
+  static bool FullMatch(const ::std::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+#if GTEST_HAS_GLOBAL_STRING
+
+  static bool FullMatch(const ::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  static bool FullMatch(const char* str, const RE& re);
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+
+  // We use a const char* instead of an std::string, as Google Test used to be
+  // used where std::string is not available.  TODO(wan@google.com): change to
+  // std::string.
+  const char* pattern_;
+  bool is_valid_;
+
+#if GTEST_USES_POSIX_RE
+
+  regex_t full_regex_;     // For FullMatch().
+  regex_t partial_regex_;  // For PartialMatch().
+
+#else  // GTEST_USES_SIMPLE_RE
+
+  const char* full_pattern_;  // For FullMatch();
+
+#endif
+
+  GTEST_DISALLOW_ASSIGN_(RE);
+};
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line);
+
+// Defines logging utilities:
+//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
+//                          message itself is streamed into the macro.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+// Formats log entry severity, provides a stream object for streaming the
+// log message, and terminates the message with a newline when going out of
+// scope.
+class GTEST_API_ GTestLog {
+ public:
+  GTestLog(GTestLogSeverity severity, const char* file, int line);
+
+  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+  ~GTestLog();
+
+  ::std::ostream& GetStream() { return ::std::cerr; }
+
+ private:
+  const GTestLogSeverity severity_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+};
+
+#if !defined(GTEST_LOG_)
+
+# define GTEST_LOG_(severity) \
+    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                  __FILE__, __LINE__).GetStream()
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(NULL); }
+
+#endif  // !defined(GTEST_LOG_)
+
+#if !defined(GTEST_CHECK_)
+// INTERNAL IMPLEMENTATION - DO NOT USE.
+//
+// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
+// is not satisfied.
+//  Synopsys:
+//    GTEST_CHECK_(boolean_condition);
+//     or
+//    GTEST_CHECK_(boolean_condition) << "Additional message";
+//
+//    This checks the condition and if the condition is not satisfied
+//    it prints message about the condition violation, including the
+//    condition itself, plus additional message streamed into it, if any,
+//    and then it aborts the program. It aborts the program irrespective of
+//    whether it is built in the debug mode or not.
+# define GTEST_CHECK_(condition) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::IsTrue(condition)) \
+      ; \
+    else \
+      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#endif  // !defined(GTEST_CHECK_)
+
+// An all-mode assert to verify that the given POSIX-style function
+// call returns 0 (indicating success).  Known limitation: this
+// doesn't expand to a balanced 'if' statement, so enclose the macro
+// in {} if you need to use it as the only statement in an 'if'
+// branch.
+#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
+  if (const int gtest_error = (posix_call)) \
+    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
+                      << gtest_error
+
+#if GTEST_HAS_STD_MOVE_
+using std::move;
+#else  // GTEST_HAS_STD_MOVE_
+template <typename T>
+const T& move(const T& t) {
+  return t;
+}
+#endif  // GTEST_HAS_STD_MOVE_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Use ImplicitCast_ as a safe version of static_cast for upcasting in
+// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
+// const Foo*).  When you use ImplicitCast_, the compiler checks that
+// the cast is safe.  Such explicit ImplicitCast_s are necessary in
+// surprisingly many situations where C++ demands an exact type match
+// instead of an argument type convertable to a target type.
+//
+// The syntax for using ImplicitCast_ is the same as for static_cast:
+//
+//   ImplicitCast_<ToType>(expr)
+//
+// ImplicitCast_ would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., implicit_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To>
+inline To ImplicitCast_(To x) { return x; }
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., down_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {  // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (false) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+    const To to = NULL;
+    ::testing::internal::ImplicitCast_<From*>(to);
+  }
+
+#if GTEST_HAS_RTTI
+  // RTTI: debug mode only!
+  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
+#endif
+  return static_cast<To>(f);
+}
+
+// Downcasts the pointer of type Base to Derived.
+// Derived must be a subclass of Base. The parameter MUST
+// point to a class of type Derived, not any subclass of it.
+// When RTTI is available, the function performs a runtime
+// check to enforce this.
+template <class Derived, class Base>
+Derived* CheckedDowncastToActualType(Base* base) {
+#if GTEST_HAS_RTTI
+  GTEST_CHECK_(typeid(*base) == typeid(Derived));
+#endif
+
+#if GTEST_HAS_DOWNCAST_
+  return ::down_cast<Derived*>(base);
+#elif GTEST_HAS_RTTI
+  return dynamic_cast<Derived*>(base);  // NOLINT
+#else
+  return static_cast<Derived*>(base);  // Poor man's downcast.
+#endif
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Defines the stderr capturer:
+//   CaptureStdout     - starts capturing stdout.
+//   GetCapturedStdout - stops capturing stdout and returns the captured string.
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+//
+GTEST_API_ void CaptureStdout();
+GTEST_API_ std::string GetCapturedStdout();
+GTEST_API_ void CaptureStderr();
+GTEST_API_ std::string GetCapturedStderr();
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Returns a path to temporary directory.
+GTEST_API_ std::string TempDir();
+
+// Returns the size (in bytes) of a file.
+GTEST_API_ size_t GetFileSize(FILE* file);
+
+// Reads the entire content of a file as a string.
+GTEST_API_ std::string ReadEntireFile(FILE* file);
+
+// All command line arguments.
+GTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
+
+#if GTEST_HAS_DEATH_TEST
+
+const ::std::vector<testing::internal::string>& GetInjectableArgvs();
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
+                             new_argvs);
+
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+#if GTEST_IS_THREADSAFE
+# if GTEST_HAS_PTHREAD
+// Sleeps for (roughly) n milliseconds.  This function is only for testing
+// Google Test's own constructs.  Don't use it in user tests, either
+// directly or indirectly.
+inline void SleepMilliseconds(int n) {
+  const timespec time = {
+    0,                  // 0 seconds.
+    n * 1000L * 1000L,  // And n ms.
+  };
+  nanosleep(&time, NULL);
+}
+# endif  // GTEST_HAS_PTHREAD
+
+# if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_HAS_PTHREAD
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class Notification {
+ public:
+  Notification() : notified_(false) {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
+  }
+  ~Notification() {
+    pthread_mutex_destroy(&mutex_);
+  }
+
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    pthread_mutex_lock(&mutex_);
+    notified_ = true;
+    pthread_mutex_unlock(&mutex_);
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    for (;;) {
+      pthread_mutex_lock(&mutex_);
+      const bool notified = notified_;
+      pthread_mutex_unlock(&mutex_);
+      if (notified)
+        break;
+      SleepMilliseconds(10);
+    }
+  }
+
+ private:
+  pthread_mutex_t mutex_;
+  bool notified_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+GTEST_API_ void SleepMilliseconds(int n);
+
+// Provides leak-safe Windows kernel handle ownership.
+// Used in death tests and in threading support.
+class GTEST_API_ AutoHandle {
+ public:
+  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
+  // avoid including <windows.h> in this header file. Including <windows.h> is
+  // undesirable because it defines a lot of symbols and macros that tend to
+  // conflict with client code. This assumption is verified by
+  // WindowsTypesTest.HANDLEIsVoidStar.
+  typedef void* Handle;
+  AutoHandle();
+  explicit AutoHandle(Handle handle);
+
+  ~AutoHandle();
+
+  Handle Get() const;
+  void Reset();
+  void Reset(Handle handle);
+
+ private:
+  // Returns true iff the handle is a valid handle object that can be closed.
+  bool IsCloseable() const;
+
+  Handle handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class GTEST_API_ Notification {
+ public:
+  Notification();
+  void Notify();
+  void WaitForNotification();
+
+ private:
+  AutoHandle event_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+# endif  // GTEST_HAS_NOTIFICATION_
+
+// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
+// defined, but we don't want to use MinGW's pthreads implementation, which
+// has conformance problems with some versions of the POSIX standard.
+# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+
+// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
+// Consequently, it cannot select a correct instantiation of ThreadWithParam
+// in order to call its Run(). Introducing ThreadWithParamBase as a
+// non-templated base class for ThreadWithParam allows us to bypass this
+// problem.
+class ThreadWithParamBase {
+ public:
+  virtual ~ThreadWithParamBase() {}
+  virtual void Run() = 0;
+};
+
+// pthread_create() accepts a pointer to a function type with the C linkage.
+// According to the Standard (7.5/1), function types with different linkages
+// are different even if they are otherwise identical.  Some compilers (for
+// example, SunStudio) treat them as different types.  Since class methods
+// cannot be defined with C-linkage we need to define a free C-function to
+// pass into pthread_create().
+extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
+  static_cast<ThreadWithParamBase*>(thread)->Run();
+  return NULL;
+}
+
+// Helper class for testing Google Test's multi-threading constructs.
+// To use it, write:
+//
+//   void ThreadFunc(int param) { /* Do things with param */ }
+//   Notification thread_can_start;
+//   ...
+//   // The thread_can_start parameter is optional; you can supply NULL.
+//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
+//   thread_can_start.Notify();
+//
+// These classes are only for testing Google Test's own constructs. Do
+// not use them in user tests, either directly or indirectly.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : func_(func),
+        param_(param),
+        thread_can_start_(thread_can_start),
+        finished_(false) {
+    ThreadWithParamBase* const base = this;
+    // The thread can be created only after all fields except thread_
+    // have been initialized.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
+  }
+  ~ThreadWithParam() { Join(); }
+
+  void Join() {
+    if (!finished_) {
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
+      finished_ = true;
+    }
+  }
+
+  virtual void Run() {
+    if (thread_can_start_ != NULL)
+      thread_can_start_->WaitForNotification();
+    func_(param_);
+  }
+
+ private:
+  UserThreadFunc* const func_;  // User-supplied thread function.
+  const T param_;  // User-supplied parameter to the thread function.
+  // When non-NULL, used to block execution until the controller thread
+  // notifies.
+  Notification* const thread_can_start_;
+  bool finished_;  // true iff we know that the thread function has finished.
+  pthread_t thread_;  // The native thread object.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+// Mutex and ThreadLocal have already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Mutex implements mutex on Windows platforms.  It is used in conjunction
+// with class MutexLock:
+//
+//   Mutex mutex;
+//   ...
+//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
+//                            // end of the current scope.
+//
+// A static Mutex *must* be defined or declared using one of the following
+// macros:
+//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
+//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
+//
+// (A non-static Mutex is defined/declared in the usual way).
+class GTEST_API_ Mutex {
+ public:
+  enum MutexType { kStatic = 0, kDynamic = 1 };
+  // We rely on kStaticMutex being 0 as it is to what the linker initializes
+  // type_ in static mutexes.  critical_section_ will be initialized lazily
+  // in ThreadSafeLazyInit().
+  enum StaticConstructorSelector { kStaticMutex = 0 };
+
+  // This constructor intentionally does nothing.  It relies on type_ being
+  // statically initialized to 0 (effectively setting it to kStatic) and on
+  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
+  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
+
+  Mutex();
+  ~Mutex();
+
+  void Lock();
+
+  void Unlock();
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld();
+
+ private:
+  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
+  void ThreadSafeLazyInit();
+
+  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
+  // we assume that 0 is an invalid value for thread IDs.
+  unsigned int owner_thread_id_;
+
+  // For static mutexes, we rely on these members being initialized to zeros
+  // by the linker.
+  MutexType type_;
+  long critical_section_init_phase_;  // NOLINT
+  _RTL_CRITICAL_SECTION* critical_section_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+    extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
+// without knowing its type.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Provides a way for a thread to send notifications to a ThreadLocal
+// regardless of its parameter type.
+class ThreadLocalBase {
+ public:
+  // Creates a new ValueHolder<T> object holding a default value passed to
+  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
+  // responsibility not to call this when the ThreadLocal<T> instance already
+  // has a value on the current thread.
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
+
+ protected:
+  ThreadLocalBase() {}
+  virtual ~ThreadLocalBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+};
+
+// Maps a thread to a set of ThreadLocals that have values instantiated on that
+// thread and notifies them when the thread exits.  A ThreadLocal instance is
+// expected to persist until all threads it has values on have terminated.
+class GTEST_API_ ThreadLocalRegistry {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance);
+
+  // Invoked when a ThreadLocal instance is destroyed.
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance);
+};
+
+class GTEST_API_ ThreadWithParamBase {
+ public:
+  void Join();
+
+ protected:
+  class Runnable {
+   public:
+    virtual ~Runnable() {}
+    virtual void Run() = 0;
+  };
+
+  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  virtual ~ThreadWithParamBase();
+
+ private:
+  AutoHandle thread_;
+};
+
+// Helper class for testing Google Test's multi-threading constructs.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
+  }
+  virtual ~ThreadWithParam() {}
+
+ private:
+  class RunnableImpl : public Runnable {
+   public:
+    RunnableImpl(UserThreadFunc* func, T param)
+        : func_(func),
+          param_(param) {
+    }
+    virtual ~RunnableImpl() {}
+    virtual void Run() {
+      func_(param_);
+    }
+
+   private:
+    UserThreadFunc* const func_;
+    const T param_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+  };
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+
+// Implements thread-local storage on Windows systems.
+//
+//   // Thread 1
+//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
+//
+//   // Thread 2
+//   tl.set(150);  // Changes the value for thread 2 only.
+//   EXPECT_EQ(150, tl.get());
+//
+//   // Thread 1
+//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
+//   tl.set(200);
+//   EXPECT_EQ(200, tl.get());
+//
+// The template type argument T must have a public copy constructor.
+// In addition, the default ThreadLocal constructor requires T to have
+// a public default constructor.
+//
+// The users of a TheadLocal instance have to make sure that all but one
+// threads (including the main one) using that instance have exited before
+// destroying it. Otherwise, the per-thread objects managed for them by the
+// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
+//
+// Google Test only uses global ThreadLocal objects.  That means they
+// will die after main() has returned.  Therefore, no per-thread
+// object managed by Google Test will be leaked as long as all threads
+// using Google Test have exited when main() returns.
+template <typename T>
+class ThreadLocal : public ThreadLocalBase {
+ public:
+  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of T.  Can be deleted via its base class without the caller
+  // knowing the type of T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+
+  T* GetOrCreateValue() const {
+    return static_cast<ValueHolder*>(
+        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+  }
+
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+    return default_factory_->MakeNewHolder();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    virtual ValueHolder* MakeNewHolder() const {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  scoped_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# elif GTEST_HAS_PTHREAD
+
+// MutexBase and Mutex implement mutex on pthreads-based platforms.
+class MutexBase {
+ public:
+  // Acquires this mutex.
+  void Lock() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
+    owner_ = pthread_self();
+    has_owner_ = true;
+  }
+
+  // Releases this mutex.
+  void Unlock() {
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
+    // mutex when this is called.
+    has_owner_ = false;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
+  }
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld() const {
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
+        << "The current thread is not holding the mutex @" << this;
+  }
+
+  // A static mutex may be used before main() is entered.  It may even
+  // be used before the dynamic initialization stage.  Therefore we
+  // must be able to initialize a static mutex object at link time.
+  // This means MutexBase has to be a POD and its member variables
+  // have to be public.
+ public:
+  pthread_mutex_t mutex_;  // The underlying pthread mutex.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
+};
+
+// Forward-declares a static mutex.
+#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+     extern ::testing::internal::MutexBase mutex
+
+// Defines and statically (i.e. at link time) initializes a static mutex.
+// The initialization list here does not explicitly initialize each field,
+// instead relying on default initialization for the unspecified fields. In
+// particular, the owner_ field (a pthread_t) is not explicitly initialized.
+// This allows initialization to work whether pthread_t is a scalar or struct.
+// The flag -Wmissing-field-initializers must not be specified for this to work.
+#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
+
+// The Mutex class can only be used for mutexes created at runtime. It
+// shares its API with MutexBase otherwise.
+class Mutex : public MutexBase {
+ public:
+  Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
+    has_owner_ = false;
+  }
+  ~Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(MutexBase* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  MutexBase* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Helpers for ThreadLocal.
+
+// pthread_key_create() requires DeleteThreadLocalValue() to have
+// C-linkage.  Therefore it cannot be templatized to access
+// ThreadLocal<T>.  Hence the need for class
+// ThreadLocalValueHolderBase.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Called by pthread to delete thread-local data stored by
+// pthread_setspecific().
+extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
+  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
+}
+
+// Implements thread-local storage on pthreads-based systems.
+template <typename T>
+class ThreadLocal {
+ public:
+  ThreadLocal()
+      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : key_(CreateKey()),
+        default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() {
+    // Destroys the managed object for the current thread, if any.
+    DeleteThreadLocalValue(pthread_getspecific(key_));
+
+    // Releases resources associated with the key.  This will *not*
+    // delete managed objects for other threads.
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
+  }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of type T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+  static pthread_key_t CreateKey() {
+    pthread_key_t key;
+    // When a thread exits, DeleteThreadLocalValue() will be called on
+    // the object managed for that thread.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_key_create(&key, &DeleteThreadLocalValue));
+    return key;
+  }
+
+  T* GetOrCreateValue() const {
+    ThreadLocalValueHolderBase* const holder =
+        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
+    if (holder != NULL) {
+      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
+    }
+
+    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
+    ThreadLocalValueHolderBase* const holder_base = new_holder;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
+    return new_holder->pointer();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    virtual ValueHolder* MakeNewHolder() const {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  // A key pthreads uses for looking up per-thread values.
+  const pthread_key_t key_;
+  scoped_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+#else  // GTEST_IS_THREADSAFE
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  void Lock() {}
+  void Unlock() {}
+  void AssertHeld() const {}
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class ThreadLocal {
+ public:
+  ThreadLocal() : value_() {}
+  explicit ThreadLocal(const T& value) : value_(value) {}
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+GTEST_API_ size_t GetThreadCount();
+
+// Passing non-POD classes through ellipsis (...) crashes the ARM
+// compiler and generates a warning in Sun Studio.  The Nokia Symbian
+// and the IBM XL C/C++ compiler try to instantiate a copy constructor
+// for objects passed through ellipsis (...), failing for uncopyable
+// objects.  We define this to ensure that only POD is passed through
+// ellipsis on these systems.
+#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
+// We lose support for NULL detection where the compiler doesn't like
+// passing non-POD classes through ellipsis (...).
+# define GTEST_ELLIPSIS_NEEDS_POD_ 1
+#else
+# define GTEST_CAN_COMPARE_NULL 1
+#endif
+
+// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
+// const T& and const T* in a function template.  These compilers
+// _can_ decide between class template specializations for T and T*,
+// so a tr1::type_traits-like is_pointer works.
+#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
+# define GTEST_NEEDS_IS_POINTER_ 1
+#endif
+
+template <bool bool_value>
+struct bool_constant {
+  typedef bool_constant<bool_value> type;
+  static const bool value = bool_value;
+};
+template <bool bool_value> const bool bool_constant<bool_value>::value;
+
+typedef bool_constant<false> false_type;
+typedef bool_constant<true> true_type;
+
+template <typename T>
+struct is_pointer : public false_type {};
+
+template <typename T>
+struct is_pointer<T*> : public true_type {};
+
+template <typename Iterator>
+struct IteratorTraits {
+  typedef typename Iterator::value_type value_type;
+};
+
+template <typename T>
+struct IteratorTraits<T*> {
+  typedef T value_type;
+};
+
+template <typename T>
+struct IteratorTraits<const T*> {
+  typedef T value_type;
+};
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_SEP_ "\\"
+# define GTEST_HAS_ALT_PATH_SEP_ 1
+// The biggest signed integer type the compiler supports.
+typedef __int64 BiggestInt;
+#else
+# define GTEST_PATH_SEP_ "/"
+# define GTEST_HAS_ALT_PATH_SEP_ 0
+typedef long long BiggestInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+// Utilities for char.
+
+// isspace(int ch) and friends accept an unsigned char or EOF.  char
+// may be signed, depending on the compiler (or compiler flags).
+// Therefore we need to cast a char to unsigned char before calling
+// isspace(), etc.
+
+inline bool IsAlpha(char ch) {
+  return isalpha(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsAlNum(char ch) {
+  return isalnum(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsDigit(char ch) {
+  return isdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsLower(char ch) {
+  return islower(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsSpace(char ch) {
+  return isspace(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsUpper(char ch) {
+  return isupper(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(char ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(wchar_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+
+inline char ToLower(char ch) {
+  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
+}
+inline char ToUpper(char ch) {
+  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
+}
+
+inline std::string StripTrailingSpaces(std::string str) {
+  std::string::iterator it = str.end();
+  while (it != str.begin() && IsSpace(*--it))
+    it = str.erase(it);
+  return str;
+}
+
+// The testing::internal::posix namespace holds wrappers for common
+// POSIX functions.  These wrappers hide the differences between
+// Windows/MSVC and POSIX systems.  Since some compilers define these
+// standard functions as macros, the wrapper cannot have the same name
+// as the wrapped function.
+
+namespace posix {
+
+// Functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+typedef struct _stat StatStruct;
+
+# ifdef __BORLANDC__
+inline int IsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+# else  // !__BORLANDC__
+#  if GTEST_OS_WINDOWS_MOBILE
+inline int IsATTY(int /* fd */) { return 0; }
+#  else
+inline int IsATTY(int fd) { return _isatty(fd); }
+#  endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+# endif  // __BORLANDC__
+
+# if GTEST_OS_WINDOWS_MOBILE
+inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
+// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
+// time and thus not defined there.
+# else
+inline int FileNo(FILE* file) { return _fileno(file); }
+inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
+inline int RmDir(const char* dir) { return _rmdir(dir); }
+inline bool IsDir(const StatStruct& st) {
+  return (_S_IFDIR & st.st_mode) != 0;
+}
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+#else
+
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int IsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#endif  // GTEST_OS_WINDOWS
+
+// Functions deprecated by MSVC 8.0.
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
+
+inline const char* StrNCpy(char* dest, const char* src, size_t n) {
+  return strncpy(dest, src, n);
+}
+
+// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
+// StrError() aren't needed on Windows CE at this time and thus not
+// defined there.
+
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+inline int ChDir(const char* dir) { return chdir(dir); }
+#endif
+inline FILE* FOpen(const char* path, const char* mode) {
+  return fopen(path, mode);
+}
+#if !GTEST_OS_WINDOWS_MOBILE
+inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+  return freopen(path, mode, stream);
+}
+inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
+#endif
+inline int FClose(FILE* fp) { return fclose(fp); }
+#if !GTEST_OS_WINDOWS_MOBILE
+inline int Read(int fd, void* buf, unsigned int count) {
+  return static_cast<int>(read(fd, buf, count));
+}
+inline int Write(int fd, const void* buf, unsigned int count) {
+  return static_cast<int>(write(fd, buf, count));
+}
+inline int Close(int fd) { return close(fd); }
+inline const char* StrError(int errnum) { return strerror(errnum); }
+#endif
+inline const char* GetEnv(const char* name) {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT
+  // We are on Windows CE, which has no environment variables.
+  static_cast<void>(name);  // To prevent 'unused argument' warning.
+  return NULL;
+#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // Environment variables which we programmatically clear will be set to the
+  // empty string rather than unset (NULL).  Handle that case.
+  const char* const env = getenv(name);
+  return (env != NULL && env[0] != '\0') ? env : NULL;
+#else
+  return getenv(name);
+#endif
+}
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Windows CE has no C library. The abort() function is used in
+// several places in Google Test. This implementation provides a reasonable
+// imitation of standard behaviour.
+void Abort();
+#else
+inline void Abort() { abort(); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace posix
+
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
+// function in order to achieve that.  We use macro definition here because
+// snprintf is a variadic function.
+#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
+// MSVC 2005 and above support variadic macros.
+# define GTEST_SNPRINTF_(buffer, size, format, ...) \
+     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#elif defined(_MSC_VER)
+// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
+// complain about _snprintf.
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
+// The maximum number a BiggestInt can represent.  This definition
+// works no matter BiggestInt is represented in one's complement or
+// two's complement.
+//
+// We cannot rely on numeric_limits in STL, as __int64 and long long
+// are not part of standard C++ and numeric_limits doesn't need to be
+// defined for them.
+const BiggestInt kMaxBiggestInt =
+    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
+
+// This template class serves as a compile-time function from size to
+// type.  It maps a size in bytes to a primitive type with that
+// size. e.g.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  typedef void UInt;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  // unsigned int has size 4 in both gcc and MSVC.
+  //
+  // As base/basictypes.h doesn't compile on Windows, we cannot use
+  // uint32, uint64, and etc here.
+  typedef int Int;
+  typedef unsigned int UInt;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+#if GTEST_OS_WINDOWS
+  typedef __int64 Int;
+  typedef unsigned __int64 UInt;
+#else
+  typedef long long Int;  // NOLINT
+  typedef unsigned long long UInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+};
+
+// Integer types of known sizes.
+typedef TypeWithSize<4>::Int Int32;
+typedef TypeWithSize<4>::UInt UInt32;
+typedef TypeWithSize<8>::Int Int64;
+typedef TypeWithSize<8>::UInt UInt64;
+typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// Macro for referencing flags.
+#if !defined(GTEST_FLAG)
+# define GTEST_FLAG(name) FLAGS_gtest_##name
+#endif  // !defined(GTEST_FLAG)
+
+#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+
+#if !defined(GTEST_DECLARE_bool_)
+# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+// Macros for declaring flags.
+# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
+# define GTEST_DECLARE_int32_(name) \
+    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
+#define GTEST_DECLARE_string_(name) \
+    GTEST_API_ extern ::std::string GTEST_FLAG(name)
+
+// Macros for defining flags.
+#define GTEST_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
+
+#endif  // !defined(GTEST_DECLARE_bool_)
+
+// Thread annotations
+#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+# define GTEST_LOCK_EXCLUDED_(locks)
+#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
+// to *value and returns true; otherwise leaves *value unchanged and returns
+// false.
+// TODO(chandlerc): Find a better way to refactor flag and environment parsing
+// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
+// function.
+bool ParseInt32(const Message& src_text, const char* str, Int32* value);
+
+// Parses a bool/Int32/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
+const char* StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+
+#if GTEST_OS_LINUX
+# include <stdlib.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#include <ctype.h>
+#include <float.h>
+#include <string.h>
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <limits>
+
+
+// Ensures that there is at least one operator<< in the global namespace.
+// See Message& operator<<(...) below for why.
+void operator<<(const testing::internal::Secret&, int);
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a stringstream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that stringstream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class GTEST_API_ Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  Message();
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new ::std::stringstream) {
+    *ss_ << str;
+  }
+
+#if GTEST_OS_SYMBIAN
+  // Streams a value (either a pointer or not) to this object.
+  template <typename T>
+  inline Message& operator <<(const T& value) {
+    StreamHelper(typename internal::is_pointer<T>::type(), value);
+    return *this;
+  }
+#else
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+    return *this;
+  }
+#endif  // GTEST_OS_SYMBIAN
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::wstring& wstr);
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+  // Gets the text streamed to this object so far as an std::string.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  std::string GetString() const;
+
+ private:
+
+#if GTEST_OS_SYMBIAN
+  // These are needed as the Nokia Symbian Compiler cannot decide between
+  // const T& and const T* in a function template. The Nokia compiler _can_
+  // decide between class template specializations for T and T*, so a
+  // tr1::type_traits-like is_pointer works, and we can overload on that.
+  template <typename T>
+  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+  }
+  template <typename T>
+  inline void StreamHelper(internal::false_type /*is_pointer*/,
+                           const T& value) {
+    // See the comments in Message& operator <<(const T&) above for why
+    // we need this using statement.
+    using ::operator <<;
+    *ss_ << value;
+  }
+#endif  // GTEST_OS_SYMBIAN
+
+  // We'll hold the text streamed to this object here.
+  const internal::scoped_ptr< ::std::stringstream> ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file declares the String class and functions used internally by
+// Google Test.  They are subject to change without notice. They should not used
+// by code external to Google Test.
+//
+// This header file is #included by <gtest/internal/gtest-internal.h>.
+// It should not be #included by other files.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#ifdef __BORLANDC__
+// string.h is not guaranteed to provide strcpy on C++ Builder.
+# include <mem.h>
+#endif
+
+#include <string.h>
+#include <string>
+
+
+namespace testing {
+namespace internal {
+
+// String - an abstract class holding static string utilities.
+class GTEST_API_ String {
+ public:
+  // Static utility methods
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+#if GTEST_OS_WINDOWS_MOBILE
+  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
+  // able to pass strings to Win32 APIs on CE we need to convert them
+  // to 'Unicode', UTF-16.
+
+  // Creates a UTF-16 wide string from the given ANSI string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the wide string, or NULL if the
+  // input is NULL.
+  //
+  // The wide string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static LPCWSTR AnsiToUtf16(const char* c_str);
+
+  // Creates an ANSI string from the given wide string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the ANSI string, or NULL if the
+  // input is NULL.
+  //
+  // The returned string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
+#endif
+
+  // Compares two C strings.  Returns true iff they have the same content.
+  //
+  // Unlike strcmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true iff they have the same
+  // content.
+  //
+  // Unlike wcscmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
+
+  // Compares two C strings, ignoring case.  Returns true iff they
+  // have the same content.
+  //
+  // Unlike strcasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Compares two wide C strings, ignoring case.  Returns true iff they
+  // have the same content.
+  //
+  // Unlike wcscasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL wide C string,
+  // including the empty string.
+  // NB: The implementations on different platforms slightly differ.
+  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+  // environment variable. On GNU platform this method uses wcscasecmp
+  // which compares according to LC_CTYPE category of the current locale.
+  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+  // current locale.
+  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                               const wchar_t* rhs);
+
+  // Returns true iff the given string ends with the given suffix, ignoring
+  // case. Any string is considered to end with an empty suffix.
+  static bool EndsWithCaseInsensitive(
+      const std::string& str, const std::string& suffix);
+
+  // Formats an int value as "%02d".
+  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
+
+  // Formats an int value as "%X".
+  static std::string FormatHexInt(int value);
+
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
+
+ private:
+  String();  // Not meant to be instantiated.
+};  // class String
+
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
+// character in the buffer is replaced with "\\0".
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: keith.ray@gmail.com (Keith Ray)
+//
+// Google Test filepath utilities
+//
+// This header file declares classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included in <gtest/internal/gtest-internal.h>.
+// Do not include this header file separately!
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class GTEST_API_ FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+    Normalize();
+  }
+
+  FilePath& operator=(const FilePath& rhs) {
+    Set(rhs);
+    return *this;
+  }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  const std::string& string() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Returns the current working directory, or "" if unsuccessful.
+  static FilePath GetCurrentDir();
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Given directory = "dir", relative_path = "test.xml",
+  // returns "dir/test.xml".
+  // On Windows, uses \ as the separator rather than /.
+  static FilePath ConcatPaths(const FilePath& directory,
+                              const FilePath& relative_path);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // Returns true iff the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+  // Returns true if pathname describes a root directory. (Windows has one
+  // root directory per disk drive.)
+  bool IsRootDirectory() const;
+
+  // Returns true if pathname describes an absolute path.
+  bool IsAbsolutePath() const;
+
+ private:
+  // Replaces multiple consecutive separators with a single separator.
+  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+  // redundancies that might be in a pathname involving "." or "..".
+  //
+  // A pathname with multiple consecutive separators may occur either through
+  // user error or as a result of some scripts or APIs that generate a pathname
+  // with a trailing separator. On other platforms the same API or script
+  // may NOT generate a pathname with a trailing "/". Then elsewhere that
+  // pathname may have another "/" and pathname components added to it,
+  // without checking for the separator already being there.
+  // The script language and operating system may allow paths like "foo//bar"
+  // but some of the functions in FilePath will not handle that correctly. In
+  // particular, RemoveTrailingPathSeparator() only removes one separator, and
+  // it is called in CreateDirectoriesRecursively() assuming that it will change
+  // a pathname from directory syntax (trailing separator) to filename syntax.
+  //
+  // On Windows this method also replaces the alternate path separator '/' with
+  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
+  // "bar\\foo".
+
+  void Normalize();
+
+  // Returns a pointer to the last occurence of a valid path separator in
+  // the FilePath. On Windows, for example, both '/' and '\' are valid path
+  // separators. Returns NULL if no path separator was found.
+  const char* FindLastPathSeparator() const;
+
+  std::string pathname_;
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+// This file was GENERATED by command:
+//     pump.py gtest-type-util.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2008 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently we support at most 50 types in a list, and at most 50
+// type-parameterized tests in one type-parameterized test case.
+// Please contact googletestframework@googlegroups.com if you need
+// more.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// GetTypeName<T>() returns a human-readable name of type T.
+// NB: This function is also used in Google Mock, so don't move it inside of
+// the typed-test-only section below.
+template <typename T>
+std::string GetTypeName() {
+# if GTEST_HAS_RTTI
+
+  const char* const name = typeid(T).name();
+#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+  int status = 0;
+  // gcc's implementation of typeid(T).name() mangles the type name,
+  // so we have to demangle it.
+#   if GTEST_HAS_CXXABI_H_
+  using abi::__cxa_demangle;
+#   endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return name_str;
+#  else
+  return name;
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+
+# else
+
+  return "<type>";
+
+# endif  // GTEST_HAS_RTTI
+}
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
+// type.  This can be used as a compile-time assertion to ensure that
+// two types are equal.
+
+template <typename T1, typename T2>
+struct AssertTypeEq;
+
+template <typename T>
+struct AssertTypeEq<T, T> {
+  typedef bool type;
+};
+
+// A unique type used as the default value for the arguments of class
+// template Types.  This allows us to simulate variadic templates
+// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
+// support directly.
+struct None {};
+
+// The following family of struct and struct templates are used to
+// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
+// represents a type list with N types (T1, T2, ..., and TN) in it.
+// Except for Types0, every struct in the family has two member types:
+// Head for the first type in the list, and Tail for the rest of the
+// list.
+
+// The empty type list.
+struct Types0 {};
+
+// Type lists of length 1, 2, 3, and so on.
+
+template <typename T1>
+struct Types1 {
+  typedef T1 Head;
+  typedef Types0 Tail;
+};
+template <typename T1, typename T2>
+struct Types2 {
+  typedef T1 Head;
+  typedef Types1<T2> Tail;
+};
+
+template <typename T1, typename T2, typename T3>
+struct Types3 {
+  typedef T1 Head;
+  typedef Types2<T2, T3> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4>
+struct Types4 {
+  typedef T1 Head;
+  typedef Types3<T2, T3, T4> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+struct Types5 {
+  typedef T1 Head;
+  typedef Types4<T2, T3, T4, T5> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+struct Types6 {
+  typedef T1 Head;
+  typedef Types5<T2, T3, T4, T5, T6> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+struct Types7 {
+  typedef T1 Head;
+  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+struct Types8 {
+  typedef T1 Head;
+  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+struct Types9 {
+  typedef T1 Head;
+  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+struct Types10 {
+  typedef T1 Head;
+  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+struct Types11 {
+  typedef T1 Head;
+  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+struct Types12 {
+  typedef T1 Head;
+  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+struct Types13 {
+  typedef T1 Head;
+  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+struct Types14 {
+  typedef T1 Head;
+  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+struct Types15 {
+  typedef T1 Head;
+  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+struct Types16 {
+  typedef T1 Head;
+  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+struct Types17 {
+  typedef T1 Head;
+  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+struct Types18 {
+  typedef T1 Head;
+  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+struct Types19 {
+  typedef T1 Head;
+  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+struct Types20 {
+  typedef T1 Head;
+  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+struct Types21 {
+  typedef T1 Head;
+  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+struct Types22 {
+  typedef T1 Head;
+  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+struct Types23 {
+  typedef T1 Head;
+  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+struct Types24 {
+  typedef T1 Head;
+  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+struct Types25 {
+  typedef T1 Head;
+  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+struct Types26 {
+  typedef T1 Head;
+  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+struct Types27 {
+  typedef T1 Head;
+  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+struct Types28 {
+  typedef T1 Head;
+  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+struct Types29 {
+  typedef T1 Head;
+  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+struct Types30 {
+  typedef T1 Head;
+  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+struct Types31 {
+  typedef T1 Head;
+  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+struct Types32 {
+  typedef T1 Head;
+  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+struct Types33 {
+  typedef T1 Head;
+  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+struct Types34 {
+  typedef T1 Head;
+  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+struct Types35 {
+  typedef T1 Head;
+  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+struct Types36 {
+  typedef T1 Head;
+  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+struct Types37 {
+  typedef T1 Head;
+  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+struct Types38 {
+  typedef T1 Head;
+  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+struct Types39 {
+  typedef T1 Head;
+  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+struct Types40 {
+  typedef T1 Head;
+  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+struct Types41 {
+  typedef T1 Head;
+  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+struct Types42 {
+  typedef T1 Head;
+  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+struct Types43 {
+  typedef T1 Head;
+  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+struct Types44 {
+  typedef T1 Head;
+  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+struct Types45 {
+  typedef T1 Head;
+  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+struct Types46 {
+  typedef T1 Head;
+  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+struct Types47 {
+  typedef T1 Head;
+  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+struct Types48 {
+  typedef T1 Head;
+  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+struct Types49 {
+  typedef T1 Head;
+  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48, T49> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+struct Types50 {
+  typedef T1 Head;
+  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48, T49, T50> Tail;
+};
+
+
+}  // namespace internal
+
+// We don't want to require the users to write TypesN<...> directly,
+// as that would require them to count the length.  Types<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Types<int>
+// will appear as Types<int, None, None, ..., None> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Types<T1, ..., TN>, and Google Test will translate
+// that to TypesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Types template.
+template <typename T1 = internal::None, typename T2 = internal::None,
+    typename T3 = internal::None, typename T4 = internal::None,
+    typename T5 = internal::None, typename T6 = internal::None,
+    typename T7 = internal::None, typename T8 = internal::None,
+    typename T9 = internal::None, typename T10 = internal::None,
+    typename T11 = internal::None, typename T12 = internal::None,
+    typename T13 = internal::None, typename T14 = internal::None,
+    typename T15 = internal::None, typename T16 = internal::None,
+    typename T17 = internal::None, typename T18 = internal::None,
+    typename T19 = internal::None, typename T20 = internal::None,
+    typename T21 = internal::None, typename T22 = internal::None,
+    typename T23 = internal::None, typename T24 = internal::None,
+    typename T25 = internal::None, typename T26 = internal::None,
+    typename T27 = internal::None, typename T28 = internal::None,
+    typename T29 = internal::None, typename T30 = internal::None,
+    typename T31 = internal::None, typename T32 = internal::None,
+    typename T33 = internal::None, typename T34 = internal::None,
+    typename T35 = internal::None, typename T36 = internal::None,
+    typename T37 = internal::None, typename T38 = internal::None,
+    typename T39 = internal::None, typename T40 = internal::None,
+    typename T41 = internal::None, typename T42 = internal::None,
+    typename T43 = internal::None, typename T44 = internal::None,
+    typename T45 = internal::None, typename T46 = internal::None,
+    typename T47 = internal::None, typename T48 = internal::None,
+    typename T49 = internal::None, typename T50 = internal::None>
+struct Types {
+  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
+};
+
+template <>
+struct Types<internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types0 type;
+};
+template <typename T1>
+struct Types<T1, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types1<T1> type;
+};
+template <typename T1, typename T2>
+struct Types<T1, T2, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types2<T1, T2> type;
+};
+template <typename T1, typename T2, typename T3>
+struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types3<T1, T2, T3> type;
+};
+template <typename T1, typename T2, typename T3, typename T4>
+struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types4<T1, T2, T3, T4> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types5<T1, T2, T3, T4, T5> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, internal::None, internal::None, internal::None> {
+  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, T48, internal::None, internal::None> {
+  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, T48, T49, internal::None> {
+  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
+};
+
+namespace internal {
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+// A unique struct template used as the default value for the
+// arguments of class template Templates.  This allows us to simulate
+// variadic templates (e.g. Templates<int>, Templates<int, double>,
+// and etc), which C++ doesn't support directly.
+template <typename T>
+struct NoneT {};
+
+// The following family of struct and struct templates are used to
+// represent template lists.  In particular, TemplatesN<T1, T2, ...,
+// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
+// for Templates0, every struct in the family has two member types:
+// Head for the selector of the first template in the list, and Tail
+// for the rest of the list.
+
+// The empty template list.
+struct Templates0 {};
+
+// Template lists of length 1, 2, 3, and so on.
+
+template <GTEST_TEMPLATE_ T1>
+struct Templates1 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates0 Tail;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
+struct Templates2 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates1<T2> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
+struct Templates3 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates2<T2, T3> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4>
+struct Templates4 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates3<T2, T3, T4> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
+struct Templates5 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates4<T2, T3, T4, T5> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
+struct Templates6 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates5<T2, T3, T4, T5, T6> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7>
+struct Templates7 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
+struct Templates8 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
+struct Templates9 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10>
+struct Templates10 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
+struct Templates11 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
+struct Templates12 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13>
+struct Templates13 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
+struct Templates14 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
+struct Templates15 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16>
+struct Templates16 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
+struct Templates17 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
+struct Templates18 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19>
+struct Templates19 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
+struct Templates20 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
+struct Templates21 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22>
+struct Templates22 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
+struct Templates23 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
+struct Templates24 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25>
+struct Templates25 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
+struct Templates26 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
+struct Templates27 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28>
+struct Templates28 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
+struct Templates29 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
+struct Templates30 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31>
+struct Templates31 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
+struct Templates32 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
+struct Templates33 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34>
+struct Templates34 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
+struct Templates35 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
+struct Templates36 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37>
+struct Templates37 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
+struct Templates38 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
+struct Templates39 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40>
+struct Templates40 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
+struct Templates41 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
+struct Templates42 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43>
+struct Templates43 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
+struct Templates44 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
+struct Templates45 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46>
+struct Templates46 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
+struct Templates47 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
+struct Templates48 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49>
+struct Templates49 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48, T49> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
+struct Templates50 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48, T49, T50> Tail;
+};
+
+
+// We don't want to require the users to write TemplatesN<...> directly,
+// as that would require them to count the length.  Templates<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Templates<list>
+// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Templates<T1, ..., TN>, and Google Test will translate
+// that to TemplatesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Templates template.
+template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
+    GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
+    GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
+    GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
+    GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
+    GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
+    GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
+    GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
+    GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
+    GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
+    GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
+    GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
+    GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
+    GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
+    GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
+    GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
+    GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
+    GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
+    GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
+    GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
+    GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
+    GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
+    GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
+    GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
+    GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
+struct Templates {
+  typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
+};
+
+template <>
+struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates0 type;
+};
+template <GTEST_TEMPLATE_ T1>
+struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates1<T1> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
+struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates2<T1, T2> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
+struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates3<T1, T2, T3> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4>
+struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates4<T1, T2, T3, T4> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
+struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates5<T1, T2, T3, T4, T5> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
+struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates6<T1, T2, T3, T4, T5, T6> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, NoneT, NoneT, NoneT> {
+  typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, T48, NoneT, NoneT> {
+  typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, T48, T49, NoneT> {
+  typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48, T49> type;
+};
+
+// The TypeList template makes it possible to use either a single type
+// or a Types<...> list in TYPED_TEST_CASE() and
+// INSTANTIATE_TYPED_TEST_CASE_P().
+
+template <typename T>
+struct TypeList {
+  typedef Types1<T> type;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49, T50> > {
+  typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+
+class ProtocolMessage;
+namespace proto2 { class Message; }
+
+namespace testing {
+
+// Forward declarations.
+
+class AssertionResult;                 // Result of an assertion.
+class Message;                         // Represents a failure message.
+class Test;                            // Represents a test.
+class TestInfo;                        // Information about a test.
+class TestPartResult;                  // Result of a test part.
+class UnitTest;                        // A collection of test cases.
+
+template <typename T>
+::std::string PrintToString(const T& value);
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class ScopedTrace;                     // Implements scoped trace.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+GTEST_API_ extern const char kStackTraceMarker[];
+
+// Two overloaded helpers for checking at compile time whether an
+// expression is a null pointer literal (i.e. NULL or any 0-valued
+// compile-time integral constant).  Their return values have
+// different sizes, so we can use sizeof() to test which version is
+// picked by the compiler.  These helpers have no implementations, as
+// we only need their signatures.
+//
+// Given IsNullLiteralHelper(x), the compiler will pick the first
+// version if x can be implicitly converted to Secret*, and pick the
+// second version otherwise.  Since Secret is a secret and incomplete
+// type, the only expression a user can write that has type Secret* is
+// a null pointer literal.  Therefore, we know that x is a null
+// pointer literal if and only if the first version is picked by the
+// compiler.
+char IsNullLiteralHelper(Secret* p);
+char (&IsNullLiteralHelper(...))[2];  // NOLINT
+
+// A compile-time bool constant that is true if and only if x is a
+// null pointer literal (i.e. NULL or any 0-valued compile-time
+// integral constant).
+#ifdef GTEST_ELLIPSIS_NEEDS_POD_
+// We lose support for NULL detection where the compiler doesn't like
+// passing non-POD classes through ellipsis (...).
+# define GTEST_IS_NULL_LITERAL_(x) false
+#else
+# define GTEST_IS_NULL_LITERAL_(x) \
+    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
+#endif  // GTEST_ELLIPSIS_NEEDS_POD_
+
+// Appends the user-supplied message to the Google-Test-generated message.
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+// This exception is thrown by (and only by) a failed Google Test
+// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
+// are enabled).  We derive it from std::runtime_error, which is for
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// A helper class for creating scoped traces in user programs.
+class GTEST_API_ ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+  ScopedTrace(const char* file, int line, const Message& message);
+
+  // The d'tor pops the info pushed by the c'tor.
+  //
+  // Note that the d'tor is not virtual in order to be efficient.
+  // Don't inherit from ScopedTrace!
+  ~ScopedTrace();
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
+} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
+                            // c'tor and d'tor.  Therefore it doesn't
+                            // need to be used otherwise.
+
+namespace edit_distance {
+// Returns the optimal edits to go from 'left' to 'right'.
+// All edits cost the same, with replace having lower priority than
+// add/remove.
+// Simple implementation of the Wagner–Fischer algorithm.
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+enum EditType { kMatch, kAdd, kRemove, kReplace };
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<size_t>& left, const std::vector<size_t>& right);
+
+// Same as above, but the input is represented as strings.
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right);
+
+// Create a diff of the input strings in Unified diff format.
+GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                                         const std::vector<std::string>& right,
+                                         size_t context = 2);
+
+}  // namespace edit_distance
+
+// Calculate the diff between 'left' and 'right' and return it in unified diff
+// format.
+// If not null, stores in 'total_line_count' the total number of lines found
+// in left + right.
+GTEST_API_ std::string DiffStrings(const std::string& left,
+                                   const std::string& right,
+                                   size_t* total_line_count);
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true iff the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
+                                     const char* actual_expression,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
+                                     bool ignoring_case);
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value);
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  static const size_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return u_.bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+
+  // Returns true iff this is NAN (not a number).
+  bool is_nan() const {
+    // It's a NAN if the exponent bits are all ones and the fraction
+    // bits are not entirely zeros.
+    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
+  }
+
+  // Returns true iff this number is at most kMaxUlps ULP's away from
+  // rhs.  In particular, this function:
+  //
+  //   - returns false if either number is (or both are) NAN.
+  //   - treats really large numbers as almost equal to infinity.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
+        <= kMaxUlps;
+  }
+
+ private:
+  // The data type used to store the actual floating-point number.
+  union FloatingPointUnion {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  FloatingPointUnion u_;
+};
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+typedef FloatingPoint<float> Float;
+typedef FloatingPoint<double> Double;
+
+// In order to catch the mistake of putting tests that use different
+// test fixture classes in the same test case, we need to assign
+// unique IDs to fixture classes and compare them.  The TypeId type is
+// used to hold such IDs.  The user should treat TypeId as an opaque
+// type: the only operation allowed on TypeId values is to compare
+// them for equality using the == operator.
+typedef const void* TypeId;
+
+template <typename T>
+class TypeIdHelper {
+ public:
+  // dummy_ must not have a const type.  Otherwise an overly eager
+  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
+  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
+  static bool dummy_;
+};
+
+template <typename T>
+bool TypeIdHelper<T>::dummy_ = false;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+TypeId GetTypeId() {
+  // The compiler is required to allocate a different
+  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
+  // the template.  Therefore, the address of dummy_ is guaranteed to
+  // be unique.
+  return &(TypeIdHelper<T>::dummy_);
+}
+
+// Returns the type ID of ::testing::Test.  Always call this instead
+// of GetTypeId< ::testing::Test>() to get the type ID of
+// ::testing::Test, as the latter may give the wrong result due to a
+// suspected linker bug when compiling Google Test as a Mac OS X
+// framework.
+GTEST_API_ TypeId GetTestTypeId();
+
+// Defines the abstract factory interface that creates instances
+// of a Test object.
+class TestFactoryBase {
+ public:
+  virtual ~TestFactoryBase() {}
+
+  // Creates a test instance to run. The instance is both created and destroyed
+  // within TestInfoImpl::Run()
+  virtual Test* CreateTest() = 0;
+
+ protected:
+  TestFactoryBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+};
+
+// This class provides implementation of TeastFactoryBase interface.
+// It is used in TEST and TEST_F macros.
+template <class TestClass>
+class TestFactoryImpl : public TestFactoryBase {
+ public:
+  virtual Test* CreateTest() { return new TestClass; }
+};
+
+#if GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
+                                            long hr);  // NOLINT
+GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
+                                            long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+// Types of SetUpTestCase() and TearDownTestCase() functions.
+typedef void (*SetUpTestCaseFunc)();
+typedef void (*TearDownTestCaseFunc)();
+
+struct CodeLocation {
+  CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {}
+
+  string file;
+  int line;
+};
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_case_name:   name of the test case
+//   name:             name of the test
+//   type_param        the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param       text representation of the test's value parameter,
+//                     or NULL if this is not a type-parameterized test.
+//   code_location:    code location where the test is defined
+//   fixture_class_id: ID of the test fixture class
+//   set_up_tc:        pointer to the function that sets up the test case
+//   tear_down_tc:     pointer to the function that tears down the test case
+//   factory:          pointer to the factory that creates a test object.
+//                     The newly created TestInfo instance will assume
+//                     ownership of the factory object.
+GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
+    const char* test_case_name,
+    const char* name,
+    const char* type_param,
+    const char* value_param,
+    CodeLocation code_location,
+    TypeId fixture_class_id,
+    SetUpTestCaseFunc set_up_tc,
+    TearDownTestCaseFunc tear_down_tc,
+    TestFactoryBase* factory);
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// State of the definition of a type-parameterized test case.
+class GTEST_API_ TypedTestCasePState {
+ public:
+  TypedTestCasePState() : registered_(false) {}
+
+  // Adds the given test name to defined_test_names_ and return true
+  // if the test case hasn't been registered; otherwise aborts the
+  // program.
+  bool AddTestName(const char* file, int line, const char* case_name,
+                   const char* test_name) {
+    if (registered_) {
+      fprintf(stderr, "%s Test %s must be defined before "
+              "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
+              FormatFileLocation(file, line).c_str(), test_name, case_name);
+      fflush(stderr);
+      posix::Abort();
+    }
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
+    return true;
+  }
+
+  bool TestExists(const std::string& test_name) const {
+    return registered_tests_.count(test_name) > 0;
+  }
+
+  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
+    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
+    GTEST_CHECK_(it != registered_tests_.end());
+    return it->second;
+  }
+
+  // Verifies that registered_tests match the test names in
+  // defined_test_names_; returns registered_tests if successful, or
+  // aborts the program otherwise.
+  const char* VerifyRegisteredTestNames(
+      const char* file, int line, const char* registered_tests);
+
+ private:
+  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+
+  bool registered_;
+  RegisteredTestsMap registered_tests_;
+};
+
+// Skips to the first non-space char after the first comma in 'str';
+// returns NULL if no comma is found in 'str'.
+inline const char* SkipComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  if (comma == NULL) {
+    return NULL;
+  }
+  while (IsSpace(*(++comma))) {}
+  return comma;
+}
+
+// Returns the prefix of 'str' before the first comma in it; returns
+// the entire string if it contains no comma.
+inline std::string GetPrefixUntilComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  return comma == NULL ? str : std::string(str, comma);
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest);
+
+// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
+// registers a list of type-parameterized tests with Google Test.  The
+// return value is insignificant - we just need to return something
+// such that we can call this function in a namespace scope.
+//
+// Implementation note: The GTEST_TEMPLATE_ macro declares a template
+// template parameter.  It's defined in gtest-type-util.h.
+template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
+class TypeParameterizedTest {
+ public:
+  // 'index' is the index of the test in the type list 'Types'
+  // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
+  // Types).  Valid values for 'index' are [0, N - 1] where N is the
+  // length of Types.
+  static bool Register(const char* prefix,
+                       CodeLocation code_location,
+                       const char* case_name, const char* test_names,
+                       int index) {
+    typedef typename Types::Head Type;
+    typedef Fixture<Type> FixtureClass;
+    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
+
+    // First, registers the first type-parameterized test in the type
+    // list.
+    MakeAndRegisterTestInfo(
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
+         + StreamableToString(index)).c_str(),
+        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
+        GetTypeName<Type>().c_str(),
+        NULL,  // No value parameter.
+        code_location,
+        GetTypeId<FixtureClass>(),
+        TestClass::SetUpTestCase,
+        TestClass::TearDownTestCase,
+        new TestFactoryImpl<TestClass>);
+
+    // Next, recurses (at compile time) with the tail of the type list.
+    return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
+        ::Register(prefix, code_location, case_name, test_names, index + 1);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, class TestSel>
+class TypeParameterizedTest<Fixture, TestSel, Types0> {
+ public:
+  static bool Register(const char* /*prefix*/, CodeLocation,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       int /*index*/) {
+    return true;
+  }
+};
+
+// TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
+// registers *all combinations* of 'Tests' and 'Types' with Google
+// Test.  The return value is insignificant - we just need to return
+// something such that we can call this function in a namespace scope.
+template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
+class TypeParameterizedTestCase {
+ public:
+  static bool Register(const char* prefix, CodeLocation code_location,
+                       const TypedTestCasePState* state,
+                       const char* case_name, const char* test_names) {
+    std::string test_name = StripTrailingSpaces(
+        GetPrefixUntilComma(test_names));
+    if (!state->TestExists(test_name)) {
+      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
+              case_name, test_name.c_str(),
+              FormatFileLocation(code_location.file.c_str(),
+                                 code_location.line).c_str());
+      fflush(stderr);
+      posix::Abort();
+    }
+    const CodeLocation& test_location = state->GetCodeLocation(test_name);
+
+    typedef typename Tests::Head Head;
+
+    // First, register the first test in 'Test' for each type in 'Types'.
+    TypeParameterizedTest<Fixture, Head, Types>::Register(
+        prefix, test_location, case_name, test_names, 0);
+
+    // Next, recurses (at compile time) with the tail of the test list.
+    return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
+        ::Register(prefix, code_location, state,
+                   case_name, SkipComma(test_names));
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, typename Types>
+class TypeParameterizedTestCase<Fixture, Templates0, Types> {
+ public:
+  static bool Register(const char* /*prefix*/, CodeLocation,
+                       const TypedTestCasePState* /*state*/,
+                       const char* /*case_name*/, const char* /*test_names*/) {
+    return true;
+  }
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
+
+// Helpers for suppressing warnings on unreachable code or constant
+// condition.
+
+// Always returns true.
+GTEST_API_ bool AlwaysTrue();
+
+// Always returns false.
+inline bool AlwaysFalse() { return !AlwaysTrue(); }
+
+// Helper for suppressing false warning from Clang on a const char*
+// variable declared in a conditional expression always being NULL in
+// the else branch.
+struct GTEST_API_ ConstCharPtr {
+  ConstCharPtr(const char* str) : value(str) {}
+  operator bool() const { return true; }
+  const char* value;
+};
+
+// A simple Linear Congruential Generator for generating random
+// numbers with a uniform distribution.  Unlike rand() and srand(), it
+// doesn't use global state (and therefore can't interfere with user
+// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
+// but it's good enough for our purposes.
+class GTEST_API_ Random {
+ public:
+  static const UInt32 kMaxRange = 1u << 31;
+
+  explicit Random(UInt32 seed) : state_(seed) {}
+
+  void Reseed(UInt32 seed) { state_ = seed; }
+
+  // Generates a random number from [0, range).  Crashes if 'range' is
+  // 0 or greater than kMaxRange.
+  UInt32 Generate(UInt32 range);
+
+ private:
+  UInt32 state_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+};
+
+// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
+// compiler error iff T1 and T2 are different types.
+template <typename T1, typename T2>
+struct CompileAssertTypesEqual;
+
+template <typename T>
+struct CompileAssertTypesEqual<T, T> {
+};
+
+// Removes the reference from a type if it is a reference type,
+// otherwise leaves it unchanged.  This is the same as
+// tr1::remove_reference, which is not widely available yet.
+template <typename T>
+struct RemoveReference { typedef T type; };  // NOLINT
+template <typename T>
+struct RemoveReference<T&> { typedef T type; };  // NOLINT
+
+// A handy wrapper around RemoveReference that works when the argument
+// T depends on template parameters.
+#define GTEST_REMOVE_REFERENCE_(T) \
+    typename ::testing::internal::RemoveReference<T>::type
+
+// Removes const from a type if it is a const type, otherwise leaves
+// it unchanged.  This is the same as tr1::remove_const, which is not
+// widely available yet.
+template <typename T>
+struct RemoveConst { typedef T type; };  // NOLINT
+template <typename T>
+struct RemoveConst<const T> { typedef T type; };  // NOLINT
+
+// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
+// definition to fail to remove the const in 'const int[3]' and 'const
+// char[3][4]'.  The following specialization works around the bug.
+template <typename T, size_t N>
+struct RemoveConst<const T[N]> {
+  typedef typename RemoveConst<T>::type type[N];
+};
+
+#if defined(_MSC_VER) && _MSC_VER < 1400
+// This is the only specialization that allows VC++ 7.1 to remove const in
+// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
+// and thus needs to be conditionally compiled.
+template <typename T, size_t N>
+struct RemoveConst<T[N]> {
+  typedef typename RemoveConst<T>::type type[N];
+};
+#endif
+
+// A handy wrapper around RemoveConst that works when the argument
+// T depends on template parameters.
+#define GTEST_REMOVE_CONST_(T) \
+    typename ::testing::internal::RemoveConst<T>::type
+
+// Turns const U&, U&, const U, and U all into U.
+#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
+    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
+
+// Adds reference to a type if it is not a reference type,
+// otherwise leaves it unchanged.  This is the same as
+// tr1::add_reference, which is not widely available yet.
+template <typename T>
+struct AddReference { typedef T& type; };  // NOLINT
+template <typename T>
+struct AddReference<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper around AddReference that works when the argument T
+// depends on template parameters.
+#define GTEST_ADD_REFERENCE_(T) \
+    typename ::testing::internal::AddReference<T>::type
+
+// Adds a reference to const on top of T as necessary.  For example,
+// it transforms
+//
+//   char         ==> const char&
+//   const char   ==> const char&
+//   char&        ==> const char&
+//   const char&  ==> const char&
+//
+// The argument T must depend on some template parameters.
+#define GTEST_REFERENCE_TO_CONST_(T) \
+    GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
+
+// ImplicitlyConvertible<From, To>::value is a compile-time bool
+// constant that's true iff type From can be implicitly converted to
+// type To.
+template <typename From, typename To>
+class ImplicitlyConvertible {
+ private:
+  // We need the following helper functions only for their types.
+  // They have no implementations.
+
+  // MakeFrom() is an expression whose type is From.  We cannot simply
+  // use From(), as the type From may not have a public default
+  // constructor.
+  static typename AddReference<From>::type MakeFrom();
+
+  // These two functions are overloaded.  Given an expression
+  // Helper(x), the compiler will pick the first version if x can be
+  // implicitly converted to type To; otherwise it will pick the
+  // second version.
+  //
+  // The first version returns a value of size 1, and the second
+  // version returns a value of size 2.  Therefore, by checking the
+  // size of Helper(x), which can be done at compile time, we can tell
+  // which version of Helper() is used, and hence whether x can be
+  // implicitly converted to type To.
+  static char Helper(To);
+  static char (&Helper(...))[2];  // NOLINT
+
+  // We have to put the 'public' section after the 'private' section,
+  // or MSVC refuses to compile the code.
+ public:
+#if defined(__BORLANDC__)
+  // C++Builder cannot use member overload resolution during template
+  // instantiation.  The simplest workaround is to use its C++0x type traits
+  // functions (C++Builder 2009 and above only).
+  static const bool value = __is_convertible(From, To);
+#else
+  // MSVC warns about implicitly converting from double to int for
+  // possible loss of data, so we need to temporarily disable the
+  // warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
+  static const bool value =
+      sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif  // __BORLANDC__
+};
+template <typename From, typename To>
+const bool ImplicitlyConvertible<From, To>::value;
+
+// IsAProtocolMessage<T>::value is a compile-time bool constant that's
+// true iff T is type ProtocolMessage, proto2::Message, or a subclass
+// of those.
+template <typename T>
+struct IsAProtocolMessage
+    : public bool_constant<
+  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
+  ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
+};
+
+// When the compiler sees expression IsContainerTest<C>(0), if C is an
+// STL-style container class, the first overload of IsContainerTest
+// will be viable (since both C::iterator* and C::const_iterator* are
+// valid types and NULL can be implicitly converted to them).  It will
+// be picked over the second overload as 'int' is a perfect match for
+// the type of argument 0.  If C::iterator or C::const_iterator is not
+// a valid type, the first overload is not viable, and the second
+// overload will be picked.  Therefore, we can determine whether C is
+// a container class by checking the type of IsContainerTest<C>(0).
+// The value of the expression is insignificant.
+//
+// Note that we look for both C::iterator and C::const_iterator.  The
+// reason is that C++ injects the name of a class as a member of the
+// class itself (e.g. you can refer to class iterator as either
+// 'iterator' or 'iterator::iterator').  If we look for C::iterator
+// only, for example, we would mistakenly think that a class named
+// iterator is an STL container.
+//
+// Also note that the simpler approach of overloading
+// IsContainerTest(typename C::const_iterator*) and
+// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
+typedef int IsContainer;
+template <class C>
+IsContainer IsContainerTest(int /* dummy */,
+                            typename C::iterator* /* it */ = NULL,
+                            typename C::const_iterator* /* const_it */ = NULL) {
+  return 0;
+}
+
+typedef char IsNotContainer;
+template <class C>
+IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+
+// EnableIf<condition>::type is void when 'Cond' is true, and
+// undefined when 'Cond' is false.  To use SFINAE to make a function
+// overload only apply when a particular expression is true, add
+// "typename EnableIf<expression>::type* = 0" as the last parameter.
+template<bool> struct EnableIf;
+template<> struct EnableIf<true> { typedef void type; };  // NOLINT
+
+// Utilities for native arrays.
+
+// ArrayEq() compares two k-dimensional native arrays using the
+// elements' operator==, where k can be any integer >= 0.  When k is
+// 0, ArrayEq() degenerates into comparing a single pair of values.
+
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+  return internal::ArrayEq(lhs, N, rhs);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous ArrayEq() function, arrays with different sizes would
+// lead to different copies of the template code.
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
+  for (size_t i = 0; i != size; i++) {
+    if (!internal::ArrayEq(lhs[i], rhs[i]))
+      return false;
+  }
+  return true;
+}
+
+// Finds the first element in the iterator range [begin, end) that
+// equals elem.  Element may be a native array type itself.
+template <typename Iter, typename Element>
+Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
+  for (Iter it = begin; it != end; ++it) {
+    if (internal::ArrayEq(*it, elem))
+      return it;
+  }
+  return end;
+}
+
+// CopyArray() copies a k-dimensional native array using the elements'
+// operator=, where k can be any integer >= 0.  When k is 0,
+// CopyArray() degenerates into copying a single value.
+
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline void CopyArray(const T& from, U* to) { *to = from; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+  internal::CopyArray(from, N, *to);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous CopyArray() function, arrays with different sizes
+// would lead to different copies of the template code.
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to) {
+  for (size_t i = 0; i != size; i++) {
+    internal::CopyArray(from[i], to + i);
+  }
+}
+
+// The relation between an NativeArray object (see below) and the
+// native array it represents.
+// We use 2 different structs to allow non-copyable types to be used, as long
+// as RelationToSourceReference() is passed.
+struct RelationToSourceReference {};
+struct RelationToSourceCopy {};
+
+// Adapts a native array to a read-only STL-style container.  Instead
+// of the complete STL container concept, this adaptor only implements
+// members useful for Google Mock's container matchers.  New members
+// should be added as needed.  To simplify the implementation, we only
+// support Element being a raw type (i.e. having no top-level const or
+// reference modifier).  It's the client's responsibility to satisfy
+// this requirement.  Element can be an array type itself (hence
+// multi-dimensional arrays are supported).
+template <typename Element>
+class NativeArray {
+ public:
+  // STL-style container typedefs.
+  typedef Element value_type;
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+
+  // Constructs from a native array. References the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
+    InitRef(array, count);
+  }
+
+  // Constructs from a native array. Copies the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
+    InitCopy(array, count);
+  }
+
+  // Copy constructor.
+  NativeArray(const NativeArray& rhs) {
+    (this->*rhs.clone_)(rhs.array_, rhs.size_);
+  }
+
+  ~NativeArray() {
+    if (clone_ != &NativeArray::InitRef)
+      delete[] array_;
+  }
+
+  // STL-style container methods.
+  size_t size() const { return size_; }
+  const_iterator begin() const { return array_; }
+  const_iterator end() const { return array_ + size_; }
+  bool operator==(const NativeArray& rhs) const {
+    return size() == rhs.size() &&
+        ArrayEq(begin(), size(), rhs.begin());
+  }
+
+ private:
+  enum {
+    kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
+        Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value,
+  };
+
+  // Initializes this object with a copy of the input.
+  void InitCopy(const Element* array, size_t a_size) {
+    Element* const copy = new Element[a_size];
+    CopyArray(array, a_size, copy);
+    array_ = copy;
+    size_ = a_size;
+    clone_ = &NativeArray::InitCopy;
+  }
+
+  // Initializes this object with a reference of the input.
+  void InitRef(const Element* array, size_t a_size) {
+    array_ = array;
+    size_ = a_size;
+    clone_ = &NativeArray::InitRef;
+  }
+
+  const Element* array_;
+  size_t size_;
+  void (NativeArray::*clone_)(const Element*, size_t);
+
+  GTEST_DISALLOW_ASSIGN_(NativeArray);
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
+  ::testing::internal::AssertHelper(result_type, file, line, message) \
+    = ::testing::Message()
+
+#define GTEST_MESSAGE_(message, result_type) \
+  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
+
+#define GTEST_FATAL_FAILURE_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
+
+#define GTEST_NONFATAL_FAILURE_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
+
+#define GTEST_SUCCESS_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
+
+// Suppresses MSVC warnings 4072 (unreachable code) for the code following
+// statement if it returns or throws (or doesn't return or throw in some
+// situations).
+#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
+  if (::testing::internal::AlwaysTrue()) { statement; }
+
+#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
+    bool gtest_caught_expected = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (expected_exception const&) { \
+      gtest_caught_expected = true; \
+    } \
+    catch (...) { \
+      gtest_msg.value = \
+          "Expected: " #statement " throws an exception of type " \
+          #expected_exception ".\n  Actual: it throws a different type."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
+    } \
+    if (!gtest_caught_expected) { \
+      gtest_msg.value = \
+          "Expected: " #statement " throws an exception of type " \
+          #expected_exception ".\n  Actual: it throws nothing."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
+      fail(gtest_msg.value)
+
+#define GTEST_TEST_NO_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
+      fail("Expected: " #statement " doesn't throw an exception.\n" \
+           "  Actual: it throws.")
+
+#define GTEST_TEST_ANY_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    bool gtest_caught_any = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      gtest_caught_any = true; \
+    } \
+    if (!gtest_caught_any) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
+      fail("Expected: " #statement " throws an exception.\n" \
+           "  Actual: it doesn't.")
+
+
+// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
+// either a boolean expression or an AssertionResult. text is a textual
+// represenation of expression as it was passed into the EXPECT_TRUE.
+#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar_ = \
+      ::testing::AssertionResult(expression)) \
+    ; \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+        gtest_ar_, text, #actual, #expected).c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
+      fail("Expected: " #statement " doesn't generate new fatal " \
+           "failures in the current thread.\n" \
+           "  Actual: it does.")
+
+// Expands to the name of the class that implements the given test.
+#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+  test_case_name##_##test_name##_Test
+
+// Helper macro for defining tests.
+#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
+class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
+ public:\
+  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
+ private:\
+  virtual void TestBody();\
+  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
+};\
+\
+::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
+  ::test_info_ =\
+    ::testing::internal::MakeAndRegisterTestInfo(\
+        #test_case_name, #test_name, NULL, NULL, \
+        ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+        (parent_id), \
+        parent_class::SetUpTestCase, \
+        parent_class::TearDownTestCase, \
+        new ::testing::internal::TestFactoryImpl<\
+            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
+void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the public API for death tests.  It is
+// #included by gtest.h so a user doesn't need to include this
+// directly.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+
+#include <stdio.h>
+
+namespace testing {
+namespace internal {
+
+GTEST_DECLARE_string_(internal_run_death_test);
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#if GTEST_HAS_DEATH_TEST
+
+// DeathTest is a class that hides much of the complexity of the
+// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
+// returns a concrete class that depends on the prevailing death test
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// exit status:  The integer exit information in the format specified
+//               by wait(2)
+// exit code:    The integer code passed to exit(3), _exit(2), or
+//               returned from main()
+class GTEST_API_ DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // argument is set.  If the death test should be skipped, the pointer
+  // is set to NULL; otherwise, it is set to the address of a new concrete
+  // DeathTest object that controls the execution of the current test.
+  static bool Create(const char* statement, const RE* regex,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED_;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the three reasons that a test might be aborted.
+  enum AbortReason {
+    TEST_ENCOUNTERED_RETURN_STATEMENT,
+    TEST_THREW_EXCEPTION,
+    TEST_DID_NOT_DIE
+  };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+  static void set_last_death_test_message(const std::string& message);
+
+ private:
+  // A string containing a description of the outcome of the last death test.
+  static std::string last_death_test_message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+};
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test);
+};
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
+
+// Traps C++ exceptions escaping statement and reports them as test
+// failures. Note that trapping SEH exceptions is not implemented here.
+# if GTEST_HAS_EXCEPTIONS
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  try { \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } catch (const ::std::exception& gtest_exception) { \
+    fprintf(\
+        stderr, \
+        "\n%s: Caught std::exception-derived exception escaping the " \
+        "death test statement. Exception message: %s\n", \
+        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
+        gtest_exception.what()); \
+    fflush(stderr); \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  } catch (...) { \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  }
+
+# else
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+
+# endif
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    const ::testing::internal::RE& gtest_regex = (regex); \
+    ::testing::internal::DeathTest* gtest_dt; \
+    if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
+        __FILE__, __LINE__, &gtest_dt)) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
+    } \
+    if (gtest_dt != NULL) { \
+      ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
+          gtest_dt_ptr(gtest_dt); \
+      switch (gtest_dt->AssumeRole()) { \
+        case ::testing::internal::DeathTest::OVERSEE_TEST: \
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
+            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
+          } \
+          break; \
+        case ::testing::internal::DeathTest::EXECUTE_TEST: { \
+          ::testing::internal::DeathTest::ReturnSentinel \
+              gtest_sentinel(gtest_dt); \
+          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
+          break; \
+        } \
+        default: \
+          break; \
+      } \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
+      fail(::testing::internal::DeathTest::LastMessage())
+// The symbol "fail" here expands to something into which a message
+// can be streamed.
+
+// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
+// NDEBUG mode. In this case we need the statements to be executed, the regex is
+// ignored, and the macro must accept a streamed message even though the message
+// is never printed.
+# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } else \
+    ::testing::Message()
+
+// A class representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+class InternalRunDeathTestFlag {
+ public:
+  InternalRunDeathTestFlag(const std::string& a_file,
+                           int a_line,
+                           int an_index,
+                           int a_write_fd)
+      : file_(a_file), line_(a_line), index_(an_index),
+        write_fd_(a_write_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (write_fd_ >= 0)
+      posix::Close(write_fd_);
+  }
+
+  const std::string& file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int write_fd() const { return write_fd_; }
+
+ private:
+  std::string file_;
+  int line_;
+  int index_;
+  int write_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#else  // GTEST_HAS_DEATH_TEST
+
+// This macro is used for implementing macros such as
+// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
+// death tests are not supported. Those macros must compile on such systems
+// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
+// systems that support death tests. This allows one to write such a macro
+// on a system that does not support death tests and be sure that it will
+// compile on a death-test supporting system.
+//
+// Parameters:
+//   statement -  A statement that a macro such as EXPECT_DEATH would test
+//                for program termination. This macro has to make sure this
+//                statement is compiled but not executed, to ensure that
+//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
+//                parameter iff EXPECT_DEATH compiles with it.
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
+//                the output of statement.  This parameter has to be
+//                compiled but not evaluated by this macro, to ensure that
+//                this macro only accepts expressions that a macro such as
+//                EXPECT_DEATH would accept.
+//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
+//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
+//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
+//                compile inside functions where ASSERT_DEATH doesn't
+//                compile.
+//
+//  The branch that has an always false condition is used to ensure that
+//  statement and regex are compiled (and thus syntactically correct) but
+//  never executed. The unreachable code macro protects the terminator
+//  statement from generating an 'unreachable code' warning in case
+//  statement unconditionally returns or throws. The Message constructor at
+//  the end allows the syntax of streaming additional messages into the
+//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
+# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::AlwaysTrue()) { \
+      GTEST_LOG_(WARNING) \
+          << "Death tests are not supported on this platform.\n" \
+          << "Statement '" #statement "' cannot be verified."; \
+    } else if (::testing::internal::AlwaysFalse()) { \
+      ::testing::internal::RE::PartialMatch(".*", (regex)); \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+      terminator; \
+    } else \
+      ::testing::Message()
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+namespace testing {
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string_(death_test_style);
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. It generates a warning if there is more than one active
+//   thread.  This is because it's safe to fork() or clone() only
+//   when there is a single thread.
+//
+//   2. The parent process clone()s a sub-process and runs the death
+//   test in it; the sub-process exits with code 0 at the end of the
+//   death test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//                  << "Failed to die on request " << i;
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+//
+// On the regular expressions used in death tests:
+//
+//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
+//   which uses the POSIX extended regex syntax.
+//
+//   On other platforms (e.g. Windows), we only support a simple regex
+//   syntax implemented as part of Google Test.  This limited
+//   implementation should be enough most of the time when writing
+//   death tests; though it lacks many features you can find in PCRE
+//   or POSIX extended regex syntax.  For example, we don't support
+//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
+//   repetition count ("x{5,7}"), among others.
+//
+//   Below is the syntax that we do support.  We chose it to be a
+//   subset of both PCRE and POSIX extended regex, so it's easy to
+//   learn wherever you come from.  In the following: 'A' denotes a
+//   literal character, period (.), or a single \\ escape sequence;
+//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
+//   natural numbers.
+//
+//     c     matches any literal character c
+//     \\d   matches any decimal digit
+//     \\D   matches any character that's not a decimal digit
+//     \\f   matches \f
+//     \\n   matches \n
+//     \\r   matches \r
+//     \\s   matches any ASCII whitespace, including \n
+//     \\S   matches any character that's not a whitespace
+//     \\t   matches \t
+//     \\v   matches \v
+//     \\w   matches any letter, _, or decimal digit
+//     \\W   matches any character that \\w doesn't match
+//     \\c   matches any literal character c, which must be a punctuation
+//     .     matches any single character except \n
+//     A?    matches 0 or 1 occurrences of A
+//     A*    matches 0 or many occurrences of A
+//     A+    matches 1 or many occurrences of A
+//     ^     matches the beginning of a string (not that of each line)
+//     $     matches the end of a string (not that of each line)
+//     xy    matches x followed by y
+//
+//   If you accidentally use PCRE or POSIX extended regex features
+//   not implemented by us, you will get a run-time failure.  In that
+//   case, please try to rewrite your regular expression within the
+//   above syntax.
+//
+//   This implementation is *not* meant to be as highly tuned or robust
+//   as a compiled regex library, but should perform well enough for a
+//   death test, which already incurs significant overhead by launching
+//   a child process.
+//
+// Known caveats:
+//
+//   A "threadsafe" style death test obtains the path to the test
+//   program from argv[0] and re-executes it in the sub-process.  For
+//   simplicity, the current implementation doesn't search the PATH
+//   when launching the sub-process.  This means that the user must
+//   invoke the test program via a path that contains at least one
+//   path separator (e.g. path/to/foo_test and
+//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
+//   is rarely a problem as people usually don't put the test binary
+//   directory in PATH.
+//
+// TODO(wan@google.com): make thread-safe death tests search the PATH.
+
+// Asserts that a given statement causes the program to exit, with an
+// integer exit status that satisfies predicate, and emitting error output
+// that matches regex.
+# define ASSERT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
+
+// Like ASSERT_EXIT, but continues on to successive tests in the
+// test case, if any:
+# define EXPECT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
+
+// Asserts that a given statement causes the program to exit, either by
+// explicitly exiting with a nonzero exit code or being killed by a
+// signal, and emitting error output that matches regex.
+# define ASSERT_DEATH(statement, regex) \
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Like ASSERT_DEATH, but continues on to successive tests in the
+// test case, if any:
+# define EXPECT_DEATH(statement, regex) \
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class GTEST_API_ ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  bool operator()(int exit_status) const;
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ExitedWithCode& other);
+
+  const int exit_code_;
+};
+
+# if !GTEST_OS_WINDOWS
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+class GTEST_API_ KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+# endif  // !GTEST_OS_WINDOWS
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+# ifdef NDEBUG
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+# else
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+
+// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
+// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
+// death tests are supported; otherwise they just issue a warning.  This is
+// useful when you are combining death test assertions with normal test
+// assertions in one test.
+#if GTEST_HAS_DEATH_TEST
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    EXPECT_DEATH(statement, regex)
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    ASSERT_DEATH(statement, regex)
+#else
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
+#endif
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+// This file was GENERATED by command:
+//     pump.py gtest-param-test.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: vladl@google.com (Vlad Losev)
+//
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing Framework (Google Test)
+//
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+
+
+// Value-parameterized tests allow you to test your code with different
+// parameters without writing multiple copies of the same test.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
+// case with any set of parameters you want. Google Test defines a number
+// of functions for generating test parameters. They return what we call
+// (surprise!) parameter generators. Here is a  summary of them, which
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// For more details, see comments at the definitions of these functions below
+// in this file.
+//
+// The following statement will instantiate tests from the FooTest test case
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more then once) the first argument to the
+// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
+// actual test case name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
+// in the given test case, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_CASE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+
+#if !GTEST_OS_SYMBIAN
+# include <utility>
+#endif
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+// Copyright 2008 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Type and function utilities for implementing parameterized tests.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+#include <ctype.h>
+
+#include <iterator>
+#include <set>
+#include <utility>
+#include <vector>
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+// Copyright 2003 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: Dan Egnor (egnor@google.com)
+//
+// A "smart" pointer type with reference tracking.  Every pointer to a
+// particular object is kept on a circular linked list.  When the last pointer
+// to an object is destroyed or reassigned, the object is deleted.
+//
+// Used properly, this deletes the object when the last reference goes away.
+// There are several caveats:
+// - Like all reference counting schemes, cycles lead to leaks.
+// - Each smart pointer is actually two pointers (8 bytes instead of 4).
+// - Every time a pointer is assigned, the entire list of pointers to that
+//   object is traversed.  This class is therefore NOT SUITABLE when there
+//   will often be more than two or three pointers to a particular object.
+// - References are only tracked as long as linked_ptr<> objects are copied.
+//   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
+//   will happen (double deletion).
+//
+// A good use of this class is storing object references in STL containers.
+// You can safely put linked_ptr<> in a vector<>.
+// Other uses may not be as good.
+//
+// Note: If you use an incomplete type with linked_ptr<>, the class
+// *containing* linked_ptr<> must have a constructor and destructor (even
+// if they do nothing!).
+//
+// Bill Gibbons suggested we use something like this.
+//
+// Thread Safety:
+//   Unlike other linked_ptr implementations, in this implementation
+//   a linked_ptr object is thread-safe in the sense that:
+//     - it's safe to copy linked_ptr objects concurrently,
+//     - it's safe to copy *from* a linked_ptr and read its underlying
+//       raw pointer (e.g. via get()) concurrently, and
+//     - it's safe to write to two linked_ptrs that point to the same
+//       shared object concurrently.
+// TODO(wan@google.com): rename this to safe_linked_ptr to avoid
+// confusion with normal linked_ptr.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
+
+#include <stdlib.h>
+#include <assert.h>
+
+
+namespace testing {
+namespace internal {
+
+// Protects copying of all linked_ptr objects.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
+
+// This is used internally by all instances of linked_ptr<>.  It needs to be
+// a non-template class because different types of linked_ptr<> can refer to
+// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
+// So, it needs to be possible for different types of linked_ptr to participate
+// in the same circular linked list, so we need a single class type here.
+//
+// DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
+class linked_ptr_internal {
+ public:
+  // Create a new circle that includes only this instance.
+  void join_new() {
+    next_ = this;
+  }
+
+  // Many linked_ptr operations may change p.link_ for some linked_ptr
+  // variable p in the same circle as this object.  Therefore we need
+  // to prevent two such operations from occurring concurrently.
+  //
+  // Note that different types of linked_ptr objects can coexist in a
+  // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
+  // linked_ptr<Derived2>).  Therefore we must use a single mutex to
+  // protect all linked_ptr objects.  This can create serious
+  // contention in production code, but is acceptable in a testing
+  // framework.
+
+  // Join an existing circle.
+  void join(linked_ptr_internal const* ptr)
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
+    MutexLock lock(&g_linked_ptr_mutex);
+
+    linked_ptr_internal const* p = ptr;
+    while (p->next_ != ptr) {
+      assert(p->next_ != this &&
+             "Trying to join() a linked ring we are already in. "
+             "Is GMock thread safety enabled?");
+      p = p->next_;
+    }
+    p->next_ = this;
+    next_ = ptr;
+  }
+
+  // Leave whatever circle we're part of.  Returns true if we were the
+  // last member of the circle.  Once this is done, you can join() another.
+  bool depart()
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
+    MutexLock lock(&g_linked_ptr_mutex);
+
+    if (next_ == this) return true;
+    linked_ptr_internal const* p = next_;
+    while (p->next_ != this) {
+      assert(p->next_ != next_ &&
+             "Trying to depart() a linked ring we are not in. "
+             "Is GMock thread safety enabled?");
+      p = p->next_;
+    }
+    p->next_ = next_;
+    return false;
+  }
+
+ private:
+  mutable linked_ptr_internal const* next_;
+};
+
+template <typename T>
+class linked_ptr {
+ public:
+  typedef T element_type;
+
+  // Take over ownership of a raw pointer.  This should happen as soon as
+  // possible after the object is created.
+  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
+  ~linked_ptr() { depart(); }
+
+  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
+  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
+  linked_ptr(linked_ptr const& ptr) {  // NOLINT
+    assert(&ptr != this);
+    copy(&ptr);
+  }
+
+  // Assignment releases the old value and acquires the new.
+  template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
+    depart();
+    copy(&ptr);
+    return *this;
+  }
+
+  linked_ptr& operator=(linked_ptr const& ptr) {
+    if (&ptr != this) {
+      depart();
+      copy(&ptr);
+    }
+    return *this;
+  }
+
+  // Smart pointer members.
+  void reset(T* ptr = NULL) {
+    depart();
+    capture(ptr);
+  }
+  T* get() const { return value_; }
+  T* operator->() const { return value_; }
+  T& operator*() const { return *value_; }
+
+  bool operator==(T* p) const { return value_ == p; }
+  bool operator!=(T* p) const { return value_ != p; }
+  template <typename U>
+  bool operator==(linked_ptr<U> const& ptr) const {
+    return value_ == ptr.get();
+  }
+  template <typename U>
+  bool operator!=(linked_ptr<U> const& ptr) const {
+    return value_ != ptr.get();
+  }
+
+ private:
+  template <typename U>
+  friend class linked_ptr;
+
+  T* value_;
+  linked_ptr_internal link_;
+
+  void depart() {
+    if (link_.depart()) delete value_;
+  }
+
+  void capture(T* ptr) {
+    value_ = ptr;
+    link_.join_new();
+  }
+
+  template <typename U> void copy(linked_ptr<U> const* ptr) {
+    value_ = ptr->get();
+    if (value_)
+      link_.join(&ptr->link_);
+    else
+      link_.join_new();
+  }
+};
+
+template<typename T> inline
+bool operator==(T* ptr, const linked_ptr<T>& x) {
+  return ptr == x.get();
+}
+
+template<typename T> inline
+bool operator!=(T* ptr, const linked_ptr<T>& x) {
+  return ptr != x.get();
+}
+
+// A function to convert T* into linked_ptr<T>
+// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
+// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
+template <typename T>
+linked_ptr<T> make_linked_ptr(T* ptr) {
+  return linked_ptr<T>(ptr);
+}
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Test - The Google C++ Testing Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// A user can teach this function how to print a class type T by
+// defining either operator<<() or PrintTo() in the namespace that
+// defines T.  More specifically, the FIRST defined function in the
+// following list will be used (assuming T is defined in namespace
+// foo):
+//
+//   1. foo::PrintTo(const T&, ostream*)
+//   2. operator<<(ostream&, const T&) defined in either foo or the
+//      global namespace.
+//
+// If none of the above is defined, it will print the debug string of
+// the value if it is a protocol buffer, or print the raw bytes in the
+// value otherwise.
+//
+// To aid debugging: when T is a reference type, the address of the
+// value is also printed; when T is a (const) char pointer, both the
+// pointer value and the NUL-terminated string it points to are
+// printed.
+//
+// We also provide some convenient wrappers:
+//
+//   // Prints a value to a string.  For a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   std::string ::testing::PrintToString(const T& value);
+//
+//   // Prints a value tersely: for a reference type, the referenced
+//   // value (but not the address) is printed; for a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
+//
+//   // Prints value using the type inferred by the compiler.  The difference
+//   // from UniversalTersePrint() is that this function prints both the
+//   // pointer and the NUL-terminated string for a (const or not) char pointer.
+//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
+//
+//   // Prints the fields of a tuple tersely to a string vector, one
+//   // element for each field. Tuple support must be enabled in
+//   // gtest-port.h.
+//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
+//       const Tuple& value);
+//
+// Known limitation:
+//
+// The print primitives print the elements of an STL-style container
+// using the compiler-inferred type of *iter where iter is a
+// const_iterator of the container.  When const_iterator is an input
+// iterator but not a forward iterator, this inferred type may not
+// match value_type, and the print output may be incorrect.  In
+// practice, this is rarely a problem as for most containers
+// const_iterator is a forward iterator.  We'll fix this if there's an
+// actual need for it.  Note that this fix cannot rely on value_type
+// being defined as many user-defined container types don't have
+// value_type.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if GTEST_HAS_STD_TUPLE_
+# include <tuple>
+#endif
+
+namespace testing {
+
+// Definitions in the 'internal' and 'internal2' name spaces are
+// subject to change without notice.  DO NOT USE THEM IN USER CODE!
+namespace internal2 {
+
+// Prints the given number of bytes in the given object to the given
+// ostream.
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
+                                     size_t count,
+                                     ::std::ostream* os);
+
+// For selecting which printer to use when a given type has neither <<
+// nor PrintTo().
+enum TypeKind {
+  kProtobuf,              // a protobuf type
+  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
+                          // (e.g. a named or unnamed enum type)
+  kOtherType              // anything else
+};
+
+// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
+// by the universal printer to print a value of type T when neither
+// operator<< nor PrintTo() is defined for T, where kTypeKind is the
+// "kind" of T as defined by enum TypeKind.
+template <typename T, TypeKind kTypeKind>
+class TypeWithoutFormatter {
+ public:
+  // This default version is called when kTypeKind is kOtherType.
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
+                         sizeof(value), os);
+  }
+};
+
+// We print a protobuf using its ShortDebugString() when the string
+// doesn't exceed this many characters; otherwise we print it using
+// DebugString() for better readability.
+const size_t kProtobufOneLinerMaxLength = 50;
+
+template <typename T>
+class TypeWithoutFormatter<T, kProtobuf> {
+ public:
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    const ::testing::internal::string short_str = value.ShortDebugString();
+    const ::testing::internal::string pretty_str =
+        short_str.length() <= kProtobufOneLinerMaxLength ?
+        short_str : ("\n" + value.DebugString());
+    *os << ("<" + pretty_str + ">");
+  }
+};
+
+template <typename T>
+class TypeWithoutFormatter<T, kConvertibleToInteger> {
+ public:
+  // Since T has no << operator or PrintTo() but can be implicitly
+  // converted to BiggestInt, we print it as a BiggestInt.
+  //
+  // Most likely T is an enum type (either named or unnamed), in which
+  // case printing it as an integer is the desired behavior.  In case
+  // T is not an enum, printing it as an integer is the best we can do
+  // given that it has no user-defined printer.
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    const internal::BiggestInt kBigInt = value;
+    *os << kBigInt;
+  }
+};
+
+// Prints the given value to the given ostream.  If the value is a
+// protocol message, its debug string is printed; if it's an enum or
+// of a type implicitly convertible to BiggestInt, it's printed as an
+// integer; otherwise the bytes in the value are printed.  This is
+// what UniversalPrinter<T>::Print() does when it knows nothing about
+// type T and T has neither << operator nor PrintTo().
+//
+// A user can override this behavior for a class type Foo by defining
+// a << operator in the namespace where Foo is defined.
+//
+// We put this operator in namespace 'internal2' instead of 'internal'
+// to simplify the implementation, as much code in 'internal' needs to
+// use << in STL, which would conflict with our own << were it defined
+// in 'internal'.
+//
+// Note that this operator<< takes a generic std::basic_ostream<Char,
+// CharTraits> type instead of the more restricted std::ostream.  If
+// we define it to take an std::ostream instead, we'll get an
+// "ambiguous overloads" compiler error when trying to print a type
+// Foo that supports streaming to std::basic_ostream<Char,
+// CharTraits>, as the compiler cannot tell whether
+// operator<<(std::ostream&, const T&) or
+// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
+// specific.
+template <typename Char, typename CharTraits, typename T>
+::std::basic_ostream<Char, CharTraits>& operator<<(
+    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
+  TypeWithoutFormatter<T,
+      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
+       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
+       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
+  return os;
+}
+
+}  // namespace internal2
+}  // namespace testing
+
+// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
+// magic needed for implementing UniversalPrinter won't work.
+namespace testing_internal {
+
+// Used to print a value that is not an STL-style container when the
+// user doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
+  // With the following statement, during unqualified name lookup,
+  // testing::internal2::operator<< appears as if it was declared in
+  // the nearest enclosing namespace that contains both
+  // ::testing_internal and ::testing::internal2, i.e. the global
+  // namespace.  For more details, refer to the C++ Standard section
+  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
+  // testing::internal2::operator<< in case T doesn't come with a <<
+  // operator.
+  //
+  // We cannot write 'using ::testing::internal2::operator<<;', which
+  // gcc 3.3 fails to compile due to a compiler bug.
+  using namespace ::testing::internal2;  // NOLINT
+
+  // Assuming T is defined in namespace foo, in the next statement,
+  // the compiler will consider all of:
+  //
+  //   1. foo::operator<< (thanks to Koenig look-up),
+  //   2. ::operator<< (as the current namespace is enclosed in ::),
+  //   3. testing::internal2::operator<< (thanks to the using statement above).
+  //
+  // The operator<< whose type matches T best will be picked.
+  //
+  // We deliberately allow #2 to be a candidate, as sometimes it's
+  // impossible to define #1 (e.g. when foo is ::std, defining
+  // anything in it is undefined behavior unless you are a compiler
+  // vendor.).
+  *os << value;
+}
+
+}  // namespace testing_internal
+
+namespace testing {
+namespace internal {
+
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
+#endif
+
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
+#endif
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
+}
+
+// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
+// value to the given ostream.  The caller must ensure that
+// 'ostream_ptr' is not NULL, or the behavior is undefined.
+//
+// We define UniversalPrinter as a class template (as opposed to a
+// function template), as we need to partially specialize it for
+// reference types, which cannot be done with function templates.
+template <typename T>
+class UniversalPrinter;
+
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os);
+
+// Used to print an STL-style container when the user doesn't define
+// a PrintTo() for it.
+template <typename C>
+void DefaultPrintTo(IsContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const C& container, ::std::ostream* os) {
+  const size_t kMaxCount = 32;  // The maximum number of elements to print.
+  *os << '{';
+  size_t count = 0;
+  for (typename C::const_iterator it = container.begin();
+       it != container.end(); ++it, ++count) {
+    if (count > 0) {
+      *os << ',';
+      if (count == kMaxCount) {  // Enough has been printed.
+        *os << " ...";
+        break;
+      }
+    }
+    *os << ' ';
+    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
+    // handle *it being a native array.
+    internal::UniversalPrint(*it, os);
+  }
+
+  if (count > 0) {
+    *os << ' ';
+  }
+  *os << '}';
+}
+
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
+template <typename T>
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    true_type /* is a pointer */,
+                    T* p, ::std::ostream* os) {
+  if (p == NULL) {
+    *os << "NULL";
+  } else {
+    // C++ doesn't allow casting from a function pointer to any object
+    // pointer.
+    //
+    // IsTrue() silences warnings: "Condition is always true",
+    // "unreachable code".
+    if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
+      // T is not a function type.  We just call << to print p,
+      // relying on ADL to pick up user-defined << for their pointer
+      // types, if any.
+      *os << p;
+    } else {
+      // T is a function type, so '*os << p' doesn't do what we want
+      // (it just prints p as bool).  We want to print p as a const
+      // void*.  However, we cannot cast it to const void* directly,
+      // even using reinterpret_cast, as earlier versions of gcc
+      // (e.g. 3.4.5) cannot compile the cast when p is a function
+      // pointer.  Casting to UInt64 first solves the problem.
+      *os << reinterpret_cast<const void*>(
+          reinterpret_cast<internal::UInt64>(p));
+    }
+  }
+}
+
+// Used to print a non-container, non-pointer value when the user
+// doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const T& value, ::std::ostream* os) {
+  ::testing_internal::DefaultPrintNonContainerTo(value, os);
+}
+
+// Prints the given value using the << operator if it has one;
+// otherwise prints the bytes in it.  This is what
+// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
+// or overloaded for type T.
+//
+// A user can override this behavior for a class type Foo by defining
+// an overload of PrintTo() in the namespace where Foo is defined.  We
+// give the user this option as sometimes defining a << operator for
+// Foo is not desirable (e.g. the coding style may prevent doing it,
+// or there is already a << operator but it doesn't do what the user
+// wants).
+template <typename T>
+void PrintTo(const T& value, ::std::ostream* os) {
+  // DefaultPrintTo() is overloaded.  The type of its first two
+  // arguments determine which version will be picked.  If T is an
+  // STL-style container, the version for container will be called; if
+  // T is a pointer, the pointer version will be called; otherwise the
+  // generic version will be called.
+  //
+  // Note that we check for container types here, prior to we check
+  // for protocol message types in our operator<<.  The rationale is:
+  //
+  // For protocol messages, we want to give people a chance to
+  // override Google Mock's format by defining a PrintTo() or
+  // operator<<.  For STL containers, other formats can be
+  // incompatible with Google Mock's format for the container
+  // elements; therefore we check for container types here to ensure
+  // that our format is used.
+  //
+  // The second argument of DefaultPrintTo() is needed to bypass a bug
+  // in Symbian's C++ compiler that prevents it from picking the right
+  // overload between:
+  //
+  //   PrintTo(const T& x, ...);
+  //   PrintTo(T* x, ...);
+  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
+}
+
+// The following list of PrintTo() overloads tells
+// UniversalPrinter<T>::Print() how to print standard types (built-in
+// types, strings, plain arrays, and pointers).
+
+// Overloads for various char types.
+GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
+GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
+inline void PrintTo(char c, ::std::ostream* os) {
+  // When printing a plain char, we always treat it as unsigned.  This
+  // way, the output won't be affected by whether the compiler thinks
+  // char is signed or not.
+  PrintTo(static_cast<unsigned char>(c), os);
+}
+
+// Overloads for other simple built-in types.
+inline void PrintTo(bool x, ::std::ostream* os) {
+  *os << (x ? "true" : "false");
+}
+
+// Overload for wchar_t type.
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its decimal code (except for L'\0').
+// The L'\0' char is printed as "L'\\0'". The decimal code is printed
+// as signed integer when wchar_t is implemented by the compiler
+// as a signed type and is printed as an unsigned integer when wchar_t
+// is implemented as an unsigned type.
+GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
+
+// Overloads for C strings.
+GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
+inline void PrintTo(char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char*>(s), os);
+}
+
+// signed/unsigned char is often used for representing binary data, so
+// we print pointers to it as void* to be safe.
+inline void PrintTo(const signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Overloads for wide C strings
+GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
+inline void PrintTo(wchar_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
+}
+#endif
+
+// Overload for C arrays.  Multi-dimensional arrays are printed
+// properly.
+
+// Prints the given number of elements in an array, without printing
+// the curly braces.
+template <typename T>
+void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
+  UniversalPrint(a[0], os);
+  for (size_t i = 1; i != count; i++) {
+    *os << ", ";
+    UniversalPrint(a[i], os);
+  }
+}
+
+// Overloads for ::string and ::std::string.
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
+inline void PrintTo(const ::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
+inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+
+// Overloads for ::wstring and ::std::wstring.
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+// Helper function for printing a tuple.  T must be instantiated with
+// a tuple type.
+template <typename T>
+void PrintTupleTo(const T& t, ::std::ostream* os);
+#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+
+#if GTEST_HAS_TR1_TUPLE
+// Overload for ::std::tr1::tuple.  Needed for printing function arguments,
+// which are packed as tuples.
+
+// Overloaded PrintTo() for tuples of various arities.  We support
+// tuples of up-to 10 fields.  The following implementation works
+// regardless of whether tr1::tuple is implemented using the
+// non-standard variadic template feature or not.
+
+inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1>
+void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2>
+void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+void PrintTo(
+    const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
+    ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+template <typename... Types>
+void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+#endif  // GTEST_HAS_STD_TUPLE_
+
+// Overload for std::pair.
+template <typename T1, typename T2>
+void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
+  *os << '(';
+  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
+  // a reference type.  The same for printing value.second.
+  UniversalPrinter<T1>::Print(value.first, os);
+  *os << ", ";
+  UniversalPrinter<T2>::Print(value.second, os);
+  *os << ')';
+}
+
+// Implements printing a non-reference type T by letting the compiler
+// pick the right overload of PrintTo() for T.
+template <typename T>
+class UniversalPrinter {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  // Note: we deliberately don't call this PrintTo(), as that name
+  // conflicts with ::testing::internal::PrintTo in the body of the
+  // function.
+  static void Print(const T& value, ::std::ostream* os) {
+    // By default, ::testing::internal::PrintTo() is used for printing
+    // the value.
+    //
+    // Thanks to Koenig look-up, if T is a class and has its own
+    // PrintTo() function defined in its namespace, that function will
+    // be visible here.  Since it is more specific than the generic ones
+    // in ::testing::internal, it will be picked by the compiler in the
+    // following statement - exactly what we want.
+    PrintTo(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// UniversalPrintArray(begin, len, os) prints an array of 'len'
+// elements, starting at address 'begin'.
+template <typename T>
+void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
+  if (len == 0) {
+    *os << "{}";
+  } else {
+    *os << "{ ";
+    const size_t kThreshold = 18;
+    const size_t kChunkSize = 8;
+    // If the array has more than kThreshold elements, we'll have to
+    // omit some details by printing only the first and the last
+    // kChunkSize elements.
+    // TODO(wan@google.com): let the user control the threshold using a flag.
+    if (len <= kThreshold) {
+      PrintRawArrayTo(begin, len, os);
+    } else {
+      PrintRawArrayTo(begin, kChunkSize, os);
+      *os << ", ..., ";
+      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
+    }
+    *os << " }";
+  }
+}
+// This overload prints a (const) char array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const char* begin, size_t len, ::std::ostream* os);
+
+// This overload prints a (const) wchar_t array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const wchar_t* begin, size_t len, ::std::ostream* os);
+
+// Implements printing an array type T[N].
+template <typename T, size_t N>
+class UniversalPrinter<T[N]> {
+ public:
+  // Prints the given array, omitting some elements when there are too
+  // many.
+  static void Print(const T (&a)[N], ::std::ostream* os) {
+    UniversalPrintArray(a, N, os);
+  }
+};
+
+// Implements printing a reference type T&.
+template <typename T>
+class UniversalPrinter<T&> {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  static void Print(const T& value, ::std::ostream* os) {
+    // Prints the address of the value.  We use reinterpret_cast here
+    // as static_cast doesn't compile when T is a function type.
+    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
+
+    // Then prints the value itself.
+    UniversalPrint(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Prints a value tersely: for a reference type, the referenced value
+// (but not the address) is printed; for a (const) char pointer, the
+// NUL-terminated string (but not the pointer) is printed.
+
+template <typename T>
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> {
+ public:
+  static void Print(char* str, ::std::ostream* os) {
+    UniversalTersePrinter<const char*>::Print(str, os);
+  }
+};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
+}
+
+// Prints a value using the type inferred by the compiler.  The
+// difference between this and UniversalTersePrint() is that for a
+// (const) char pointer, this prints both the pointer and the
+// NUL-terminated string.
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os) {
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
+}
+
+typedef ::std::vector<string> Strings;
+
+// TuplePolicy<TupleT> must provide:
+// - tuple_size
+//     size of tuple TupleT.
+// - get<size_t I>(const TupleT& t)
+//     static function extracting element I of tuple TupleT.
+// - tuple_element<size_t I>::type
+//     type of element I of tuple TupleT.
+template <typename TupleT>
+struct TuplePolicy;
+
+#if GTEST_HAS_TR1_TUPLE
+template <typename TupleT>
+struct TuplePolicy {
+  typedef TupleT Tuple;
+  static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
+
+  template <size_t I>
+  struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};
+
+  template <size_t I>
+  static typename AddReference<
+      const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
+      const Tuple& tuple) {
+    return ::std::tr1::get<I>(tuple);
+  }
+};
+template <typename TupleT>
+const size_t TuplePolicy<TupleT>::tuple_size;
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+template <typename... Types>
+struct TuplePolicy< ::std::tuple<Types...> > {
+  typedef ::std::tuple<Types...> Tuple;
+  static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
+
+  template <size_t I>
+  struct tuple_element : ::std::tuple_element<I, Tuple> {};
+
+  template <size_t I>
+  static const typename ::std::tuple_element<I, Tuple>::type& get(
+      const Tuple& tuple) {
+    return ::std::get<I>(tuple);
+  }
+};
+template <typename... Types>
+const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
+#endif  // GTEST_HAS_STD_TUPLE_
+
+#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+// This helper template allows PrintTo() for tuples and
+// UniversalTersePrintTupleFieldsToStrings() to be defined by
+// induction on the number of tuple fields.  The idea is that
+// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
+// fields in tuple t, and can be defined in terms of
+// TuplePrefixPrinter<N - 1>.
+//
+// The inductive case.
+template <size_t N>
+struct TuplePrefixPrinter {
+  // Prints the first N fields of a tuple.
+  template <typename Tuple>
+  static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
+    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
+    GTEST_INTENTIONAL_CONST_COND_PUSH_()
+    if (N > 1) {
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+      *os << ", ";
+    }
+    UniversalPrinter<
+        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
+        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
+  }
+
+  // Tersely prints the first N fields of a tuple to a string vector,
+  // one element for each field.
+  template <typename Tuple>
+  static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
+    TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
+    ::std::stringstream ss;
+    UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
+    strings->push_back(ss.str());
+  }
+};
+
+// Base case.
+template <>
+struct TuplePrefixPrinter<0> {
+  template <typename Tuple>
+  static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
+
+  template <typename Tuple>
+  static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
+};
+
+// Helper function for printing a tuple.
+// Tuple must be either std::tr1::tuple or std::tuple type.
+template <typename Tuple>
+void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
+  *os << "(";
+  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t, os);
+  *os << ")";
+}
+
+// Prints the fields of a tuple tersely to a string vector, one
+// element for each field.  See the comment before
+// UniversalTersePrint() for how we define "tersely".
+template <typename Tuple>
+Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
+  Strings result;
+  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
+      TersePrintPrefixToStrings(value, &result);
+  return result;
+}
+#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+
+}  // namespace internal
+
+template <typename T>
+::std::string PrintToString(const T& value) {
+  ::std::stringstream ss;
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+}  // namespace testing
+
+// Include any custom printer added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+// Copyright 2015, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// This file provides an injection point for custom printers in a local
+// installation of gTest.
+// It will be included from gtest-printers.h and the overrides in this file
+// will be visible to everyone.
+// See documentation at gtest/gtest-printers.h for details on how to define a
+// custom printer.
+//
+// ** Custom implementation starts here **
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Input to a parameterized test name generator, describing a test parameter.
+// Consists of the parameter value and the integer parameter index.
+template <class ParamType>
+struct TestParamInfo {
+  TestParamInfo(const ParamType& a_param, size_t an_index) :
+    param(a_param),
+    index(an_index) {}
+  ParamType param;
+  size_t index;
+};
+
+// A builtin parameterized test name generator which returns the result of
+// testing::PrintToString.
+struct PrintToStringParamName {
+  template <class ParamType>
+  std::string operator()(const TestParamInfo<ParamType>& info) const {
+    return PrintToString(info.param);
+  }
+};
+
+namespace internal {
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Outputs a message explaining invalid registration of different
+// fixture class for the same test case. This may happen when
+// TEST_P macro is used to define two tests with the same name
+// but in different namespaces.
+GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
+                                          CodeLocation code_location);
+
+template <typename> class ParamGeneratorInterface;
+template <typename> class ParamGenerator;
+
+// Interface for iterating over elements provided by an implementation
+// of ParamGeneratorInterface<T>.
+template <typename T>
+class ParamIteratorInterface {
+ public:
+  virtual ~ParamIteratorInterface() {}
+  // A pointer to the base generator instance.
+  // Used only for the purposes of iterator comparison
+  // to make sure that two iterators belong to the same generator.
+  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
+  // Advances iterator to point to the next element
+  // provided by the generator. The caller is responsible
+  // for not calling Advance() on an iterator equal to
+  // BaseGenerator()->End().
+  virtual void Advance() = 0;
+  // Clones the iterator object. Used for implementing copy semantics
+  // of ParamIterator<T>.
+  virtual ParamIteratorInterface* Clone() const = 0;
+  // Dereferences the current iterator and provides (read-only) access
+  // to the pointed value. It is the caller's responsibility not to call
+  // Current() on an iterator equal to BaseGenerator()->End().
+  // Used for implementing ParamGenerator<T>::operator*().
+  virtual const T* Current() const = 0;
+  // Determines whether the given iterator and other point to the same
+  // element in the sequence generated by the generator.
+  // Used for implementing ParamGenerator<T>::operator==().
+  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
+};
+
+// Class iterating over elements provided by an implementation of
+// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
+// and implements the const forward iterator concept.
+template <typename T>
+class ParamIterator {
+ public:
+  typedef T value_type;
+  typedef const T& reference;
+  typedef ptrdiff_t difference_type;
+
+  // ParamIterator assumes ownership of the impl_ pointer.
+  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
+  ParamIterator& operator=(const ParamIterator& other) {
+    if (this != &other)
+      impl_.reset(other.impl_->Clone());
+    return *this;
+  }
+
+  const T& operator*() const { return *impl_->Current(); }
+  const T* operator->() const { return impl_->Current(); }
+  // Prefix version of operator++.
+  ParamIterator& operator++() {
+    impl_->Advance();
+    return *this;
+  }
+  // Postfix version of operator++.
+  ParamIterator operator++(int /*unused*/) {
+    ParamIteratorInterface<T>* clone = impl_->Clone();
+    impl_->Advance();
+    return ParamIterator(clone);
+  }
+  bool operator==(const ParamIterator& other) const {
+    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
+  }
+  bool operator!=(const ParamIterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class ParamGenerator<T>;
+  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
+  scoped_ptr<ParamIteratorInterface<T> > impl_;
+};
+
+// ParamGeneratorInterface<T> is the binary interface to access generators
+// defined in other translation units.
+template <typename T>
+class ParamGeneratorInterface {
+ public:
+  typedef T ParamType;
+
+  virtual ~ParamGeneratorInterface() {}
+
+  // Generator interface definition
+  virtual ParamIteratorInterface<T>* Begin() const = 0;
+  virtual ParamIteratorInterface<T>* End() const = 0;
+};
+
+// Wraps ParamGeneratorInterface<T> and provides general generator syntax
+// compatible with the STL Container concept.
+// This class implements copy initialization semantics and the contained
+// ParamGeneratorInterface<T> instance is shared among all copies
+// of the original object. This is possible because that instance is immutable.
+template<typename T>
+class ParamGenerator {
+ public:
+  typedef ParamIterator<T> iterator;
+
+  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
+  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
+
+  ParamGenerator& operator=(const ParamGenerator& other) {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+  iterator begin() const { return iterator(impl_->Begin()); }
+  iterator end() const { return iterator(impl_->End()); }
+
+ private:
+  linked_ptr<const ParamGeneratorInterface<T> > impl_;
+};
+
+// Generates values from a range of two comparable values. Can be used to
+// generate sequences of user-defined types that implement operator+() and
+// operator<().
+// This class is used in the Range() function.
+template <typename T, typename IncrementT>
+class RangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  RangeGenerator(T begin, T end, IncrementT step)
+      : begin_(begin), end_(end),
+        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+  virtual ~RangeGenerator() {}
+
+  virtual ParamIteratorInterface<T>* Begin() const {
+    return new Iterator(this, begin_, 0, step_);
+  }
+  virtual ParamIteratorInterface<T>* End() const {
+    return new Iterator(this, end_, end_index_, step_);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
+             IncrementT step)
+        : base_(base), value_(value), index_(index), step_(step) {}
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
+      return base_;
+    }
+    virtual void Advance() {
+      value_ = static_cast<T>(value_ + step_);
+      index_++;
+    }
+    virtual ParamIteratorInterface<T>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const T* Current() const { return &value_; }
+    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const int other_index =
+          CheckedDowncastToActualType<const Iterator>(&other)->index_;
+      return index_ == other_index;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : ParamIteratorInterface<T>(),
+          base_(other.base_), value_(other.value_), index_(other.index_),
+          step_(other.step_) {}
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<T>* const base_;
+    T value_;
+    int index_;
+    const IncrementT step_;
+  };  // class RangeGenerator::Iterator
+
+  static int CalculateEndIndex(const T& begin,
+                               const T& end,
+                               const IncrementT& step) {
+    int end_index = 0;
+    for (T i = begin; i < end; i = static_cast<T>(i + step))
+      end_index++;
+    return end_index;
+  }
+
+  // No implementation - assignment is unsupported.
+  void operator=(const RangeGenerator& other);
+
+  const T begin_;
+  const T end_;
+  const IncrementT step_;
+  // The index for the end() iterator. All the elements in the generated
+  // sequence are indexed (0-based) to aid iterator comparison.
+  const int end_index_;
+};  // class RangeGenerator
+
+
+// Generates values from a pair of STL-style iterators. Used in the
+// ValuesIn() function. The elements are copied from the source range
+// since the source can be located on the stack, and the generator
+// is likely to persist beyond that stack frame.
+template <typename T>
+class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  template <typename ForwardIterator>
+  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
+      : container_(begin, end) {}
+  virtual ~ValuesInIteratorRangeGenerator() {}
+
+  virtual ParamIteratorInterface<T>* Begin() const {
+    return new Iterator(this, container_.begin());
+  }
+  virtual ParamIteratorInterface<T>* End() const {
+    return new Iterator(this, container_.end());
+  }
+
+ private:
+  typedef typename ::std::vector<T> ContainerType;
+
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base,
+             typename ContainerType::const_iterator iterator)
+        : base_(base), iterator_(iterator) {}
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
+      return base_;
+    }
+    virtual void Advance() {
+      ++iterator_;
+      value_.reset();
+    }
+    virtual ParamIteratorInterface<T>* Clone() const {
+      return new Iterator(*this);
+    }
+    // We need to use cached value referenced by iterator_ because *iterator_
+    // can return a temporary object (and of type other then T), so just
+    // having "return &*iterator_;" doesn't work.
+    // value_ is updated here and not in Advance() because Advance()
+    // can advance iterator_ beyond the end of the range, and we cannot
+    // detect that fact. The client code, on the other hand, is
+    // responsible for not calling Current() on an out-of-range iterator.
+    virtual const T* Current() const {
+      if (value_.get() == NULL)
+        value_.reset(new T(*iterator_));
+      return value_.get();
+    }
+    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      return iterator_ ==
+          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+          // The explicit constructor call suppresses a false warning
+          // emitted by gcc when supplied with the -Wextra option.
+        : ParamIteratorInterface<T>(),
+          base_(other.base_),
+          iterator_(other.iterator_) {}
+
+    const ParamGeneratorInterface<T>* const base_;
+    typename ContainerType::const_iterator iterator_;
+    // A cached value of *iterator_. We keep it here to allow access by
+    // pointer in the wrapping iterator's operator->().
+    // value_ needs to be mutable to be accessed in Current().
+    // Use of scoped_ptr helps manage cached value's lifetime,
+    // which is bound by the lifespan of the iterator itself.
+    mutable scoped_ptr<const T> value_;
+  };  // class ValuesInIteratorRangeGenerator::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const ValuesInIteratorRangeGenerator& other);
+
+  const ContainerType container_;
+};  // class ValuesInIteratorRangeGenerator
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Default parameterized test name generator, returns a string containing the
+// integer test parameter index.
+template <class ParamType>
+std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Parameterized test name overload helpers, which help the
+// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
+// test name generator and user param name generator.
+template <class ParamType, class ParamNameGenFunctor>
+ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
+  return func;
+}
+
+template <class ParamType>
+struct ParamNameGenFunc {
+  typedef std::string Type(const TestParamInfo<ParamType>&);
+};
+
+template <class ParamType>
+typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
+  return DefaultParamName;
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Stores a parameter value and later creates tests parameterized with that
+// value.
+template <class TestClass>
+class ParameterizedTestFactory : public TestFactoryBase {
+ public:
+  typedef typename TestClass::ParamType ParamType;
+  explicit ParameterizedTestFactory(ParamType parameter) :
+      parameter_(parameter) {}
+  virtual Test* CreateTest() {
+    TestClass::SetParam(&parameter_);
+    return new TestClass();
+  }
+
+ private:
+  const ParamType parameter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactoryBase is a base class for meta-factories that create
+// test factories for passing into MakeAndRegisterTestInfo function.
+template <class ParamType>
+class TestMetaFactoryBase {
+ public:
+  virtual ~TestMetaFactoryBase() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactory creates test factories for passing into
+// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
+// ownership of test factory pointer, same factory object cannot be passed
+// into that method twice. But ParameterizedTestCaseInfo is going to call
+// it for each Test/Parameter value combination. Thus it needs meta factory
+// creator class.
+template <class TestCase>
+class TestMetaFactory
+    : public TestMetaFactoryBase<typename TestCase::ParamType> {
+ public:
+  typedef typename TestCase::ParamType ParamType;
+
+  TestMetaFactory() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
+    return new ParameterizedTestFactory<TestCase>(parameter);
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseInfoBase is a generic interface
+// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
+// accumulates test information provided by TEST_P macro invocations
+// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
+// and uses that information to register all resulting test instances
+// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
+// a collection of pointers to the ParameterizedTestCaseInfo objects
+// and calls RegisterTests() on each of them when asked.
+class ParameterizedTestCaseInfoBase {
+ public:
+  virtual ~ParameterizedTestCaseInfoBase() {}
+
+  // Base part of test case name for display purposes.
+  virtual const string& GetTestCaseName() const = 0;
+  // Test case id to verify identity.
+  virtual TypeId GetTestCaseTypeId() const = 0;
+  // UnitTest class invokes this method to register tests in this
+  // test case right before running them in RUN_ALL_TESTS macro.
+  // This method should not be called more then once on any single
+  // instance of a ParameterizedTestCaseInfoBase derived class.
+  virtual void RegisterTests() = 0;
+
+ protected:
+  ParameterizedTestCaseInfoBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
+// macro invocations for a particular test case and generators
+// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
+// test case. It registers tests with all values generated by all
+// generators when asked.
+template <class TestCase>
+class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
+ public:
+  // ParamType and GeneratorCreationFunc are private types but are required
+  // for declarations of public methods AddTestPattern() and
+  // AddTestCaseInstantiation().
+  typedef typename TestCase::ParamType ParamType;
+  // A function that returns an instance of appropriate generator type.
+  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
+  typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
+
+  explicit ParameterizedTestCaseInfo(
+      const char* name, CodeLocation code_location)
+      : test_case_name_(name), code_location_(code_location) {}
+
+  // Test case base name for display purposes.
+  virtual const string& GetTestCaseName() const { return test_case_name_; }
+  // Test case id to verify identity.
+  virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
+  // TEST_P macro uses AddTestPattern() to record information
+  // about a single test in a LocalTestInfo structure.
+  // test_case_name is the base name of the test case (without invocation
+  // prefix). test_base_name is the name of an individual test without
+  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
+  // test case base name and DoBar is test base name.
+  void AddTestPattern(const char* test_case_name,
+                      const char* test_base_name,
+                      TestMetaFactoryBase<ParamType>* meta_factory) {
+    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
+                                                       test_base_name,
+                                                       meta_factory)));
+  }
+  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
+  // about a generator.
+  int AddTestCaseInstantiation(const string& instantiation_name,
+                               GeneratorCreationFunc* func,
+                               ParamNameGeneratorFunc* name_func,
+                               const char* file,
+                               int line) {
+    instantiations_.push_back(
+        InstantiationInfo(instantiation_name, func, name_func, file, line));
+    return 0;  // Return value used only to run this method in namespace scope.
+  }
+  // UnitTest class invokes this method to register tests in this test case
+  // test cases right before running tests in RUN_ALL_TESTS macro.
+  // This method should not be called more then once on any single
+  // instance of a ParameterizedTestCaseInfoBase derived class.
+  // UnitTest has a guard to prevent from calling this method more then once.
+  virtual void RegisterTests() {
+    for (typename TestInfoContainer::iterator test_it = tests_.begin();
+         test_it != tests_.end(); ++test_it) {
+      linked_ptr<TestInfo> test_info = *test_it;
+      for (typename InstantiationContainer::iterator gen_it =
+               instantiations_.begin(); gen_it != instantiations_.end();
+               ++gen_it) {
+        const string& instantiation_name = gen_it->name;
+        ParamGenerator<ParamType> generator((*gen_it->generator)());
+        ParamNameGeneratorFunc* name_func = gen_it->name_func;
+        const char* file = gen_it->file;
+        int line = gen_it->line;
+
+        string test_case_name;
+        if ( !instantiation_name.empty() )
+          test_case_name = instantiation_name + "/";
+        test_case_name += test_info->test_case_base_name;
+
+        size_t i = 0;
+        std::set<std::string> test_param_names;
+        for (typename ParamGenerator<ParamType>::iterator param_it =
+                 generator.begin();
+             param_it != generator.end(); ++param_it, ++i) {
+          Message test_name_stream;
+
+          std::string param_name = name_func(
+              TestParamInfo<ParamType>(*param_it, i));
+
+          GTEST_CHECK_(IsValidParamName(param_name))
+              << "Parameterized test name '" << param_name
+              << "' is invalid, in " << file
+              << " line " << line << std::endl;
+
+          GTEST_CHECK_(test_param_names.count(param_name) == 0)
+              << "Duplicate parameterized test name '" << param_name
+              << "', in " << file << " line " << line << std::endl;
+
+          test_param_names.insert(param_name);
+
+          test_name_stream << test_info->test_base_name << "/" << param_name;
+          MakeAndRegisterTestInfo(
+              test_case_name.c_str(),
+              test_name_stream.GetString().c_str(),
+              NULL,  // No type parameter.
+              PrintToString(*param_it).c_str(),
+              code_location_,
+              GetTestCaseTypeId(),
+              TestCase::SetUpTestCase,
+              TestCase::TearDownTestCase,
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }  // for gen_it
+    }  // for test_it
+  }  // RegisterTests
+
+ private:
+  // LocalTestInfo structure keeps information about a single test registered
+  // with TEST_P macro.
+  struct TestInfo {
+    TestInfo(const char* a_test_case_base_name,
+             const char* a_test_base_name,
+             TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
+        test_case_base_name(a_test_case_base_name),
+        test_base_name(a_test_base_name),
+        test_meta_factory(a_test_meta_factory) {}
+
+    const string test_case_base_name;
+    const string test_base_name;
+    const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+  };
+  typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
+  // Records data received from INSTANTIATE_TEST_CASE_P macros:
+  //  <Instantiation name, Sequence generator creation function,
+  //     Name generator function, Source file, Source line>
+  struct InstantiationInfo {
+      InstantiationInfo(const std::string &name_in,
+                        GeneratorCreationFunc* generator_in,
+                        ParamNameGeneratorFunc* name_func_in,
+                        const char* file_in,
+                        int line_in)
+          : name(name_in),
+            generator(generator_in),
+            name_func(name_func_in),
+            file(file_in),
+            line(line_in) {}
+
+      std::string name;
+      GeneratorCreationFunc* generator;
+      ParamNameGeneratorFunc* name_func;
+      const char* file;
+      int line;
+  };
+  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
+
+  static bool IsValidParamName(const std::string& name) {
+    // Check for empty string
+    if (name.empty())
+      return false;
+
+    // Check for invalid characters
+    for (std::string::size_type index = 0; index < name.size(); ++index) {
+      if (!isalnum(name[index]) && name[index] != '_')
+        return false;
+    }
+
+    return true;
+  }
+
+  const string test_case_name_;
+  CodeLocation code_location_;
+  TestInfoContainer tests_;
+  InstantiationContainer instantiations_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
+};  // class ParameterizedTestCaseInfo
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
+// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
+// macros use it to locate their corresponding ParameterizedTestCaseInfo
+// descriptors.
+class ParameterizedTestCaseRegistry {
+ public:
+  ParameterizedTestCaseRegistry() {}
+  ~ParameterizedTestCaseRegistry() {
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      delete *it;
+    }
+  }
+
+  // Looks up or creates and returns a structure containing information about
+  // tests and instantiations of a particular test case.
+  template <class TestCase>
+  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
+      const char* test_case_name,
+      CodeLocation code_location) {
+    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      if ((*it)->GetTestCaseName() == test_case_name) {
+        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
+          // Complain about incorrect usage of Google Test facilities
+          // and terminate the program since we cannot guaranty correct
+          // test case setup and tear-down in this case.
+          ReportInvalidTestCaseType(test_case_name, code_location);
+          posix::Abort();
+        } else {
+          // At this point we are sure that the object we found is of the same
+          // type we are looking for, so we downcast it to that type
+          // without further checks.
+          typed_test_info = CheckedDowncastToActualType<
+              ParameterizedTestCaseInfo<TestCase> >(*it);
+        }
+        break;
+      }
+    }
+    if (typed_test_info == NULL) {
+      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
+          test_case_name, code_location);
+      test_case_infos_.push_back(typed_test_info);
+    }
+    return typed_test_info;
+  }
+  void RegisterTests() {
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      (*it)->RegisterTests();
+    }
+  }
+
+ private:
+  typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
+
+  TestCaseInfoContainer test_case_infos_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  //  GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+// This file was GENERATED by command:
+//     pump.py gtest-param-util-generated.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2008 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Type and function utilities for implementing parameterized tests.
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently Google Test supports at most 50 arguments in Values,
+// and at most 10 arguments in Combine. Please contact
+// googletestframework@googlegroups.com if you need more.
+// Please note that the number of arguments to Combine is limited
+// by the maximum arity of the implementation of tuple which is
+// currently set at 10.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end);
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+
+// Used in the Values() function to provide polymorphic capabilities.
+template <typename T1>
+class ValueArray1 {
+ public:
+  explicit ValueArray1(T1 v1) : v1_(v1) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray1& other);
+
+  const T1 v1_;
+};
+
+template <typename T1, typename T2>
+class ValueArray2 {
+ public:
+  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray2& other);
+
+  const T1 v1_;
+  const T2 v2_;
+};
+
+template <typename T1, typename T2, typename T3>
+class ValueArray3 {
+ public:
+  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray3& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4>
+class ValueArray4 {
+ public:
+  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray4& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+class ValueArray5 {
+ public:
+  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray5& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+class ValueArray6 {
+ public:
+  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray6& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+class ValueArray7 {
+ public:
+  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray7& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+class ValueArray8 {
+ public:
+  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray8& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+class ValueArray9 {
+ public:
+  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray9& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+class ValueArray10 {
+ public:
+  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray10& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+class ValueArray11 {
+ public:
+  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray11& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+class ValueArray12 {
+ public:
+  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray12& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+class ValueArray13 {
+ public:
+  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray13& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+class ValueArray14 {
+ public:
+  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray14& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+class ValueArray15 {
+ public:
+  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray15& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+class ValueArray16 {
+ public:
+  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray16& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+class ValueArray17 {
+ public:
+  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray17& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+class ValueArray18 {
+ public:
+  ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray18& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+class ValueArray19 {
+ public:
+  ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray19& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+class ValueArray20 {
+ public:
+  ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray20& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+class ValueArray21 {
+ public:
+  ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray21& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+class ValueArray22 {
+ public:
+  ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray22& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+class ValueArray23 {
+ public:
+  ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray23& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+class ValueArray24 {
+ public:
+  ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray24& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+class ValueArray25 {
+ public:
+  ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+      T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray25& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+class ValueArray26 {
+ public:
+  ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray26& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+class ValueArray27 {
+ public:
+  ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray27& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+class ValueArray28 {
+ public:
+  ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray28& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+class ValueArray29 {
+ public:
+  ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray29& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+class ValueArray30 {
+ public:
+  ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray30& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+class ValueArray31 {
+ public:
+  ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray31& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+class ValueArray32 {
+ public:
+  ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray32& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+class ValueArray33 {
+ public:
+  ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
+      T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray33& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+class ValueArray34 {
+ public:
+  ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray34& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+class ValueArray35 {
+ public:
+  ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
+      v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray35& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+class ValueArray36 {
+ public:
+  ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
+      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray36& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+class ValueArray37 {
+ public:
+  ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
+      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
+      v36_(v36), v37_(v37) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray37& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+class ValueArray38 {
+ public:
+  ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray38& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+class ValueArray39 {
+ public:
+  ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray39& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+class ValueArray40 {
+ public:
+  ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
+      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
+      v40_(v40) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray40& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+class ValueArray41 {
+ public:
+  ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
+      T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray41& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+class ValueArray42 {
+ public:
+  ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray42& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+class ValueArray43 {
+ public:
+  ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
+      v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
+      v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray43& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+class ValueArray44 {
+ public:
+  ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
+      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
+      v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
+      v43_(v43), v44_(v44) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray44& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+class ValueArray45 {
+ public:
+  ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
+      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
+      v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
+      v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray45& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+class ValueArray46 {
+ public:
+  ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
+      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray46& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+class ValueArray47 {
+ public:
+  ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
+      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
+      v47_(v47) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray47& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+class ValueArray48 {
+ public:
+  ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
+      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
+      v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
+      v46_(v46), v47_(v47), v48_(v48) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray48& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+class ValueArray49 {
+ public:
+  ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
+      T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
+      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray49& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+  const T49 v49_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+class ValueArray50 {
+ public:
+  ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
+      T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
+      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray50& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+  const T49 v49_;
+  const T50 v50_;
+};
+
+# if GTEST_HAS_COMBINE
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Generates values from the Cartesian product of values produced
+// by the argument generators.
+//
+template <typename T1, typename T2>
+class CartesianProductGenerator2
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2> > {
+ public:
+  typedef ::testing::tuple<T1, T2> ParamType;
+
+  CartesianProductGenerator2(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2)
+      : g1_(g1), g2_(g2) {}
+  virtual ~CartesianProductGenerator2() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current2_;
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator2::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator2& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+};  // class CartesianProductGenerator2
+
+
+template <typename T1, typename T2, typename T3>
+class CartesianProductGenerator3
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3> ParamType;
+
+  CartesianProductGenerator3(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
+      : g1_(g1), g2_(g2), g3_(g3) {}
+  virtual ~CartesianProductGenerator3() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current3_;
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator3::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator3& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+};  // class CartesianProductGenerator3
+
+
+template <typename T1, typename T2, typename T3, typename T4>
+class CartesianProductGenerator4
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4> ParamType;
+
+  CartesianProductGenerator4(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
+  virtual ~CartesianProductGenerator4() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current4_;
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator4::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator4& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+};  // class CartesianProductGenerator4
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+class CartesianProductGenerator5
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5> ParamType;
+
+  CartesianProductGenerator5(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
+  virtual ~CartesianProductGenerator5() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current5_;
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator5::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator5& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+};  // class CartesianProductGenerator5
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+class CartesianProductGenerator6
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5,
+        T6> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
+
+  CartesianProductGenerator6(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
+  virtual ~CartesianProductGenerator6() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current6_;
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator6::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator6& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+};  // class CartesianProductGenerator6
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+class CartesianProductGenerator7
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
+
+  CartesianProductGenerator7(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
+  virtual ~CartesianProductGenerator7() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current7_;
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator7::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator7& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+};  // class CartesianProductGenerator7
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+class CartesianProductGenerator8
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
+
+  CartesianProductGenerator8(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
+          g8_(g8) {}
+  virtual ~CartesianProductGenerator8() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current8_;
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator8::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator8& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+};  // class CartesianProductGenerator8
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+class CartesianProductGenerator9
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8, T9> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
+
+  CartesianProductGenerator9(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9) {}
+  virtual ~CartesianProductGenerator9() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end(), g9_, g9_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8,
+      const ParamGenerator<T9>& g9,
+      const typename ParamGenerator<T9>::iterator& current9)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
+          begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current9_;
+      if (current9_ == end9_) {
+        current9_ = begin9_;
+        ++current8_;
+      }
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_ &&
+          current9_ == typed_other->current9_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_),
+        begin9_(other.begin9_),
+        end9_(other.end9_),
+        current9_(other.current9_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_,
+            *current9_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_ ||
+          current9_ == end9_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    const typename ParamGenerator<T9>::iterator begin9_;
+    const typename ParamGenerator<T9>::iterator end9_;
+    typename ParamGenerator<T9>::iterator current9_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator9::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator9& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+  const ParamGenerator<T9> g9_;
+};  // class CartesianProductGenerator9
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+class CartesianProductGenerator10
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8, T9, T10> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
+
+  CartesianProductGenerator10(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
+      const ParamGenerator<T10>& g10)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9), g10_(g10) {}
+  virtual ~CartesianProductGenerator10() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end(), g9_, g9_.end(), g10_, g10_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8,
+      const ParamGenerator<T9>& g9,
+      const typename ParamGenerator<T9>::iterator& current9,
+      const ParamGenerator<T10>& g10,
+      const typename ParamGenerator<T10>::iterator& current10)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
+          begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
+          begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current10_;
+      if (current10_ == end10_) {
+        current10_ = begin10_;
+        ++current9_;
+      }
+      if (current9_ == end9_) {
+        current9_ = begin9_;
+        ++current8_;
+      }
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&other);
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_ &&
+          current9_ == typed_other->current9_ &&
+          current10_ == typed_other->current10_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_),
+        begin9_(other.begin9_),
+        end9_(other.end9_),
+        current9_(other.current9_),
+        begin10_(other.begin10_),
+        end10_(other.end10_),
+        current10_(other.current10_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_,
+            *current9_, *current10_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_ ||
+          current9_ == end9_ ||
+          current10_ == end10_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    const typename ParamGenerator<T9>::iterator begin9_;
+    const typename ParamGenerator<T9>::iterator end9_;
+    typename ParamGenerator<T9>::iterator current9_;
+    const typename ParamGenerator<T10>::iterator begin10_;
+    const typename ParamGenerator<T10>::iterator end10_;
+    typename ParamGenerator<T10>::iterator current10_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator10::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator10& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+  const ParamGenerator<T9> g9_;
+  const ParamGenerator<T10> g10_;
+};  // class CartesianProductGenerator10
+
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Helper classes providing Combine() with polymorphic features. They allow
+// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
+// convertible to U.
+//
+template <class Generator1, class Generator2>
+class CartesianProductHolder2 {
+ public:
+CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
+      : g1_(g1), g2_(g2) {}
+  template <typename T1, typename T2>
+  operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2> >(
+        new CartesianProductGenerator2<T1, T2>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder2& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+};  // class CartesianProductHolder2
+
+template <class Generator1, class Generator2, class Generator3>
+class CartesianProductHolder3 {
+ public:
+CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3)
+      : g1_(g1), g2_(g2), g3_(g3) {}
+  template <typename T1, typename T2, typename T3>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
+        new CartesianProductGenerator3<T1, T2, T3>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder3& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+};  // class CartesianProductHolder3
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4>
+class CartesianProductHolder4 {
+ public:
+CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
+  template <typename T1, typename T2, typename T3, typename T4>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
+        new CartesianProductGenerator4<T1, T2, T3, T4>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder4& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+};  // class CartesianProductHolder4
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5>
+class CartesianProductHolder5 {
+ public:
+CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
+        new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder5& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+};  // class CartesianProductHolder5
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6>
+class CartesianProductHolder6 {
+ public:
+CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
+        new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder6& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+};  // class CartesianProductHolder6
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7>
+class CartesianProductHolder7 {
+ public:
+CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+      T7> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
+        new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder7& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+};  // class CartesianProductHolder7
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8>
+class CartesianProductHolder8 {
+ public:
+CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
+          g8_(g8) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
+      T8> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
+        new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder8& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+};  // class CartesianProductHolder8
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8, class Generator9>
+class CartesianProductHolder9 {
+ public:
+CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8,
+    const Generator9& g9)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8, typename T9>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
+      T9> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
+        T9> >(
+        new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_),
+        static_cast<ParamGenerator<T9> >(g9_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder9& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+  const Generator9 g9_;
+};  // class CartesianProductHolder9
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8, class Generator9, class Generator10>
+class CartesianProductHolder10 {
+ public:
+CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8,
+    const Generator9& g9, const Generator10& g10)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9), g10_(g10) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8, typename T9, typename T10>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+      T10> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+        T10> >(
+        new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+            T10>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_),
+        static_cast<ParamGenerator<T9> >(g9_),
+        static_cast<ParamGenerator<T10> >(g10_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder10& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+  const Generator9 g9_;
+  const Generator10 g10_;
+};  // class CartesianProductHolder10
+
+# endif  // GTEST_HAS_COMBINE
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  //  GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test case is instantiated
+// with a particular generator, Google Test creates and runs tests
+// for each element in the sequence produced by the generator.
+//
+// In the following sample, tests from test case FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test case StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
+//
+// This instantiates tests from test case StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_CASE_P(CharSequence,
+//                         StlStringTest,
+//                         ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_CASE_P(CharSequence2,
+//                         CharTest,
+//                         ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
+      ::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test case BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
+//
+// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+// Currently, Values() supports from 1 to 50 parameters.
+//
+template <typename T1>
+internal::ValueArray1<T1> Values(T1 v1) {
+  return internal::ValueArray1<T1>(v1);
+}
+
+template <typename T1, typename T2>
+internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
+  return internal::ValueArray2<T1, T2>(v1, v2);
+}
+
+template <typename T1, typename T2, typename T3>
+internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
+  return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
+  return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5) {
+  return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6) {
+  return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7) {
+  return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
+      v6, v7);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+  return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
+      v5, v6, v7, v8);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+  return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+  return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+    T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11) {
+  return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+      T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+    T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12) {
+  return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+    T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13) {
+  return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
+  return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
+  return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16) {
+  return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17) {
+  return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18) {
+  return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
+  return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
+  return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
+  return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22) {
+  return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23) {
+  return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24) {
+  return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
+      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+      v19, v20, v21, v22, v23, v24);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
+    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
+    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
+  return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
+      v18, v19, v20, v21, v22, v23, v24, v25);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+    T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26) {
+  return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+    T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27) {
+  return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
+      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+    T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28) {
+  return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
+      v28);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29) {
+  return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
+      v27, v28, v29);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
+  return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
+      v26, v27, v28, v29, v30);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
+  return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
+      v25, v26, v27, v28, v29, v30, v31);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32) {
+  return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33) {
+  return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
+    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
+    T31 v31, T32 v32, T33 v33, T34 v34) {
+  return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
+      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
+  return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
+  return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37) {
+  return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36, v37);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37, T38 v38) {
+  return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
+      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+      v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
+      v33, v34, v35, v36, v37, v38);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37, T38 v38, T39 v39) {
+  return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
+      v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+      v32, v33, v34, v35, v36, v37, v38, v39);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
+    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
+    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
+    T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
+    T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
+  return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
+      v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+    T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
+  return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
+      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
+      v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+    T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42) {
+  return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
+      v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
+      v42);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+    T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42, T43 v43) {
+  return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
+      v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
+      v41, v42, v43);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42, T43 v43, T44 v44) {
+  return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
+      v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
+      v40, v41, v42, v43, v44);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
+    T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
+    T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
+  return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
+      v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
+      v39, v40, v41, v42, v43, v44, v45);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
+  return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
+      v38, v39, v40, v41, v42, v43, v44, v45, v46);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
+  return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
+      v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
+    T48 v48) {
+  return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
+      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
+      v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
+    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
+    T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
+    T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
+    T47 v47, T48 v48, T49 v49) {
+  return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
+      v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
+    T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
+    T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
+  return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+      v48, v49, v50);
+}
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test case FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+# if GTEST_HAS_COMBINE
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - returns a generator producing sequences with elements coming from
+//     the Cartesian product of elements from the sequences generated by
+//     gen1, gen2, ..., genN. The sequence elements will have a type of
+//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Combine can have up to 10 arguments. This number is currently limited
+// by the maximum number of elements in the tuple implementation used by Google
+// Test.
+//
+// Example:
+//
+// This will instantiate tests in test case AnimalTest each one with
+// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
+// tuple("dog", BLACK), and tuple("dog", WHITE):
+//
+// enum Color { BLACK, GRAY, WHITE };
+// class AnimalTest
+//     : public testing::TestWithParam<tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
+//                         Combine(Values("cat", "dog"),
+//                                 Values(BLACK, WHITE)));
+//
+// This will instantiate tests in FlagDependentTest with all variations of two
+// Boolean flags:
+//
+// class FlagDependentTest
+//     : public testing::TestWithParam<tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     tie(external_flag_1, external_flag_2) = GetParam();
+//   }
+// };
+//
+// TEST_P(FlagDependentTest, TestFeature1) {
+//   // Test your code using external_flag_1 and external_flag_2 here.
+// }
+// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
+//                         Combine(Bool(), Bool()));
+//
+template <typename Generator1, typename Generator2>
+internal::CartesianProductHolder2<Generator1, Generator2> Combine(
+    const Generator1& g1, const Generator2& g2) {
+  return internal::CartesianProductHolder2<Generator1, Generator2>(
+      g1, g2);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3>
+internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3) {
+  return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
+      g1, g2, g3);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4>
+internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
+    Generator4> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4) {
+  return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
+      Generator4>(
+      g1, g2, g3, g4);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5>
+internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
+    Generator4, Generator5> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5) {
+  return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
+      Generator4, Generator5>(
+      g1, g2, g3, g4, g5);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6>
+internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6) {
+  return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6>(
+      g1, g2, g3, g4, g5, g6);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7>
+internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7) {
+  return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7>(
+      g1, g2, g3, g4, g5, g6, g7);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8>
+internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8) {
+  return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8>(
+      g1, g2, g3, g4, g5, g6, g7, g8);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8, typename Generator9>
+internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8,
+    Generator9> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8, const Generator9& g9) {
+  return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
+      g1, g2, g3, g4, g5, g6, g7, g8, g9);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8, typename Generator9,
+    typename Generator10>
+internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
+    Generator10> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8, const Generator9& g9,
+        const Generator10& g10) {
+  return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
+      Generator10>(
+      g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
+}
+# endif  // GTEST_HAS_COMBINE
+
+
+
+# define TEST_P(test_case_name, test_name) \
+  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+      : public test_case_name { \
+   public: \
+    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
+    virtual void TestBody(); \
+   private: \
+    static int AddToRegistry() { \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestPattern(\
+                      #test_case_name, \
+                      #test_name, \
+                      new ::testing::internal::TestMetaFactory< \
+                          GTEST_TEST_CLASS_NAME_(\
+                              test_case_name, test_name)>()); \
+      return 0; \
+    } \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
+  }; \
+  int GTEST_TEST_CLASS_NAME_(test_case_name, \
+                             test_name)::gtest_registering_dummy_ = \
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
+  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
+
+// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
+// to specify a function or functor that generates custom test name suffixes
+// based on the test parameters. The function should accept one argument of
+// type testing::TestParamInfo<class ParamType>, and return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()). It does not work
+// for std::string or C strings.
+//
+// Note: test names must be non-empty, unique, and may only contain ASCII
+// alphanumeric characters or underscore.
+
+# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
+  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
+      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
+  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
+      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
+    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
+        (__VA_ARGS__)(info); \
+  } \
+  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
+                      #prefix, \
+                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
+                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
+                      __FILE__, __LINE__)
+
+}  // namespace testing
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+// Copyright 2006, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Google C++ Testing Framework definitions useful in production code.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+
+// When you need to test the private or protected members of a class,
+// use the FRIEND_TEST macro to declare your tests as friends of the
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void MyMethod();
+//   FRIEND_TEST(MyClassTest, MyMethod);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, MyMethod) {
+//   // Can call MyClass::MyMethod() here.
+// }
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+#include <iosfwd>
+#include <vector>
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class GTEST_API_ TestPartResult {
+ public:
+  // The possible outcomes of a test part (i.e. an assertion or an
+  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+  enum Type {
+    kSuccess,          // Succeeded.
+    kNonFatalFailure,  // Failed but the test can continue.
+    kFatalFailure      // Failed and the test should be terminated.
+  };
+
+  // C'tor.  TestPartResult does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestPartResult object.
+  TestPartResult(Type a_type,
+                 const char* a_file_name,
+                 int a_line_number,
+                 const char* a_message)
+      : type_(a_type),
+        file_name_(a_file_name == NULL ? "" : a_file_name),
+        line_number_(a_line_number),
+        summary_(ExtractSummary(a_message)),
+        message_(a_message) {
+  }
+
+  // Gets the outcome of the test part.
+  Type type() const { return type_; }
+
+  // Gets the name of the source file where the test part took place, or
+  // NULL if it's unknown.
+  const char* file_name() const {
+    return file_name_.empty() ? NULL : file_name_.c_str();
+  }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the summary of the failure message.
+  const char* summary() const { return summary_.c_str(); }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true iff the test part passed.
+  bool passed() const { return type_ == kSuccess; }
+
+  // Returns true iff the test part failed.
+  bool failed() const { return type_ != kSuccess; }
+
+  // Returns true iff the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
+
+  // Returns true iff the test part fatally failed.
+  bool fatally_failed() const { return type_ == kFatalFailure; }
+
+ private:
+  Type type_;
+
+  // Gets the summary of the failure message by omitting the stack
+  // trace in it.
+  static std::string ExtractSummary(const char* message);
+
+  // The name of the source file where the test part took place, or
+  // "" if the source file is unknown.
+  std::string file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class GTEST_API_ TestPartResultArray {
+ public:
+  TestPartResultArray() {}
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+
+ private:
+  std::vector<TestPartResult> array_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+namespace internal {
+
+// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
+// statement generates new fatal failures. To do so it registers itself as the
+// current test part result reporter. Besides checking if fatal failures were
+// reported, it only delegates the reporting to the former result reporter.
+// The original result reporter is restored in the destructor.
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+class GTEST_API_ HasNewFatalFailureHelper
+    : public TestPartResultReporterInterface {
+ public:
+  HasNewFatalFailureHelper();
+  virtual ~HasNewFatalFailureHelper();
+  virtual void ReportTestPartResult(const TestPartResult& result);
+  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+ private:
+  bool has_new_fatal_failure_;
+  TestPartResultReporterInterface* original_reporter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+// Copyright 2008 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// This header implements typed tests and type-parameterized tests.
+
+// Typed (aka type-driven) tests repeat the same test for types in a
+// list.  You must know which types you want to test with when writing
+// typed tests. Here's how you do it:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+
+// Next, associate a list of types with the test case, which will be
+// repeated for each type in the list.  The typedef is necessary for
+// the macro to parse correctly.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_CASE(FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   TYPED_TEST_CASE(FooTest, int);
+
+// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
+// tests for this test case as you want.
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  // Since we are inside a derived class template, C++ requires use to
+  // visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the TestFixture::
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the "typename
+  // TestFixture::" prefix.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+
+#endif  // 0
+
+// Type-parameterized tests are abstract test patterns parameterized
+// by a type.  Compared with typed tests, type-parameterized tests
+// allow you to define the test pattern without knowing what the type
+// parameters are.  The defined pattern can be instantiated with
+// different types any number of times, in any number of translation
+// units.
+//
+// If you are designing an interface or concept, you can define a
+// suite of type-parameterized tests to verify properties that any
+// valid implementation of the interface/concept should have.  Then,
+// each implementation can easily instantiate the test suite to verify
+// that it conforms to the requirements, without having to write
+// similar tests repeatedly.  Here's an example:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+  ...
+};
+
+// Next, declare that you will define a type-parameterized test case
+// (the _P suffix is for "parameterized" or "pattern", whichever you
+// prefer):
+TYPED_TEST_CASE_P(FooTest);
+
+// Then, use TYPED_TEST_P() to define as many type-parameterized tests
+// for this type-parameterized test case as you want.
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+
+// Now the tricky part: you need to register all test patterns before
+// you can instantiate them.  The first argument of the macro is the
+// test case name; the rest are the names of the tests in this test
+// case.
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+
+// Finally, you are free to instantiate the pattern with the types you
+// want.  If you put the above code in a header file, you can #include
+// it in multiple C++ source files and instantiate it multiple times.
+//
+// To distinguish different instances of the pattern, the first
+// argument to the INSTANTIATE_* macro is a prefix that will be added
+// to the actual test case name.  Remember to pick unique prefixes for
+// different instances.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+
+#endif  // 0
+
+
+// Implements typed tests.
+
+#if GTEST_HAS_TYPED_TEST
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the typedef for the type parameters of the
+// given test case.
+# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
+
+// The 'Types' template argument below must have spaces around it
+// since some compilers may choke on '>>' when passing a template
+// instance (e.g. Types<int>)
+# define TYPED_TEST_CASE(CaseName, Types) \
+  typedef ::testing::internal::TypeList< Types >::type \
+      GTEST_TYPE_PARAMS_(CaseName)
+
+# define TYPED_TEST(CaseName, TestName) \
+  template <typename gtest_TypeParam_> \
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
+      : public CaseName<gtest_TypeParam_> { \
+   private: \
+    typedef CaseName<gtest_TypeParam_> TestFixture; \
+    typedef gtest_TypeParam_ TypeParam; \
+    virtual void TestBody(); \
+  }; \
+  bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::internal::TypeParameterizedTest< \
+          CaseName, \
+          ::testing::internal::TemplateSel< \
+              GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
+          GTEST_TYPE_PARAMS_(CaseName)>::Register(\
+              "", ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+              #CaseName, #TestName, 0); \
+  template <typename gtest_TypeParam_> \
+  void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Implements type-parameterized tests.
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the namespace name that the type-parameterized tests for
+// the given type-parameterized test case are defined in.  The exact
+// name of the namespace is subject to change without notice.
+# define GTEST_CASE_NAMESPACE_(TestCaseName) \
+  gtest_case_##TestCaseName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the variable used to remember the names of
+// the defined tests in the given test case.
+# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
+  gtest_typed_test_case_p_state_##TestCaseName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
+//
+// Expands to the name of the variable used to remember the names of
+// the registered tests in the given test case.
+# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
+  gtest_registered_test_names_##TestCaseName##_
+
+// The variables defined in the type-parameterized test macros are
+// static as typically these macros are used in a .h file that can be
+// #included in multiple translation units linked together.
+# define TYPED_TEST_CASE_P(CaseName) \
+  static ::testing::internal::TypedTestCasePState \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
+
+# define TYPED_TEST_P(CaseName, TestName) \
+  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
+  template <typename gtest_TypeParam_> \
+  class TestName : public CaseName<gtest_TypeParam_> { \
+   private: \
+    typedef CaseName<gtest_TypeParam_> TestFixture; \
+    typedef gtest_TypeParam_ TypeParam; \
+    virtual void TestBody(); \
+  }; \
+  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
+          __FILE__, __LINE__, #CaseName, #TestName); \
+  } \
+  template <typename gtest_TypeParam_> \
+  void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
+
+# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
+  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
+  typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
+  } \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
+          __FILE__, __LINE__, #__VA_ARGS__)
+
+// The 'Types' template argument below must have spaces around it
+// since some compilers may choke on '>>' when passing a template
+// instance (e.g. Types<int>)
+# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
+  bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::internal::TypeParameterizedTestCase<CaseName, \
+          GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
+          ::testing::internal::TypeList< Types >::type>::Register(\
+              #Prefix, \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+              &GTEST_TYPED_TEST_CASE_P_STATE_(CaseName), \
+              #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// Depending on the platform, different string classes are available.
+// On Linux, in addition to ::std::string, Google also makes use of
+// class ::string, which has the same interface as ::std::string, but
+// has a different implementation.
+//
+// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
+// ::string is available AND is a distinct type to ::std::string, or
+// define it to 0 to indicate otherwise.
+//
+// If ::std::string and ::string are the same class on your platform
+// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
+//
+// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
+// heuristically.
+
+namespace testing {
+
+// Declares the flags.
+
+// This flag temporary enables the disabled tests.
+GTEST_DECLARE_bool_(also_run_disabled_tests);
+
+// This flag brings the debugger on an assertion failure.
+GTEST_DECLARE_bool_(break_on_failure);
+
+// This flag controls whether Google Test catches all test-thrown exceptions
+// and logs them as failures.
+GTEST_DECLARE_bool_(catch_exceptions);
+
+// This flag enables using colors in terminal output. Available values are
+// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
+// to let Google Test decide.
+GTEST_DECLARE_string_(color);
+
+// This flag sets up the filter to select by name using a glob pattern
+// the tests to run. If the filter is not given all tests are executed.
+GTEST_DECLARE_string_(filter);
+
+// This flag causes the Google Test to list tests. None of the tests listed
+// are actually run if the flag is provided.
+GTEST_DECLARE_bool_(list_tests);
+
+// This flag controls whether Google Test emits a detailed XML report to a file
+// in addition to its normal textual output.
+GTEST_DECLARE_string_(output);
+
+// This flags control whether Google Test prints the elapsed time for each
+// test.
+GTEST_DECLARE_bool_(print_time);
+
+// This flag specifies the random number seed.
+GTEST_DECLARE_int32_(random_seed);
+
+// This flag sets how many times the tests are repeated. The default value
+// is 1. If the value is -1 the tests are repeating forever.
+GTEST_DECLARE_int32_(repeat);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool_(show_internal_stack_frames);
+
+// When this flag is specified, tests' order is randomized on every iteration.
+GTEST_DECLARE_bool_(shuffle);
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32_(stack_trace_depth);
+
+// When this flag is specified, a failed assertion will throw an
+// exception if exceptions are enabled, or exit the program with a
+// non-zero code otherwise.
+GTEST_DECLARE_bool_(throw_on_failure);
+
+// When this flag is set with a "host:port" string, on supported
+// platforms test results are streamed to the specified port on
+// the specified host machine.
+GTEST_DECLARE_string_(stream_result_to);
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+namespace internal {
+
+class AssertHelper;
+class DefaultGlobalTestPartResultReporter;
+class ExecDeathTest;
+class NoExecDeathTest;
+class FinalSuccessChecker;
+class GTestFlagSaver;
+class StreamingListenerTest;
+class TestResultAccessor;
+class TestEventListenersAccessor;
+class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
+class WindowsDeathTest;
+class UnitTestImpl* GetUnitTestImpl();
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message);
+
+}  // namespace internal
+
+// The friend relationship of some of these classes is cyclic.
+// If we don't forward declare them the compiler might confuse the classes
+// in friendship clauses with same named classes on the scope.
+class Test;
+class TestCase;
+class TestInfo;
+class UnitTest;
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename internal::EnableIf<
+          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
+          /*enabler*/ = NULL)
+      : success_(success) {}
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true iff the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != NULL ?  message_->c_str() : "";
+  }
+  // TODO(vladl@google.com): Remove this after making sure no clients use it.
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T> AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == NULL)
+      message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  internal::scoped_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestCases, and
+// each TestCase contains one or many Tests.
+//
+// When you define a test using the TEST macro, you don't need to
+// explicitly derive from Test - the TEST macro automatically does
+// this for you.
+//
+// The only time you derive from Test is when defining a test fixture
+// to be used a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { ... }
+//     void TearDown() override { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class GTEST_API_ Test {
+ public:
+  friend class TestInfo;
+
+  // Defines types for pointers to functions that set up and tear down
+  // a test case.
+  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
+  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Sets up the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::SetUpTestCase() before running the first
+  // test in test case Foo.  Hence a sub-class can define its own
+  // SetUpTestCase() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestCase() {}
+
+  // Tears down the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::TearDownTestCase() after running the last
+  // test in test case Foo.  Hence a sub-class can define its own
+  // TearDownTestCase() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestCase() {}
+
+  // Returns true iff the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Returns true iff the current test has a non-fatal failure.
+  static bool HasNonfatalFailure();
+
+  // Returns true iff the current test has a (either fatal or
+  // non-fatal) failure.
+  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
+
+  // Logs a property for the current test, test case, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test case.  Only the last value for a given key is remembered.  These
+  // are public static so they can be called from utility functions that are
+  // not members of the test fixture.  Calls to RecordProperty made during
+  // lifespan of the test (from the moment its constructor starts to the
+  // moment its destructor finishes) will be output in XML as attributes of
+  // the <testcase> element.  Properties recorded from fixture's
+  // SetUpTestCase or TearDownTestCase are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true iff the current test has the same fixture class as
+  // the first test in the current test case.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Deletes self.  We deliberately pick an unusual name for this
+  // internal method to avoid clashing with names used in user TESTs.
+  void DeleteSelf_() { delete this; }
+
+  const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
+
+  // Often a user misspells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if void Setup() is declared in the user's
+  //   test fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if the method is called from the user's test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+};
+
+typedef internal::TimeInMillis TimeInMillis;
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const std::string& a_key, const std::string& a_value) :
+    key_(a_key), value_(a_value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const std::string& new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  std::string key_;
+  // The value supplied by the user.
+  std::string value_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class GTEST_API_ TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns the number of the test properties.
+  int test_property_count() const;
+
+  // Returns true iff the test passed (i.e. no test part failed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test failed.
+  bool Failed() const;
+
+  // Returns true iff the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns true iff the test has a non-fatal failure.
+  bool HasNonfatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns the i-th test part result among all the results. i can range
+  // from 0 to test_property_count() - 1. If i is not in that range, aborts
+  // the program.
+  const TestPartResult& GetTestPartResult(int i) const;
+
+  // Returns the i-th test property. i can range from 0 to
+  // test_property_count() - 1. If i is not in that range, aborts the
+  // program.
+  const TestProperty& GetTestProperty(int i) const;
+
+ private:
+  friend class TestInfo;
+  friend class TestCase;
+  friend class UnitTest;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::ExecDeathTest;
+  friend class internal::TestResultAccessor;
+  friend class internal::UnitTestImpl;
+  friend class internal::WindowsDeathTest;
+
+  // Gets the vector of TestPartResults.
+  const std::vector<TestPartResult>& test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the vector of TestProperties.
+  const std::vector<TestProperty>& test_properties() const {
+    return test_properties_;
+  }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testcase tags.  Returns true if the property is valid.
+  // TODO(russr): Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the test part results.
+  void ClearTestPartResults();
+
+  // Clears the object.
+  void Clear();
+
+  // Protects mutable state of the property vector and of owned
+  // properties, whose values may be updated.
+  internal::Mutex test_properites_mutex_;
+
+  // The vector of TestPartResults
+  std::vector<TestPartResult> test_part_results_;
+  // The vector of TestProperties
+  std::vector<TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+};  // class TestResult
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test case name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class GTEST_API_ TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Returns the test case name.
+  const char* test_case_name() const { return test_case_name_.c_str(); }
+
+  // Returns the test name.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a typed
+  // or a type-parameterized test.
+  const char* type_param() const {
+    if (type_param_.get() != NULL)
+      return type_param_->c_str();
+    return NULL;
+  }
+
+  // Returns the text representation of the value parameter, or NULL if this
+  // is not a value-parameterized test.
+  const char* value_param() const {
+    if (value_param_.get() != NULL)
+      return value_param_->c_str();
+    return NULL;
+  }
+
+  // Returns the file name where this test is defined.
+  const char* file() const { return location_.file.c_str(); }
+
+  // Returns the line where this test is defined.
+  int line() const { return location_.line; }
+
+  // Returns true if this test should run, that is if the test is not
+  // disabled (or it is disabled but the also_run_disabled_tests flag has
+  // been specified) and its full name matches the user-specified filter.
+  //
+  // Google Test allows the user to filter the tests by their full names.
+  // The full name of a test Bar in test case Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const { return should_run_; }
+
+  // Returns true iff this test will appear in the XML report.
+  bool is_reportable() const {
+    // For now, the XML report includes all tests matching the filter.
+    // In the future, we may trim tests that are excluded because of
+    // sharding.
+    return matches_filter_;
+  }
+
+  // Returns the result of the test.
+  const TestResult* result() const { return &result_; }
+
+ private:
+#if GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class Test;
+  friend class TestCase;
+  friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
+  friend TestInfo* internal::MakeAndRegisterTestInfo(
+      const char* test_case_name,
+      const char* name,
+      const char* type_param,
+      const char* value_param,
+      internal::CodeLocation code_location,
+      internal::TypeId fixture_class_id,
+      Test::SetUpTestCaseFunc set_up_tc,
+      Test::TearDownTestCaseFunc tear_down_tc,
+      internal::TestFactoryBase* factory);
+
+  // Constructs a TestInfo object. The newly constructed instance assumes
+  // ownership of the factory object.
+  TestInfo(const std::string& test_case_name,
+           const std::string& name,
+           const char* a_type_param,   // NULL if not a type-parameterized test
+           const char* a_value_param,  // NULL if not a value-parameterized test
+           internal::CodeLocation a_code_location,
+           internal::TypeId fixture_class_id,
+           internal::TestFactoryBase* factory);
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count() {
+    return result_.increment_death_test_count();
+  }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  static void ClearTestResult(TestInfo* test_info) {
+    test_info->result_.Clear();
+  }
+
+  // These fields are immutable properties of the test.
+  const std::string test_case_name_;     // Test case name
+  const std::string name_;               // Test name
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const internal::scoped_ptr<const ::std::string> type_param_;
+  // Text representation of the value parameter, or NULL if this is not a
+  // value-parameterized test.
+  const internal::scoped_ptr<const ::std::string> value_param_;
+  internal::CodeLocation location_;
+  const internal::TypeId fixture_class_id_;   // ID of the test fixture class
+  bool should_run_;                 // True iff this test should run
+  bool is_disabled_;                // True iff this test is disabled
+  bool matches_filter_;             // True if this test matches the
+                                    // user-specified filter.
+  internal::TestFactoryBase* const factory_;  // The factory that creates
+                                              // the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+};
+
+// A test case, which consists of a vector of TestInfos.
+//
+// TestCase is not copyable.
+class GTEST_API_ TestCase {
+ public:
+  // Creates a TestCase with the given name.
+  //
+  // TestCase does NOT have a default constructor.  Always use this
+  // constructor to create a TestCase object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test case
+  //   a_type_param: the name of the test's type parameter, or NULL if
+  //                 this is not a type-parameterized test.
+  //   set_up_tc:    pointer to the function that sets up the test case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  TestCase(const char* name, const char* a_type_param,
+           Test::SetUpTestCaseFunc set_up_tc,
+           Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Destructor of TestCase.
+  virtual ~TestCase();
+
+  // Gets the name of the TestCase.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a
+  // type-parameterized test case.
+  const char* type_param() const {
+    if (type_param_.get() != NULL)
+      return type_param_->c_str();
+    return NULL;
+  }
+
+  // Returns true if any test in this test case should run.
+  bool should_run() const { return should_run_; }
+
+  // Gets the number of successful tests in this test case.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests in this test case.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests in this test case.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Get the number of tests in this test case that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test case.
+  int total_test_count() const;
+
+  // Returns true iff the test case passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test case failed.
+  bool Failed() const { return failed_test_count() > 0; }
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  const TestInfo* GetTestInfo(int i) const;
+
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestCase and TearDownTestCase.
+  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
+
+ private:
+  friend class Test;
+  friend class internal::UnitTestImpl;
+
+  // Gets the (mutable) vector of TestInfos in this TestCase.
+  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
+
+  // Gets the (immutable) vector of TestInfos in this TestCase.
+  const std::vector<TestInfo*>& test_info_list() const {
+    return test_info_list_;
+  }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  TestInfo* GetMutableTestInfo(int i);
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
+  // destruction of the TestCase object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Clears the results of all tests in this test case.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test case.
+  static void ClearTestCaseResult(TestCase* test_case) {
+    test_case->ClearResult();
+  }
+
+  // Runs every test in this TestCase.
+  void Run();
+
+  // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
+  // for catching exceptions thrown from SetUpTestCase().
+  void RunSetUpTestCase() { (*set_up_tc_)(); }
+
+  // Runs TearDownTestCase() for this TestCase.  This wrapper is
+  // needed for catching exceptions thrown from TearDownTestCase().
+  void RunTearDownTestCase() { (*tear_down_tc_)(); }
+
+  // Returns true iff test passed.
+  static bool TestPassed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Passed();
+  }
+
+  // Returns true iff test failed.
+  static bool TestFailed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Failed();
+  }
+
+  // Returns true iff the test is disabled and will be reported in the XML
+  // report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
+  // Returns true iff test is disabled.
+  static bool TestDisabled(const TestInfo* test_info) {
+    return test_info->is_disabled_;
+  }
+
+  // Returns true iff this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo* test_info) {
+    return test_info->should_run();
+  }
+
+  // Shuffles the tests in this test case.
+  void ShuffleTests(internal::Random* random);
+
+  // Restores the test order to before the first shuffle.
+  void UnshuffleTests();
+
+  // Name of the test case.
+  std::string name_;
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const internal::scoped_ptr<const ::std::string> type_param_;
+  // The vector of TestInfos in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestInfo*> test_info_list_;
+  // Provides a level of indirection for the test list to allow easy
+  // shuffling and restoring the test order.  The i-th element in this
+  // vector is the index of the i-th test in the shuffled test list.
+  std::vector<int> test_indices_;
+  // Pointer to the function that sets up the test case.
+  Test::SetUpTestCaseFunc set_up_tc_;
+  // Pointer to the function that tears down the test case.
+  Test::TearDownTestCaseFunc tear_down_tc_;
+  // True iff any test in this test case should run.
+  bool should_run_;
+  // Elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestCase and
+  // TearDownTestCase.
+  TestResult ad_hoc_test_result_;
+
+  // We disallow copying TestCases.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  You should subclass this to define your own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+};
+
+// The interface for tracing execution of tests. The methods are organized in
+// the order the corresponding events are fired.
+class TestEventListener {
+ public:
+  virtual ~TestEventListener() {}
+
+  // Fired before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
+
+  // Fired before each iteration of tests starts.  There may be more than
+  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
+  // index, starting from 0.
+  virtual void OnTestIterationStart(const UnitTest& unit_test,
+                                    int iteration) = 0;
+
+  // Fired before environment set-up for each iteration of tests starts.
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment set-up for each iteration of tests ends.
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
+
+  // Fired before the test case starts.
+  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
+
+  // Fired before the test starts.
+  virtual void OnTestStart(const TestInfo& test_info) = 0;
+
+  // Fired after a failed assertion or a SUCCEED() invocation.
+  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
+
+  // Fired after the test ends.
+  virtual void OnTestEnd(const TestInfo& test_info) = 0;
+
+  // Fired after the test case ends.
+  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
+
+  // Fired before environment tear-down for each iteration of tests starts.
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment tear-down for each iteration of tests ends.
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
+
+  // Fired after each iteration of tests finishes.
+  virtual void OnTestIterationEnd(const UnitTest& unit_test,
+                                  int iteration) = 0;
+
+  // Fired after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
+};
+
+// The convenience class for users who need to override just one or two
+// methods and are not concerned that a possible change to a signature of
+// the methods they override will not be caught during the build.  For
+// comments about each method please see the definition of TestEventListener
+// above.
+class EmptyTestEventListener : public TestEventListener {
+ public:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int /*iteration*/) {}
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
+  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
+  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
+  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int /*iteration*/) {}
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
+};
+
+// TestEventListeners lets users add listeners to track events in Google Test.
+class GTEST_API_ TestEventListeners {
+ public:
+  TestEventListeners();
+  ~TestEventListeners();
+
+  // Appends an event listener to the end of the list. Google Test assumes
+  // the ownership of the listener (i.e. it will delete the listener when
+  // the test program finishes).
+  void Append(TestEventListener* listener);
+
+  // Removes the given event listener from the list and returns it.  It then
+  // becomes the caller's responsibility to delete the listener. Returns
+  // NULL if the listener is not found in the list.
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Returns the standard listener responsible for the default console
+  // output.  Can be removed from the listeners list to shut down default
+  // console output.  Note that removing this object from the listener list
+  // with Release transfers its ownership to the caller and makes this
+  // function return NULL the next time.
+  TestEventListener* default_result_printer() const {
+    return default_result_printer_;
+  }
+
+  // Returns the standard listener responsible for the default XML output
+  // controlled by the --gtest_output=xml flag.  Can be removed from the
+  // listeners list by users who want to shut down the default XML output
+  // controlled by this flag and substitute it with custom one.  Note that
+  // removing this object from the listener list with Release transfers its
+  // ownership to the caller and makes this function return NULL the next
+  // time.
+  TestEventListener* default_xml_generator() const {
+    return default_xml_generator_;
+  }
+
+ private:
+  friend class TestCase;
+  friend class TestInfo;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::NoExecDeathTest;
+  friend class internal::TestEventListenersAccessor;
+  friend class internal::UnitTestImpl;
+
+  // Returns repeater that broadcasts the TestEventListener events to all
+  // subscribers.
+  TestEventListener* repeater();
+
+  // Sets the default_result_printer attribute to the provided listener.
+  // The listener is also added to the listener list and previous
+  // default_result_printer is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultResultPrinter(TestEventListener* listener);
+
+  // Sets the default_xml_generator attribute to the provided listener.  The
+  // listener is also added to the listener list and previous
+  // default_xml_generator is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultXmlGenerator(TestEventListener* listener);
+
+  // Controls whether events will be forwarded by the repeater to the
+  // listeners in the list.
+  bool EventForwardingEnabled() const;
+  void SuppressEventForwarding();
+
+  // The actual list of listeners.
+  internal::TestEventRepeater* repeater_;
+  // Listener responsible for the standard result output.
+  TestEventListener* default_result_printer_;
+  // Listener responsible for the creation of the XML output file.
+  TestEventListener* default_xml_generator_;
+
+  // We disallow copying TestEventListeners.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+};
+
+// A UnitTest consists of a vector of TestCases.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class GTEST_API_ UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // This method can only be called from the main thread.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  int Run() GTEST_MUST_USE_RESULT_;
+
+  // Returns the working directory when the first TEST() or TEST_F()
+  // was executed.  The UnitTest object owns the string.
+  const char* original_working_dir() const;
+
+  // Returns the TestCase object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestCase* current_test_case() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the random seed used at the start of the current test run.
+  int random_seed() const;
+
+#if GTEST_HAS_PARAM_TEST
+  // Returns the ParameterizedTestCaseRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Gets the number of successful test cases.
+  int successful_test_case_count() const;
+
+  // Gets the number of failed test cases.
+  int failed_test_case_count() const;
+
+  // Gets the number of all test cases.
+  int total_test_case_count() const;
+
+  // Gets the number of all test cases that contain at least one test
+  // that should run.
+  int test_case_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const;
+
+  // Returns true iff the unit test passed (i.e. all test cases passed).
+  bool Passed() const;
+
+  // Returns true iff the unit test failed (i.e. some test case failed
+  // or something outside of all tests failed).
+  bool Failed() const;
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  const TestCase* GetTestCase(int i) const;
+
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test cases.
+  const TestResult& ad_hoc_test_result() const;
+
+  // Returns the list of event listeners that can be used to track events
+  // inside Google Test.
+  TestEventListeners& listeners();
+
+ private:
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  void AddTestPartResult(TestPartResult::Type result_type,
+                         const char* file_name,
+                         int line_number,
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+  // from SetUpTestCase or TearDownTestCase, or to the global property set
+  // when invoked elsewhere.  If the result already contains a property with
+  // the same key, the value will be updated.
+  void RecordProperty(const std::string& key, const std::string& value);
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  TestCase* GetMutableTestCase(int i);
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+
+  // These classes and funcions are friends as they need to access private
+  // members of UnitTest.
+  friend class Test;
+  friend class internal::AssertHelper;
+  friend class internal::ScopedTrace;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
+  friend Environment* AddGlobalTestEnvironment(Environment* env);
+  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
+  friend void internal::ReportFailureInUnknownLocation(
+      TestPartResult::Type result_type,
+      const std::string& message);
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+GTEST_API_ void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
+
+namespace internal {
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_* in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQFailure(const char* expected_expression,
+                                   const char* actual_expression,
+                                   const T1& expected, const T2& actual) {
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   FormatForComparisonFailureMessage(expected, actual),
+                   FormatForComparisonFailureMessage(actual, expected),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* expected_expression,
+                            const char* actual_expression,
+                            const T1& expected,
+                            const T2& actual) {
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
+  if (expected == actual) {
+    return AssertionSuccess();
+  }
+GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  return CmpHelperEQFailure(expected_expression, actual_expression, expected,
+                            actual);
+}
+
+// With this overloaded version, we allow anonymous enums to be used
+// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
+// can be implicitly cast to BiggestInt.
+GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
+                                       const char* actual_expression,
+                                       BiggestInt expected,
+                                       BiggestInt actual);
+
+// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
+// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
+// is a null pointer literal.  The following default implementation is
+// for lhs_is_null_literal being false.
+template <bool lhs_is_null_literal>
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <typename T1, typename T2>
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 const T1& expected,
+                                 const T2& actual) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* expected_expression,
+                                 const char* actual_expression,
+                                 BiggestInt expected,
+                                 BiggestInt actual) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+};
+
+// This specialization is used when the first argument to ASSERT_EQ()
+// is a null pointer literal, like NULL, false, or 0.
+template <>
+class EqHelper<true> {
+ public:
+  // We define two overloaded versions of Compare().  The first
+  // version will be picked when the second argument to ASSERT_EQ() is
+  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
+  // EXPECT_EQ(false, a_bool).
+  template <typename T1, typename T2>
+  static AssertionResult Compare(
+      const char* expected_expression,
+      const char* actual_expression,
+      const T1& expected,
+      const T2& actual,
+      // The following line prevents this overload from being considered if T2
+      // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
+      // expands to Compare("", "", NULL, my_ptr), which requires a conversion
+      // to match the Secret* in the other overload, which would otherwise make
+      // this template match better.
+      typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
+    return CmpHelperEQ(expected_expression, actual_expression, expected,
+                       actual);
+  }
+
+  // This version will be picked when the second argument to ASSERT_EQ() is a
+  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
+  template <typename T>
+  static AssertionResult Compare(
+      const char* expected_expression,
+      const char* actual_expression,
+      // We used to have a second template parameter instead of Secret*.  That
+      // template parameter would deduce to 'long', making this a better match
+      // than the first overload even without the first overload's EnableIf.
+      // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
+      // non-pointer argument" (even a deduced integral argument), so the old
+      // implementation caused warnings in user code.
+      Secret* /* expected (NULL) */,
+      T* actual) {
+    // We already know that 'expected' is a null pointer.
+    return CmpHelperEQ(expected_expression, actual_expression,
+                       static_cast<T*>(NULL), actual);
+  }
+};
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_OP in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
+                                   const T1& val1, const T2& val2,
+                                   const char* op) {
+  return AssertionFailure()
+         << "Expected: (" << expr1 << ") " << op << " (" << expr2
+         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
+         << " vs " << FormatForComparisonFailureMessage(val2, val1);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// For each templatized helper function, we also define an overloaded
+// version for BiggestInt in order to reduce code bloat and allow
+// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
+// with gcc 4.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}\
+GTEST_API_ AssertionResult CmpHelper##op_name(\
+    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER_(NE, !=);
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER_(LE, <=);
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER_(LT, <);
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER_(GE, >=);
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER_(GT, >);
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                                          const char* actual_expression,
+                                          const char* expected,
+                                          const char* actual);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
+                                              const char* actual_expression,
+                                              const char* expected,
+                                              const char* actual);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                                          const char* actual_expression,
+                                          const wchar_t* expected,
+                                          const wchar_t* actual);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
+                                         const char* actual_expression,
+                                         RawType expected,
+                                         RawType actual) {
+  const FloatingPoint<RawType> lhs(expected), rhs(actual);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  ::std::stringstream expected_ss;
+  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+              << expected;
+
+  ::std::stringstream actual_ss;
+  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+            << actual;
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   StringStreamToString(&expected_ss),
+                   StringStreamToString(&actual_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
+                                                const char* expr2,
+                                                const char* abs_error_expr,
+                                                double val1,
+                                                double val2,
+                                                double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class GTEST_API_ AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResult::Type type,
+               const char* file,
+               int line,
+               const char* message);
+  ~AssertHelper();
+
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE_ macro below.
+  void operator=(const Message& message) const;
+
+ private:
+  // We put our data in a struct so that the size of the AssertHelper class can
+  // be as small as possible.  This is important because gcc is incapable of
+  // re-using stack space even for temporary variables, so every EXPECT_EQ
+  // reserves stack space for another AssertHelper.
+  struct AssertHelperData {
+    AssertHelperData(TestPartResult::Type t,
+                     const char* srcfile,
+                     int line_num,
+                     const char* msg)
+        : type(t), file(srcfile), line(line_num), message(msg) { }
+
+    TestPartResult::Type const type;
+    const char* const file;
+    int const line;
+    std::string const message;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+  };
+
+  AssertHelperData* const data_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+};
+
+}  // namespace internal
+
+#if GTEST_HAS_PARAM_TEST
+// The pure interface class that all value-parameterized tests inherit from.
+// A value-parameterized class must inherit from both ::testing::Test and
+// ::testing::WithParamInterface. In most cases that just means inheriting
+// from ::testing::TestWithParam, but more complicated test hierarchies
+// may need to inherit from Test and WithParamInterface at different levels.
+//
+// This interface has support for accessing the test parameter value via
+// the GetParam() method.
+//
+// Use it with one of the parameter generator defining functions, like Range(),
+// Values(), ValuesIn(), Bool(), and Combine().
+//
+// class FooTest : public ::testing::TestWithParam<int> {
+//  protected:
+//   FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   virtual ~FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   virtual void SetUp() {
+//     // Can use GetParam() here.
+//   }
+//   virtual void TearDown {
+//     // Can use GetParam() here.
+//   }
+// };
+// TEST_P(FooTest, DoesBar) {
+//   // Can use GetParam() method here.
+//   Foo foo;
+//   ASSERT_TRUE(foo.DoesBar(GetParam()));
+// }
+// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+
+template <typename T>
+class WithParamInterface {
+ public:
+  typedef T ParamType;
+  virtual ~WithParamInterface() {}
+
+  // The current parameter value. Is also available in the test fixture's
+  // constructor. This member function is non-static, even though it only
+  // references static data, to reduce the opportunity for incorrect uses
+  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
+  // uses a fixture whose parameter type is int.
+  const ParamType& GetParam() const {
+    GTEST_CHECK_(parameter_ != NULL)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
+
+ private:
+  // Sets parameter value. The caller is responsible for making sure the value
+  // remains alive and unchanged throughout the current test.
+  static void SetParam(const ParamType* parameter) {
+    parameter_ = parameter;
+  }
+
+  // Static value used for accessing parameter during a test lifetime.
+  static const ParamType* parameter_;
+
+  // TestClass must be a subclass of WithParamInterface<T> and Test.
+  template <class TestClass> friend class internal::ParameterizedTestFactory;
+};
+
+template <typename T>
+const T* WithParamInterface<T>::parameter_ = NULL;
+
+// Most value-parameterized classes can ignore the existence of
+// WithParamInterface, and can just inherit from ::testing::TestWithParam.
+
+template <typename T>
+class TestWithParam : public Test, public WithParamInterface<T> {
+};
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Macros for indicating success/failure in test code.
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
+
+// Generates a nonfatal failure at the given source file location with
+// a generic message.
+#define ADD_FAILURE_AT(file, line) \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kNonFatalFailure)
+
+// Generates a fatal failure with a generic message.
+#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
+
+// Define this macro to 1 to omit the definition of FAIL(), which is a
+// generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_FAIL
+# define FAIL() GTEST_FAIL()
+#endif
+
+// Generates a success with a generic message.
+#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
+
+// Define this macro to 1 to omit the definition of SUCCEED(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_SUCCEED
+# define SUCCEED() GTEST_SUCCEED()
+#endif
+
+// Macros for testing exceptions.
+//
+//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
+//         Tests that the statement throws the expected exception.
+//    * {ASSERT|EXPECT}_NO_THROW(statement):
+//         Tests that the statement doesn't throw any exception.
+//    * {ASSERT|EXPECT}_ANY_THROW(statement):
+//         Tests that the statement throws an exception.
+
+#define EXPECT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+#define ASSERT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+#define ASSERT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+// Boolean assertions. Condition can be either a Boolean expression or an
+// AssertionResult. For more information on how to use AssertionResult with
+// these macros see comments on that class.
+#define EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_NONFATAL_FAILURE_)
+#define EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_NONFATAL_FAILURE_)
+#define ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_FATAL_FAILURE_)
+#define ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_FATAL_FAILURE_)
+
+// Includes the auto-generated header that implements a family of
+// generic predicate assertion macros.
+// Copyright 2006, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+// Makes sure this header is not included before gtest.h.
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1_(pred, v1, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
+                                             #v1, \
+                                             pred, \
+                                             v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ", "
+                            << e2 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1
+                            << "\n" << e2 << " evaluates to " << v2;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2_(pred, v1, v2, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             pred, \
+                                             v1, \
+                                             v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3) {
+  if (pred(v1, v2, v3)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ", "
+                            << e2 << ", "
+                            << e3 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4) {
+  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ", "
+                            << e2 << ", "
+                            << e3 << ", "
+                            << e4 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3
+                            << "\n" << e4 << " evaluates to " << v4;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  const T5& v5) {
+  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ", "
+                            << e2 << ", "
+                            << e3 << ", "
+                            << e4 << ", "
+                            << e5 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3
+                            << "\n" << e4 << " evaluates to " << v4
+                            << "\n" << e5 << " evaluates to " << v5;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             #v5, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4, \
+                                             v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+
+
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
+//    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
+//   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(5, Foo());
+//   EXPECT_EQ(NULL, a_pointer);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
+                      expected, actual)
+#define EXPECT_NE(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define GTEST_ASSERT_EQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
+                      expected, actual)
+#define GTEST_ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define GTEST_ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define GTEST_ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define GTEST_ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define GTEST_ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
+// ASSERT_XY(), which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_ASSERT_EQ
+# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_NE
+# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LE
+# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LT
+# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GE
+# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GT
+# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#endif
+
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(expected, actual) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(expected, actual) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(expected, actual)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      expected, actual)
+
+#define EXPECT_DOUBLE_EQ(expected, actual)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      expected, actual)
+
+#define ASSERT_FLOAT_EQ(expected, actual)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      expected, actual)
+
+#define ASSERT_DOUBLE_EQ(expected, actual)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      expected, actual)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
+                                   float val1, float val2);
+GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                                    double val1, double val2);
+
+
+#if GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the
+// expected result and the actual result with both a human-readable
+// string representation of the error, if available, as well as the
+// hex result code.
+# define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+# define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+// Macros that execute statement and check that it doesn't generate new fatal
+// failures in the current thread.
+//
+//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
+//
+// Examples:
+//
+//   EXPECT_NO_FATAL_FAILURE(Process());
+//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
+//
+#define ASSERT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+#define EXPECT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+#define SCOPED_TRACE(message) \
+  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, ::testing::Message() << (message))
+
+// Compile-time assertion for type equality.
+// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
+// the same type.  The value it returns is not interesting.
+//
+// Instead of making StaticAssertTypeEq a class template, we make it a
+// function template that invokes a helper class template.  This
+// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
+// defining objects of that type.
+//
+// CAVEAT:
+//
+// When used inside a method of a class template,
+// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
+// instantiated.  For example, given:
+//
+//   template <typename T> class Foo {
+//    public:
+//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
+//   };
+//
+// the code:
+//
+//   void Test1() { Foo<bool> foo; }
+//
+// will NOT generate a compiler error, as Foo<bool>::Bar() is never
+// actually instantiated.  Instead, you need:
+//
+//   void Test2() { Foo<bool> foo; foo.Bar(); }
+//
+// to cause a compiler error.
+template <typename T1, typename T2>
+bool StaticAssertTypeEq() {
+  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
+  return true;
+}
+
+// Defines a test.
+//
+// The first parameter is the name of the test case, and the second
+// parameter is the name of the test within the test case.
+//
+// The convention is to end the test case name with "Test".  For
+// example, a test case for the Foo class can be named FooTest.
+//
+// Test code should appear between braces after an invocation of
+// this macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+// Note that we call GetTestTypeId() instead of GetTypeId<
+// ::testing::Test>() here to get the type ID of testing::Test.  This
+// is to work around a suspected linker bug when using Google Test as
+// a framework on Mac OS X.  The bug causes GetTypeId<
+// ::testing::Test>() to return different values depending on whether
+// the call is from the Google Test framework itself or from user test
+// code.  GetTestTypeId() is guaranteed to always return the same
+// value, as it always calls GetTypeId<>() from the Google Test
+// framework.
+#define GTEST_TEST(test_case_name, test_name)\
+  GTEST_TEST_(test_case_name, test_name, \
+              ::testing::Test, ::testing::internal::GetTestTypeId())
+
+// Define this macro to 1 to omit the definition of TEST(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_TEST
+# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
+#endif
+
+// Defines a test that uses a test fixture.
+//
+// The first parameter is the name of the test fixture class, which
+// also doubles as the test case name.  The second parameter is the
+// name of the test within the test case.
+//
+// A test fixture class must be declared earlier.  The user should put
+// his test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     virtual void SetUp() { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(0, a_.size());
+//     EXPECT_EQ(1, b_.size());
+//   }
+
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+//
+// This function was formerly a macro; thus, it is in the global
+// namespace and has an all-caps name.
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_

From 1f4db88f31f9a28d422b57f77d11b824ea86be2a Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Fri, 11 Apr 2025 01:35:33 -0700
Subject: [PATCH 115/235] Back out
 "fbcode/mapillary/opensfm/opensfm/src/third_party/gtest"

Summary:
Original commit changeset: 4a3676ec81b9

Original Phabricator Diff: D63970962

Reviewed By: bal-a

Differential Revision: D72844841

fbshipit-source-id: 70bde393cc8ced39bae53d22154fccf80350d882
---
 .../src/third_party/gtest/gmock_gtest_all.cc  | 12225 ++++++++++++++++
 opensfm/src/third_party/gtest/gmock_main.cc   |    68 +
 2 files changed, 12293 insertions(+)
 create mode 100644 opensfm/src/third_party/gtest/gmock_gtest_all.cc
 create mode 100644 opensfm/src/third_party/gtest/gmock_main.cc

diff --git a/opensfm/src/third_party/gtest/gmock_gtest_all.cc b/opensfm/src/third_party/gtest/gmock_gtest_all.cc
new file mode 100644
index 000000000..2fc3e3cfb
--- /dev/null
+++ b/opensfm/src/third_party/gtest/gmock_gtest_all.cc
@@ -0,0 +1,12225 @@
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+// Google C++ Testing Framework (Google Test)
+//
+// Sometimes it's desirable to build Google Test by compiling a single file.
+// This file serves this purpose.
+
+// This line ensures that gtest.h can be compiled on its own, even
+// when it's fused.
+#include "gtest/gtest.h"
+
+// The following lines pull in the real gtest *.cc files.
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  virtual ~ScopedFakeTestPartResultReporter();
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type,
+                       const string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include <ctype.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include <algorithm>
+#include <iomanip>
+#include <limits>
+#include <list>
+#include <map>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <vector>
+
+#if GTEST_OS_LINUX
+
+// TODO(kenton@google.com): Use autoconf to detect availability of
+// gettimeofday().
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+
+# include <fcntl.h>  // NOLINT
+# include <limits.h>  // NOLINT
+# include <sched.h>  // NOLINT
+// Declares vsnprintf().  This header is not available on Windows.
+# include <strings.h>  // NOLINT
+# include <sys/mman.h>  // NOLINT
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+# include <string>
+
+#elif GTEST_OS_SYMBIAN
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+# include <sys/time.h>  // NOLINT
+
+#elif GTEST_OS_ZOS
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+# include <sys/time.h>  // NOLINT
+
+// On z/OS we additionally need strings.h for strcasecmp.
+# include <strings.h>  // NOLINT
+
+#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#elif GTEST_OS_WINDOWS  // We are on Windows proper.
+
+# include <io.h>  // NOLINT
+# include <sys/timeb.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+# include <sys/stat.h>  // NOLINT
+
+# if GTEST_OS_WINDOWS_MINGW
+// MinGW has gettimeofday() but not _ftime64().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+// TODO(kenton@google.com): There are other ways to get the time on
+//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
+//   supports these.  consider using them instead.
+#  define GTEST_HAS_GETTIMEOFDAY_ 1
+#  include <sys/time.h>  // NOLINT
+# endif  // GTEST_OS_WINDOWS_MINGW
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <windows.h>  // NOLINT
+# undef min
+
+#else
+
+// Assume other platforms have gettimeofday().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+# include <sys/socket.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+#endif
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// Utility functions and classes used by the Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This file contains purely Google Test's internal implementation.  Please
+// DO NOT #INCLUDE IT IN A USER PROGRAM.
+
+#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
+#define GTEST_SRC_GTEST_INTERNAL_INL_H_
+
+// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
+// part of Google Test's implementation; otherwise it's undefined.
+#if !GTEST_IMPLEMENTATION_
+// If this file is included from the user's code, just say no.
+# error "gtest-internal-inl.h is part of Google Test's internal implementation."
+# error "It must not be included except by Google Test itself."
+#endif  // GTEST_IMPLEMENTATION_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif  // !_WIN32_WCE
+#include <stddef.h>
+#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
+#include <string.h>  // For memmove.
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+#endif
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+
+namespace testing {
+
+// Declares the flags.
+//
+// We don't want the users to modify this flag in the code, but want
+// Google Test's own unit tests to be able to access it. Therefore we
+// declare it here as opposed to in gtest.h.
+GTEST_DECLARE_bool_(death_test_use_fork);
+
+namespace internal {
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
+const char kBreakOnFailureFlag[] = "break_on_failure";
+const char kCatchExceptionsFlag[] = "catch_exceptions";
+const char kColorFlag[] = "color";
+const char kFilterFlag[] = "filter";
+const char kListTestsFlag[] = "list_tests";
+const char kOutputFlag[] = "output";
+const char kPrintTimeFlag[] = "print_time";
+const char kRandomSeedFlag[] = "random_seed";
+const char kRepeatFlag[] = "repeat";
+const char kShuffleFlag[] = "shuffle";
+const char kStackTraceDepthFlag[] = "stack_trace_depth";
+const char kStreamResultToFlag[] = "stream_result_to";
+const char kThrowOnFailureFlag[] = "throw_on_failure";
+const char kFlagfileFlag[] = "flagfile";
+
+// A valid random seed must be in [1, kMaxRandomSeed].
+const int kMaxRandomSeed = 99999;
+
+// g_help_flag is true iff the --help flag or an equivalent form is
+// specified on the command line.
+GTEST_API_ extern bool g_help_flag;
+
+// Returns the current time in milliseconds.
+GTEST_API_ TimeInMillis GetTimeInMillis();
+
+// Returns true iff Google Test should use colors in the output.
+GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
+
+// Formats the given time in milliseconds as seconds.
+GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
+
+// Converts the given time in milliseconds to a date string in the ISO 8601
+// format, without the timezone information.  N.B.: due to the use the
+// non-reentrant localtime() function, this function is not thread safe.  Do
+// not use it in any code that can be called from multiple threads.
+GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
+
+// Parses a string for an Int32 flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+GTEST_API_ bool ParseInt32Flag(
+    const char* str, const char* flag, Int32* value);
+
+// Returns a random seed in range [1, kMaxRandomSeed] based on the
+// given --gtest_random_seed flag value.
+inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
+  const unsigned int raw_seed = (random_seed_flag == 0) ?
+      static_cast<unsigned int>(GetTimeInMillis()) :
+      static_cast<unsigned int>(random_seed_flag);
+
+  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
+  // it's easy to type.
+  const int normalized_seed =
+      static_cast<int>((raw_seed - 1U) %
+                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
+  return normalized_seed;
+}
+
+// Returns the first valid random seed after 'seed'.  The behavior is
+// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
+// considered to be 1.
+inline int GetNextRandomSeed(int seed) {
+  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
+      << "Invalid random seed " << seed << " - must be in [1, "
+      << kMaxRandomSeed << "].";
+  const int next_seed = seed + 1;
+  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
+}
+
+// This class saves the values of all Google Test flags in its c'tor, and
+// restores them in its d'tor.
+class GTestFlagSaver {
+ public:
+  // The c'tor.
+  GTestFlagSaver() {
+    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
+    break_on_failure_ = GTEST_FLAG(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
+    color_ = GTEST_FLAG(color);
+    death_test_style_ = GTEST_FLAG(death_test_style);
+    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
+    filter_ = GTEST_FLAG(filter);
+    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
+    list_tests_ = GTEST_FLAG(list_tests);
+    output_ = GTEST_FLAG(output);
+    print_time_ = GTEST_FLAG(print_time);
+    random_seed_ = GTEST_FLAG(random_seed);
+    repeat_ = GTEST_FLAG(repeat);
+    shuffle_ = GTEST_FLAG(shuffle);
+    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
+    stream_result_to_ = GTEST_FLAG(stream_result_to);
+    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
+  }
+
+  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
+  ~GTestFlagSaver() {
+    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
+    GTEST_FLAG(break_on_failure) = break_on_failure_;
+    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
+    GTEST_FLAG(color) = color_;
+    GTEST_FLAG(death_test_style) = death_test_style_;
+    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
+    GTEST_FLAG(filter) = filter_;
+    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
+    GTEST_FLAG(list_tests) = list_tests_;
+    GTEST_FLAG(output) = output_;
+    GTEST_FLAG(print_time) = print_time_;
+    GTEST_FLAG(random_seed) = random_seed_;
+    GTEST_FLAG(repeat) = repeat_;
+    GTEST_FLAG(shuffle) = shuffle_;
+    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
+    GTEST_FLAG(stream_result_to) = stream_result_to_;
+    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
+  }
+
+ private:
+  // Fields for saving the original values of flags.
+  bool also_run_disabled_tests_;
+  bool break_on_failure_;
+  bool catch_exceptions_;
+  std::string color_;
+  std::string death_test_style_;
+  bool death_test_use_fork_;
+  std::string filter_;
+  std::string internal_run_death_test_;
+  bool list_tests_;
+  std::string output_;
+  bool print_time_;
+  internal::Int32 random_seed_;
+  internal::Int32 repeat_;
+  bool shuffle_;
+  internal::Int32 stack_trace_depth_;
+  std::string stream_result_to_;
+  bool throw_on_failure_;
+} GTEST_ATTRIBUTE_UNUSED_;
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type UInt32 because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+GTEST_API_ std::string CodePointToUtf8(UInt32 code_point);
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded();
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (e.g., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+GTEST_API_ bool ShouldShard(const char* total_shards_str,
+                            const char* shard_index_str,
+                            bool in_subprocess_for_death_test);
+
+// Parses the environment variable var as an Int32. If it is unset,
+// returns default_val. If it is not an Int32, prints an error and
+// and aborts.
+GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true iff the test should be run on this shard. The test id is
+// some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+GTEST_API_ bool ShouldRunTestOnShard(
+    int total_shards, int shard_index, int test_id);
+
+// STL container utilities.
+
+// Returns the number of elements in the given container that satisfy
+// the given predicate.
+template <class Container, typename Predicate>
+inline int CountIf(const Container& c, Predicate predicate) {
+  // Implemented as an explicit loop since std::count_if() in libCstd on
+  // Solaris has a non-standard signature.
+  int count = 0;
+  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
+    if (predicate(*it))
+      ++count;
+  }
+  return count;
+}
+
+// Applies a function/functor to each element in the container.
+template <class Container, typename Functor>
+void ForEach(const Container& c, Functor functor) {
+  std::for_each(c.begin(), c.end(), functor);
+}
+
+// Returns the i-th element of the vector, or default_value if i is not
+// in range [0, v.size()).
+template <typename E>
+inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
+  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
+}
+
+// Performs an in-place shuffle of a range of the vector's elements.
+// 'begin' and 'end' are element indices as an STL-style range;
+// i.e. [begin, end) are shuffled, where 'end' == size() means to
+// shuffle to the end of the vector.
+template <typename E>
+void ShuffleRange(internal::Random* random, int begin, int end,
+                  std::vector<E>* v) {
+  const int size = static_cast<int>(v->size());
+  GTEST_CHECK_(0 <= begin && begin <= size)
+      << "Invalid shuffle range start " << begin << ": must be in range [0, "
+      << size << "].";
+  GTEST_CHECK_(begin <= end && end <= size)
+      << "Invalid shuffle range finish " << end << ": must be in range ["
+      << begin << ", " << size << "].";
+
+  // Fisher-Yates shuffle, from
+  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+  for (int range_width = end - begin; range_width >= 2; range_width--) {
+    const int last_in_range = begin + range_width - 1;
+    const int selected = begin + random->Generate(range_width);
+    std::swap((*v)[selected], (*v)[last_in_range]);
+  }
+}
+
+// Performs an in-place shuffle of the vector's elements.
+template <typename E>
+inline void Shuffle(internal::Random* random, std::vector<E>* v) {
+  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
+}
+
+// A function for deleting an object.  Handy for being used as a
+// functor.
+template <typename T>
+static void Delete(T* x) {
+  delete x;
+}
+
+// A predicate that checks the key of a TestProperty against a known key.
+//
+// TestPropertyKeyIs is copyable.
+class TestPropertyKeyIs {
+ public:
+  // Constructor.
+  //
+  // TestPropertyKeyIs has NO default constructor.
+  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
+
+  // Returns true iff the test name of test property matches on key_.
+  bool operator()(const TestProperty& test_property) const {
+    return test_property.key() == key_;
+  }
+
+ private:
+  std::string key_;
+};
+
+// Class UnitTestOptions.
+//
+// This class contains functions for processing options the user
+// specifies when running the tests.  It has only static members.
+//
+// In most cases, the user can specify an option using either an
+// environment variable or a command line flag.  E.g. you can set the
+// test filter using either GTEST_FILTER or --gtest_filter.  If both
+// the variable and the flag are present, the latter overrides the
+// former.
+class GTEST_API_ UnitTestOptions {
+ public:
+  // Functions for processing the gtest_output flag.
+
+  // Returns the output format, or "" for normal printed output.
+  static std::string GetOutputFormat();
+
+  // Returns the absolute path of the requested output file, or the
+  // default (test_detail.xml in the original working directory) if
+  // none was explicitly specified.
+  static std::string GetAbsolutePathToOutputFile();
+
+  // Functions for processing the gtest_filter flag.
+
+  // Returns true iff the wildcard pattern matches the string.  The
+  // first ':' or '\0' character in pattern marks the end of it.
+  //
+  // This recursive algorithm isn't very efficient, but is clear and
+  // works well enough for matching test names, which are short.
+  static bool PatternMatchesString(const char *pattern, const char *str);
+
+  // Returns true iff the user-specified filter matches the test case
+  // name and the test name.
+  static bool FilterMatchesTest(const std::string &test_case_name,
+                                const std::string &test_name);
+
+#if GTEST_OS_WINDOWS
+  // Function for supporting the gtest_catch_exception flag.
+
+  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+  // This function is useful as an __except condition.
+  static int GTestShouldProcessSEH(DWORD exception_code);
+#endif  // GTEST_OS_WINDOWS
+
+  // Returns true if "name" matches the ':' separated list of glob-style
+  // filters in "filter".
+  static bool MatchesFilter(const std::string& name, const char* filter);
+};
+
+// Returns the current application's name, removing directory path if that
+// is present.  Used by UnitTestOptions::GetOutputFile.
+GTEST_API_ FilePath GetCurrentExecutableName();
+
+// The role interface for getting the OS stack trace as a string.
+class OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetterInterface() {}
+  virtual ~OsStackTraceGetterInterface() {}
+
+  // Returns the current OS stack trace as an std::string.  Parameters:
+  //
+  //   max_depth  - the maximum number of stack frames to be included
+  //                in the trace.
+  //   skip_count - the number of top frames to be skipped; doesn't count
+  //                against max_depth.
+  virtual string CurrentStackTrace(int max_depth, int skip_count) = 0;
+
+  // UponLeavingGTest() should be called immediately before Google Test calls
+  // user code. It saves some information about the current stack that
+  // CurrentStackTrace() will use to find and hide Google Test stack frames.
+  virtual void UponLeavingGTest() = 0;
+
+  // This string is inserted in place of stack frames that are part of
+  // Google Test's implementation.
+  static const char* const kElidedFramesMarker;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
+};
+
+// A working implementation of the OsStackTraceGetterInterface interface.
+class OsStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetter() {}
+
+  virtual string CurrentStackTrace(int max_depth, int skip_count);
+  virtual void UponLeavingGTest();
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
+};
+
+// Information about a Google Test trace point.
+struct TraceInfo {
+  const char* file;
+  int line;
+  std::string message;
+};
+
+// This is the default global test part result reporter used in UnitTestImpl.
+// This class should only be used by UnitTestImpl.
+class DefaultGlobalTestPartResultReporter
+  : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. Reports the test part
+  // result in the current test.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
+};
+
+// This is the default per thread test part result reporter used in
+// UnitTestImpl. This class should only be used by UnitTestImpl.
+class DefaultPerThreadTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. The implementation just
+  // delegates to the current global test part result reporter of *unit_test_.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
+};
+
+// The private implementation of the UnitTest class.  We don't protect
+// the methods under a mutex, as this class is not accessible by a
+// user and the UnitTest class that delegates work to this class does
+// proper locking.
+class GTEST_API_ UnitTestImpl {
+ public:
+  explicit UnitTestImpl(UnitTest* parent);
+  virtual ~UnitTestImpl();
+
+  // There are two different ways to register your own TestPartResultReporter.
+  // You can register your own repoter to listen either only for test results
+  // from the current thread or for results from all threads.
+  // By default, each per-thread test result repoter just passes a new
+  // TestPartResult to the global test result reporter, which registers the
+  // test part result for the currently running test.
+
+  // Returns the global test part result reporter.
+  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
+
+  // Sets the global test part result reporter.
+  void SetGlobalTestPartResultReporter(
+      TestPartResultReporterInterface* reporter);
+
+  // Returns the test part result reporter for the current thread.
+  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
+
+  // Sets the test part result reporter for the current thread.
+  void SetTestPartResultReporterForCurrentThread(
+      TestPartResultReporterInterface* reporter);
+
+  // Gets the number of successful test cases.
+  int successful_test_case_count() const;
+
+  // Gets the number of failed test cases.
+  int failed_test_case_count() const;
+
+  // Gets the number of all test cases.
+  int total_test_case_count() const;
+
+  // Gets the number of all test cases that contain at least one test
+  // that should run.
+  int test_case_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns true iff the unit test passed (i.e. all test cases passed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the unit test failed (i.e. some test case failed
+  // or something outside of all tests failed).
+  bool Failed() const {
+    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
+  }
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  const TestCase* GetTestCase(int i) const {
+    const int index = GetElementOr(test_case_indices_, i, -1);
+    return index < 0 ? NULL : test_cases_[i];
+  }
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  TestCase* GetMutableTestCase(int i) {
+    const int index = GetElementOr(test_case_indices_, i, -1);
+    return index < 0 ? NULL : test_cases_[index];
+  }
+
+  // Provides access to the event listener list.
+  TestEventListeners* listeners() { return &listeners_; }
+
+  // Returns the TestResult for the test that's currently running, or
+  // the TestResult for the ad hoc test if no test is running.
+  TestResult* current_test_result();
+
+  // Returns the TestResult for the ad hoc test.
+  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
+
+  // Sets the OS stack trace getter.
+  //
+  // Does nothing if the input and the current OS stack trace getter
+  // are the same; otherwise, deletes the old getter and makes the
+  // input the current getter.
+  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
+
+  // Returns the current OS stack trace getter if it is not NULL;
+  // otherwise, creates an OsStackTraceGetter, makes it the current
+  // getter, and returns it.
+  OsStackTraceGetterInterface* os_stack_trace_getter();
+
+  // Returns the current OS stack trace as an std::string.
+  //
+  // The maximum number of stack frames to be included is specified by
+  // the gtest_stack_trace_depth flag.  The skip_count parameter
+  // specifies the number of top frames to be skipped, which doesn't
+  // count against the number of frames to be included.
+  //
+  // For example, if Foo() calls Bar(), which in turn calls
+  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
+
+  // Finds and returns a TestCase with the given name.  If one doesn't
+  // exist, creates one and returns it.
+  //
+  // Arguments:
+  //
+  //   test_case_name: name of the test case
+  //   type_param:     the name of the test's type parameter, or NULL if
+  //                   this is not a typed or a type-parameterized test.
+  //   set_up_tc:      pointer to the function that sets up the test case
+  //   tear_down_tc:   pointer to the function that tears down the test case
+  TestCase* GetTestCase(const char* test_case_name,
+                        const char* type_param,
+                        Test::SetUpTestCaseFunc set_up_tc,
+                        Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Adds a TestInfo to the unit test.
+  //
+  // Arguments:
+  //
+  //   set_up_tc:    pointer to the function that sets up the test case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  //   test_info:    the TestInfo object
+  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc,
+                   TestInfo* test_info) {
+    // In order to support thread-safe death tests, we need to
+    // remember the original working directory when the test program
+    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
+    // the user may have changed the current directory before calling
+    // RUN_ALL_TESTS().  Therefore we capture the current directory in
+    // AddTestInfo(), which is called to register a TEST or TEST_F
+    // before main() is reached.
+    if (original_working_dir_.IsEmpty()) {
+      original_working_dir_.Set(FilePath::GetCurrentDir());
+      GTEST_CHECK_(!original_working_dir_.IsEmpty())
+          << "Failed to get the current working directory.";
+    }
+
+    GetTestCase(test_info->test_case_name(),
+                test_info->type_param(),
+                set_up_tc,
+                tear_down_tc)->AddTestInfo(test_info);
+  }
+
+#if GTEST_HAS_PARAM_TEST
+  // Returns ParameterizedTestCaseRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
+    return parameterized_test_registry_;
+  }
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Sets the TestCase object for the test that's currently running.
+  void set_current_test_case(TestCase* a_current_test_case) {
+    current_test_case_ = a_current_test_case;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* a_current_test_info) {
+    current_test_info_ = a_current_test_info;
+  }
+
+  // Registers all parameterized tests defined using TEST_P and
+  // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter
+  // combination. This method can be called more then once; it has guards
+  // protecting from registering the tests more then once.  If
+  // value-parameterized tests are disabled, RegisterParameterizedTests is
+  // present but does nothing.
+  void RegisterParameterizedTests();
+
+  // Runs all tests in this UnitTest object, prints the result, and
+  // returns true if all tests are successful.  If any exception is
+  // thrown during a test, this test is considered to be failed, but
+  // the rest of the tests will still be run.
+  bool RunAllTests();
+
+  // Clears the results of all tests, except the ad hoc tests.
+  void ClearNonAdHocTestResult() {
+    ForEach(test_cases_, TestCase::ClearTestCaseResult);
+  }
+
+  // Clears the results of ad-hoc test assertions.
+  void ClearAdHocTestResult() {
+    ad_hoc_test_result_.Clear();
+  }
+
+  // Adds a TestProperty to the current TestResult object when invoked in a
+  // context of a test or a test case, or to the global property set. If the
+  // result already contains a property with the same key, the value will be
+  // updated.
+  void RecordProperty(const TestProperty& test_property);
+
+  enum ReactionToSharding {
+    HONOR_SHARDING_PROTOCOL,
+    IGNORE_SHARDING_PROTOCOL
+  };
+
+  // Matches the full name of each test against the user-specified
+  // filter to decide whether the test should run, then records the
+  // result in each TestCase and TestInfo object.
+  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
+  // based on sharding variables in the environment.
+  // Returns the number of tests that should run.
+  int FilterTests(ReactionToSharding shard_tests);
+
+  // Prints the names of the tests matching the user-specified filter flag.
+  void ListTestsMatchingFilter();
+
+  const TestCase* current_test_case() const { return current_test_case_; }
+  TestInfo* current_test_info() { return current_test_info_; }
+  const TestInfo* current_test_info() const { return current_test_info_; }
+
+  // Returns the vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*>& environments() { return environments_; }
+
+  // Getters for the per-thread Google Test trace stack.
+  std::vector<TraceInfo>& gtest_trace_stack() {
+    return *(gtest_trace_stack_.pointer());
+  }
+  const std::vector<TraceInfo>& gtest_trace_stack() const {
+    return gtest_trace_stack_.get();
+  }
+
+#if GTEST_HAS_DEATH_TEST
+  void InitDeathTestSubprocessControlInfo() {
+    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
+  }
+  // Returns a pointer to the parsed --gtest_internal_run_death_test
+  // flag, or NULL if that flag was not specified.
+  // This information is useful only in a death test child process.
+  // Must not be called before a call to InitGoogleTest.
+  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
+    return internal_run_death_test_flag_.get();
+  }
+
+  // Returns a pointer to the current death test factory.
+  internal::DeathTestFactory* death_test_factory() {
+    return death_test_factory_.get();
+  }
+
+  void SuppressTestEventsIfInSubprocess();
+
+  friend class ReplaceDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // Initializes the event listener performing XML output as specified by
+  // UnitTestOptions. Must not be called before InitGoogleTest.
+  void ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+  // Initializes the event listener for streaming test results to a socket.
+  // Must not be called before InitGoogleTest.
+  void ConfigureStreamingOutput();
+#endif
+
+  // Performs initialization dependent upon flag values obtained in
+  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+  // this function is also called from RunAllTests.  Since this function can be
+  // called more than once, it has to be idempotent.
+  void PostFlagParsingInit();
+
+  // Gets the random seed used at the start of the current test iteration.
+  int random_seed() const { return random_seed_; }
+
+  // Gets the random number generator.
+  internal::Random* random() { return &random_; }
+
+  // Shuffles all test cases, and the tests within each test case,
+  // making sure that death tests are still run first.
+  void ShuffleTests();
+
+  // Restores the test cases and tests to their order before the first shuffle.
+  void UnshuffleTests();
+
+  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
+  // UnitTest::Run() starts.
+  bool catch_exceptions() const { return catch_exceptions_; }
+
+ private:
+  friend class ::testing::UnitTest;
+
+  // Used by UnitTest::Run() to capture the state of
+  // GTEST_FLAG(catch_exceptions) at the moment it starts.
+  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
+
+  // The UnitTest object that owns this implementation object.
+  UnitTest* const parent_;
+
+  // The working directory when the first TEST() or TEST_F() was
+  // executed.
+  internal::FilePath original_working_dir_;
+
+  // The default test part result reporters.
+  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
+  DefaultPerThreadTestPartResultReporter
+      default_per_thread_test_part_result_reporter_;
+
+  // Points to (but doesn't own) the global test part result reporter.
+  TestPartResultReporterInterface* global_test_part_result_repoter_;
+
+  // Protects read and write access to global_test_part_result_reporter_.
+  internal::Mutex global_test_part_result_reporter_mutex_;
+
+  // Points to (but doesn't own) the per-thread test part result reporter.
+  internal::ThreadLocal<TestPartResultReporterInterface*>
+      per_thread_test_part_result_reporter_;
+
+  // The vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*> environments_;
+
+  // The vector of TestCases in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestCase*> test_cases_;
+
+  // Provides a level of indirection for the test case list to allow
+  // easy shuffling and restoring the test case order.  The i-th
+  // element of this vector is the index of the i-th test case in the
+  // shuffled order.
+  std::vector<int> test_case_indices_;
+
+#if GTEST_HAS_PARAM_TEST
+  // ParameterizedTestRegistry object used to register value-parameterized
+  // tests.
+  internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
+
+  // Indicates whether RegisterParameterizedTests() has been called already.
+  bool parameterized_tests_registered_;
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Index of the last death test case registered.  Initially -1.
+  int last_death_test_case_;
+
+  // This points to the TestCase for the currently running test.  It
+  // changes as Google Test goes through one test case after another.
+  // When no test is running, this is set to NULL and Google Test
+  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestCase* current_test_case_;
+
+  // This points to the TestInfo for the currently running test.  It
+  // changes as Google Test goes through one test after another.  When
+  // no test is running, this is set to NULL and Google Test stores
+  // assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestInfo* current_test_info_;
+
+  // Normally, a user only writes assertions inside a TEST or TEST_F,
+  // or inside a function called by a TEST or TEST_F.  Since Google
+  // Test keeps track of which test is current running, it can
+  // associate such an assertion with the test it belongs to.
+  //
+  // If an assertion is encountered when no TEST or TEST_F is running,
+  // Google Test attributes the assertion result to an imaginary "ad hoc"
+  // test, and records the result in ad_hoc_test_result_.
+  TestResult ad_hoc_test_result_;
+
+  // The list of event listeners that can be used to track events inside
+  // Google Test.
+  TestEventListeners listeners_;
+
+  // The OS stack trace getter.  Will be deleted when the UnitTest
+  // object is destructed.  By default, an OsStackTraceGetter is used,
+  // but the user can set this field to use a custom getter if that is
+  // desired.
+  OsStackTraceGetterInterface* os_stack_trace_getter_;
+
+  // True iff PostFlagParsingInit() has been called.
+  bool post_flag_parse_init_performed_;
+
+  // The random number seed used at the beginning of the test run.
+  int random_seed_;
+
+  // Our random number generator.
+  internal::Random random_;
+
+  // The time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp_;
+
+  // How long the test took to run, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+#if GTEST_HAS_DEATH_TEST
+  // The decomposed components of the gtest_internal_run_death_test flag,
+  // parsed when RUN_ALL_TESTS is called.
+  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
+  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
+  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
+
+  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
+  // starts.
+  bool catch_exceptions_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
+};  // class UnitTestImpl
+
+// Convenience function for accessing the global UnitTest
+// implementation object.
+inline UnitTestImpl* GetUnitTestImpl() {
+  return UnitTest::GetInstance()->impl();
+}
+
+#if GTEST_USES_SIMPLE_RE
+
+// Internal helper functions for implementing the simple regular
+// expression matcher.
+GTEST_API_ bool IsInSet(char ch, const char* str);
+GTEST_API_ bool IsAsciiDigit(char ch);
+GTEST_API_ bool IsAsciiPunct(char ch);
+GTEST_API_ bool IsRepeat(char ch);
+GTEST_API_ bool IsAsciiWhiteSpace(char ch);
+GTEST_API_ bool IsAsciiWordChar(char ch);
+GTEST_API_ bool IsValidEscape(char ch);
+GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
+GTEST_API_ bool ValidateRegex(const char* regex);
+GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
+GTEST_API_ bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char ch, char repeat, const char* regex, const char* str);
+GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
+
+#endif  // GTEST_USES_SIMPLE_RE
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
+
+#if GTEST_HAS_DEATH_TEST
+
+// Returns the message describing the last system error, regardless of the
+// platform.
+GTEST_API_ std::string GetLastErrnoDescription();
+
+// Attempts to parse a string into a positive integer pointed to by the
+// number parameter.  Returns true if that is possible.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
+// it here.
+template <typename Integer>
+bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtoXXX's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !IsDigit(str[0])) {
+    return false;
+  }
+  errno = 0;
+
+  char* end;
+  // BiggestConvertible is the largest integer type that system-provided
+  // string-to-number conversion routines can return.
+
+# if GTEST_OS_WINDOWS && !defined(__GNUC__)
+
+  // MSVC and C++ Builder define __int64 instead of the standard long long.
+  typedef unsigned __int64 BiggestConvertible;
+  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
+
+# else
+
+  typedef unsigned long long BiggestConvertible;  // NOLINT
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
+
+# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
+
+  const bool parse_success = *end == '\0' && errno == 0;
+
+  // TODO(vladl@google.com): Convert this to compile time assertion when it is
+  // available.
+  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
+
+  const Integer result = static_cast<Integer>(parsed);
+  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
+    *number = result;
+    return true;
+  }
+  return false;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// TestResult contains some private methods that should be hidden from
+// Google Test user but are required for testing. This class allow our tests
+// to access them.
+//
+// This class is supplied only for the purpose of testing Google Test's own
+// constructs. Do not use it in user tests, either directly or indirectly.
+class TestResultAccessor {
+ public:
+  static void RecordProperty(TestResult* test_result,
+                             const std::string& xml_element,
+                             const TestProperty& property) {
+    test_result->RecordProperty(xml_element, property);
+  }
+
+  static void ClearTestPartResults(TestResult* test_result) {
+    test_result->ClearTestPartResults();
+  }
+
+  static const std::vector<testing::TestPartResult>& test_part_results(
+      const TestResult& test_result) {
+    return test_result.test_part_results();
+  }
+};
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Streams test results to the given port on the given host machine.
+class StreamingListener : public EmptyTestEventListener {
+ public:
+  // Abstract base class for writing strings to a socket.
+  class AbstractSocketWriter {
+   public:
+    virtual ~AbstractSocketWriter() {}
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) = 0;
+
+    // Closes the socket.
+    virtual void CloseConnection() {}
+
+    // Sends a string and a newline to the socket.
+    void SendLn(const string& message) {
+      Send(message + "\n");
+    }
+  };
+
+  // Concrete class for actually writing strings to a socket.
+  class SocketWriter : public AbstractSocketWriter {
+   public:
+    SocketWriter(const string& host, const string& port)
+        : sockfd_(-1), host_name_(host), port_num_(port) {
+      MakeConnection();
+    }
+
+    virtual ~SocketWriter() {
+      if (sockfd_ != -1)
+        CloseConnection();
+    }
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "Send() can be called only when there is a connection.";
+
+      const int len = static_cast<int>(message.length());
+      if (write(sockfd_, message.c_str(), len) != len) {
+        GTEST_LOG_(WARNING)
+            << "stream_result_to: failed to stream to "
+            << host_name_ << ":" << port_num_;
+      }
+    }
+
+   private:
+    // Creates a client socket and connects to the server.
+    void MakeConnection();
+
+    // Closes the socket.
+    void CloseConnection() {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "CloseConnection() can be called only when there is a connection.";
+
+      close(sockfd_);
+      sockfd_ = -1;
+    }
+
+    int sockfd_;  // socket file descriptor
+    const string host_name_;
+    const string port_num_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+  };  // class SocketWriter
+
+  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
+  static string UrlEncode(const char* str);
+
+  StreamingListener(const string& host, const string& port)
+      : socket_writer_(new SocketWriter(host, port)) { Start(); }
+
+  explicit StreamingListener(AbstractSocketWriter* socket_writer)
+      : socket_writer_(socket_writer) { Start(); }
+
+  void OnTestProgramStart(const UnitTest& /* unit_test */) {
+    SendLn("event=TestProgramStart");
+  }
+
+  void OnTestProgramEnd(const UnitTest& unit_test) {
+    // Note that Google Test current only report elapsed time for each
+    // test iteration, not for the entire test program.
+    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
+
+    // Notify the streaming server to stop.
+    socket_writer_->CloseConnection();
+  }
+
+  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
+    SendLn("event=TestIterationStart&iteration=" +
+           StreamableToString(iteration));
+  }
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
+    SendLn("event=TestIterationEnd&passed=" +
+           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
+           StreamableToString(unit_test.elapsed_time()) + "ms");
+  }
+
+  void OnTestCaseStart(const TestCase& test_case) {
+    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  }
+
+  void OnTestCaseEnd(const TestCase& test_case) {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
+           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
+           + "ms");
+  }
+
+  void OnTestStart(const TestInfo& test_info) {
+    SendLn(std::string("event=TestStart&name=") + test_info.name());
+  }
+
+  void OnTestEnd(const TestInfo& test_info) {
+    SendLn("event=TestEnd&passed=" +
+           FormatBool((test_info.result())->Passed()) +
+           "&elapsed_time=" +
+           StreamableToString((test_info.result())->elapsed_time()) + "ms");
+  }
+
+  void OnTestPartResult(const TestPartResult& test_part_result) {
+    const char* file_name = test_part_result.file_name();
+    if (file_name == NULL)
+      file_name = "";
+    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
+           "&line=" + StreamableToString(test_part_result.line_number()) +
+           "&message=" + UrlEncode(test_part_result.message()));
+  }
+
+ private:
+  // Sends the given message and a newline to the socket.
+  void SendLn(const string& message) { socket_writer_->SendLn(message); }
+
+  // Called at the start of streaming to notify the receiver what
+  // protocol we are using.
+  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
+
+  string FormatBool(bool value) { return value ? "1" : "0"; }
+
+  const scoped_ptr<AbstractSocketWriter> socket_writer_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+};  // class StreamingListener
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
+#undef GTEST_IMPLEMENTATION_
+
+#if GTEST_OS_WINDOWS
+# define vsnprintf _vsnprintf
+#endif  // GTEST_OS_WINDOWS
+
+namespace testing {
+
+using internal::CountIf;
+using internal::ForEach;
+using internal::GetElementOr;
+using internal::Shuffle;
+
+// Constants.
+
+// A test whose test case name or test name matches this filter is
+// disabled and not run.
+static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
+
+// A test case whose name matches this filter is considered a death
+// test case and will be run before test cases whose name doesn't
+// match this filter.
+static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
+
+// A test filter that matches everything.
+static const char kUniversalFilter[] = "*";
+
+// The default output file for XML output.
+static const char kDefaultOutputFile[] = "test_detail.xml";
+
+// The environment variable name for the test shard index.
+static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
+// The environment variable name for the total number of test shards.
+static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
+// The environment variable name for the test shard status file.
+static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
+
+namespace internal {
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+const char kStackTraceMarker[] = "\nStack trace:\n";
+
+// g_help_flag is true iff the --help flag or an equivalent form is
+// specified on the command line.
+bool g_help_flag = false;
+
+}  // namespace internal
+
+static const char* GetDefaultFilter() {
+#ifdef GTEST_TEST_FILTER_ENV_VAR_
+  const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
+  if (testbridge_test_only != NULL) {
+    return testbridge_test_only;
+  }
+#endif  // GTEST_TEST_FILTER_ENV_VAR_
+  return kUniversalFilter;
+}
+
+GTEST_DEFINE_bool_(
+    also_run_disabled_tests,
+    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
+    "Run disabled tests too, in addition to the tests normally being run.");
+
+GTEST_DEFINE_bool_(
+    break_on_failure,
+    internal::BoolFromGTestEnv("break_on_failure", false),
+    "True iff a failed assertion should be a debugger break-point.");
+
+GTEST_DEFINE_bool_(
+    catch_exceptions,
+    internal::BoolFromGTestEnv("catch_exceptions", true),
+    "True iff " GTEST_NAME_
+    " should catch exceptions and treat them as test failures.");
+
+GTEST_DEFINE_string_(
+    color,
+    internal::StringFromGTestEnv("color", "auto"),
+    "Whether to use colors in the output.  Valid values: yes, no, "
+    "and auto.  'auto' means to use colors if the output is "
+    "being sent to a terminal and the TERM environment variable "
+    "is set to a terminal type that supports colors.");
+
+GTEST_DEFINE_string_(
+    filter,
+    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
+    "A colon-separated list of glob (not regex) patterns "
+    "for filtering the tests to run, optionally followed by a "
+    "'-' and a : separated list of negative patterns (tests to "
+    "exclude).  A test is run if it matches one of the positive "
+    "patterns and does not match any of the negative patterns.");
+
+GTEST_DEFINE_bool_(list_tests, false,
+                   "List all tests without running them.");
+
+GTEST_DEFINE_string_(
+    output,
+    internal::StringFromGTestEnv("output", ""),
+    "A format (currently must be \"xml\"), optionally followed "
+    "by a colon and an output file name or directory. A directory "
+    "is indicated by a trailing pathname separator. "
+    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
+    "If a directory is specified, output files will be created "
+    "within that directory, with file-names based on the test "
+    "executable's name and, if necessary, made unique by adding "
+    "digits.");
+
+GTEST_DEFINE_bool_(
+    print_time,
+    internal::BoolFromGTestEnv("print_time", true),
+    "True iff " GTEST_NAME_
+    " should display elapsed time in text output.");
+
+GTEST_DEFINE_int32_(
+    random_seed,
+    internal::Int32FromGTestEnv("random_seed", 0),
+    "Random number seed to use when shuffling test orders.  Must be in range "
+    "[1, 99999], or 0 to use a seed based on the current time.");
+
+GTEST_DEFINE_int32_(
+    repeat,
+    internal::Int32FromGTestEnv("repeat", 1),
+    "How many times to repeat each test.  Specify a negative number "
+    "for repeating forever.  Useful for shaking out flaky tests.");
+
+GTEST_DEFINE_bool_(
+    show_internal_stack_frames, false,
+    "True iff " GTEST_NAME_ " should include internal stack frames when "
+    "printing test failure stack traces.");
+
+GTEST_DEFINE_bool_(
+    shuffle,
+    internal::BoolFromGTestEnv("shuffle", false),
+    "True iff " GTEST_NAME_
+    " should randomize tests' order on every run.");
+
+GTEST_DEFINE_int32_(
+    stack_trace_depth,
+    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    "The maximum number of stack frames to print when an "
+    "assertion fails.  The valid range is 0 through 100, inclusive.");
+
+GTEST_DEFINE_string_(
+    stream_result_to,
+    internal::StringFromGTestEnv("stream_result_to", ""),
+    "This flag specifies the host name and the port number on which to stream "
+    "test results. Example: \"localhost:555\". The flag is effective only on "
+    "Linux.");
+
+GTEST_DEFINE_bool_(
+    throw_on_failure,
+    internal::BoolFromGTestEnv("throw_on_failure", false),
+    "When this flag is specified, a failed assertion will throw an exception "
+    "if exceptions are enabled or exit the program with a non-zero code "
+    "otherwise.");
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DEFINE_string_(
+    flagfile,
+    internal::StringFromGTestEnv("flagfile", ""),
+    "This flag specifies the flagfile to read command-line flags from.");
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+namespace internal {
+
+// Generates a random number from [0, range), using a Linear
+// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
+// than kMaxRange.
+UInt32 Random::Generate(UInt32 range) {
+  // These constants are the same as are used in glibc's rand(3).
+  state_ = (1103515245U*state_ + 12345U) % kMaxRange;
+
+  GTEST_CHECK_(range > 0)
+      << "Cannot generate a number in the range [0, 0).";
+  GTEST_CHECK_(range <= kMaxRange)
+      << "Generation of a number in [0, " << range << ") was requested, "
+      << "but this can only generate numbers in [0, " << kMaxRange << ").";
+
+  // Converting via modulus introduces a bit of downward bias, but
+  // it's simple, and a linear congruential generator isn't too good
+  // to begin with.
+  return state_ % range;
+}
+
+// GTestIsInitialized() returns true iff the user has initialized
+// Google Test.  Useful for catching the user mistake of not initializing
+// Google Test before calling RUN_ALL_TESTS().
+static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
+
+// Iterates over a vector of TestCases, keeping a running sum of the
+// results of calling a given int-returning method on each.
+// Returns the sum.
+static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
+                               int (TestCase::*method)() const) {
+  int sum = 0;
+  for (size_t i = 0; i < case_list.size(); i++) {
+    sum += (case_list[i]->*method)();
+  }
+  return sum;
+}
+
+// Returns true iff the test case passed.
+static bool TestCasePassed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Passed();
+}
+
+// Returns true iff the test case failed.
+static bool TestCaseFailed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Failed();
+}
+
+// Returns true iff test_case contains at least one test that should
+// run.
+static bool ShouldRunTestCase(const TestCase* test_case) {
+  return test_case->should_run();
+}
+
+// AssertHelper constructor.
+AssertHelper::AssertHelper(TestPartResult::Type type,
+                           const char* file,
+                           int line,
+                           const char* message)
+    : data_(new AssertHelperData(type, file, line, message)) {
+}
+
+AssertHelper::~AssertHelper() {
+  delete data_;
+}
+
+// Message assignment, for assertion streaming support.
+void AssertHelper::operator=(const Message& message) const {
+  UnitTest::GetInstance()->
+    AddTestPartResult(data_->type, data_->file, data_->line,
+                      AppendUserMessage(data_->message, message),
+                      UnitTest::GetInstance()->impl()
+                      ->CurrentOsStackTraceExceptTop(1)
+                      // Skips the stack frame for this function itself.
+                      );  // NOLINT
+}
+
+// Mutex for linked pointers.
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+::std::vector<testing::internal::string> g_argvs;
+
+const ::std::vector<testing::internal::string>& GetArgvs() {
+#if defined(GTEST_CUSTOM_GET_ARGVS_)
+  return GTEST_CUSTOM_GET_ARGVS_();
+#else  // defined(GTEST_CUSTOM_GET_ARGVS_)
+  return g_argvs;
+#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
+}
+
+// Returns the current application's name, removing directory path if that
+// is present.
+FilePath GetCurrentExecutableName() {
+  FilePath result;
+
+#if GTEST_OS_WINDOWS
+  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
+#else
+  result.Set(FilePath(GetArgvs()[0]));
+#endif  // GTEST_OS_WINDOWS
+
+  return result.RemoveDirectoryName();
+}
+
+// Functions for processing the gtest_output flag.
+
+// Returns the output format, or "" for normal printed output.
+std::string UnitTestOptions::GetOutputFormat() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL) return std::string("");
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  return (colon == NULL) ?
+      std::string(gtest_output_flag) :
+      std::string(gtest_output_flag, colon - gtest_output_flag);
+}
+
+// Returns the name of the requested output file, or the default if none
+// was explicitly specified.
+std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL)
+    return "";
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  if (colon == NULL)
+    return internal::FilePath::ConcatPaths(
+        internal::FilePath(
+            UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(kDefaultOutputFile)).string();
+
+  internal::FilePath output_name(colon + 1);
+  if (!output_name.IsAbsolutePath())
+    // TODO(wan@google.com): on Windows \some\path is not an absolute
+    // path (as its meaning depends on the current drive), yet the
+    // following logic for turning it into an absolute path is wrong.
+    // Fix it.
+    output_name = internal::FilePath::ConcatPaths(
+        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(colon + 1));
+
+  if (!output_name.IsDirectory())
+    return output_name.string();
+
+  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
+      output_name, internal::GetCurrentExecutableName(),
+      GetOutputFormat().c_str()));
+  return result.string();
+}
+
+// Returns true iff the wildcard pattern matches the string.  The
+// first ':' or '\0' character in pattern marks the end of it.
+//
+// This recursive algorithm isn't very efficient, but is clear and
+// works well enough for matching test names, which are short.
+bool UnitTestOptions::PatternMatchesString(const char *pattern,
+                                           const char *str) {
+  switch (*pattern) {
+    case '\0':
+    case ':':  // Either ':' or '\0' marks the end of the pattern.
+      return *str == '\0';
+    case '?':  // Matches any single character.
+      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
+    case '*':  // Matches any string (possibly empty) of characters.
+      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
+          PatternMatchesString(pattern + 1, str);
+    default:  // Non-special character.  Matches itself.
+      return *pattern == *str &&
+          PatternMatchesString(pattern + 1, str + 1);
+  }
+}
+
+bool UnitTestOptions::MatchesFilter(
+    const std::string& name, const char* filter) {
+  const char *cur_pattern = filter;
+  for (;;) {
+    if (PatternMatchesString(cur_pattern, name.c_str())) {
+      return true;
+    }
+
+    // Finds the next pattern in the filter.
+    cur_pattern = strchr(cur_pattern, ':');
+
+    // Returns if no more pattern can be found.
+    if (cur_pattern == NULL) {
+      return false;
+    }
+
+    // Skips the pattern separater (the ':' character).
+    cur_pattern++;
+  }
+}
+
+// Returns true iff the user-specified filter matches the test case
+// name and the test name.
+bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
+                                        const std::string &test_name) {
+  const std::string& full_name = test_case_name + "." + test_name.c_str();
+
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = GTEST_FLAG(filter).c_str();
+  const char* const dash = strchr(p, '-');
+  std::string positive;
+  std::string negative;
+  if (dash == NULL) {
+    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
+    negative = "";
+  } else {
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = kUniversalFilter;
+    }
+  }
+
+  // A filter is a colon-separated list of patterns.  It matches a
+  // test if any pattern in it matches the test.
+  return (MatchesFilter(full_name, positive.c_str()) &&
+          !MatchesFilter(full_name, negative.c_str()));
+}
+
+#if GTEST_HAS_SEH
+// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+// This function is useful as an __except condition.
+int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
+  // Google Test should handle a SEH exception if:
+  //   1. the user wants it to, AND
+  //   2. this is not a breakpoint exception, AND
+  //   3. this is not a C++ exception (VC++ implements them via SEH,
+  //      apparently).
+  //
+  // SEH exception code for C++ exceptions.
+  // (see http://support.microsoft.com/kb/185294 for more information).
+  const DWORD kCxxExceptionCode = 0xe06d7363;
+
+  bool should_handle = true;
+
+  if (!GTEST_FLAG(catch_exceptions))
+    should_handle = false;
+  else if (exception_code == EXCEPTION_BREAKPOINT)
+    should_handle = false;
+  else if (exception_code == kCxxExceptionCode)
+    should_handle = false;
+
+  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+#endif  // GTEST_HAS_SEH
+
+}  // namespace internal
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results. Intercepts only failures from the current thread.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    TestPartResultArray* result)
+    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
+      result_(result) {
+  Init();
+}
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    InterceptMode intercept_mode, TestPartResultArray* result)
+    : intercept_mode_(intercept_mode),
+      result_(result) {
+  Init();
+}
+
+void ScopedFakeTestPartResultReporter::Init() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    old_reporter_ = impl->GetGlobalTestPartResultReporter();
+    impl->SetGlobalTestPartResultReporter(this);
+  } else {
+    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
+    impl->SetTestPartResultReporterForCurrentThread(this);
+  }
+}
+
+// The d'tor restores the test part result reporter used by Google Test
+// before.
+ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    impl->SetGlobalTestPartResultReporter(old_reporter_);
+  } else {
+    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
+  }
+}
+
+// Increments the test part result count and remembers the result.
+// This method is from the TestPartResultReporterInterface interface.
+void ScopedFakeTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  result_->Append(result);
+}
+
+namespace internal {
+
+// Returns the type ID of ::testing::Test.  We should always call this
+// instead of GetTypeId< ::testing::Test>() to get the type ID of
+// testing::Test.  This is to work around a suspected linker bug when
+// using Google Test as a framework on Mac OS X.  The bug causes
+// GetTypeId< ::testing::Test>() to return different values depending
+// on whether the call is from the Google Test framework itself or
+// from user test code.  GetTestTypeId() is guaranteed to always
+// return the same value, as it always calls GetTypeId<>() from the
+// gtest.cc, which is within the Google Test framework.
+TypeId GetTestTypeId() {
+  return GetTypeId<Test>();
+}
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
+
+// This predicate-formatter checks that 'results' contains a test part
+// failure of the given type and that the failure message contains the
+// given substring.
+AssertionResult HasOneFailure(const char* /* results_expr */,
+                              const char* /* type_expr */,
+                              const char* /* substr_expr */,
+                              const TestPartResultArray& results,
+                              TestPartResult::Type type,
+                              const string& substr) {
+  const std::string expected(type == TestPartResult::kFatalFailure ?
+                        "1 fatal failure" :
+                        "1 non-fatal failure");
+  Message msg;
+  if (results.size() != 1) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual: " << results.size() << " failures";
+    for (int i = 0; i < results.size(); i++) {
+      msg << "\n" << results.GetTestPartResult(i);
+    }
+    return AssertionFailure() << msg;
+  }
+
+  const TestPartResult& r = results.GetTestPartResult(0);
+  if (r.type() != type) {
+    return AssertionFailure() << "Expected: " << expected << "\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  if (strstr(r.message(), substr.c_str()) == NULL) {
+    return AssertionFailure() << "Expected: " << expected << " containing \""
+                              << substr << "\"\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  return AssertionSuccess();
+}
+
+// The constructor of SingleFailureChecker remembers where to look up
+// test part results, what type of failure we expect, and what
+// substring the failure message should contain.
+SingleFailureChecker:: SingleFailureChecker(
+    const TestPartResultArray* results,
+    TestPartResult::Type type,
+    const string& substr)
+    : results_(results),
+      type_(type),
+      substr_(substr) {}
+
+// The destructor of SingleFailureChecker verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+SingleFailureChecker::~SingleFailureChecker() {
+  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
+}
+
+DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->current_test_result()->AddTestPartResult(result);
+  unit_test_->listeners()->repeater()->OnTestPartResult(result);
+}
+
+DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
+}
+
+// Returns the global test part result reporter.
+TestPartResultReporterInterface*
+UnitTestImpl::GetGlobalTestPartResultReporter() {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  return global_test_part_result_repoter_;
+}
+
+// Sets the global test part result reporter.
+void UnitTestImpl::SetGlobalTestPartResultReporter(
+    TestPartResultReporterInterface* reporter) {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  global_test_part_result_repoter_ = reporter;
+}
+
+// Returns the test part result reporter for the current thread.
+TestPartResultReporterInterface*
+UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
+  return per_thread_test_part_result_reporter_.get();
+}
+
+// Sets the test part result reporter for the current thread.
+void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
+    TestPartResultReporterInterface* reporter) {
+  per_thread_test_part_result_reporter_.set(reporter);
+}
+
+// Gets the number of successful test cases.
+int UnitTestImpl::successful_test_case_count() const {
+  return CountIf(test_cases_, TestCasePassed);
+}
+
+// Gets the number of failed test cases.
+int UnitTestImpl::failed_test_case_count() const {
+  return CountIf(test_cases_, TestCaseFailed);
+}
+
+// Gets the number of all test cases.
+int UnitTestImpl::total_test_case_count() const {
+  return static_cast<int>(test_cases_.size());
+}
+
+// Gets the number of all test cases that contain at least one test
+// that should run.
+int UnitTestImpl::test_case_to_run_count() const {
+  return CountIf(test_cases_, ShouldRunTestCase);
+}
+
+// Gets the number of successful tests.
+int UnitTestImpl::successful_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
+}
+
+// Gets the number of failed tests.
+int UnitTestImpl::failed_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTestImpl::reportable_disabled_test_count() const {
+  return SumOverTestCaseList(test_cases_,
+                             &TestCase::reportable_disabled_test_count);
+}
+
+// Gets the number of disabled tests.
+int UnitTestImpl::disabled_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTestImpl::reportable_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
+}
+
+// Gets the number of all tests.
+int UnitTestImpl::total_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
+}
+
+// Gets the number of tests that should run.
+int UnitTestImpl::test_to_run_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+  return os_stack_trace_getter()->CurrentStackTrace(
+      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
+      skip_count + 1
+      // Skips the user-specified number of frames plus this function
+      // itself.
+      );  // NOLINT
+}
+
+// Returns the current time in milliseconds.
+TimeInMillis GetTimeInMillis() {
+#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
+  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
+  // http://analogous.blogspot.com/2005/04/epoch.html
+  const TimeInMillis kJavaEpochToWinFileTimeDelta =
+    static_cast<TimeInMillis>(116444736UL) * 100000UL;
+  const DWORD kTenthMicrosInMilliSecond = 10000;
+
+  SYSTEMTIME now_systime;
+  FILETIME now_filetime;
+  ULARGE_INTEGER now_int64;
+  // TODO(kenton@google.com): Shouldn't this just use
+  //   GetSystemTimeAsFileTime()?
+  GetSystemTime(&now_systime);
+  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
+    now_int64.LowPart = now_filetime.dwLowDateTime;
+    now_int64.HighPart = now_filetime.dwHighDateTime;
+    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
+      kJavaEpochToWinFileTimeDelta;
+    return now_int64.QuadPart;
+  }
+  return 0;
+#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
+  __timeb64 now;
+
+  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
+  // (deprecated function) there.
+  // TODO(kenton@google.com): Use GetTickCount()?  Or use
+  //   SystemTimeToFileTime()
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+  _ftime64(&now);
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
+#elif GTEST_HAS_GETTIMEOFDAY_
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
+#else
+# error "Don't know how to get the current time on your system."
+#endif
+}
+
+// Utilities
+
+// class String.
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Creates a UTF-16 wide string from the given ANSI string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the wide string, or NULL if the
+// input is NULL.
+LPCWSTR String::AnsiToUtf16(const char* ansi) {
+  if (!ansi) return NULL;
+  const int length = strlen(ansi);
+  const int unicode_length =
+      MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                          NULL, 0);
+  WCHAR* unicode = new WCHAR[unicode_length + 1];
+  MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                      unicode, unicode_length);
+  unicode[unicode_length] = 0;
+  return unicode;
+}
+
+// Creates an ANSI string from the given wide string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the ANSI string, or NULL if the
+// input is NULL.
+const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
+  if (!utf16_str) return NULL;
+  const int ansi_length =
+      WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
+                          NULL, 0, NULL, NULL);
+  char* ansi = new char[ansi_length + 1];
+  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
+                      ansi, ansi_length, NULL, NULL);
+  ansi[ansi_length] = 0;
+  return ansi;
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Compares two C strings.  Returns true iff they have the same content.
+//
+// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CStringEquals(const char * lhs, const char * rhs) {
+  if ( lhs == NULL ) return rhs == NULL;
+
+  if ( rhs == NULL ) return false;
+
+  return strcmp(lhs, rhs) == 0;
+}
+
+#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+// Converts an array of wide chars to a narrow string using the UTF-8
+// encoding, and streams the result to the given Message object.
+static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
+                                     Message* msg) {
+  for (size_t i = 0; i != length; ) {  // NOLINT
+    if (wstr[i] != L'\0') {
+      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
+      while (i != length && wstr[i] != L'\0')
+        i++;
+    } else {
+      *msg << '\0';
+      i++;
+    }
+  }
+}
+
+#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest) {
+  ::std::vector< ::std::string> parsed;
+  ::std::string::size_type pos = 0;
+  while (::testing::internal::AlwaysTrue()) {
+    const ::std::string::size_type colon = str.find(delimiter, pos);
+    if (colon == ::std::string::npos) {
+      parsed.push_back(str.substr(pos));
+      break;
+    } else {
+      parsed.push_back(str.substr(pos, colon - pos));
+      pos = colon + 1;
+    }
+  }
+  dest->swap(parsed);
+}
+
+}  // namespace internal
+
+// Constructs an empty Message.
+// We allocate the stringstream separately because otherwise each use of
+// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+// stack frame leading to huge stack frames in some cases; gcc does not reuse
+// the stack space.
+Message::Message() : ss_(new ::std::stringstream) {
+  // By default, we want there to be enough precision when printing
+  // a double to a Message.
+  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+}
+
+// These two overloads allow streaming a wide C string to a Message
+// using the UTF-8 encoding.
+Message& Message::operator <<(const wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+Message& Message::operator <<(wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::std::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Gets the text streamed to this object so far as an std::string.
+// Each '\0' character in the buffer is replaced with "\\0".
+std::string Message::GetString() const {
+  return internal::StringStreamToString(ss_.get());
+}
+
+// AssertionResult constructors.
+// Used in EXPECT_TRUE/FALSE(assertion_result).
+AssertionResult::AssertionResult(const AssertionResult& other)
+    : success_(other.success_),
+      message_(other.message_.get() != NULL ?
+               new ::std::string(*other.message_) :
+               static_cast< ::std::string*>(NULL)) {
+}
+
+// Swaps two AssertionResults.
+void AssertionResult::swap(AssertionResult& other) {
+  using std::swap;
+  swap(success_, other.success_);
+  swap(message_, other.message_);
+}
+
+// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+AssertionResult AssertionResult::operator!() const {
+  AssertionResult negation(!success_);
+  if (message_.get() != NULL)
+    negation << *message_;
+  return negation;
+}
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() {
+  return AssertionResult(true);
+}
+
+// Makes a failed assertion result.
+AssertionResult AssertionFailure() {
+  return AssertionResult(false);
+}
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionFailure() << message;
+}
+
+namespace internal {
+
+namespace edit_distance {
+std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
+                                            const std::vector<size_t>& right) {
+  std::vector<std::vector<double> > costs(
+      left.size() + 1, std::vector<double>(right.size() + 1));
+  std::vector<std::vector<EditType> > best_move(
+      left.size() + 1, std::vector<EditType>(right.size() + 1));
+
+  // Populate for empty right.
+  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
+    costs[l_i][0] = static_cast<double>(l_i);
+    best_move[l_i][0] = kRemove;
+  }
+  // Populate for empty left.
+  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
+    costs[0][r_i] = static_cast<double>(r_i);
+    best_move[0][r_i] = kAdd;
+  }
+
+  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
+    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
+      if (left[l_i] == right[r_i]) {
+        // Found a match. Consume it.
+        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
+        best_move[l_i + 1][r_i + 1] = kMatch;
+        continue;
+      }
+
+      const double add = costs[l_i + 1][r_i];
+      const double remove = costs[l_i][r_i + 1];
+      const double replace = costs[l_i][r_i];
+      if (add < remove && add < replace) {
+        costs[l_i + 1][r_i + 1] = add + 1;
+        best_move[l_i + 1][r_i + 1] = kAdd;
+      } else if (remove < add && remove < replace) {
+        costs[l_i + 1][r_i + 1] = remove + 1;
+        best_move[l_i + 1][r_i + 1] = kRemove;
+      } else {
+        // We make replace a little more expensive than add/remove to lower
+        // their priority.
+        costs[l_i + 1][r_i + 1] = replace + 1.00001;
+        best_move[l_i + 1][r_i + 1] = kReplace;
+      }
+    }
+  }
+
+  // Reconstruct the best path. We do it in reverse order.
+  std::vector<EditType> best_path;
+  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
+    EditType move = best_move[l_i][r_i];
+    best_path.push_back(move);
+    l_i -= move != kAdd;
+    r_i -= move != kRemove;
+  }
+  std::reverse(best_path.begin(), best_path.end());
+  return best_path;
+}
+
+namespace {
+
+// Helper class to convert string into ids with deduplication.
+class InternalStrings {
+ public:
+  size_t GetId(const std::string& str) {
+    IdMap::iterator it = ids_.find(str);
+    if (it != ids_.end()) return it->second;
+    size_t id = ids_.size();
+    return ids_[str] = id;
+  }
+
+ private:
+  typedef std::map<std::string, size_t> IdMap;
+  IdMap ids_;
+};
+
+}  // namespace
+
+std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right) {
+  std::vector<size_t> left_ids, right_ids;
+  {
+    InternalStrings intern_table;
+    for (size_t i = 0; i < left.size(); ++i) {
+      left_ids.push_back(intern_table.GetId(left[i]));
+    }
+    for (size_t i = 0; i < right.size(); ++i) {
+      right_ids.push_back(intern_table.GetId(right[i]));
+    }
+  }
+  return CalculateOptimalEdits(left_ids, right_ids);
+}
+
+namespace {
+
+// Helper class that holds the state for one hunk and prints it out to the
+// stream.
+// It reorders adds/removes when possible to group all removes before all
+// adds. It also adds the hunk header before printint into the stream.
+class Hunk {
+ public:
+  Hunk(size_t left_start, size_t right_start)
+      : left_start_(left_start),
+        right_start_(right_start),
+        adds_(),
+        removes_(),
+        common_() {}
+
+  void PushLine(char edit, const char* line) {
+    switch (edit) {
+      case ' ':
+        ++common_;
+        FlushEdits();
+        hunk_.push_back(std::make_pair(' ', line));
+        break;
+      case '-':
+        ++removes_;
+        hunk_removes_.push_back(std::make_pair('-', line));
+        break;
+      case '+':
+        ++adds_;
+        hunk_adds_.push_back(std::make_pair('+', line));
+        break;
+    }
+  }
+
+  void PrintTo(std::ostream* os) {
+    PrintHeader(os);
+    FlushEdits();
+    for (std::list<std::pair<char, const char*> >::const_iterator it =
+             hunk_.begin();
+         it != hunk_.end(); ++it) {
+      *os << it->first << it->second << "\n";
+    }
+  }
+
+  bool has_edits() const { return adds_ || removes_; }
+
+ private:
+  void FlushEdits() {
+    hunk_.splice(hunk_.end(), hunk_removes_);
+    hunk_.splice(hunk_.end(), hunk_adds_);
+  }
+
+  // Print a unified diff header for one hunk.
+  // The format is
+  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
+  // where the left/right parts are ommitted if unnecessary.
+  void PrintHeader(std::ostream* ss) const {
+    *ss << "@@ ";
+    if (removes_) {
+      *ss << "-" << left_start_ << "," << (removes_ + common_);
+    }
+    if (removes_ && adds_) {
+      *ss << " ";
+    }
+    if (adds_) {
+      *ss << "+" << right_start_ << "," << (adds_ + common_);
+    }
+    *ss << " @@\n";
+  }
+
+  size_t left_start_, right_start_;
+  size_t adds_, removes_, common_;
+  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
+};
+
+}  // namespace
+
+// Create a list of diff hunks in Unified diff format.
+// Each hunk has a header generated by PrintHeader above plus a body with
+// lines prefixed with ' ' for no change, '-' for deletion and '+' for
+// addition.
+// 'context' represents the desired unchanged prefix/suffix around the diff.
+// If two hunks are close enough that their contexts overlap, then they are
+// joined into one hunk.
+std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                              const std::vector<std::string>& right,
+                              size_t context) {
+  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
+
+  size_t l_i = 0, r_i = 0, edit_i = 0;
+  std::stringstream ss;
+  while (edit_i < edits.size()) {
+    // Find first edit.
+    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
+      ++l_i;
+      ++r_i;
+      ++edit_i;
+    }
+
+    // Find the first line to include in the hunk.
+    const size_t prefix_context = std::min(l_i, context);
+    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
+    for (size_t i = prefix_context; i > 0; --i) {
+      hunk.PushLine(' ', left[l_i - i].c_str());
+    }
+
+    // Iterate the edits until we found enough suffix for the hunk or the input
+    // is over.
+    size_t n_suffix = 0;
+    for (; edit_i < edits.size(); ++edit_i) {
+      if (n_suffix >= context) {
+        // Continue only if the next hunk is very close.
+        std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
+        while (it != edits.end() && *it == kMatch) ++it;
+        if (it == edits.end() || (it - edits.begin()) - edit_i >= context) {
+          // There is no next edit or it is too far away.
+          break;
+        }
+      }
+
+      EditType edit = edits[edit_i];
+      // Reset count when a non match is found.
+      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
+
+      if (edit == kMatch || edit == kRemove || edit == kReplace) {
+        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
+      }
+      if (edit == kAdd || edit == kReplace) {
+        hunk.PushLine('+', right[r_i].c_str());
+      }
+
+      // Advance indices, depending on edit type.
+      l_i += edit != kAdd;
+      r_i += edit != kRemove;
+    }
+
+    if (!hunk.has_edits()) {
+      // We are done. We don't want this hunk.
+      break;
+    }
+
+    hunk.PrintTo(&ss);
+  }
+  return ss.str();
+}
+
+}  // namespace edit_distance
+
+namespace {
+
+// The string representation of the values received in EqFailure() are already
+// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
+// characters the same.
+std::vector<std::string> SplitEscapedString(const std::string& str) {
+  std::vector<std::string> lines;
+  size_t start = 0, end = str.size();
+  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
+    ++start;
+    --end;
+  }
+  bool escaped = false;
+  for (size_t i = start; i + 1 < end; ++i) {
+    if (escaped) {
+      escaped = false;
+      if (str[i] == 'n') {
+        lines.push_back(str.substr(start, i - start - 1));
+        start = i + 1;
+      }
+    } else {
+      escaped = str[i] == '\\';
+    }
+  }
+  lines.push_back(str.substr(start, end - start));
+  return lines;
+}
+
+}  // namespace
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true iff the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+AssertionResult EqFailure(const char* expected_expression,
+                          const char* actual_expression,
+                          const std::string& expected_value,
+                          const std::string& actual_value,
+                          bool ignoring_case) {
+  Message msg;
+  msg << "Value of: " << actual_expression;
+  if (actual_value != actual_expression) {
+    msg << "\n  Actual: " << actual_value;
+  }
+
+  msg << "\nExpected: " << expected_expression;
+  if (ignoring_case) {
+    msg << " (ignoring case)";
+  }
+  if (expected_value != expected_expression) {
+    msg << "\nWhich is: " << expected_value;
+  }
+
+  if (!expected_value.empty() && !actual_value.empty()) {
+    const std::vector<std::string> expected_lines =
+        SplitEscapedString(expected_value);
+    const std::vector<std::string> actual_lines =
+        SplitEscapedString(actual_value);
+    if (expected_lines.size() > 1 || actual_lines.size() > 1) {
+      msg << "\nWith diff:\n"
+          << edit_distance::CreateUnifiedDiff(expected_lines, actual_lines);
+    }
+  }
+
+  return AssertionFailure() << msg;
+}
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value) {
+  const char* actual_message = assertion_result.message();
+  Message msg;
+  msg << "Value of: " << expression_text
+      << "\n  Actual: " << actual_predicate_value;
+  if (actual_message[0] != '\0')
+    msg << " (" << actual_message << ")";
+  msg << "\nExpected: " << expected_predicate_value;
+  return msg.GetString();
+}
+
+// Helper function for implementing ASSERT_NEAR.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error) {
+  const double diff = fabs(val1 - val2);
+  if (diff <= abs_error) return AssertionSuccess();
+
+  // TODO(wan): do not print the value of an expression if it's
+  // already a literal.
+  return AssertionFailure()
+      << "The difference between " << expr1 << " and " << expr2
+      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
+      << expr1 << " evaluates to " << val1 << ",\n"
+      << expr2 << " evaluates to " << val2 << ", and\n"
+      << abs_error_expr << " evaluates to " << abs_error << ".";
+}
+
+
+// Helper template for implementing FloatLE() and DoubleLE().
+template <typename RawType>
+AssertionResult FloatingPointLE(const char* expr1,
+                                const char* expr2,
+                                RawType val1,
+                                RawType val2) {
+  // Returns success if val1 is less than val2,
+  if (val1 < val2) {
+    return AssertionSuccess();
+  }
+
+  // or if val1 is almost equal to val2.
+  const FloatingPoint<RawType> lhs(val1), rhs(val2);
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  // Note that the above two checks will both fail if either val1 or
+  // val2 is NaN, as the IEEE floating-point standard requires that
+  // any predicate involving a NaN must return false.
+
+  ::std::stringstream val1_ss;
+  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val1;
+
+  ::std::stringstream val2_ss;
+  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val2;
+
+  return AssertionFailure()
+      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
+      << StringStreamToString(&val2_ss);
+}
+
+}  // namespace internal
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2) {
+  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
+}
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2) {
+  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
+}
+
+namespace internal {
+
+// The helper function for {ASSERT|EXPECT}_EQ with int or enum
+// arguments.
+AssertionResult CmpHelperEQ(const char* expected_expression,
+                            const char* actual_expression,
+                            BiggestInt expected,
+                            BiggestInt actual) {
+  if (expected == actual) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   FormatForComparisonFailureMessage(expected, actual),
+                   FormatForComparisonFailureMessage(actual, expected),
+                   false);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
+// just to avoid copy-and-paste of similar code.
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   BiggestInt val1, BiggestInt val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return AssertionFailure() \
+        << "Expected: (" << expr1 << ") " #op " (" << expr2\
+        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
+        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
+  }\
+}
+
+// Implements the helper function for {ASSERT|EXPECT}_NE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(LT, < )
+// Implements the helper function for {ASSERT|EXPECT}_GE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(GT, > )
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const char* expected,
+                               const char* actual) {
+  if (String::CStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   PrintToString(expected),
+                   PrintToString(actual),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
+                                   const char* actual_expression,
+                                   const char* expected,
+                                   const char* actual) {
+  if (String::CaseInsensitiveCStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   PrintToString(expected),
+                   PrintToString(actual),
+                   true);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2) {
+  if (!String::CStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                              << s2_expression << "), actual: \""
+                              << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2) {
+  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure()
+        << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << ") (ignoring case), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+}  // namespace internal
+
+namespace {
+
+// Helper functions for implementing IsSubString() and IsNotSubstring().
+
+// This group of overloaded functions return true iff needle is a
+// substring of haystack.  NULL is considered a substring of itself
+// only.
+
+bool IsSubstringPred(const char* needle, const char* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return strstr(haystack, needle) != NULL;
+}
+
+bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return wcsstr(haystack, needle) != NULL;
+}
+
+// StringType here can be either ::std::string or ::std::wstring.
+template <typename StringType>
+bool IsSubstringPred(const StringType& needle,
+                     const StringType& haystack) {
+  return haystack.find(needle) != StringType::npos;
+}
+
+// This function implements either IsSubstring() or IsNotSubstring(),
+// depending on the value of the expected_to_be_substring parameter.
+// StringType here can be const char*, const wchar_t*, ::std::string,
+// or ::std::wstring.
+template <typename StringType>
+AssertionResult IsSubstringImpl(
+    bool expected_to_be_substring,
+    const char* needle_expr, const char* haystack_expr,
+    const StringType& needle, const StringType& haystack) {
+  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(needle[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure()
+      << "Value of: " << needle_expr << "\n"
+      << "  Actual: " << begin_string_quote << needle << "\"\n"
+      << "Expected: " << (expected_to_be_substring ? "" : "not ")
+      << "a substring of " << haystack_expr << "\n"
+      << "Which is: " << begin_string_quote << haystack << "\"";
+}
+
+}  // namespace
+
+// IsSubstring() and IsNotSubstring() check whether needle is a
+// substring of haystack (NULL is considered a substring of itself
+// only), and return an appropriate error message when they fail.
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+
+namespace {
+
+// Helper function for IsHRESULT{SuccessFailure} predicates
+AssertionResult HRESULTFailureHelper(const char* expr,
+                                     const char* expected,
+                                     long hr) {  // NOLINT
+# if GTEST_OS_WINDOWS_MOBILE
+
+  // Windows CE doesn't support FormatMessage.
+  const char error_text[] = "";
+
+# else
+
+  // Looks up the human-readable system message for the HRESULT code
+  // and since we're not passing any params to FormatMessage, we don't
+  // want inserts expanded.
+  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kBufSize = 4096;
+  // Gets the system's human readable message string for this HRESULT.
+  char error_text[kBufSize] = { '\0' };
+  DWORD message_length = ::FormatMessageA(kFlags,
+                                          0,  // no source, we're asking system
+                                          hr,  // the error
+                                          0,  // no line width restrictions
+                                          error_text,  // output buffer
+                                          kBufSize,  // buf size
+                                          NULL);  // no arguments for inserts
+  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
+  for (; message_length && IsSpace(error_text[message_length - 1]);
+          --message_length) {
+    error_text[message_length - 1] = '\0';
+  }
+
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+  const std::string error_hex("0x" + String::FormatHexInt(hr));
+  return ::testing::AssertionFailure()
+      << "Expected: " << expr << " " << expected << ".\n"
+      << "  Actual: " << error_hex << " " << error_text << "\n";
+}
+
+}  // namespace
+
+AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
+  if (SUCCEEDED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "succeeds", hr);
+}
+
+AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
+  if (FAILED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "fails", hr);
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Utility functions for encoding Unicode text (wide strings) in
+// UTF-8.
+
+// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
+// like this:
+//
+// Code-point length   Encoding
+//   0 -  7 bits       0xxxxxxx
+//   8 - 11 bits       110xxxxx 10xxxxxx
+//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
+//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+// The maximum code-point a one-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
+
+// The maximum code-point a two-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
+
+// The maximum code-point a three-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
+
+// The maximum code-point a four-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1;
+
+// Chops off the n lowest bits from a bit pattern.  Returns the n
+// lowest bits.  As a side effect, the original bit pattern will be
+// shifted to the right by n bits.
+inline UInt32 ChopLowBits(UInt32* bits, int n) {
+  const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
+  *bits >>= n;
+  return low_bits;
+}
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type UInt32 because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+std::string CodePointToUtf8(UInt32 code_point) {
+  if (code_point > kMaxCodePoint4) {
+    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
+  }
+
+  char str[5];  // Big enough for the largest valid code point.
+  if (code_point <= kMaxCodePoint1) {
+    str[1] = '\0';
+    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
+  } else if (code_point <= kMaxCodePoint2) {
+    str[2] = '\0';
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
+  } else if (code_point <= kMaxCodePoint3) {
+    str[3] = '\0';
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
+  } else {  // code_point <= kMaxCodePoint4
+    str[4] = '\0';
+    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
+  }
+  return str;
+}
+
+// The following two functions only make sense if the the system
+// uses UTF-16 for wide string encoding. All supported systems
+// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
+
+// Determines if the arguments constitute UTF-16 surrogate pair
+// and thus should be combined into a single Unicode code point
+// using CreateCodePointFromUtf16SurrogatePair.
+inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
+  return sizeof(wchar_t) == 2 &&
+      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
+}
+
+// Creates a Unicode code point from UTF16 surrogate pair.
+inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
+                                                    wchar_t second) {
+  const UInt32 mask = (1 << 10) - 1;
+  return (sizeof(wchar_t) == 2) ?
+      (((first & mask) << 10) | (second & mask)) + 0x10000 :
+      // This function should not be called when the condition is
+      // false, but we provide a sensible default in case it is.
+      static_cast<UInt32>(first);
+}
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
+  if (num_chars == -1)
+    num_chars = static_cast<int>(wcslen(str));
+
+  ::std::stringstream stream;
+  for (int i = 0; i < num_chars; ++i) {
+    UInt32 unicode_code_point;
+
+    if (str[i] == L'\0') {
+      break;
+    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
+      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
+                                                                 str[i + 1]);
+      i++;
+    } else {
+      unicode_code_point = static_cast<UInt32>(str[i]);
+    }
+
+    stream << CodePointToUtf8(unicode_code_point);
+  }
+  return StringStreamToString(&stream);
+}
+
+// Converts a wide C string to an std::string using the UTF-8 encoding.
+// NULL will be converted to "(null)".
+std::string String::ShowWideCString(const wchar_t * wide_c_str) {
+  if (wide_c_str == NULL)  return "(null)";
+
+  return internal::WideStringToUtf8(wide_c_str, -1);
+}
+
+// Compares two wide C strings.  Returns true iff they have the same
+// content.
+//
+// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
+  if (lhs == NULL) return rhs == NULL;
+
+  if (rhs == NULL) return false;
+
+  return wcscmp(lhs, rhs) == 0;
+}
+
+// Helper function for *_STREQ on wide strings.
+AssertionResult CmpHelperSTREQ(const char* expected_expression,
+                               const char* actual_expression,
+                               const wchar_t* expected,
+                               const wchar_t* actual) {
+  if (String::WideCStringEquals(expected, actual)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(expected_expression,
+                   actual_expression,
+                   PrintToString(expected),
+                   PrintToString(actual),
+                   false);
+}
+
+// Helper function for *_STRNE on wide strings.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2) {
+  if (!String::WideCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  }
+
+  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                            << s2_expression << "), actual: "
+                            << PrintToString(s1)
+                            << " vs " << PrintToString(s2);
+}
+
+// Compares two C strings, ignoring case.  Returns true iff they have
+// the same content.
+//
+// Unlike strcasecmp(), this function can handle NULL argument(s).  A
+// NULL C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
+  if (lhs == NULL)
+    return rhs == NULL;
+  if (rhs == NULL)
+    return false;
+  return posix::StrCaseCmp(lhs, rhs) == 0;
+}
+
+  // Compares two wide C strings, ignoring case.  Returns true iff they
+  // have the same content.
+  //
+  // Unlike wcscasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL wide C string,
+  // including the empty string.
+  // NB: The implementations on different platforms slightly differ.
+  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+  // environment variable. On GNU platform this method uses wcscasecmp
+  // which compares according to LC_CTYPE category of the current locale.
+  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+  // current locale.
+bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                              const wchar_t* rhs) {
+  if (lhs == NULL) return rhs == NULL;
+
+  if (rhs == NULL) return false;
+
+#if GTEST_OS_WINDOWS
+  return _wcsicmp(lhs, rhs) == 0;
+#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
+  return wcscasecmp(lhs, rhs) == 0;
+#else
+  // Android, Mac OS X and Cygwin don't define wcscasecmp.
+  // Other unknown OSes may not define it either.
+  wint_t left, right;
+  do {
+    left = towlower(*lhs++);
+    right = towlower(*rhs++);
+  } while (left && left == right);
+  return left == right;
+#endif  // OS selector
+}
+
+// Returns true iff str ends with the given suffix, ignoring case.
+// Any string is considered to end with an empty suffix.
+bool String::EndsWithCaseInsensitive(
+    const std::string& str, const std::string& suffix) {
+  const size_t str_len = str.length();
+  const size_t suffix_len = suffix.length();
+  return (str_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
+                                      suffix.c_str());
+}
+
+// Formats an int value as "%02d".
+std::string String::FormatIntWidth2(int value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexInt(int value) {
+  std::stringstream ss;
+  ss << std::hex << std::uppercase << value;
+  return ss.str();
+}
+
+// Formats a byte as "%02X".
+std::string String::FormatByte(unsigned char value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
+     << static_cast<unsigned int>(value);
+  return ss.str();
+}
+
+// Converts the buffer in a stringstream to an std::string, converting NUL
+// bytes to "\\0" along the way.
+std::string StringStreamToString(::std::stringstream* ss) {
+  const ::std::string& str = ss->str();
+  const char* const start = str.c_str();
+  const char* const end = start + str.length();
+
+  std::string result;
+  result.reserve(2 * (end - start));
+  for (const char* ch = start; ch != end; ++ch) {
+    if (*ch == '\0') {
+      result += "\\0";  // Replaces NUL with "\\0";
+    } else {
+      result += *ch;
+    }
+  }
+
+  return result;
+}
+
+// Appends the user-supplied message to the Google-Test-generated message.
+std::string AppendUserMessage(const std::string& gtest_msg,
+                              const Message& user_msg) {
+  // Appends the user message if it's non-empty.
+  const std::string user_msg_string = user_msg.GetString();
+  if (user_msg_string.empty()) {
+    return gtest_msg;
+  }
+
+  return gtest_msg + "\n" + user_msg_string;
+}
+
+}  // namespace internal
+
+// class TestResult
+
+// Creates an empty TestResult.
+TestResult::TestResult()
+    : death_test_count_(0),
+      elapsed_time_(0) {
+}
+
+// D'tor.
+TestResult::~TestResult() {
+}
+
+// Returns the i-th test part result among all the results. i can
+// range from 0 to total_part_count() - 1. If i is not in that range,
+// aborts the program.
+const TestPartResult& TestResult::GetTestPartResult(int i) const {
+  if (i < 0 || i >= total_part_count())
+    internal::posix::Abort();
+  return test_part_results_.at(i);
+}
+
+// Returns the i-th test property. i can range from 0 to
+// test_property_count() - 1. If i is not in that range, aborts the
+// program.
+const TestProperty& TestResult::GetTestProperty(int i) const {
+  if (i < 0 || i >= test_property_count())
+    internal::posix::Abort();
+  return test_properties_.at(i);
+}
+
+// Clears the test part results.
+void TestResult::ClearTestPartResults() {
+  test_part_results_.clear();
+}
+
+// Adds a test part result to the list.
+void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
+  test_part_results_.push_back(test_part_result);
+}
+
+// Adds a test property to the list. If a property with the same key as the
+// supplied property is already represented, the value of this test_property
+// replaces the old value for that key.
+void TestResult::RecordProperty(const std::string& xml_element,
+                                const TestProperty& test_property) {
+  if (!ValidateTestProperty(xml_element, test_property)) {
+    return;
+  }
+  internal::MutexLock lock(&test_properites_mutex_);
+  const std::vector<TestProperty>::iterator property_with_matching_key =
+      std::find_if(test_properties_.begin(), test_properties_.end(),
+                   internal::TestPropertyKeyIs(test_property.key()));
+  if (property_with_matching_key == test_properties_.end()) {
+    test_properties_.push_back(test_property);
+    return;
+  }
+  property_with_matching_key->SetValue(test_property.value());
+}
+
+// The list of reserved attributes used in the <testsuites> element of XML
+// output.
+static const char* const kReservedTestSuitesAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "random_seed",
+  "tests",
+  "time",
+  "timestamp"
+};
+
+// The list of reserved attributes used in the <testsuite> element of XML
+// output.
+static const char* const kReservedTestSuiteAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "tests",
+  "time"
+};
+
+// The list of reserved attributes used in the <testcase> element of XML output.
+static const char* const kReservedTestCaseAttributes[] = {
+  "classname",
+  "name",
+  "status",
+  "time",
+  "type_param",
+  "value_param"
+};
+
+template <int kSize>
+std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
+  return std::vector<std::string>(array, array + kSize);
+}
+
+static std::vector<std::string> GetReservedAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+static std::string FormatWordList(const std::vector<std::string>& words) {
+  Message word_list;
+  for (size_t i = 0; i < words.size(); ++i) {
+    if (i > 0 && words.size() > 2) {
+      word_list << ", ";
+    }
+    if (i == words.size() - 1) {
+      word_list << "and ";
+    }
+    word_list << "'" << words[i] << "'";
+  }
+  return word_list.GetString();
+}
+
+bool ValidateTestPropertyName(const std::string& property_name,
+                              const std::vector<std::string>& reserved_names) {
+  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
+          reserved_names.end()) {
+    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
+                  << " (" << FormatWordList(reserved_names)
+                  << " are reserved by " << GTEST_NAME_ << ")";
+    return false;
+  }
+  return true;
+}
+
+// Adds a failure if the key is a reserved attribute of the element named
+// xml_element.  Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const std::string& xml_element,
+                                      const TestProperty& test_property) {
+  return ValidateTestPropertyName(test_property.key(),
+                                  GetReservedAttributesForElement(xml_element));
+}
+
+// Clears the object.
+void TestResult::Clear() {
+  test_part_results_.clear();
+  test_properties_.clear();
+  death_test_count_ = 0;
+  elapsed_time_ = 0;
+}
+
+// Returns true iff the test failed.
+bool TestResult::Failed() const {
+  for (int i = 0; i < total_part_count(); ++i) {
+    if (GetTestPartResult(i).failed())
+      return true;
+  }
+  return false;
+}
+
+// Returns true iff the test part fatally failed.
+static bool TestPartFatallyFailed(const TestPartResult& result) {
+  return result.fatally_failed();
+}
+
+// Returns true iff the test fatally failed.
+bool TestResult::HasFatalFailure() const {
+  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
+}
+
+// Returns true iff the test part non-fatally failed.
+static bool TestPartNonfatallyFailed(const TestPartResult& result) {
+  return result.nonfatally_failed();
+}
+
+// Returns true iff the test has a non-fatal failure.
+bool TestResult::HasNonfatalFailure() const {
+  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
+}
+
+// Gets the number of all test parts.  This is the sum of the number
+// of successful test parts and the number of failed test parts.
+int TestResult::total_part_count() const {
+  return static_cast<int>(test_part_results_.size());
+}
+
+// Returns the number of the test properties.
+int TestResult::test_property_count() const {
+  return static_cast<int>(test_properties_.size());
+}
+
+// class Test
+
+// Creates a Test object.
+
+// The c'tor saves the states of all flags.
+Test::Test()
+    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
+}
+
+// The d'tor restores the states of all flags.  The actual work is
+// done by the d'tor of the gtest_flag_saver_ field, and thus not
+// visible here.
+Test::~Test() {
+}
+
+// Sets up the test fixture.
+//
+// A sub-class may override this.
+void Test::SetUp() {
+}
+
+// Tears down the test fixture.
+//
+// A sub-class may override this.
+void Test::TearDown() {
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, const std::string& value) {
+  UnitTest::GetInstance()->RecordProperty(key, value);
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, int value) {
+  Message value_message;
+  value_message << value;
+  RecordProperty(key, value_message.GetString().c_str());
+}
+
+namespace internal {
+
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message) {
+  // This function is a friend of UnitTest and as such has access to
+  // AddTestPartResult.
+  UnitTest::GetInstance()->AddTestPartResult(
+      result_type,
+      NULL,  // No info about the source file where the exception occurred.
+      -1,    // We have no info on which line caused the exception.
+      message,
+      "");   // No stack trace, either.
+}
+
+}  // namespace internal
+
+// Google Test requires all tests in the same test case to use the same test
+// fixture class.  This function checks if the current test has the
+// same fixture class as the first test in the current test case.  If
+// yes, it returns true; otherwise it generates a Google Test failure and
+// returns false.
+bool Test::HasSameFixtureClass() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  const TestCase* const test_case = impl->current_test_case();
+
+  // Info about the first test in the current test case.
+  const TestInfo* const first_test_info = test_case->test_info_list()[0];
+  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
+  const char* const first_test_name = first_test_info->name();
+
+  // Info about the current test.
+  const TestInfo* const this_test_info = impl->current_test_info();
+  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
+  const char* const this_test_name = this_test_info->name();
+
+  if (this_fixture_id != first_fixture_id) {
+    // Is the first test defined using TEST?
+    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
+    // Is this test defined using TEST?
+    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
+
+    if (first_is_TEST || this_is_TEST) {
+      // Both TEST and TEST_F appear in same test case, which is incorrect.
+      // Tell the user how to fix this.
+
+      // Gets the name of the TEST and the name of the TEST_F.  Note
+      // that first_is_TEST and this_is_TEST cannot both be true, as
+      // the fixture IDs are different for the two tests.
+      const char* const TEST_name =
+          first_is_TEST ? first_test_name : this_test_name;
+      const char* const TEST_F_name =
+          first_is_TEST ? this_test_name : first_test_name;
+
+      ADD_FAILURE()
+          << "All tests in the same test case must use the same test fixture\n"
+          << "class, so mixing TEST_F and TEST in the same test case is\n"
+          << "illegal.  In test case " << this_test_info->test_case_name()
+          << ",\n"
+          << "test " << TEST_F_name << " is defined using TEST_F but\n"
+          << "test " << TEST_name << " is defined using TEST.  You probably\n"
+          << "want to change the TEST to TEST_F or move it to another test\n"
+          << "case.";
+    } else {
+      // Two fixture classes with the same name appear in two different
+      // namespaces, which is not allowed. Tell the user how to fix this.
+      ADD_FAILURE()
+          << "All tests in the same test case must use the same test fixture\n"
+          << "class.  However, in test case "
+          << this_test_info->test_case_name() << ",\n"
+          << "you defined test " << first_test_name
+          << " and test " << this_test_name << "\n"
+          << "using two different test fixture classes.  This can happen if\n"
+          << "the two classes are from different namespaces or translation\n"
+          << "units and have the same name.  You should probably rename one\n"
+          << "of the classes to put the tests into different test cases.";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#if GTEST_HAS_SEH
+
+// Adds an "exception thrown" fatal failure to the current test.  This
+// function returns its result via an output parameter pointer because VC++
+// prohibits creation of objects with destructors on stack in functions
+// using __try (see error C2712).
+static std::string* FormatSehExceptionMessage(DWORD exception_code,
+                                              const char* location) {
+  Message message;
+  message << "SEH exception with code 0x" << std::setbase(16) <<
+    exception_code << std::setbase(10) << " thrown in " << location << ".";
+
+  return new std::string(message.GetString());
+}
+
+#endif  // GTEST_HAS_SEH
+
+namespace internal {
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Adds an "exception thrown" fatal failure to the current test.
+static std::string FormatCxxExceptionMessage(const char* description,
+                                             const char* location) {
+  Message message;
+  if (description != NULL) {
+    message << "C++ exception with description \"" << description << "\"";
+  } else {
+    message << "Unknown C++ exception";
+  }
+  message << " thrown in " << location << ".";
+
+  return message.GetString();
+}
+
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result);
+
+GoogleTestFailureException::GoogleTestFailureException(
+    const TestPartResult& failure)
+    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// We put these helper functions in the internal namespace as IBM's xlC
+// compiler rejects the code if they were declared static.
+
+// Runs the given method and handles SEH exceptions it throws, when
+// SEH is supported; returns the 0-value for type Result in case of an
+// SEH exception.  (Microsoft compilers cannot handle SEH and C++
+// exceptions in the same function.  Therefore, we provide a separate
+// wrapper function for handling SEH exceptions.)
+template <class T, typename Result>
+Result HandleSehExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+#if GTEST_HAS_SEH
+  __try {
+    return (object->*method)();
+  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
+      GetExceptionCode())) {
+    // We create the exception message on the heap because VC++ prohibits
+    // creation of objects with destructors on stack in functions using __try
+    // (see error C2712).
+    std::string* exception_message = FormatSehExceptionMessage(
+        GetExceptionCode(), location);
+    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
+                                             *exception_message);
+    delete exception_message;
+    return static_cast<Result>(0);
+  }
+#else
+  (void)location;
+  return (object->*method)();
+#endif  // GTEST_HAS_SEH
+}
+
+// Runs the given method and catches and reports C++ and/or SEH-style
+// exceptions, if they are supported; returns the 0-value for type
+// Result in case of an SEH exception.
+template <class T, typename Result>
+Result HandleExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+  // NOTE: The user code can affect the way in which Google Test handles
+  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
+  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
+  // after the exception is caught and either report or re-throw the
+  // exception based on the flag's value:
+  //
+  // try {
+  //   // Perform the test method.
+  // } catch (...) {
+  //   if (GTEST_FLAG(catch_exceptions))
+  //     // Report the exception as failure.
+  //   else
+  //     throw;  // Re-throws the original exception.
+  // }
+  //
+  // However, the purpose of this flag is to allow the program to drop into
+  // the debugger when the exception is thrown. On most platforms, once the
+  // control enters the catch block, the exception origin information is
+  // lost and the debugger will stop the program at the point of the
+  // re-throw in this function -- instead of at the point of the original
+  // throw statement in the code under test.  For this reason, we perform
+  // the check early, sacrificing the ability to affect Google Test's
+  // exception handling in the method where the exception is thrown.
+  if (internal::GetUnitTestImpl()->catch_exceptions()) {
+#if GTEST_HAS_EXCEPTIONS
+    try {
+      return HandleSehExceptionsInMethodIfSupported(object, method, location);
+    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
+      // This exception type can only be thrown by a failed Google
+      // Test assertion with the intention of letting another testing
+      // framework catch it.  Therefore we just re-throw it.
+      throw;
+    } catch (const std::exception& e) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(e.what(), location));
+    } catch (...) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(NULL, location));
+    }
+    return static_cast<Result>(0);
+#else
+    return HandleSehExceptionsInMethodIfSupported(object, method, location);
+#endif  // GTEST_HAS_EXCEPTIONS
+  } else {
+    return (object->*method)();
+  }
+}
+
+}  // namespace internal
+
+// Runs the test and updates the test result.
+void Test::Run() {
+  if (!HasSameFixtureClass()) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
+  // We will run the test only if SetUp() was successful.
+  if (!HasFatalFailure()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        this, &Test::TestBody, "the test body");
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &Test::TearDown, "TearDown()");
+}
+
+// Returns true iff the current test has a fatal failure.
+bool Test::HasFatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
+}
+
+// Returns true iff the current test has a non-fatal failure.
+bool Test::HasNonfatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->
+      HasNonfatalFailure();
+}
+
+// class TestInfo
+
+// Constructs a TestInfo object. It assumes ownership of the test factory
+// object.
+TestInfo::TestInfo(const std::string& a_test_case_name,
+                   const std::string& a_name,
+                   const char* a_type_param,
+                   const char* a_value_param,
+                   internal::CodeLocation a_code_location,
+                   internal::TypeId fixture_class_id,
+                   internal::TestFactoryBase* factory)
+    : test_case_name_(a_test_case_name),
+      name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
+      value_param_(a_value_param ? new std::string(a_value_param) : NULL),
+      location_(a_code_location),
+      fixture_class_id_(fixture_class_id),
+      should_run_(false),
+      is_disabled_(false),
+      matches_filter_(false),
+      factory_(factory),
+      result_() {}
+
+// Destructs a TestInfo object.
+TestInfo::~TestInfo() { delete factory_; }
+
+namespace internal {
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_case_name:   name of the test case
+//   name:             name of the test
+//   type_param:       the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param:      text representation of the test's value parameter,
+//                     or NULL if this is not a value-parameterized test.
+//   code_location:    code location where the test is defined
+//   fixture_class_id: ID of the test fixture class
+//   set_up_tc:        pointer to the function that sets up the test case
+//   tear_down_tc:     pointer to the function that tears down the test case
+//   factory:          pointer to the factory that creates a test object.
+//                     The newly created TestInfo instance will assume
+//                     ownership of the factory object.
+TestInfo* MakeAndRegisterTestInfo(
+    const char* test_case_name,
+    const char* name,
+    const char* type_param,
+    const char* value_param,
+    CodeLocation code_location,
+    TypeId fixture_class_id,
+    SetUpTestCaseFunc set_up_tc,
+    TearDownTestCaseFunc tear_down_tc,
+    TestFactoryBase* factory) {
+  TestInfo* const test_info =
+      new TestInfo(test_case_name, name, type_param, value_param,
+                   code_location, fixture_class_id, factory);
+  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
+  return test_info;
+}
+
+#if GTEST_HAS_PARAM_TEST
+void ReportInvalidTestCaseType(const char* test_case_name,
+                               CodeLocation code_location) {
+  Message errors;
+  errors
+      << "Attempted redefinition of test case " << test_case_name << ".\n"
+      << "All tests in the same test case must use the same test fixture\n"
+      << "class.  However, in test case " << test_case_name << ", you tried\n"
+      << "to define a test using a fixture class different from the one\n"
+      << "used earlier. This can happen if the two fixture classes are\n"
+      << "from different namespaces and have the same name. You should\n"
+      << "probably rename one of the classes to put the tests into different\n"
+      << "test cases.";
+
+  fprintf(stderr, "%s %s",
+          FormatFileLocation(code_location.file.c_str(),
+                             code_location.line).c_str(),
+          errors.GetString().c_str());
+}
+#endif  // GTEST_HAS_PARAM_TEST
+
+}  // namespace internal
+
+namespace {
+
+// A predicate that checks the test name of a TestInfo against a known
+// value.
+//
+// This is used for implementation of the TestCase class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestNameIs is copyable.
+class TestNameIs {
+ public:
+  // Constructor.
+  //
+  // TestNameIs has NO default constructor.
+  explicit TestNameIs(const char* name)
+      : name_(name) {}
+
+  // Returns true iff the test name of test_info matches name_.
+  bool operator()(const TestInfo * test_info) const {
+    return test_info && test_info->name() == name_;
+  }
+
+ private:
+  std::string name_;
+};
+
+}  // namespace
+
+namespace internal {
+
+// This method expands all parameterized tests registered with macros TEST_P
+// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
+// This will be done just once during the program runtime.
+void UnitTestImpl::RegisterParameterizedTests() {
+#if GTEST_HAS_PARAM_TEST
+  if (!parameterized_tests_registered_) {
+    parameterized_test_registry_.RegisterTests();
+    parameterized_tests_registered_ = true;
+  }
+#endif
+}
+
+}  // namespace internal
+
+// Creates the test object, runs it, records its result, and then
+// deletes it.
+void TestInfo::Run() {
+  if (!should_run_) return;
+
+  // Tells UnitTest where to store test result.
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Notifies the unit test event listeners that a test is about to start.
+  repeater->OnTestStart(*this);
+
+  const TimeInMillis start = internal::GetTimeInMillis();
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+
+  // Creates the test object.
+  Test* const test = internal::HandleExceptionsInMethodIfSupported(
+      factory_, &internal::TestFactoryBase::CreateTest,
+      "the test fixture's constructor");
+
+  // Runs the test only if the test object was created and its
+  // constructor didn't generate a fatal failure.
+  if ((test != NULL) && !Test::HasFatalFailure()) {
+    // This doesn't throw as all user code that can throw are wrapped into
+    // exception handling code.
+    test->Run();
+  }
+
+  // Deletes the test object.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      test, &Test::DeleteSelf_, "the test fixture's destructor");
+
+  result_.set_elapsed_time(internal::GetTimeInMillis() - start);
+
+  // Notifies the unit test event listener that a test has just finished.
+  repeater->OnTestEnd(*this);
+
+  // Tells UnitTest to stop associating assertion results to this
+  // test.
+  impl->set_current_test_info(NULL);
+}
+
+// class TestCase
+
+// Gets the number of successful tests in this test case.
+int TestCase::successful_test_count() const {
+  return CountIf(test_info_list_, TestPassed);
+}
+
+// Gets the number of failed tests in this test case.
+int TestCase::failed_test_count() const {
+  return CountIf(test_info_list_, TestFailed);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int TestCase::reportable_disabled_test_count() const {
+  return CountIf(test_info_list_, TestReportableDisabled);
+}
+
+// Gets the number of disabled tests in this test case.
+int TestCase::disabled_test_count() const {
+  return CountIf(test_info_list_, TestDisabled);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int TestCase::reportable_test_count() const {
+  return CountIf(test_info_list_, TestReportable);
+}
+
+// Get the number of tests in this test case that should run.
+int TestCase::test_to_run_count() const {
+  return CountIf(test_info_list_, ShouldRunTest);
+}
+
+// Gets the number of all tests.
+int TestCase::total_test_count() const {
+  return static_cast<int>(test_info_list_.size());
+}
+
+// Creates a TestCase with the given name.
+//
+// Arguments:
+//
+//   name:         name of the test case
+//   a_type_param: the name of the test case's type parameter, or NULL if
+//                 this is not a typed or a type-parameterized test case.
+//   set_up_tc:    pointer to the function that sets up the test case
+//   tear_down_tc: pointer to the function that tears down the test case
+TestCase::TestCase(const char* a_name, const char* a_type_param,
+                   Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc)
+    : name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
+      set_up_tc_(set_up_tc),
+      tear_down_tc_(tear_down_tc),
+      should_run_(false),
+      elapsed_time_(0) {
+}
+
+// Destructor of TestCase.
+TestCase::~TestCase() {
+  // Deletes every Test in the collection.
+  ForEach(test_info_list_, internal::Delete<TestInfo>);
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+const TestInfo* TestCase::GetTestInfo(int i) const {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? NULL : test_info_list_[index];
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+TestInfo* TestCase::GetMutableTestInfo(int i) {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? NULL : test_info_list_[index];
+}
+
+// Adds a test to this test case.  Will delete the test upon
+// destruction of the TestCase object.
+void TestCase::AddTestInfo(TestInfo * test_info) {
+  test_info_list_.push_back(test_info);
+  test_indices_.push_back(static_cast<int>(test_indices_.size()));
+}
+
+// Runs every test in this TestCase.
+void TestCase::Run() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_case(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  repeater->OnTestCaseStart(*this);
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
+
+  const internal::TimeInMillis start = internal::GetTimeInMillis();
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Run();
+  }
+  elapsed_time_ = internal::GetTimeInMillis() - start;
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
+
+  repeater->OnTestCaseEnd(*this);
+  impl->set_current_test_case(NULL);
+}
+
+// Clears the results of all tests in this test case.
+void TestCase::ClearResult() {
+  ad_hoc_test_result_.Clear();
+  ForEach(test_info_list_, TestInfo::ClearTestResult);
+}
+
+// Shuffles the tests in this test case.
+void TestCase::ShuffleTests(internal::Random* random) {
+  Shuffle(random, &test_indices_);
+}
+
+// Restores the test order to before the first shuffle.
+void TestCase::UnshuffleTests() {
+  for (size_t i = 0; i < test_indices_.size(); i++) {
+    test_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Formats a countable noun.  Depending on its quantity, either the
+// singular form or the plural form is used. e.g.
+//
+// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
+// FormatCountableNoun(5, "book", "books") returns "5 books".
+static std::string FormatCountableNoun(int count,
+                                       const char * singular_form,
+                                       const char * plural_form) {
+  return internal::StreamableToString(count) + " " +
+      (count == 1 ? singular_form : plural_form);
+}
+
+// Formats the count of tests.
+static std::string FormatTestCount(int test_count) {
+  return FormatCountableNoun(test_count, "test", "tests");
+}
+
+// Formats the count of test cases.
+static std::string FormatTestCaseCount(int test_case_count) {
+  return FormatCountableNoun(test_case_count, "test case", "test cases");
+}
+
+// Converts a TestPartResult::Type enum to human-friendly string
+// representation.  Both kNonFatalFailure and kFatalFailure are translated
+// to "Failure", as the user usually doesn't care about the difference
+// between the two when viewing the test result.
+static const char * TestPartResultTypeToString(TestPartResult::Type type) {
+  switch (type) {
+    case TestPartResult::kSuccess:
+      return "Success";
+
+    case TestPartResult::kNonFatalFailure:
+    case TestPartResult::kFatalFailure:
+#ifdef _MSC_VER
+      return "error: ";
+#else
+      return "Failure\n";
+#endif
+    default:
+      return "Unknown result type";
+  }
+}
+
+namespace internal {
+
+// Prints a TestPartResult to an std::string.
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result) {
+  return (Message()
+          << internal::FormatFileLocation(test_part_result.file_name(),
+                                          test_part_result.line_number())
+          << " " << TestPartResultTypeToString(test_part_result.type())
+          << test_part_result.message()).GetString();
+}
+
+// Prints a TestPartResult.
+static void PrintTestPartResult(const TestPartResult& test_part_result) {
+  const std::string& result =
+      PrintTestPartResultToString(test_part_result);
+  printf("%s\n", result.c_str());
+  fflush(stdout);
+  // If the test program runs in Visual Studio or a debugger, the
+  // following statements add the test part result message to the Output
+  // window such that the user can double-click on it to jump to the
+  // corresponding source code location; otherwise they do nothing.
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  // We don't call OutputDebugString*() on Windows Mobile, as printing
+  // to stdout is done by OutputDebugString() there already - we don't
+  // want the same message printed twice.
+  ::OutputDebugStringA(result.c_str());
+  ::OutputDebugStringA("\n");
+#endif
+}
+
+// class PrettyUnitTestResultPrinter
+
+enum GTestColor {
+  COLOR_DEFAULT,
+  COLOR_RED,
+  COLOR_GREEN,
+  COLOR_YELLOW
+};
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Returns the character attribute for the given color.
+WORD GetColorAttribute(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:    return FOREGROUND_RED;
+    case COLOR_GREEN:  return FOREGROUND_GREEN;
+    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
+    default:           return 0;
+  }
+}
+
+#else
+
+// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
+// an invalid input.
+const char* GetAnsiColorCode(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:     return "1";
+    case COLOR_GREEN:   return "2";
+    case COLOR_YELLOW:  return "3";
+    default:            return NULL;
+  };
+}
+
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+
+// Returns true iff Google Test should use colors in the output.
+bool ShouldUseColor(bool stdout_is_tty) {
+  const char* const gtest_color = GTEST_FLAG(color).c_str();
+
+  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
+#if GTEST_OS_WINDOWS
+    // On Windows the TERM variable is usually not set, but the
+    // console there does support colors.
+    return stdout_is_tty;
+#else
+    // On non-Windows platforms, we rely on the TERM variable.
+    const char* const term = posix::GetEnv("TERM");
+    const bool term_supports_color =
+        String::CStringEquals(term, "xterm") ||
+        String::CStringEquals(term, "xterm-color") ||
+        String::CStringEquals(term, "xterm-256color") ||
+        String::CStringEquals(term, "screen") ||
+        String::CStringEquals(term, "screen-256color") ||
+        String::CStringEquals(term, "rxvt-unicode") ||
+        String::CStringEquals(term, "rxvt-unicode-256color") ||
+        String::CStringEquals(term, "linux") ||
+        String::CStringEquals(term, "cygwin");
+    return stdout_is_tty && term_supports_color;
+#endif  // GTEST_OS_WINDOWS
+  }
+
+  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+      String::CStringEquals(gtest_color, "1");
+  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
+  // value is neither one of these nor "auto", we treat it as "no" to
+  // be conservative.
+}
+
+// Helpers for printing colored strings to stdout. Note that on Windows, we
+// cannot simply emit special characters and have the terminal change colors.
+// This routine must actually emit the characters rather than return a string
+// that would be colored when printed, as can be done on Linux.
+void ColoredPrintf(GTestColor color, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
+    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+  const bool use_color = AlwaysFalse();
+#else
+  static const bool in_color_mode =
+      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
+  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
+#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
+  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
+
+  if (!use_color) {
+    vprintf(fmt, args);
+    va_end(args);
+    return;
+  }
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+  // Gets the current text color.
+  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
+  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
+  const WORD old_color_attrs = buffer_info.wAttributes;
+
+  // We need to flush the stream buffers into the console before each
+  // SetConsoleTextAttribute call lest it affect the text that is already
+  // printed but has not yet reached the console.
+  fflush(stdout);
+  SetConsoleTextAttribute(stdout_handle,
+                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
+  vprintf(fmt, args);
+
+  fflush(stdout);
+  // Restores the text color.
+  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
+#else
+  printf("\033[0;3%sm", GetAnsiColorCode(color));
+  vprintf(fmt, args);
+  printf("\033[m");  // Resets the terminal to default.
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  va_end(args);
+}
+
+// Text printed in Google Test's text output and --gunit_list_tests
+// output to label the type parameter and value parameter for a test.
+static const char kTypeParamLabel[] = "TypeParam";
+static const char kValueParamLabel[] = "GetParam()";
+
+void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
+  const char* const type_param = test_info.type_param();
+  const char* const value_param = test_info.value_param();
+
+  if (type_param != NULL || value_param != NULL) {
+    printf(", where ");
+    if (type_param != NULL) {
+      printf("%s = %s", kTypeParamLabel, type_param);
+      if (value_param != NULL)
+        printf(" and ");
+    }
+    if (value_param != NULL) {
+      printf("%s = %s", kValueParamLabel, value_param);
+    }
+  }
+}
+
+// This class implements the TestEventListener interface.
+//
+// Class PrettyUnitTestResultPrinter is copyable.
+class PrettyUnitTestResultPrinter : public TestEventListener {
+ public:
+  PrettyUnitTestResultPrinter() {}
+  static void PrintTestName(const char * test_case, const char * test) {
+    printf("%s.%s", test_case, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestCaseStart(const TestCase& test_case);
+  virtual void OnTestStart(const TestInfo& test_info);
+  virtual void OnTestPartResult(const TestPartResult& result);
+  virtual void OnTestEnd(const TestInfo& test_info);
+  virtual void OnTestCaseEnd(const TestCase& test_case);
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
+
+ private:
+  static void PrintFailedTests(const UnitTest& unit_test);
+};
+
+  // Fired before each iteration of tests starts.
+void PrettyUnitTestResultPrinter::OnTestIterationStart(
+    const UnitTest& unit_test, int iteration) {
+  if (GTEST_FLAG(repeat) != 1)
+    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
+
+  const char* const filter = GTEST_FLAG(filter).c_str();
+
+  // Prints the filter if it's not *.  This reminds the user that some
+  // tests may be skipped.
+  if (!String::CStringEquals(filter, kUniversalFilter)) {
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
+  }
+
+  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
+    const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: This is test shard %d of %s.\n",
+                  static_cast<int>(shard_index) + 1,
+                  internal::posix::GetEnv(kTestTotalShards));
+  }
+
+  if (GTEST_FLAG(shuffle)) {
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: Randomizing tests' orders with a seed of %d .\n",
+                  unit_test.random_seed());
+  }
+
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("Running %s from %s.\n",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment set-up.\n");
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_case.name());
+  if (test_case.type_param() == NULL) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
+  }
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
+  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
+  PrintTestName(test_info.test_case_name(), test_info.name());
+  printf("\n");
+  fflush(stdout);
+}
+
+// Called after an assertion failure.
+void PrettyUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  // If the test part succeeded, we don't need to do anything.
+  if (result.type() == TestPartResult::kSuccess)
+    return;
+
+  // Print failure message from the assertion (e.g. expected this and got that).
+  PrintTestPartResult(result);
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
+  if (test_info.result()->Passed()) {
+    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
+  } else {
+    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+  }
+  PrintTestName(test_info.test_case_name(), test_info.name());
+  if (test_info.result()->Failed())
+    PrintFullTestCommentIfPresent(test_info);
+
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms)\n", internal::StreamableToString(
+           test_info.result()->elapsed_time()).c_str());
+  } else {
+    printf("\n");
+  }
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
+  if (!GTEST_FLAG(print_time)) return;
+
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
+  printf("%s from %s (%s ms total)\n\n",
+         counts.c_str(), test_case.name(),
+         internal::StreamableToString(test_case.elapsed_time()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment tear-down\n");
+  fflush(stdout);
+}
+
+// Internal helper for printing the list of failed tests.
+void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
+  const int failed_test_count = unit_test.failed_test_count();
+  if (failed_test_count == 0) {
+    return;
+  }
+
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    const TestCase& test_case = *unit_test.GetTestCase(i);
+    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_case.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_case.GetTestInfo(j);
+      if (!test_info.should_run() || test_info.result()->Passed()) {
+        continue;
+      }
+      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+      printf("%s.%s", test_case.name(), test_info.name());
+      PrintFullTestCommentIfPresent(test_info);
+      printf("\n");
+    }
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                     int /*iteration*/) {
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms total)",
+           internal::StreamableToString(unit_test.elapsed_time()).c_str());
+  }
+  printf("\n");
+  ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  int num_failures = unit_test.failed_test_count();
+  if (!unit_test.Passed()) {
+    const int failed_test_count = unit_test.failed_test_count();
+    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
+    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+    PrintFailedTests(unit_test);
+    printf("\n%2d FAILED %s\n", num_failures,
+                        num_failures == 1 ? "TEST" : "TESTS");
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (!num_failures) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(COLOR_YELLOW,
+                  "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled,
+                  num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End PrettyUnitTestResultPrinter
+
+// class TestEventRepeater
+//
+// This class forwards events to other event listeners.
+class TestEventRepeater : public TestEventListener {
+ public:
+  TestEventRepeater() : forwarding_enabled_(true) {}
+  virtual ~TestEventRepeater();
+  void Append(TestEventListener *listener);
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled() const { return forwarding_enabled_; }
+  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
+
+  virtual void OnTestProgramStart(const UnitTest& unit_test);
+  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
+  virtual void OnTestCaseStart(const TestCase& test_case);
+  virtual void OnTestStart(const TestInfo& test_info);
+  virtual void OnTestPartResult(const TestPartResult& result);
+  virtual void OnTestEnd(const TestInfo& test_info);
+  virtual void OnTestCaseEnd(const TestCase& test_case);
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+  virtual void OnTestProgramEnd(const UnitTest& unit_test);
+
+ private:
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled_;
+  // The list of listeners that receive events.
+  std::vector<TestEventListener*> listeners_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
+};
+
+TestEventRepeater::~TestEventRepeater() {
+  ForEach(listeners_, Delete<TestEventListener>);
+}
+
+void TestEventRepeater::Append(TestEventListener *listener) {
+  listeners_.push_back(listener);
+}
+
+// TODO(vladl@google.com): Factor the search functionality into Vector::Find.
+TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
+  for (size_t i = 0; i < listeners_.size(); ++i) {
+    if (listeners_[i] == listener) {
+      listeners_.erase(listeners_.begin() + i);
+      return listener;
+    }
+  }
+
+  return NULL;
+}
+
+// Since most methods are very similar, use macros to reduce boilerplate.
+// This defines a member that forwards the call to all listeners.
+#define GTEST_REPEATER_METHOD_(Name, Type) \
+void TestEventRepeater::Name(const Type& parameter) { \
+  if (forwarding_enabled_) { \
+    for (size_t i = 0; i < listeners_.size(); i++) { \
+      listeners_[i]->Name(parameter); \
+    } \
+  } \
+}
+// This defines a member that forwards the call to all listeners in reverse
+// order.
+#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \
+void TestEventRepeater::Name(const Type& parameter) { \
+  if (forwarding_enabled_) { \
+    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
+      listeners_[i]->Name(parameter); \
+    } \
+  } \
+}
+
+GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
+GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
+GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
+GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
+
+#undef GTEST_REPEATER_METHOD_
+#undef GTEST_REVERSE_REPEATER_METHOD_
+
+void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
+                                             int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = 0; i < listeners_.size(); i++) {
+      listeners_[i]->OnTestIterationStart(unit_test, iteration);
+    }
+  }
+}
+
+void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
+                                           int iteration) {
+  if (forwarding_enabled_) {
+    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
+      listeners_[i]->OnTestIterationEnd(unit_test, iteration);
+    }
+  }
+}
+
+// End TestEventRepeater
+
+// This class generates an XML output file.
+class XmlUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit XmlUnitTestResultPrinter(const char* output_file);
+
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+
+ private:
+  // Is c a whitespace character that is normalized to a space character
+  // when it appears in an XML attribute value?
+  static bool IsNormalizableWhitespace(char c) {
+    return c == 0x9 || c == 0xA || c == 0xD;
+  }
+
+  // May c appear in a well-formed XML document?
+  static bool IsValidXmlCharacter(char c) {
+    return IsNormalizableWhitespace(c) || c >= 0x20;
+  }
+
+  // Returns an XML-escaped copy of the input string str.  If
+  // is_attribute is true, the text is meant to appear as an attribute
+  // value, and normalizable whitespace is preserved by replacing it
+  // with character references.
+  static std::string EscapeXml(const std::string& str, bool is_attribute);
+
+  // Returns the given string with all characters invalid in XML removed.
+  static std::string RemoveInvalidXmlCharacters(const std::string& str);
+
+  // Convenience wrapper around EscapeXml when str is an attribute value.
+  static std::string EscapeXmlAttribute(const std::string& str) {
+    return EscapeXml(str, true);
+  }
+
+  // Convenience wrapper around EscapeXml when str is not an attribute value.
+  static std::string EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Verifies that the given attribute belongs to the given element and
+  // streams the attribute as XML.
+  static void OutputXmlAttribute(std::ostream* stream,
+                                 const std::string& element_name,
+                                 const std::string& name,
+                                 const std::string& value);
+
+  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
+
+  // Streams an XML representation of a TestInfo object.
+  static void OutputXmlTestInfo(::std::ostream* stream,
+                                const char* test_case_name,
+                                const TestInfo& test_info);
+
+  // Prints an XML representation of a TestCase object
+  static void PrintXmlTestCase(::std::ostream* stream,
+                               const TestCase& test_case);
+
+  // Prints an XML summary of unit_test to output stream out.
+  static void PrintXmlUnitTest(::std::ostream* stream,
+                               const UnitTest& unit_test);
+
+  // Produces a string representing the test properties in a result as space
+  // delimited XML attributes based on the property key="value" pairs.
+  // When the std::string is not empty, it includes a space at the beginning,
+  // to delimit this attribute from prior attributes.
+  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
+};
+
+// Creates a new XmlUnitTestResultPrinter.
+XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.c_str() == NULL || output_file_.empty()) {
+    fprintf(stderr, "XML output file may not be null\n");
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+}
+
+// Called after the unit test ends.
+void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* xmlout = NULL;
+  FilePath output_file(output_file_);
+  FilePath output_dir(output_file.RemoveFileName());
+
+  if (output_dir.CreateDirectoriesRecursively()) {
+    xmlout = posix::FOpen(output_file_.c_str(), "w");
+  }
+  if (xmlout == NULL) {
+    // TODO(wan): report the reason of the failure.
+    //
+    // We don't do it for now as:
+    //
+    //   1. There is no urgent need for it.
+    //   2. It's a bit involved to make the errno variable thread-safe on
+    //      all three operating systems (Linux, Windows, and Mac OS).
+    //   3. To interpret the meaning of errno in a thread-safe way,
+    //      we need the strerror_r() function, which is not available on
+    //      Windows.
+    fprintf(stderr,
+            "Unable to open file \"%s\"\n",
+            output_file_.c_str());
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+  std::stringstream stream;
+  PrintXmlUnitTest(&stream, unit_test);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
+  fclose(xmlout);
+}
+
+// Returns an XML-escaped copy of the input string str.  If is_attribute
+// is true, the text is meant to appear as an attribute value, and
+// normalizable whitespace is preserved by replacing it with character
+// references.
+//
+// Invalid XML characters in str, if any, are stripped from the output.
+// It is expected that most, if not all, of the text processed by this
+// module will consist of ordinary English text.
+// If this module is ever modified to produce version 1.1 XML output,
+// most invalid characters can be retained using character references.
+// TODO(wan): It might be nice to have a minimally invasive, human-readable
+// escaping scheme for invalid characters, rather than dropping them.
+std::string XmlUnitTestResultPrinter::EscapeXml(
+    const std::string& str, bool is_attribute) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '<':
+        m << "&lt;";
+        break;
+      case '>':
+        m << "&gt;";
+        break;
+      case '&':
+        m << "&amp;";
+        break;
+      case '\'':
+        if (is_attribute)
+          m << "&apos;";
+        else
+          m << '\'';
+        break;
+      case '"':
+        if (is_attribute)
+          m << "&quot;";
+        else
+          m << '"';
+        break;
+      default:
+        if (IsValidXmlCharacter(ch)) {
+          if (is_attribute && IsNormalizableWhitespace(ch))
+            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
+              << ";";
+          else
+            m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// Returns the given string with all characters invalid in XML removed.
+// Currently invalid characters are dropped from the string. An
+// alternative is to replace them with certain characters such as . or ?.
+std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
+    const std::string& str) {
+  std::string output;
+  output.reserve(str.size());
+  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    if (IsValidXmlCharacter(*it))
+      output.push_back(*it);
+
+  return output;
+}
+
+// The following routines generate an XML representation of a UnitTest
+// object.
+//
+// This is how Google Test concepts map to the DTD:
+//
+// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
+//   <testsuite name="testcase-name">  <-- corresponds to a TestCase object
+//     <testcase name="test-name">     <-- corresponds to a TestInfo object
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//                                     <-- individual assertion failures
+//     </testcase>
+//   </testsuite>
+// </testsuites>
+
+// Formats the given time in milliseconds as seconds.
+std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3);
+  return ss.str();
+}
+
+static bool PortableLocaltime(time_t seconds, struct tm* out) {
+#if defined(_MSC_VER)
+  return localtime_s(out, &seconds) == 0;
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
+  // Windows' localtime(), which has a thread-local tm buffer.
+  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
+  if (tm_ptr == NULL)
+    return false;
+  *out = *tm_ptr;
+  return true;
+#else
+  return localtime_r(&seconds, out) != NULL;
+#endif
+}
+
+// Converts the given epoch time in milliseconds to a date string in the ISO
+// 8601 format, without the timezone information.
+std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
+  struct tm time_struct;
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
+    return "";
+  // YYYY-MM-DDThh:mm:ss
+  return StreamableToString(time_struct.tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct.tm_min) + ":" +
+      String::FormatIntWidth2(time_struct.tm_sec);
+}
+
+// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
+                                                     const char* data) {
+  const char* segment = data;
+  *stream << "<![CDATA[";
+  for (;;) {
+    const char* const next_segment = strstr(segment, "]]>");
+    if (next_segment != NULL) {
+      stream->write(
+          segment, static_cast<std::streamsize>(next_segment - segment));
+      *stream << "]]>]]&gt;<![CDATA[";
+      segment = next_segment + strlen("]]>");
+    } else {
+      *stream << segment;
+      break;
+    }
+  }
+  *stream << "]]>";
+}
+
+void XmlUnitTestResultPrinter::OutputXmlAttribute(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Attribute " << name << " is not allowed for element <" << element_name
+      << ">.";
+
+  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
+}
+
+// Prints an XML representation of a TestInfo object.
+// TODO(wan): There is also value in printing properties with the plain printer.
+void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
+                                                 const char* test_case_name,
+                                                 const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestcase = "testcase";
+
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
+
+  if (test_info.value_param() != NULL) {
+    OutputXmlAttribute(stream, kTestcase, "value_param",
+                       test_info.value_param());
+  }
+  if (test_info.type_param() != NULL) {
+    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
+  }
+
+  OutputXmlAttribute(stream, kTestcase, "status",
+                     test_info.should_run() ? "run" : "notrun");
+  OutputXmlAttribute(stream, kTestcase, "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
+  *stream << TestPropertiesAsXmlAttributes(result);
+
+  int failures = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      if (++failures == 1) {
+        *stream << ">\n";
+      }
+      const string location = internal::FormatCompilerIndependentFileLocation(
+          part.file_name(), part.line_number());
+      const string summary = location + "\n" + part.summary();
+      *stream << "      <failure message=\""
+              << EscapeXmlAttribute(summary.c_str())
+              << "\" type=\"\">";
+      const string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</failure>\n";
+    }
+  }
+
+  if (failures == 0)
+    *stream << " />\n";
+  else
+    *stream << "    </testcase>\n";
+}
+
+// Prints an XML representation of a TestCase object
+void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
+                                                const TestCase& test_case) {
+  const std::string kTestsuite = "testsuite";
+  *stream << "  <" << kTestsuite;
+  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
+  OutputXmlAttribute(stream, kTestsuite, "tests",
+                     StreamableToString(test_case.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "failures",
+                     StreamableToString(test_case.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuite, "disabled",
+      StreamableToString(test_case.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+  OutputXmlAttribute(stream, kTestsuite, "time",
+                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
+  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
+          << ">\n";
+
+  for (int i = 0; i < test_case.total_test_count(); ++i) {
+    if (test_case.GetTestInfo(i)->is_reportable())
+      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
+  }
+  *stream << "  </" << kTestsuite << ">\n";
+}
+
+// Prints an XML summary of unit_test to output stream out.
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
+                                                const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(unit_test.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "failures",
+                     StreamableToString(unit_test.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "disabled",
+      StreamableToString(unit_test.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
+  OutputXmlAttribute(
+      stream, kTestsuites, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
+  OutputXmlAttribute(stream, kTestsuites, "time",
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+
+  if (GTEST_FLAG(shuffle)) {
+    OutputXmlAttribute(stream, kTestsuites, "random_seed",
+                       StreamableToString(unit_test.random_seed()));
+  }
+
+  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
+
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
+      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
+  }
+  *stream << "</" << kTestsuites << ">\n";
+}
+
+// Produces a string representing the test properties in a result as space
+// delimited XML attributes based on the property key="value" pairs.
+std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
+    const TestResult& result) {
+  Message attributes;
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    attributes << " " << property.key() << "="
+        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+// End XmlUnitTestResultPrinter
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
+// replaces them by "%xx" where xx is their hexadecimal value. For
+// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
+// in both time and space -- important as the input str may contain an
+// arbitrarily long test failure message and stack trace.
+string StreamingListener::UrlEncode(const char* str) {
+  string result;
+  result.reserve(strlen(str) + 1);
+  for (char ch = *str; ch != '\0'; ch = *++str) {
+    switch (ch) {
+      case '%':
+      case '=':
+      case '&':
+      case '\n':
+        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
+        break;
+      default:
+        result.push_back(ch);
+        break;
+    }
+  }
+  return result;
+}
+
+void StreamingListener::SocketWriter::MakeConnection() {
+  GTEST_CHECK_(sockfd_ == -1)
+      << "MakeConnection() can't be called when there is already a connection.";
+
+  addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
+  hints.ai_socktype = SOCK_STREAM;
+  addrinfo* servinfo = NULL;
+
+  // Use the getaddrinfo() to get a linked list of IP addresses for
+  // the given host name.
+  const int error_num = getaddrinfo(
+      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
+  if (error_num != 0) {
+    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
+                        << gai_strerror(error_num);
+  }
+
+  // Loop through all the results and connect to the first we can.
+  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
+       cur_addr = cur_addr->ai_next) {
+    sockfd_ = socket(
+        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
+    if (sockfd_ != -1) {
+      // Connect the client socket to the server socket.
+      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
+        close(sockfd_);
+        sockfd_ = -1;
+      }
+    }
+  }
+
+  freeaddrinfo(servinfo);  // all done with this structure
+
+  if (sockfd_ == -1) {
+    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
+                        << host_name_ << ":" << port_num_;
+  }
+}
+
+// End of class Streaming Listener
+#endif  // GTEST_CAN_STREAM_RESULTS__
+
+// Class ScopedTrace
+
+// Pushes the given source file location and message onto a per-thread
+// trace stack maintained by Google Test.
+ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  TraceInfo trace;
+  trace.file = file;
+  trace.line = line;
+  trace.message = message.GetString();
+
+  UnitTest::GetInstance()->PushGTestTrace(trace);
+}
+
+// Pops the info pushed by the c'tor.
+ScopedTrace::~ScopedTrace()
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  UnitTest::GetInstance()->PopGTestTrace();
+}
+
+
+// class OsStackTraceGetter
+
+const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
+    "... " GTEST_NAME_ " internal frames ...";
+
+string OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/,
+                                             int /*skip_count*/) {
+  return "";
+}
+
+void OsStackTraceGetter::UponLeavingGTest() {}
+
+// A helper class that creates the premature-exit file in its
+// constructor and deletes the file in its destructor.
+class ScopedPrematureExitFile {
+ public:
+  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
+      : premature_exit_filepath_(premature_exit_filepath) {
+    // If a path to the premature-exit file is specified...
+    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
+      // create the file with a single "0" character in it.  I/O
+      // errors are ignored as there's nothing better we can do and we
+      // don't want to fail the test because of this.
+      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      fwrite("0", 1, 1, pfile);
+      fclose(pfile);
+    }
+  }
+
+  ~ScopedPrematureExitFile() {
+    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
+      remove(premature_exit_filepath_);
+    }
+  }
+
+ private:
+  const char* const premature_exit_filepath_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+};
+
+}  // namespace internal
+
+// class TestEventListeners
+
+TestEventListeners::TestEventListeners()
+    : repeater_(new internal::TestEventRepeater()),
+      default_result_printer_(NULL),
+      default_xml_generator_(NULL) {
+}
+
+TestEventListeners::~TestEventListeners() { delete repeater_; }
+
+// Returns the standard listener responsible for the default console
+// output.  Can be removed from the listeners list to shut down default
+// console output.  Note that removing this object from the listener list
+// with Release transfers its ownership to the user.
+void TestEventListeners::Append(TestEventListener* listener) {
+  repeater_->Append(listener);
+}
+
+// Removes the given event listener from the list and returns it.  It then
+// becomes the caller's responsibility to delete the listener. Returns
+// NULL if the listener is not found in the list.
+TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
+  if (listener == default_result_printer_)
+    default_result_printer_ = NULL;
+  else if (listener == default_xml_generator_)
+    default_xml_generator_ = NULL;
+  return repeater_->Release(listener);
+}
+
+// Returns repeater that broadcasts the TestEventListener events to all
+// subscribers.
+TestEventListener* TestEventListeners::repeater() { return repeater_; }
+
+// Sets the default_result_printer attribute to the provided listener.
+// The listener is also added to the listener list and previous
+// default_result_printer is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
+  if (default_result_printer_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_result_printer_);
+    default_result_printer_ = listener;
+    if (listener != NULL)
+      Append(listener);
+  }
+}
+
+// Sets the default_xml_generator attribute to the provided listener.  The
+// listener is also added to the listener list and previous
+// default_xml_generator is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
+  if (default_xml_generator_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_xml_generator_);
+    default_xml_generator_ = listener;
+    if (listener != NULL)
+      Append(listener);
+  }
+}
+
+// Controls whether events will be forwarded by the repeater to the
+// listeners in the list.
+bool TestEventListeners::EventForwardingEnabled() const {
+  return repeater_->forwarding_enabled();
+}
+
+void TestEventListeners::SuppressEventForwarding() {
+  repeater_->set_forwarding_enabled(false);
+}
+
+// class UnitTest
+
+// Gets the singleton UnitTest object.  The first time this method is
+// called, a UnitTest object is constructed and returned.  Consecutive
+// calls will return the same object.
+//
+// We don't protect this under mutex_ as a user is not supposed to
+// call this before main() starts, from which point on the return
+// value will never change.
+UnitTest* UnitTest::GetInstance() {
+  // When compiled with MSVC 7.1 in optimized mode, destroying the
+  // UnitTest object upon exiting the program messes up the exit code,
+  // causing successful tests to appear failed.  We have to use a
+  // different implementation in this case to bypass the compiler bug.
+  // This implementation makes the compiler happy, at the cost of
+  // leaking the UnitTest object.
+
+  // CodeGear C++Builder insists on a public destructor for the
+  // default implementation.  Use this implementation to keep good OO
+  // design with private destructor.
+
+#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
+  static UnitTest* const instance = new UnitTest;
+  return instance;
+#else
+  static UnitTest instance;
+  return &instance;
+#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
+}
+
+// Gets the number of successful test cases.
+int UnitTest::successful_test_case_count() const {
+  return impl()->successful_test_case_count();
+}
+
+// Gets the number of failed test cases.
+int UnitTest::failed_test_case_count() const {
+  return impl()->failed_test_case_count();
+}
+
+// Gets the number of all test cases.
+int UnitTest::total_test_case_count() const {
+  return impl()->total_test_case_count();
+}
+
+// Gets the number of all test cases that contain at least one test
+// that should run.
+int UnitTest::test_case_to_run_count() const {
+  return impl()->test_case_to_run_count();
+}
+
+// Gets the number of successful tests.
+int UnitTest::successful_test_count() const {
+  return impl()->successful_test_count();
+}
+
+// Gets the number of failed tests.
+int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTest::reportable_disabled_test_count() const {
+  return impl()->reportable_disabled_test_count();
+}
+
+// Gets the number of disabled tests.
+int UnitTest::disabled_test_count() const {
+  return impl()->disabled_test_count();
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTest::reportable_test_count() const {
+  return impl()->reportable_test_count();
+}
+
+// Gets the number of all tests.
+int UnitTest::total_test_count() const { return impl()->total_test_count(); }
+
+// Gets the number of tests that should run.
+int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
+
+// Gets the time of the test program start, in ms from the start of the
+// UNIX epoch.
+internal::TimeInMillis UnitTest::start_timestamp() const {
+    return impl()->start_timestamp();
+}
+
+// Gets the elapsed time, in milliseconds.
+internal::TimeInMillis UnitTest::elapsed_time() const {
+  return impl()->elapsed_time();
+}
+
+// Returns true iff the unit test passed (i.e. all test cases passed).
+bool UnitTest::Passed() const { return impl()->Passed(); }
+
+// Returns true iff the unit test failed (i.e. some test case failed
+// or something outside of all tests failed).
+bool UnitTest::Failed() const { return impl()->Failed(); }
+
+// Gets the i-th test case among all the test cases. i can range from 0 to
+// total_test_case_count() - 1. If i is not in that range, returns NULL.
+const TestCase* UnitTest::GetTestCase(int i) const {
+  return impl()->GetTestCase(i);
+}
+
+// Returns the TestResult containing information on test failures and
+// properties logged outside of individual test cases.
+const TestResult& UnitTest::ad_hoc_test_result() const {
+  return *impl()->ad_hoc_test_result();
+}
+
+// Gets the i-th test case among all the test cases. i can range from 0 to
+// total_test_case_count() - 1. If i is not in that range, returns NULL.
+TestCase* UnitTest::GetMutableTestCase(int i) {
+  return impl()->GetMutableTestCase(i);
+}
+
+// Returns the list of event listeners that can be used to track events
+// inside Google Test.
+TestEventListeners& UnitTest::listeners() {
+  return *impl()->listeners();
+}
+
+// Registers and returns a global test environment.  When a test
+// program is run, all global test environments will be set-up in the
+// order they were registered.  After all tests in the program have
+// finished, all global test environments will be torn-down in the
+// *reverse* order they were registered.
+//
+// The UnitTest object takes ownership of the given environment.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+Environment* UnitTest::AddEnvironment(Environment* env) {
+  if (env == NULL) {
+    return NULL;
+  }
+
+  impl_->environments().push_back(env);
+  return env;
+}
+
+// Adds a TestPartResult to the current TestResult object.  All Google Test
+// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
+// this to report their results.  The user code should use the
+// assertion macros instead of calling this directly.
+void UnitTest::AddTestPartResult(
+    TestPartResult::Type result_type,
+    const char* file_name,
+    int line_number,
+    const std::string& message,
+    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
+  Message msg;
+  msg << message;
+
+  internal::MutexLock lock(&mutex_);
+  if (impl_->gtest_trace_stack().size() > 0) {
+    msg << "\n" << GTEST_NAME_ << " trace:";
+
+    for (int i = static_cast<int>(impl_->gtest_trace_stack().size());
+         i > 0; --i) {
+      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
+      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
+          << " " << trace.message;
+    }
+  }
+
+  if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) {
+    msg << internal::kStackTraceMarker << os_stack_trace;
+  }
+
+  const TestPartResult result =
+    TestPartResult(result_type, file_name, line_number,
+                   msg.GetString().c_str());
+  impl_->GetTestPartResultReporterForCurrentThread()->
+      ReportTestPartResult(result);
+
+  if (result_type != TestPartResult::kSuccess) {
+    // gtest_break_on_failure takes precedence over
+    // gtest_throw_on_failure.  This allows a user to set the latter
+    // in the code (perhaps in order to use Google Test assertions
+    // with another testing framework) and specify the former on the
+    // command line for debugging.
+    if (GTEST_FLAG(break_on_failure)) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+      // Using DebugBreak on Windows allows gtest to still break into a debugger
+      // when a failure happens and both the --gtest_break_on_failure and
+      // the --gtest_catch_exceptions flags are specified.
+      DebugBreak();
+#else
+      // Dereference NULL through a volatile pointer to prevent the compiler
+      // from removing. We use this rather than abort() or __builtin_trap() for
+      // portability: Symbian doesn't implement abort() well, and some debuggers
+      // don't correctly trap abort().
+      *static_cast<volatile int*>(NULL) = 1;
+#endif  // GTEST_OS_WINDOWS
+    } else if (GTEST_FLAG(throw_on_failure)) {
+#if GTEST_HAS_EXCEPTIONS
+      throw internal::GoogleTestFailureException(result);
+#else
+      // We cannot call abort() as it generates a pop-up in debug mode
+      // that cannot be suppressed in VC 7.1 or below.
+      exit(1);
+#endif
+    }
+  }
+}
+
+// Adds a TestProperty to the current TestResult object when invoked from
+// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+// from SetUpTestCase or TearDownTestCase, or to the global property set
+// when invoked elsewhere.  If the result already contains a property with
+// the same key, the value will be updated.
+void UnitTest::RecordProperty(const std::string& key,
+                              const std::string& value) {
+  impl_->RecordProperty(TestProperty(key, value));
+}
+
+// Runs all tests in this UnitTest object and prints the result.
+// Returns 0 if successful, or 1 otherwise.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+int UnitTest::Run() {
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+
+  // Google Test implements this protocol for catching that a test
+  // program exits before returning control to Google Test:
+  //
+  //   1. Upon start, Google Test creates a file whose absolute path
+  //      is specified by the environment variable
+  //      TEST_PREMATURE_EXIT_FILE.
+  //   2. When Google Test has finished its work, it deletes the file.
+  //
+  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
+  // running a Google-Test-based test program and check the existence
+  // of the file at the end of the test execution to see if it has
+  // exited prematurely.
+
+  // If we are in the child process of a death test, don't
+  // create/delete the premature exit file, as doing so is unnecessary
+  // and will confuse the parent process.  Otherwise, create/delete
+  // the file upon entering/leaving this function.  If the program
+  // somehow exits before this function has a chance to return, the
+  // premature-exit file will be left undeleted, causing a test runner
+  // that understands the premature-exit-file protocol to report the
+  // test as having failed.
+  const internal::ScopedPrematureExitFile premature_exit_file(
+      in_death_test_child_process ?
+      NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+
+  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
+  // used for the duration of the program.
+  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
+
+#if GTEST_HAS_SEH
+  // Either the user wants Google Test to catch exceptions thrown by the
+  // tests or this is executing in the context of death test child
+  // process. In either case the user does not want to see pop-up dialogs
+  // about crashes - they are expected.
+  if (impl()->catch_exceptions() || in_death_test_child_process) {
+# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+    // SetErrorMode doesn't exist on CE.
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+
+# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
+    // Death test children can be terminated with _abort().  On Windows,
+    // _abort() can show a dialog with a warning message.  This forces the
+    // abort message to go to stderr instead.
+    _set_error_mode(_OUT_TO_STDERR);
+# endif
+
+# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
+    // In the debug version, Visual Studio pops up a separate dialog
+    // offering a choice to debug the aborted program. We need to suppress
+    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
+    // executed. Google Test will notify the user of any unexpected
+    // failure via stderr.
+    //
+    // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
+    // Users of prior VC versions shall suffer the agony and pain of
+    // clicking through the countless debug dialogs.
+    // TODO(vladl@google.com): find a way to suppress the abort dialog() in the
+    // debug mode when compiled with VC 7.1 or lower.
+    if (!GTEST_FLAG(break_on_failure))
+      _set_abort_behavior(
+          0x0,                                    // Clear the following flags:
+          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
+# endif
+  }
+#endif  // GTEST_HAS_SEH
+
+  return internal::HandleExceptionsInMethodIfSupported(
+      impl(),
+      &internal::UnitTestImpl::RunAllTests,
+      "auxiliary test code (environments or event listeners)") ? 0 : 1;
+}
+
+// Returns the working directory when the first TEST() or TEST_F() was
+// executed.
+const char* UnitTest::original_working_dir() const {
+  return impl_->original_working_dir_.c_str();
+}
+
+// Returns the TestCase object for the test that's currently running,
+// or NULL if no test is running.
+const TestCase* UnitTest::current_test_case() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_case();
+}
+
+// Returns the TestInfo object for the test that's currently running,
+// or NULL if no test is running.
+const TestInfo* UnitTest::current_test_info() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_info();
+}
+
+// Returns the random seed used at the start of the current test run.
+int UnitTest::random_seed() const { return impl_->random_seed(); }
+
+#if GTEST_HAS_PARAM_TEST
+// Returns ParameterizedTestCaseRegistry object used to keep track of
+// value-parameterized tests and instantiate and register them.
+internal::ParameterizedTestCaseRegistry&
+    UnitTest::parameterized_test_registry()
+        GTEST_LOCK_EXCLUDED_(mutex_) {
+  return impl_->parameterized_test_registry();
+}
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Creates an empty UnitTest.
+UnitTest::UnitTest() {
+  impl_ = new internal::UnitTestImpl(this);
+}
+
+// Destructor of UnitTest.
+UnitTest::~UnitTest() {
+  delete impl_;
+}
+
+// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+// Google Test trace stack.
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().push_back(trace);
+}
+
+// Pops a trace from the per-thread Google Test trace stack.
+void UnitTest::PopGTestTrace()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().pop_back();
+}
+
+namespace internal {
+
+UnitTestImpl::UnitTestImpl(UnitTest* parent)
+    : parent_(parent),
+      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
+      default_global_test_part_result_reporter_(this),
+      default_per_thread_test_part_result_reporter_(this),
+      GTEST_DISABLE_MSC_WARNINGS_POP_()
+      global_test_part_result_repoter_(
+          &default_global_test_part_result_reporter_),
+      per_thread_test_part_result_reporter_(
+          &default_per_thread_test_part_result_reporter_),
+#if GTEST_HAS_PARAM_TEST
+      parameterized_test_registry_(),
+      parameterized_tests_registered_(false),
+#endif  // GTEST_HAS_PARAM_TEST
+      last_death_test_case_(-1),
+      current_test_case_(NULL),
+      current_test_info_(NULL),
+      ad_hoc_test_result_(),
+      os_stack_trace_getter_(NULL),
+      post_flag_parse_init_performed_(false),
+      random_seed_(0),  // Will be overridden by the flag before first use.
+      random_(0),  // Will be reseeded before first use.
+      start_timestamp_(0),
+      elapsed_time_(0),
+#if GTEST_HAS_DEATH_TEST
+      death_test_factory_(new DefaultDeathTestFactory),
+#endif
+      // Will be overridden by the flag before first use.
+      catch_exceptions_(false) {
+  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
+}
+
+UnitTestImpl::~UnitTestImpl() {
+  // Deletes every TestCase.
+  ForEach(test_cases_, internal::Delete<TestCase>);
+
+  // Deletes every Environment.
+  ForEach(environments_, internal::Delete<Environment>);
+
+  delete os_stack_trace_getter_;
+}
+
+// Adds a TestProperty to the current TestResult object when invoked in a
+// context of a test, to current test case's ad_hoc_test_result when invoke
+// from SetUpTestCase/TearDownTestCase, or to the global property set
+// otherwise.  If the result already contains a property with the same key,
+// the value will be updated.
+void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
+  std::string xml_element;
+  TestResult* test_result;  // TestResult appropriate for property recording.
+
+  if (current_test_info_ != NULL) {
+    xml_element = "testcase";
+    test_result = &(current_test_info_->result_);
+  } else if (current_test_case_ != NULL) {
+    xml_element = "testsuite";
+    test_result = &(current_test_case_->ad_hoc_test_result_);
+  } else {
+    xml_element = "testsuites";
+    test_result = &ad_hoc_test_result_;
+  }
+  test_result->RecordProperty(xml_element, test_property);
+}
+
+#if GTEST_HAS_DEATH_TEST
+// Disables event forwarding if the control is currently in a death test
+// subprocess. Must not be called before InitGoogleTest.
+void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
+  if (internal_run_death_test_flag_.get() != NULL)
+    listeners()->SuppressEventForwarding();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Initializes event listeners performing XML output as specified by
+// UnitTestOptions. Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureXmlOutput() {
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml") {
+    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format != "") {
+    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
+           output_format.c_str());
+    fflush(stdout);
+  }
+}
+
+#if GTEST_CAN_STREAM_RESULTS_
+// Initializes event listeners for streaming test results in string form.
+// Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureStreamingOutput() {
+  const std::string& target = GTEST_FLAG(stream_result_to);
+  if (!target.empty()) {
+    const size_t pos = target.find(':');
+    if (pos != std::string::npos) {
+      listeners()->Append(new StreamingListener(target.substr(0, pos),
+                                                target.substr(pos+1)));
+    } else {
+      printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
+             target.c_str());
+      fflush(stdout);
+    }
+  }
+}
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+// Performs initialization dependent upon flag values obtained in
+// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+// this function is also called from RunAllTests.  Since this function can be
+// called more than once, it has to be idempotent.
+void UnitTestImpl::PostFlagParsingInit() {
+  // Ensures that this function does not execute more than once.
+  if (!post_flag_parse_init_performed_) {
+    post_flag_parse_init_performed_ = true;
+
+#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+    // Register to send notifications about key process state changes.
+    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
+#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+
+#if GTEST_HAS_DEATH_TEST
+    InitDeathTestSubprocessControlInfo();
+    SuppressTestEventsIfInSubprocess();
+#endif  // GTEST_HAS_DEATH_TEST
+
+    // Registers parameterized tests. This makes parameterized tests
+    // available to the UnitTest reflection API without running
+    // RUN_ALL_TESTS.
+    RegisterParameterizedTests();
+
+    // Configures listeners for XML output. This makes it possible for users
+    // to shut down the default XML output before invoking RUN_ALL_TESTS.
+    ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+    // Configures listeners for streaming test results to the specified server.
+    ConfigureStreamingOutput();
+#endif  // GTEST_CAN_STREAM_RESULTS_
+  }
+}
+
+// A predicate that checks the name of a TestCase against a known
+// value.
+//
+// This is used for implementation of the UnitTest class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestCaseNameIs is copyable.
+class TestCaseNameIs {
+ public:
+  // Constructor.
+  explicit TestCaseNameIs(const std::string& name)
+      : name_(name) {}
+
+  // Returns true iff the name of test_case matches name_.
+  bool operator()(const TestCase* test_case) const {
+    return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
+  }
+
+ private:
+  std::string name_;
+};
+
+// Finds and returns a TestCase with the given name.  If one doesn't
+// exist, creates one and returns it.  It's the CALLER'S
+// RESPONSIBILITY to ensure that this function is only called WHEN THE
+// TESTS ARE NOT SHUFFLED.
+//
+// Arguments:
+//
+//   test_case_name: name of the test case
+//   type_param:     the name of the test case's type parameter, or NULL if
+//                   this is not a typed or a type-parameterized test case.
+//   set_up_tc:      pointer to the function that sets up the test case
+//   tear_down_tc:   pointer to the function that tears down the test case
+TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
+                                    const char* type_param,
+                                    Test::SetUpTestCaseFunc set_up_tc,
+                                    Test::TearDownTestCaseFunc tear_down_tc) {
+  // Can we find a TestCase with the given name?
+  const std::vector<TestCase*>::const_iterator test_case =
+      std::find_if(test_cases_.begin(), test_cases_.end(),
+                   TestCaseNameIs(test_case_name));
+
+  if (test_case != test_cases_.end())
+    return *test_case;
+
+  // No.  Let's create one.
+  TestCase* const new_test_case =
+      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
+
+  // Is this a death test case?
+  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
+                                               kDeathTestCaseFilter)) {
+    // Yes.  Inserts the test case after the last death test case
+    // defined so far.  This only works when the test cases haven't
+    // been shuffled.  Otherwise we may end up running a death test
+    // after a non-death test.
+    ++last_death_test_case_;
+    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
+                       new_test_case);
+  } else {
+    // No.  Appends to the end of the list.
+    test_cases_.push_back(new_test_case);
+  }
+
+  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
+  return new_test_case;
+}
+
+// Helpers for setting up / tearing down the given environment.  They
+// are for use in the ForEach() function.
+static void SetUpEnvironment(Environment* env) { env->SetUp(); }
+static void TearDownEnvironment(Environment* env) { env->TearDown(); }
+
+// Runs all tests in this UnitTest object, prints the result, and
+// returns true if all tests are successful.  If any exception is
+// thrown during a test, the test is considered to be failed, but the
+// rest of the tests will still be run.
+//
+// When parameterized tests are enabled, it expands and registers
+// parameterized tests first in RegisterParameterizedTests().
+// All other functions called from RunAllTests() may safely assume that
+// parameterized tests are ready to be counted and run.
+bool UnitTestImpl::RunAllTests() {
+  // Makes sure InitGoogleTest() was called.
+  if (!GTestIsInitialized()) {
+    printf("%s",
+           "\nThis test program did NOT call ::testing::InitGoogleTest "
+           "before calling RUN_ALL_TESTS().  Please fix it.\n");
+    return false;
+  }
+
+  // Do not run any test if the --help flag was specified.
+  if (g_help_flag)
+    return true;
+
+  // Repeats the call to the post-flag parsing initialization in case the
+  // user didn't call InitGoogleTest.
+  PostFlagParsingInit();
+
+  // Even if sharding is not on, test runners may want to use the
+  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
+  // protocol.
+  internal::WriteToShardStatusFileIfNeeded();
+
+  // True iff we are in a subprocess for running a thread-safe-style
+  // death test.
+  bool in_subprocess_for_death_test = false;
+
+#if GTEST_HAS_DEATH_TEST
+  in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL);
+# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+  if (in_subprocess_for_death_test) {
+    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
+  }
+# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#endif  // GTEST_HAS_DEATH_TEST
+
+  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
+                                        in_subprocess_for_death_test);
+
+  // Compares the full test names with the filter to decide which
+  // tests to run.
+  const bool has_tests_to_run = FilterTests(should_shard
+                                              ? HONOR_SHARDING_PROTOCOL
+                                              : IGNORE_SHARDING_PROTOCOL) > 0;
+
+  // Lists the tests and exits if the --gtest_list_tests flag was specified.
+  if (GTEST_FLAG(list_tests)) {
+    // This must be called *after* FilterTests() has been called.
+    ListTestsMatchingFilter();
+    return true;
+  }
+
+  random_seed_ = GTEST_FLAG(shuffle) ?
+      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
+
+  // True iff at least one test has failed.
+  bool failed = false;
+
+  TestEventListener* repeater = listeners()->repeater();
+
+  start_timestamp_ = GetTimeInMillis();
+  repeater->OnTestProgramStart(*parent_);
+
+  // How many times to repeat the tests?  We don't want to repeat them
+  // when we are inside the subprocess of a death test.
+  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
+  // Repeats forever if the repeat count is negative.
+  const bool forever = repeat < 0;
+  for (int i = 0; forever || i != repeat; i++) {
+    // We want to preserve failures generated by ad-hoc test
+    // assertions executed before RUN_ALL_TESTS().
+    ClearNonAdHocTestResult();
+
+    const TimeInMillis start = GetTimeInMillis();
+
+    // Shuffles test cases and tests if requested.
+    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
+      random()->Reseed(random_seed_);
+      // This should be done before calling OnTestIterationStart(),
+      // such that a test event listener can see the actual test order
+      // in the event.
+      ShuffleTests();
+    }
+
+    // Tells the unit test event listeners that the tests are about to start.
+    repeater->OnTestIterationStart(*parent_, i);
+
+    // Runs each test case if there is at least one test to run.
+    if (has_tests_to_run) {
+      // Sets up all environments beforehand.
+      repeater->OnEnvironmentsSetUpStart(*parent_);
+      ForEach(environments_, SetUpEnvironment);
+      repeater->OnEnvironmentsSetUpEnd(*parent_);
+
+      // Runs the tests only if there was no fatal failure during global
+      // set-up.
+      if (!Test::HasFatalFailure()) {
+        for (int test_index = 0; test_index < total_test_case_count();
+             test_index++) {
+          GetMutableTestCase(test_index)->Run();
+        }
+      }
+
+      // Tears down all environments in reverse order afterwards.
+      repeater->OnEnvironmentsTearDownStart(*parent_);
+      std::for_each(environments_.rbegin(), environments_.rend(),
+                    TearDownEnvironment);
+      repeater->OnEnvironmentsTearDownEnd(*parent_);
+    }
+
+    elapsed_time_ = GetTimeInMillis() - start;
+
+    // Tells the unit test event listener that the tests have just finished.
+    repeater->OnTestIterationEnd(*parent_, i);
+
+    // Gets the result and clears it.
+    if (!Passed()) {
+      failed = true;
+    }
+
+    // Restores the original test order after the iteration.  This
+    // allows the user to quickly repro a failure that happens in the
+    // N-th iteration without repeating the first (N - 1) iterations.
+    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
+    // case the user somehow changes the value of the flag somewhere
+    // (it's always safe to unshuffle the tests).
+    UnshuffleTests();
+
+    if (GTEST_FLAG(shuffle)) {
+      // Picks a new random seed for each iteration.
+      random_seed_ = GetNextRandomSeed(random_seed_);
+    }
+  }
+
+  repeater->OnTestProgramEnd(*parent_);
+
+  return !failed;
+}
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded() {
+  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
+  if (test_shard_file != NULL) {
+    FILE* const file = posix::FOpen(test_shard_file, "w");
+    if (file == NULL) {
+      ColoredPrintf(COLOR_RED,
+                    "Could not write to the test shard status file \"%s\" "
+                    "specified by the %s environment variable.\n",
+                    test_shard_file, kTestShardStatusFile);
+      fflush(stdout);
+      exit(EXIT_FAILURE);
+    }
+    fclose(file);
+  }
+}
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (i.e., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+bool ShouldShard(const char* total_shards_env,
+                 const char* shard_index_env,
+                 bool in_subprocess_for_death_test) {
+  if (in_subprocess_for_death_test) {
+    return false;
+  }
+
+  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
+  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
+
+  if (total_shards == -1 && shard_index == -1) {
+    return false;
+  } else if (total_shards == -1 && shard_index != -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestShardIndex << " = " << shard_index
+      << ", but have left " << kTestTotalShards << " unset.\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (total_shards != -1 && shard_index == -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestTotalShards << " = " << total_shards
+      << ", but have left " << kTestShardIndex << " unset.\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (shard_index < 0 || shard_index >= total_shards) {
+    const Message msg = Message()
+      << "Invalid environment variables: we require 0 <= "
+      << kTestShardIndex << " < " << kTestTotalShards
+      << ", but you have " << kTestShardIndex << "=" << shard_index
+      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  }
+
+  return total_shards > 1;
+}
+
+// Parses the environment variable var as an Int32. If it is unset,
+// returns default_val. If it is not an Int32, prints an error
+// and aborts.
+Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
+  const char* str_val = posix::GetEnv(var);
+  if (str_val == NULL) {
+    return default_val;
+  }
+
+  Int32 result;
+  if (!ParseInt32(Message() << "The value of environment variable " << var,
+                  str_val, &result)) {
+    exit(EXIT_FAILURE);
+  }
+  return result;
+}
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true iff the test should be run on this shard. The test id is
+// some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
+  return (test_id % total_shards) == shard_index;
+}
+
+// Compares the name of each test with the user-specified filter to
+// decide whether the test should be run, then records the result in
+// each TestCase and TestInfo object.
+// If shard_tests == true, further filters tests based on sharding
+// variables in the environment - see
+// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
+// Returns the number of tests that should run.
+int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
+  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
+  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
+
+  // num_runnable_tests are the number of tests that will
+  // run across all shards (i.e., match filter and are not disabled).
+  // num_selected_tests are the number of tests to be run on
+  // this shard.
+  int num_runnable_tests = 0;
+  int num_selected_tests = 0;
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    TestCase* const test_case = test_cases_[i];
+    const std::string &test_case_name = test_case->name();
+    test_case->set_should_run(false);
+
+    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
+      TestInfo* const test_info = test_case->test_info_list()[j];
+      const std::string test_name(test_info->name());
+      // A test is disabled if test case name or test name matches
+      // kDisableTestFilter.
+      const bool is_disabled =
+          internal::UnitTestOptions::MatchesFilter(test_case_name,
+                                                   kDisableTestFilter) ||
+          internal::UnitTestOptions::MatchesFilter(test_name,
+                                                   kDisableTestFilter);
+      test_info->is_disabled_ = is_disabled;
+
+      const bool matches_filter =
+          internal::UnitTestOptions::FilterMatchesTest(test_case_name,
+                                                       test_name);
+      test_info->matches_filter_ = matches_filter;
+
+      const bool is_runnable =
+          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
+          matches_filter;
+
+      const bool is_selected = is_runnable &&
+          (shard_tests == IGNORE_SHARDING_PROTOCOL ||
+           ShouldRunTestOnShard(total_shards, shard_index,
+                                num_runnable_tests));
+
+      num_runnable_tests += is_runnable;
+      num_selected_tests += is_selected;
+
+      test_info->should_run_ = is_selected;
+      test_case->set_should_run(test_case->should_run() || is_selected);
+    }
+  }
+  return num_selected_tests;
+}
+
+// Prints the given C-string on a single line by replacing all '\n'
+// characters with string "\\n".  If the output takes more than
+// max_length characters, only prints the first max_length characters
+// and "...".
+static void PrintOnOneLine(const char* str, int max_length) {
+  if (str != NULL) {
+    for (int i = 0; *str != '\0'; ++str) {
+      if (i >= max_length) {
+        printf("...");
+        break;
+      }
+      if (*str == '\n') {
+        printf("\\n");
+        i += 2;
+      } else {
+        printf("%c", *str);
+        ++i;
+      }
+    }
+  }
+}
+
+// Prints the names of the tests matching the user-specified filter flag.
+void UnitTestImpl::ListTestsMatchingFilter() {
+  // Print at most this many characters for each type/value parameter.
+  const int kMaxParamLength = 250;
+
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    const TestCase* const test_case = test_cases_[i];
+    bool printed_test_case_name = false;
+
+    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
+      const TestInfo* const test_info =
+          test_case->test_info_list()[j];
+      if (test_info->matches_filter_) {
+        if (!printed_test_case_name) {
+          printed_test_case_name = true;
+          printf("%s.", test_case->name());
+          if (test_case->type_param() != NULL) {
+            printf("  # %s = ", kTypeParamLabel);
+            // We print the type parameter on a single line to make
+            // the output easy to parse by a program.
+            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
+          }
+          printf("\n");
+        }
+        printf("  %s", test_info->name());
+        if (test_info->value_param() != NULL) {
+          printf("  # %s = ", kValueParamLabel);
+          // We print the value parameter on a single line to make the
+          // output easy to parse by a program.
+          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
+        }
+        printf("\n");
+      }
+    }
+  }
+  fflush(stdout);
+}
+
+// Sets the OS stack trace getter.
+//
+// Does nothing if the input and the current OS stack trace getter are
+// the same; otherwise, deletes the old getter and makes the input the
+// current getter.
+void UnitTestImpl::set_os_stack_trace_getter(
+    OsStackTraceGetterInterface* getter) {
+  if (os_stack_trace_getter_ != getter) {
+    delete os_stack_trace_getter_;
+    os_stack_trace_getter_ = getter;
+  }
+}
+
+// Returns the current OS stack trace getter if it is not NULL;
+// otherwise, creates an OsStackTraceGetter, makes it the current
+// getter, and returns it.
+OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
+  if (os_stack_trace_getter_ == NULL) {
+#ifdef GTEST_OS_STACK_TRACE_GETTER_
+    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
+#else
+    os_stack_trace_getter_ = new OsStackTraceGetter;
+#endif  // GTEST_OS_STACK_TRACE_GETTER_
+  }
+
+  return os_stack_trace_getter_;
+}
+
+// Returns the TestResult for the test that's currently running, or
+// the TestResult for the ad hoc test if no test is running.
+TestResult* UnitTestImpl::current_test_result() {
+  return current_test_info_ ?
+      &(current_test_info_->result_) : &ad_hoc_test_result_;
+}
+
+// Shuffles all test cases, and the tests within each test case,
+// making sure that death tests are still run first.
+void UnitTestImpl::ShuffleTests() {
+  // Shuffles the death test cases.
+  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
+
+  // Shuffles the non-death test cases.
+  ShuffleRange(random(), last_death_test_case_ + 1,
+               static_cast<int>(test_cases_.size()), &test_case_indices_);
+
+  // Shuffles the tests inside each test case.
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    test_cases_[i]->ShuffleTests(random());
+  }
+}
+
+// Restores the test cases and tests to their order before the first shuffle.
+void UnitTestImpl::UnshuffleTests() {
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    // Unshuffles the tests in each test case.
+    test_cases_[i]->UnshuffleTests();
+    // Resets the index of each test case.
+    test_case_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
+                                            int skip_count) {
+  // We pass skip_count + 1 to skip this wrapper function in addition
+  // to what the user really wants to skip.
+  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
+}
+
+// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
+// suppress unreachable code warnings.
+namespace {
+class ClassUniqueToAlwaysTrue {};
+}
+
+bool IsTrue(bool condition) { return condition; }
+
+bool AlwaysTrue() {
+#if GTEST_HAS_EXCEPTIONS
+  // This condition is always false so AlwaysTrue() never actually throws,
+  // but it makes the compiler think that it may throw.
+  if (IsTrue(false))
+    throw ClassUniqueToAlwaysTrue();
+#endif  // GTEST_HAS_EXCEPTIONS
+  return true;
+}
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+bool SkipPrefix(const char* prefix, const char** pstr) {
+  const size_t prefix_len = strlen(prefix);
+  if (strncmp(*pstr, prefix, prefix_len) == 0) {
+    *pstr += prefix_len;
+    return true;
+  }
+  return false;
+}
+
+// Parses a string as a command line flag.  The string should have
+// the format "--flag=value".  When def_optional is true, the "=value"
+// part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+const char* ParseFlagValue(const char* str,
+                           const char* flag,
+                           bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == NULL || flag == NULL) return NULL;
+
+  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
+  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return NULL;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a bool flag, in the form of either
+// "--flag=value" or "--flag".
+//
+// In the former case, the value is taken as true as long as it does
+// not start with '0', 'f', or 'F'.
+//
+// In the latter case, the value is taken as true.
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for an Int32 flag, in the form of
+// "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// Parses a string for a string flag, in the form of
+// "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// Determines whether a string has a prefix that Google Test uses for its
+// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
+// If Google Test detects that a command line flag has its prefix but is not
+// recognized, it will print its help message. Flags starting with
+// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
+// internal flags and do not trigger the help message.
+static bool HasGoogleTestFlagPrefix(const char* str) {
+  return (SkipPrefix("--", &str) ||
+          SkipPrefix("-", &str) ||
+          SkipPrefix("/", &str)) &&
+         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
+         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
+          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
+}
+
+// Prints a string containing code-encoded text.  The following escape
+// sequences can be used in the string to control the text color:
+//
+//   @@    prints a single '@' character.
+//   @R    changes the color to red.
+//   @G    changes the color to green.
+//   @Y    changes the color to yellow.
+//   @D    changes to the default terminal text color.
+//
+// TODO(wan@google.com): Write tests for this once we add stdout
+// capturing to Google Test.
+static void PrintColorEncoded(const char* str) {
+  GTestColor color = COLOR_DEFAULT;  // The current color.
+
+  // Conceptually, we split the string into segments divided by escape
+  // sequences.  Then we print one segment at a time.  At the end of
+  // each iteration, the str pointer advances to the beginning of the
+  // next segment.
+  for (;;) {
+    const char* p = strchr(str, '@');
+    if (p == NULL) {
+      ColoredPrintf(color, "%s", str);
+      return;
+    }
+
+    ColoredPrintf(color, "%s", std::string(str, p).c_str());
+
+    const char ch = p[1];
+    str = p + 2;
+    if (ch == '@') {
+      ColoredPrintf(color, "@");
+    } else if (ch == 'D') {
+      color = COLOR_DEFAULT;
+    } else if (ch == 'R') {
+      color = COLOR_RED;
+    } else if (ch == 'G') {
+      color = COLOR_GREEN;
+    } else if (ch == 'Y') {
+      color = COLOR_YELLOW;
+    } else {
+      --str;
+    }
+  }
+}
+
+static const char kColorEncodedHelpMessage[] =
+"This program contains tests written using " GTEST_NAME_ ". You can use the\n"
+"following command line flags to control its behavior:\n"
+"\n"
+"Test Selection:\n"
+"  @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n"
+"      List the names of all tests instead of running them. The name of\n"
+"      TEST(Foo, Bar) is \"Foo.Bar\".\n"
+"  @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS"
+    "[@G-@YNEGATIVE_PATTERNS]@D\n"
+"      Run only the tests whose name matches one of the positive patterns but\n"
+"      none of the negative patterns. '?' matches any single character; '*'\n"
+"      matches any substring; ':' separates two patterns.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n"
+"      Run all disabled tests too.\n"
+"\n"
+"Test Execution:\n"
+"  @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n"
+"      Run the tests repeatedly; use a negative count to repeat forever.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n"
+"      Randomize tests' orders on every iteration.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n"
+"      Random number seed to use for shuffling test orders (between 1 and\n"
+"      99999, or 0 to use a seed based on the current time).\n"
+"\n"
+"Test Output:\n"
+"  @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
+"      Enable/disable colored output. The default is @Gauto@D.\n"
+"  -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n"
+"      Don't print the elapsed time of each test.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
+    GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
+"      Generate an XML report in the given directory or with the given file\n"
+"      name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n"
+#if GTEST_CAN_STREAM_RESULTS_
+"  @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n"
+"      Stream test results to the given server.\n"
+#endif  // GTEST_CAN_STREAM_RESULTS_
+"\n"
+"Assertion Behavior:\n"
+#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+"  @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
+"      Set the default death test style.\n"
+#endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+"  @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n"
+"      Turn assertion failures into debugger break-points.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n"
+"      Turn assertion failures into C++ exceptions.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n"
+"      Do not report exceptions as test failures. Instead, allow them\n"
+"      to crash the program or throw a pop-up (on Windows).\n"
+"\n"
+"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set "
+    "the corresponding\n"
+"environment variable of a flag (all letters in upper-case). For example, to\n"
+"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_
+    "color=no@D or set\n"
+"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n"
+"\n"
+"For more information, please read the " GTEST_NAME_ " documentation at\n"
+"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n"
+"(not one in your own code or tests), please report it to\n"
+"@G<" GTEST_DEV_EMAIL_ ">@D.\n";
+
+bool ParseGoogleTestFlag(const char* const arg) {
+  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
+                       &GTEST_FLAG(also_run_disabled_tests)) ||
+      ParseBoolFlag(arg, kBreakOnFailureFlag,
+                    &GTEST_FLAG(break_on_failure)) ||
+      ParseBoolFlag(arg, kCatchExceptionsFlag,
+                    &GTEST_FLAG(catch_exceptions)) ||
+      ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
+      ParseStringFlag(arg, kDeathTestStyleFlag,
+                      &GTEST_FLAG(death_test_style)) ||
+      ParseBoolFlag(arg, kDeathTestUseFork,
+                    &GTEST_FLAG(death_test_use_fork)) ||
+      ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
+      ParseStringFlag(arg, kInternalRunDeathTestFlag,
+                      &GTEST_FLAG(internal_run_death_test)) ||
+      ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
+      ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
+      ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
+      ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
+      ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
+      ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
+      ParseInt32Flag(arg, kStackTraceDepthFlag,
+                     &GTEST_FLAG(stack_trace_depth)) ||
+      ParseStringFlag(arg, kStreamResultToFlag,
+                      &GTEST_FLAG(stream_result_to)) ||
+      ParseBoolFlag(arg, kThrowOnFailureFlag,
+                    &GTEST_FLAG(throw_on_failure));
+}
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+void LoadFlagsFromFile(const std::string& path) {
+  FILE* flagfile = posix::FOpen(path.c_str(), "r");
+  if (!flagfile) {
+    fprintf(stderr,
+            "Unable to open file \"%s\"\n",
+            GTEST_FLAG(flagfile).c_str());
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+  std::string contents(ReadEntireFile(flagfile));
+  posix::FClose(flagfile);
+  std::vector<std::string> lines;
+  SplitString(contents, '\n', &lines);
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (lines[i].empty())
+      continue;
+    if (!ParseGoogleTestFlag(lines[i].c_str()))
+      g_help_flag = true;
+  }
+}
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.  The type parameter CharType can be
+// instantiated to either char or wchar_t.
+template <typename CharType>
+void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
+  for (int i = 1; i < *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    using internal::ParseBoolFlag;
+    using internal::ParseInt32Flag;
+    using internal::ParseStringFlag;
+
+    bool remove_flag = false;
+    if (ParseGoogleTestFlag(arg)) {
+      remove_flag = true;
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
+      LoadFlagsFromFile(GTEST_FLAG(flagfile));
+      remove_flag = true;
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (arg_string == "--help" || arg_string == "-h" ||
+               arg_string == "-?" || arg_string == "/?" ||
+               HasGoogleTestFlagPrefix(arg)) {
+      // Both help flag and unrecognized Google Test flags (excluding
+      // internal ones) trigger help display.
+      g_help_flag = true;
+    }
+
+    if (remove_flag) {
+      // Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+
+  if (g_help_flag) {
+    // We print the help here instead of in RUN_ALL_TESTS(), as the
+    // latter may not be called at all if the user is using Google
+    // Test with another testing framework.
+    PrintColorEncoded(kColorEncodedHelpMessage);
+  }
+}
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+
+// The internal implementation of InitGoogleTest().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleTestImpl(int* argc, CharType** argv) {
+  // We don't want to run the initialization code twice.
+  if (GTestIsInitialized()) return;
+
+  if (*argc <= 0) return;
+
+  g_argvs.clear();
+  for (int i = 0; i != *argc; i++) {
+    g_argvs.push_back(StreamableToString(argv[i]));
+  }
+
+  ParseGoogleTestFlagsOnly(argc, argv);
+  GetUnitTestImpl()->PostFlagParsingInit();
+}
+
+}  // namespace internal
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+void InitGoogleTest(int* argc, char** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+void InitGoogleTest(int* argc, wchar_t** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+}  // namespace testing
+// Copyright 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
+//
+// This file implements death tests.
+
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_OS_MAC
+#  include <crt_externs.h>
+# endif  // GTEST_OS_MAC
+
+# include <errno.h>
+# include <fcntl.h>
+# include <limits.h>
+
+# if GTEST_OS_LINUX
+#  include <signal.h>
+# endif  // GTEST_OS_LINUX
+
+# include <stdarg.h>
+
+# if GTEST_OS_WINDOWS
+#  include <windows.h>
+# else
+#  include <sys/mman.h>
+#  include <sys/wait.h>
+# endif  // GTEST_OS_WINDOWS
+
+# if GTEST_OS_QNX
+#  include <spawn.h>
+# endif  // GTEST_OS_QNX
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+
+// Constants.
+
+// The default death test style.
+static const char kDefaultDeathTestStyle[] = "fast";
+
+GTEST_DEFINE_string_(
+    death_test_style,
+    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    "Indicates how to run a death test in a forked child process: "
+    "\"threadsafe\" (child process re-executes the test binary "
+    "from the beginning, running only the specific death test) or "
+    "\"fast\" (child process runs the death test immediately "
+    "after forking).");
+
+GTEST_DEFINE_bool_(
+    death_test_use_fork,
+    internal::BoolFromGTestEnv("death_test_use_fork", false),
+    "Instructs to use fork()/_exit() instead of clone() in death tests. "
+    "Ignored and always uses fork() on POSIX systems where clone() is not "
+    "implemented. Useful when running under valgrind or similar tools if "
+    "those do not support clone(). Valgrind 3.3.1 will just fail if "
+    "it sees an unsupported combination of clone() flags. "
+    "It is not recommended to use this flag w/o valgrind though it will "
+    "work in 99% of the cases. Once valgrind is fixed, this flag will "
+    "most likely be removed.");
+
+namespace internal {
+GTEST_DEFINE_string_(
+    internal_run_death_test, "",
+    "Indicates the file, line number, temporal index of "
+    "the single death test to run, and a file descriptor to "
+    "which a success code may be sent, all separated by "
+    "the '|' characters.  This flag is specified if and only if the current "
+    "process is a sub-process launched for running a thread-safe "
+    "death test.  FOR INTERNAL USE ONLY.");
+}  // namespace internal
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Valid only for fast death tests. Indicates the code is running in the
+// child process of a fast style death test.
+# if !GTEST_OS_WINDOWS
+static bool g_in_fast_death_test_child = false;
+# endif
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+bool InDeathTestChild() {
+# if GTEST_OS_WINDOWS
+
+  // On Windows, death tests are thread-safe regardless of the value of the
+  // death_test_style flag.
+  return !GTEST_FLAG(internal_run_death_test).empty();
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe")
+    return !GTEST_FLAG(internal_run_death_test).empty();
+  else
+    return g_in_fast_death_test_child;
+#endif
+}
+
+}  // namespace internal
+
+// ExitedWithCode constructor.
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
+}
+
+// ExitedWithCode function-call operator.
+bool ExitedWithCode::operator()(int exit_status) const {
+# if GTEST_OS_WINDOWS
+
+  return exit_status == exit_code_;
+
+# else
+
+  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
+
+# endif  // GTEST_OS_WINDOWS
+}
+
+# if !GTEST_OS_WINDOWS
+// KilledBySignal constructor.
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
+}
+
+// KilledBySignal function-call operator.
+bool KilledBySignal::operator()(int exit_status) const {
+#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  {
+    bool result;
+    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
+      return result;
+    }
+  }
+#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
+}
+# endif  // !GTEST_OS_WINDOWS
+
+namespace internal {
+
+// Utilities needed for death tests.
+
+// Generates a textual description of a given exit code, in the format
+// specified by wait(2).
+static std::string ExitSummary(int exit_code) {
+  Message m;
+
+# if GTEST_OS_WINDOWS
+
+  m << "Exited with exit status " << exit_code;
+
+# else
+
+  if (WIFEXITED(exit_code)) {
+    m << "Exited with exit status " << WEXITSTATUS(exit_code);
+  } else if (WIFSIGNALED(exit_code)) {
+    m << "Terminated by signal " << WTERMSIG(exit_code);
+  }
+#  ifdef WCOREDUMP
+  if (WCOREDUMP(exit_code)) {
+    m << " (core dumped)";
+  }
+#  endif
+# endif  // GTEST_OS_WINDOWS
+
+  return m.GetString();
+}
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status) {
+  return !ExitedWithCode(0)(exit_status);
+}
+
+# if !GTEST_OS_WINDOWS
+// Generates a textual failure message when a death test finds more than
+// one thread running, or cannot determine the number of threads, prior
+// to executing the given statement.  It is the responsibility of the
+// caller not to pass a thread_count of 1.
+static std::string DeathTestThreadWarning(size_t thread_count) {
+  Message msg;
+  msg << "Death tests use fork(), which is unsafe particularly"
+      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
+  if (thread_count == 0)
+    msg << "couldn't detect the number of threads.";
+  else
+    msg << "detected " << thread_count << " threads.";
+  return msg.GetString();
+}
+# endif  // !GTEST_OS_WINDOWS
+
+// Flag characters for reporting a death test that did not die.
+static const char kDeathTestLived = 'L';
+static const char kDeathTestReturned = 'R';
+static const char kDeathTestThrew = 'T';
+static const char kDeathTestInternalError = 'I';
+
+// An enumeration describing all of the possible ways that a death test can
+// conclude.  DIED means that the process died while executing the test
+// code; LIVED means that process lived beyond the end of the test code;
+// RETURNED means that the test statement attempted to execute a return
+// statement, which is not allowed; THREW means that the test statement
+// returned control by throwing an exception.  IN_PROGRESS means the test
+// has not yet concluded.
+// TODO(vladl@google.com): Unify names and possibly values for
+// AbortReason, DeathTestOutcome, and flag characters above.
+enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
+
+// Routine for aborting the program which is safe to call from an
+// exec-style death test child process, in which case the error
+// message is propagated back to the parent process.  Otherwise, the
+// message is simply printed to stderr.  In either case, the program
+// then exits with status 1.
+void DeathTestAbort(const std::string& message) {
+  // On a POSIX system, this function may be called from a threadsafe-style
+  // death test child process, which operates on a very small stack.  Use
+  // the heap for any additional non-minuscule memory requirements.
+  const InternalRunDeathTestFlag* const flag =
+      GetUnitTestImpl()->internal_run_death_test_flag();
+  if (flag != NULL) {
+    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
+    fputc(kDeathTestInternalError, parent);
+    fprintf(parent, "%s", message.c_str());
+    fflush(parent);
+    _exit(1);
+  } else {
+    fprintf(stderr, "%s", message.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// A replacement for CHECK that calls DeathTestAbort if the assertion
+// fails.
+# define GTEST_DEATH_TEST_CHECK_(expression) \
+  do { \
+    if (!::testing::internal::IsTrue(expression)) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
+// evaluating any system call that fulfills two conditions: it must return
+// -1 on failure, and set errno to EINTR when it is interrupted and
+// should be tried again.  The macro expands to a loop that repeatedly
+// evaluates the expression as long as it evaluates to -1 and sets
+// errno to EINTR.  If the expression evaluates to -1 but errno is
+// something other than EINTR, DeathTestAbort is called.
+# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
+  do { \
+    int gtest_retval; \
+    do { \
+      gtest_retval = (expression); \
+    } while (gtest_retval == -1 && errno == EINTR); \
+    if (gtest_retval == -1) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression + " != -1"); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// Returns the message describing the last system error in errno.
+std::string GetLastErrnoDescription() {
+    return errno == 0 ? "" : posix::StrError(errno);
+}
+
+// This is called from a death test parent process to read a failure
+// message from the death test child process and log it with the FATAL
+// severity. On Windows, the message is read from a pipe handle. On other
+// platforms, it is read from a file descriptor.
+static void FailFromInternalError(int fd) {
+  Message error;
+  char buffer[256];
+  int num_read;
+
+  do {
+    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
+      buffer[num_read] = '\0';
+      error << buffer;
+    }
+  } while (num_read == -1 && errno == EINTR);
+
+  if (num_read == 0) {
+    GTEST_LOG_(FATAL) << error.GetString();
+  } else {
+    const int last_error = errno;
+    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
+                      << GetLastErrnoDescription() << " [" << last_error << "]";
+  }
+}
+
+// Death test constructor.  Increments the running death test count
+// for the current test.
+DeathTest::DeathTest() {
+  TestInfo* const info = GetUnitTestImpl()->current_test_info();
+  if (info == NULL) {
+    DeathTestAbort("Cannot run a death test outside of a TEST or "
+                   "TEST_F construct");
+  }
+}
+
+// Creates and returns a death test by dispatching to the current
+// death test factory.
+bool DeathTest::Create(const char* statement, const RE* regex,
+                       const char* file, int line, DeathTest** test) {
+  return GetUnitTestImpl()->death_test_factory()->Create(
+      statement, regex, file, line, test);
+}
+
+const char* DeathTest::LastMessage() {
+  return last_death_test_message_.c_str();
+}
+
+void DeathTest::set_last_death_test_message(const std::string& message) {
+  last_death_test_message_ = message;
+}
+
+std::string DeathTest::last_death_test_message_;
+
+// Provides cross platform implementation for some death functionality.
+class DeathTestImpl : public DeathTest {
+ protected:
+  DeathTestImpl(const char* a_statement, const RE* a_regex)
+      : statement_(a_statement),
+        regex_(a_regex),
+        spawned_(false),
+        status_(-1),
+        outcome_(IN_PROGRESS),
+        read_fd_(-1),
+        write_fd_(-1) {}
+
+  // read_fd_ is expected to be closed and cleared by a derived class.
+  ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
+
+  void Abort(AbortReason reason);
+  virtual bool Passed(bool status_ok);
+
+  const char* statement() const { return statement_; }
+  const RE* regex() const { return regex_; }
+  bool spawned() const { return spawned_; }
+  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
+  int status() const { return status_; }
+  void set_status(int a_status) { status_ = a_status; }
+  DeathTestOutcome outcome() const { return outcome_; }
+  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
+  int read_fd() const { return read_fd_; }
+  void set_read_fd(int fd) { read_fd_ = fd; }
+  int write_fd() const { return write_fd_; }
+  void set_write_fd(int fd) { write_fd_ = fd; }
+
+  // Called in the parent process only. Reads the result code of the death
+  // test child process via a pipe, interprets it to set the outcome_
+  // member, and closes read_fd_.  Outputs diagnostics and terminates in
+  // case of unexpected codes.
+  void ReadAndInterpretStatusByte();
+
+ private:
+  // The textual content of the code this object is testing.  This class
+  // doesn't own this string and should not attempt to delete it.
+  const char* const statement_;
+  // The regular expression which test output must match.  DeathTestImpl
+  // doesn't own this object and should not attempt to delete it.
+  const RE* const regex_;
+  // True if the death test child process has been successfully spawned.
+  bool spawned_;
+  // The exit status of the child process.
+  int status_;
+  // How the death test concluded.
+  DeathTestOutcome outcome_;
+  // Descriptor to the read end of the pipe to the child process.  It is
+  // always -1 in the child process.  The child keeps its write end of the
+  // pipe in write_fd_.
+  int read_fd_;
+  // Descriptor to the child's write end of the pipe to the parent process.
+  // It is always -1 in the parent process.  The parent keeps its end of the
+  // pipe in read_fd_.
+  int write_fd_;
+};
+
+// Called in the parent process only. Reads the result code of the death
+// test child process via a pipe, interprets it to set the outcome_
+// member, and closes read_fd_.  Outputs diagnostics and terminates in
+// case of unexpected codes.
+void DeathTestImpl::ReadAndInterpretStatusByte() {
+  char flag;
+  int bytes_read;
+
+  // The read() here blocks until data is available (signifying the
+  // failure of the death test) or until the pipe is closed (signifying
+  // its success), so it's okay to call this in the parent before
+  // the child process has exited.
+  do {
+    bytes_read = posix::Read(read_fd(), &flag, 1);
+  } while (bytes_read == -1 && errno == EINTR);
+
+  if (bytes_read == 0) {
+    set_outcome(DIED);
+  } else if (bytes_read == 1) {
+    switch (flag) {
+      case kDeathTestReturned:
+        set_outcome(RETURNED);
+        break;
+      case kDeathTestThrew:
+        set_outcome(THREW);
+        break;
+      case kDeathTestLived:
+        set_outcome(LIVED);
+        break;
+      case kDeathTestInternalError:
+        FailFromInternalError(read_fd());  // Does not return.
+        break;
+      default:
+        GTEST_LOG_(FATAL) << "Death test child process reported "
+                          << "unexpected status byte ("
+                          << static_cast<unsigned int>(flag) << ")";
+    }
+  } else {
+    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
+                      << GetLastErrnoDescription();
+  }
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
+  set_read_fd(-1);
+}
+
+// Signals that the death test code which should have exited, didn't.
+// Should be called only in a death test child process.
+// Writes a status byte to the child's status file descriptor, then
+// calls _exit(1).
+void DeathTestImpl::Abort(AbortReason reason) {
+  // The parent process considers the death test to be a failure if
+  // it finds any data in our pipe.  So, here we write a single flag byte
+  // to the pipe, then exit.
+  const char status_ch =
+      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
+      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
+
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
+  // We are leaking the descriptor here because on some platforms (i.e.,
+  // when built as Windows DLL), destructors of global objects will still
+  // run after calling _exit(). On such systems, write_fd_ will be
+  // indirectly closed from the destructor of UnitTestImpl, causing double
+  // close if it is also closed here. On debug configurations, double close
+  // may assert. As there are no in-process buffers to flush here, we are
+  // relying on the OS to close the descriptor after the process terminates
+  // when the destructors are not run.
+  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+}
+
+// Returns an indented copy of stderr output for a death test.
+// This makes distinguishing death test output lines from regular log lines
+// much easier.
+static ::std::string FormatDeathTestOutput(const ::std::string& output) {
+  ::std::string ret;
+  for (size_t at = 0; ; ) {
+    const size_t line_end = output.find('\n', at);
+    ret += "[  DEATH   ] ";
+    if (line_end == ::std::string::npos) {
+      ret += output.substr(at);
+      break;
+    }
+    ret += output.substr(at, line_end + 1 - at);
+    at = line_end + 1;
+  }
+  return ret;
+}
+
+// Assesses the success or failure of a death test, using both private
+// members which have previously been set, and one argument:
+//
+// Private data members:
+//   outcome:  An enumeration describing how the death test
+//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
+//             fails in the latter three cases.
+//   status:   The exit status of the child process. On *nix, it is in the
+//             in the format specified by wait(2). On Windows, this is the
+//             value supplied to the ExitProcess() API or a numeric code
+//             of the exception that terminated the program.
+//   regex:    A regular expression object to be applied to
+//             the test's captured standard error output; the death test
+//             fails if it does not match.
+//
+// Argument:
+//   status_ok: true if exit_status is acceptable in the context of
+//              this particular death test, which fails if it is false
+//
+// Returns true iff all of the above conditions are met.  Otherwise, the
+// first failing condition, in the order given above, is the one that is
+// reported. Also sets the last death test message string.
+bool DeathTestImpl::Passed(bool status_ok) {
+  if (!spawned())
+    return false;
+
+  const std::string error_message = GetCapturedStderr();
+
+  bool success = false;
+  Message buffer;
+
+  buffer << "Death test: " << statement() << "\n";
+  switch (outcome()) {
+    case LIVED:
+      buffer << "    Result: failed to die.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case THREW:
+      buffer << "    Result: threw an exception.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case RETURNED:
+      buffer << "    Result: illegal return in test statement.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case DIED:
+      if (status_ok) {
+        const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
+        if (matched) {
+          success = true;
+        } else {
+          buffer << "    Result: died but not with expected error.\n"
+                 << "  Expected: " << regex()->pattern() << "\n"
+                 << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+        }
+      } else {
+        buffer << "    Result: died but not with expected exit code:\n"
+               << "            " << ExitSummary(status()) << "\n"
+               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+      }
+      break;
+    case IN_PROGRESS:
+    default:
+      GTEST_LOG_(FATAL)
+          << "DeathTest::Passed somehow called before conclusion of test";
+  }
+
+  DeathTest::set_last_death_test_message(buffer.GetString());
+  return success;
+}
+
+# if GTEST_OS_WINDOWS
+// WindowsDeathTest implements death tests on Windows. Due to the
+// specifics of starting new processes on Windows, death tests there are
+// always threadsafe, and Google Test considers the
+// --gtest_death_test_style=fast setting to be equivalent to
+// --gtest_death_test_style=threadsafe there.
+//
+// A few implementation notes:  Like the Linux version, the Windows
+// implementation uses pipes for child-to-parent communication. But due to
+// the specifics of pipes on Windows, some extra steps are required:
+//
+// 1. The parent creates a communication pipe and stores handles to both
+//    ends of it.
+// 2. The parent starts the child and provides it with the information
+//    necessary to acquire the handle to the write end of the pipe.
+// 3. The child acquires the write end of the pipe and signals the parent
+//    using a Windows event.
+// 4. Now the parent can release the write end of the pipe on its side. If
+//    this is done before step 3, the object's reference count goes down to
+//    0 and it is destroyed, preventing the child from acquiring it. The
+//    parent now has to release it, or read operations on the read end of
+//    the pipe will not return when the child terminates.
+// 5. The parent reads child's output through the pipe (outcome code and
+//    any possible error messages) from the pipe, and its stderr and then
+//    determines whether to fail the test.
+//
+// Note: to distinguish Win32 API calls from the local method and function
+// calls, the former are explicitly resolved in the global namespace.
+//
+class WindowsDeathTest : public DeathTestImpl {
+ public:
+  WindowsDeathTest(const char* a_statement,
+                   const RE* a_regex,
+                   const char* file,
+                   int line)
+      : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+  virtual TestRole AssumeRole();
+
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+  // Handle to the write end of the pipe to the child process.
+  AutoHandle write_handle_;
+  // Child process handle.
+  AutoHandle child_handle_;
+  // Event the child process uses to signal the parent that it has
+  // acquired the handle to the write end of the pipe. After seeing this
+  // event the parent can release its own handles to make sure its
+  // ReadFile() calls return when the child terminates.
+  AutoHandle event_handle_;
+};
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int WindowsDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  // Wait until the child either signals that it has acquired the write end
+  // of the pipe or it dies.
+  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
+  switch (::WaitForMultipleObjects(2,
+                                   wait_handles,
+                                   FALSE,  // Waits for any of the handles.
+                                   INFINITE)) {
+    case WAIT_OBJECT_0:
+    case WAIT_OBJECT_0 + 1:
+      break;
+    default:
+      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
+  }
+
+  // The child has acquired the write end of the pipe or exited.
+  // We release the handle on our side and continue.
+  write_handle_.Reset();
+  event_handle_.Reset();
+
+  ReadAndInterpretStatusByte();
+
+  // Waits for the child process to exit if it haven't already. This
+  // returns immediately if the child has already exited, regardless of
+  // whether previous calls to WaitForMultipleObjects synchronized on this
+  // handle or not.
+  GTEST_DEATH_TEST_CHECK_(
+      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
+                                             INFINITE));
+  DWORD status_code;
+  GTEST_DEATH_TEST_CHECK_(
+      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
+  child_handle_.Reset();
+  set_status(static_cast<int>(status_code));
+  return status();
+}
+
+// The AssumeRole process for a Windows death test.  It creates a child
+// process with the same executable as the current process to run the
+// death test.  The child process is given the --gtest_filter and
+// --gtest_internal_run_death_test flags such that it knows to run the
+// current death test only.
+DeathTest::TestRole WindowsDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != NULL) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  // WindowsDeathTest uses an anonymous pipe to communicate results of
+  // a death test.
+  SECURITY_ATTRIBUTES handles_are_inheritable = {
+    sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
+  HANDLE read_handle, write_handle;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
+                   0)  // Default buffer size.
+      != FALSE);
+  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
+                                O_RDONLY));
+  write_handle_.Reset(write_handle);
+  event_handle_.Reset(::CreateEvent(
+      &handles_are_inheritable,
+      TRUE,    // The event will automatically reset to non-signaled state.
+      FALSE,   // The initial state is non-signalled.
+      NULL));  // The even is unnamed.
+  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
+  const std::string filter_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
+      info->test_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
+      "=" + file_ + "|" + StreamableToString(line_) + "|" +
+      StreamableToString(death_test_index) + "|" +
+      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
+      // size_t has the same width as pointers on both 32-bit and 64-bit
+      // Windows platforms.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
+      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
+
+  char executable_path[_MAX_PATH + 1];  // NOLINT
+  GTEST_DEATH_TEST_CHECK_(
+      _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
+                                            executable_path,
+                                            _MAX_PATH));
+
+  std::string command_line =
+      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
+      internal_flag + "\"";
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // The child process will share the standard handles with the parent.
+  STARTUPINFOA startup_info;
+  memset(&startup_info, 0, sizeof(STARTUPINFO));
+  startup_info.dwFlags = STARTF_USESTDHANDLES;
+  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
+  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
+  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
+
+  PROCESS_INFORMATION process_info;
+  GTEST_DEATH_TEST_CHECK_(::CreateProcessA(
+      executable_path,
+      const_cast<char*>(command_line.c_str()),
+      NULL,   // Retuned process handle is not inheritable.
+      NULL,   // Retuned thread handle is not inheritable.
+      TRUE,   // Child inherits all inheritable handles (for write_handle_).
+      0x0,    // Default creation flags.
+      NULL,   // Inherit the parent's environment.
+      UnitTest::GetInstance()->original_working_dir(),
+      &startup_info,
+      &process_info) != FALSE);
+  child_handle_.Reset(process_info.hProcess);
+  ::CloseHandle(process_info.hThread);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+# else  // We are not on Windows.
+
+// ForkingDeathTest provides implementations for most of the abstract
+// methods of the DeathTest interface.  Only the AssumeRole method is
+// left undefined.
+class ForkingDeathTest : public DeathTestImpl {
+ public:
+  ForkingDeathTest(const char* statement, const RE* regex);
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+
+ protected:
+  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
+
+ private:
+  // PID of child process during death test; 0 in the child process itself.
+  pid_t child_pid_;
+};
+
+// Constructs a ForkingDeathTest.
+ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
+    : DeathTestImpl(a_statement, a_regex),
+      child_pid_(-1) {}
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int ForkingDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  ReadAndInterpretStatusByte();
+
+  int status_value;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
+  set_status(status_value);
+  return status_value;
+}
+
+// A concrete death test class that forks, then immediately runs the test
+// in the child process.
+class NoExecDeathTest : public ForkingDeathTest {
+ public:
+  NoExecDeathTest(const char* a_statement, const RE* a_regex) :
+      ForkingDeathTest(a_statement, a_regex) { }
+  virtual TestRole AssumeRole();
+};
+
+// The AssumeRole process for a fork-and-run death test.  It implements a
+// straightforward fork, with a simple pipe to transmit the status byte.
+DeathTest::TestRole NoExecDeathTest::AssumeRole() {
+  const size_t thread_count = GetThreadCount();
+  if (thread_count != 1) {
+    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+
+  DeathTest::set_last_death_test_message("");
+  CaptureStderr();
+  // When we fork the process below, the log file buffers are copied, but the
+  // file descriptors are shared.  We flush all log files here so that closing
+  // the file descriptors in the child process doesn't throw off the
+  // synchronization between descriptors and buffers in the parent process.
+  // This is as close to the fork as possible to avoid a race condition in case
+  // there are multiple threads running before the death test, and another
+  // thread writes to the log file.
+  FlushInfoLog();
+
+  const pid_t child_pid = fork();
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  set_child_pid(child_pid);
+  if (child_pid == 0) {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
+    set_write_fd(pipe_fd[1]);
+    // Redirects all logging to stderr in the child process to prevent
+    // concurrent writes to the log files.  We capture stderr in the parent
+    // process and append the child process' output to a log.
+    LogToStderr();
+    // Event forwarding to the listeners of event listener API mush be shut
+    // down in death test subprocesses.
+    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    g_in_fast_death_test_child = true;
+    return EXECUTE_TEST;
+  } else {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+    set_read_fd(pipe_fd[0]);
+    set_spawned(true);
+    return OVERSEE_TEST;
+  }
+}
+
+// A concrete death test class that forks and re-executes the main
+// program from the beginning, with command-line flags set that cause
+// only this specific death test to be run.
+class ExecDeathTest : public ForkingDeathTest {
+ public:
+  ExecDeathTest(const char* a_statement, const RE* a_regex,
+                const char* file, int line) :
+      ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
+  virtual TestRole AssumeRole();
+ private:
+  static ::std::vector<testing::internal::string>
+  GetArgvsForDeathTestChildProcess() {
+    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
+#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    ::std::vector<testing::internal::string> extra_args =
+        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
+    args.insert(args.end(), extra_args.begin(), extra_args.end());
+#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    return args;
+  }
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() {
+    args_.push_back(NULL);
+  }
+
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, posix::StrDup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// A struct that encompasses the arguments to the child process of a
+// threadsafe-style death test process.
+struct ExecDeathTestArgs {
+  char* const* argv;  // Command-line arguments for the child's call to exec
+  int close_fd;       // File descriptor to close; the read end of a pipe
+};
+
+#  if GTEST_OS_MAC
+inline char** GetEnviron() {
+  // When Google Test is built as a framework on MacOS X, the environ variable
+  // is unavailable. Apple's documentation (man environ) recommends using
+  // _NSGetEnviron() instead.
+  return *_NSGetEnviron();
+}
+#  else
+// Some POSIX platforms expect you to declare environ. extern "C" makes
+// it reside in the global namespace.
+extern "C" char** environ;
+inline char** GetEnviron() { return environ; }
+#  endif  // GTEST_OS_MAC
+
+#  if !GTEST_OS_QNX
+// The main function for a threadsafe-style death test child process.
+// This function is called in a clone()-ed process and thus must avoid
+// any potentially unsafe operations like malloc or libc functions.
+static int ExecDeathTestChildMain(void* child_arg) {
+  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
+
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  // We can safely call execve() as it's a direct system call.  We
+  // cannot use execvp() as it's a libc function and thus potentially
+  // unsafe.  Since execve() doesn't search the PATH, the user must
+  // invoke the test program via a valid path that contains at least
+  // one path separator.
+  execve(args->argv[0], args->argv, GetEnviron());
+  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
+                 original_dir + " failed: " +
+                 GetLastErrnoDescription());
+  return EXIT_FAILURE;
+}
+#  endif  // !GTEST_OS_QNX
+
+// Two utility routines that together determine the direction the stack
+// grows.
+// This could be accomplished more elegantly by a single recursive
+// function, but we want to guard against the unlikely possibility of
+// a smart compiler optimizing the recursion away.
+//
+// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
+// StackLowerThanAddress into StackGrowsDown, which then doesn't give
+// correct answer.
+void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
+void StackLowerThanAddress(const void* ptr, bool* result) {
+  int dummy;
+  *result = (&dummy < ptr);
+}
+
+// Make sure AddressSanitizer does not tamper with the stack here.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+bool StackGrowsDown() {
+  int dummy;
+  bool result;
+  StackLowerThanAddress(&dummy, &result);
+  return result;
+}
+
+// Spawns a child process with the same executable as the current process in
+// a thread-safe manner and instructs it to run the death test.  The
+// implementation uses fork(2) + exec.  On systems where clone(2) is
+// available, it is used instead, being slightly more thread-safe.  On QNX,
+// fork supports only single-threaded environments, so this function uses
+// spawn(2) there instead.  The function dies with an error message if
+// anything goes wrong.
+static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
+  ExecDeathTestArgs args = { argv, close_fd };
+  pid_t child_pid = -1;
+
+#  if GTEST_OS_QNX
+  // Obtains the current directory and sets it to be closed in the child
+  // process.
+  const int cwd_fd = open(".", O_RDONLY);
+  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  int fd_flags;
+  // Set close_fd to be closed after spawn.
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
+                                        fd_flags | FD_CLOEXEC));
+  struct inheritance inherit = {0};
+  // spawn is a system call.
+  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
+  // Restores the current working directory.
+  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
+
+#  else   // GTEST_OS_QNX
+#   if GTEST_OS_LINUX
+  // When a SIGPROF signal is received while fork() or clone() are executing,
+  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
+  // it after the call to fork()/clone() is complete.
+  struct sigaction saved_sigprof_action;
+  struct sigaction ignore_sigprof_action;
+  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
+  sigemptyset(&ignore_sigprof_action.sa_mask);
+  ignore_sigprof_action.sa_handler = SIG_IGN;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
+      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#   endif  // GTEST_OS_LINUX
+
+#   if GTEST_HAS_CLONE
+  const bool use_fork = GTEST_FLAG(death_test_use_fork);
+
+  if (!use_fork) {
+    static const bool stack_grows_down = StackGrowsDown();
+    const size_t stack_size = getpagesize();
+    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
+    void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
+                             MAP_ANON | MAP_PRIVATE, -1, 0);
+    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
+
+    // Maximum stack alignment in bytes:  For a downward-growing stack, this
+    // amount is subtracted from size of the stack space to get an address
+    // that is within the stack space and is aligned on all systems we care
+    // about.  As far as I know there is no ABI with stack alignment greater
+    // than 64.  We assume stack and stack_size already have alignment of
+    // kMaxStackAlignment.
+    const size_t kMaxStackAlignment = 64;
+    void* const stack_top =
+        static_cast<char*>(stack) +
+            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
+        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
+
+    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
+
+    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
+  }
+#   else
+  const bool use_fork = true;
+#   endif  // GTEST_HAS_CLONE
+
+  if (use_fork && (child_pid = fork()) == 0) {
+      ExecDeathTestChildMain(&args);
+      _exit(0);
+  }
+#  endif  // GTEST_OS_QNX
+#  if GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &saved_sigprof_action, NULL));
+#  endif  // GTEST_OS_LINUX
+
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  return child_pid;
+}
+
+// The AssumeRole process for a fork-and-exec death test.  It re-executes the
+// main program from the beginning, setting the --gtest_filter
+// and --gtest_internal_run_death_test flags to cause only the current
+// death test to be re-run.
+DeathTest::TestRole ExecDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != NULL) {
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+  // Clear the close-on-exec flag on the write end of the pipe, lest
+  // it be closed when the child process does an exec:
+  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
+
+  const std::string filter_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
+      + info->test_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|" + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index) + "|"
+      + StreamableToString(pipe_fd[1]);
+  Arguments args;
+  args.AddArguments(GetArgvsForDeathTestChildProcess());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // See the comment in NoExecDeathTest::AssumeRole for why the next line
+  // is necessary.
+  FlushInfoLog();
+
+  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+  set_child_pid(child_pid);
+  set_read_fd(pipe_fd[0]);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# endif  // !GTEST_OS_WINDOWS
+
+// Creates a concrete DeathTest-derived class that depends on the
+// --gtest_death_test_style flag, and sets the pointer pointed to
+// by the "test" argument to its address.  If the test should be
+// skipped, sets that pointer to NULL.  Returns true, unless the
+// flag is set to an invalid value.
+bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
+                                     const char* file, int line,
+                                     DeathTest** test) {
+  UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const int death_test_index = impl->current_test_info()
+      ->increment_death_test_count();
+
+  if (flag != NULL) {
+    if (death_test_index > flag->index()) {
+      DeathTest::set_last_death_test_message(
+          "Death test count (" + StreamableToString(death_test_index)
+          + ") somehow exceeded expected maximum ("
+          + StreamableToString(flag->index()) + ")");
+      return false;
+    }
+
+    if (!(flag->file() == file && flag->line() == line &&
+          flag->index() == death_test_index)) {
+      *test = NULL;
+      return true;
+    }
+  }
+
+# if GTEST_OS_WINDOWS
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new WindowsDeathTest(statement, regex, file, line);
+  }
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+    *test = new ExecDeathTest(statement, regex, file, line);
+  } else if (GTEST_FLAG(death_test_style) == "fast") {
+    *test = new NoExecDeathTest(statement, regex);
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
+    DeathTest::set_last_death_test_message(
+        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
+        + "\" encountered");
+    return false;
+  }
+
+  return true;
+}
+
+# if GTEST_OS_WINDOWS
+// Recreates the pipe and event handles from the provided parameters,
+// signals the event, and returns a file descriptor wrapped around the pipe
+// handle. This function is called in the child process only.
+int GetStatusFileDescriptor(unsigned int parent_process_id,
+                            size_t write_handle_as_size_t,
+                            size_t event_handle_as_size_t) {
+  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
+                                                   FALSE,  // Non-inheritable.
+                                                   parent_process_id));
+  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
+    DeathTestAbort("Unable to open parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  // TODO(vladl@google.com): Replace the following check with a
+  // compile-time assertion when available.
+  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
+
+  const HANDLE write_handle =
+      reinterpret_cast<HANDLE>(write_handle_as_size_t);
+  HANDLE dup_write_handle;
+
+  // The newly initialized handle is accessible only in in the parent
+  // process. To obtain one accessible within the child, we need to use
+  // DuplicateHandle.
+  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
+                         ::GetCurrentProcess(), &dup_write_handle,
+                         0x0,    // Requested privileges ignored since
+                                 // DUPLICATE_SAME_ACCESS is used.
+                         FALSE,  // Request non-inheritable handler.
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
+  HANDLE dup_event_handle;
+
+  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
+                         ::GetCurrentProcess(), &dup_event_handle,
+                         0x0,
+                         FALSE,
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the event handle " +
+                   StreamableToString(event_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const int write_fd =
+      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
+  if (write_fd == -1) {
+    DeathTestAbort("Unable to convert pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " to a file descriptor");
+  }
+
+  // Signals the parent that the write end of the pipe has been acquired
+  // so the parent can release its own write end.
+  ::SetEvent(dup_event_handle);
+
+  return write_fd;
+}
+# endif  // GTEST_OS_WINDOWS
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
+  if (GTEST_FLAG(internal_run_death_test) == "") return NULL;
+
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  int line = -1;
+  int index = -1;
+  ::std::vector< ::std::string> fields;
+  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
+  int write_fd = -1;
+
+# if GTEST_OS_WINDOWS
+
+  unsigned int parent_process_id = 0;
+  size_t write_handle_as_size_t = 0;
+  size_t event_handle_as_size_t = 0;
+
+  if (fields.size() != 6
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &parent_process_id)
+      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
+      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG(internal_run_death_test));
+  }
+  write_fd = GetStatusFileDescriptor(parent_process_id,
+                                     write_handle_as_size_t,
+                                     event_handle_as_size_t);
+# else
+
+  if (fields.size() != 4
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &write_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
+}
+
+}  // namespace internal
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Authors: keith.ray@gmail.com (Keith Ray)
+
+
+#include <stdlib.h>
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>
+#elif GTEST_OS_WINDOWS
+# include <direct.h>
+# include <io.h>
+#elif GTEST_OS_SYMBIAN
+// Symbian OpenC has PATH_MAX in sys/syslimits.h
+# include <sys/syslimits.h>
+#else
+# include <limits.h>
+# include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_MAX_ _MAX_PATH
+#elif defined(PATH_MAX)
+# define GTEST_PATH_MAX_ PATH_MAX
+#elif defined(_XOPEN_PATH_MAX)
+# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#else
+# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#endif  // GTEST_OS_WINDOWS
+
+
+namespace testing {
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+// On Windows, '\\' is the standard path separator, but many tools and the
+// Windows API also accept '/' as an alternate path separator. Unless otherwise
+// noted, a file path can contain either kind of path separators, or a mixture
+// of them.
+const char kPathSeparator = '\\';
+const char kAlternatePathSeparator = '/';
+const char kAlternatePathSeparatorString[] = "/";
+# if GTEST_OS_WINDOWS_MOBILE
+// Windows CE doesn't have a current directory. You should not use
+// the current directory in tests on Windows CE, but this at least
+// provides a reasonable fallback.
+const char kCurrentDirectoryString[] = "\\";
+// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
+const DWORD kInvalidFileAttributes = 0xffffffff;
+# else
+const char kCurrentDirectoryString[] = ".\\";
+# endif  // GTEST_OS_WINDOWS_MOBILE
+#else
+const char kPathSeparator = '/';
+const char kCurrentDirectoryString[] = "./";
+#endif  // GTEST_OS_WINDOWS
+
+// Returns whether the given character is a valid path separator.
+static bool IsPathSeparator(char c) {
+#if GTEST_HAS_ALT_PATH_SEP_
+  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
+#else
+  return c == kPathSeparator;
+#endif
+}
+
+// Returns the current working directory, or "" if unsuccessful.
+FilePath FilePath::GetCurrentDir() {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+  // Windows CE doesn't have a current directory, so we just return
+  // something reasonable.
+  return FilePath(kCurrentDirectoryString);
+#elif GTEST_OS_WINDOWS
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
+#else
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char* result = getcwd(cwd, sizeof(cwd));
+# if GTEST_OS_NACL
+  // getcwd will likely fail in NaCl due to the sandbox, so return something
+  // reasonable. The user may have provided a shim implementation for getcwd,
+  // however, so fallback only when failure is detected.
+  return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
+# endif  // GTEST_OS_NACL
+  return FilePath(result == NULL ? "" : cwd);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns a copy of the FilePath with the case-insensitive extension removed.
+// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+// FilePath("dir/file"). If a case-insensitive extension is not
+// found, returns a copy of the original FilePath.
+FilePath FilePath::RemoveExtension(const char* extension) const {
+  const std::string dot_extension = std::string(".") + extension;
+  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
+    return FilePath(pathname_.substr(
+        0, pathname_.length() - dot_extension.length()));
+  }
+  return *this;
+}
+
+// Returns a pointer to the last occurence of a valid path separator in
+// the FilePath. On Windows, for example, both '/' and '\' are valid path
+// separators. Returns NULL if no path separator was found.
+const char* FilePath::FindLastPathSeparator() const {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+#if GTEST_HAS_ALT_PATH_SEP_
+  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
+  // Comparing two pointers of which only one is NULL is undefined.
+  if (last_alt_sep != NULL &&
+      (last_sep == NULL || last_alt_sep > last_sep)) {
+    return last_alt_sep;
+  }
+#endif
+  return last_sep;
+}
+
+// Returns a copy of the FilePath with the directory part removed.
+// Example: FilePath("path/to/file").RemoveDirectoryName() returns
+// FilePath("file"). If there is no directory part ("just_a_file"), it returns
+// the FilePath unmodified. If there is no file part ("just_a_dir/") it
+// returns an empty FilePath ("").
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveDirectoryName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  return last_sep ? FilePath(last_sep + 1) : *this;
+}
+
+// RemoveFileName returns the directory path with the filename removed.
+// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveFileName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  std::string dir;
+  if (last_sep) {
+    dir = std::string(c_str(), last_sep + 1 - c_str());
+  } else {
+    dir = kCurrentDirectoryString;
+  }
+  return FilePath(dir);
+}
+
+// Helper functions for naming files in a directory for xml output.
+
+// Given directory = "dir", base_name = "test", number = 0,
+// extension = "xml", returns "dir/test.xml". If number is greater
+// than zero (e.g., 12), returns "dir/test_12.xml".
+// On Windows platform, uses \ as the separator rather than /.
+FilePath FilePath::MakeFileName(const FilePath& directory,
+                                const FilePath& base_name,
+                                int number,
+                                const char* extension) {
+  std::string file;
+  if (number == 0) {
+    file = base_name.string() + "." + extension;
+  } else {
+    file = base_name.string() + "_" + StreamableToString(number)
+        + "." + extension;
+  }
+  return ConcatPaths(directory, FilePath(file));
+}
+
+// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
+// On Windows, uses \ as the separator rather than /.
+FilePath FilePath::ConcatPaths(const FilePath& directory,
+                               const FilePath& relative_path) {
+  if (directory.IsEmpty())
+    return relative_path;
+  const FilePath dir(directory.RemoveTrailingPathSeparator());
+  return FilePath(dir.string() + kPathSeparator + relative_path.string());
+}
+
+// Returns true if pathname describes something findable in the file-system,
+// either a file, directory, or whatever.
+bool FilePath::FileOrDirectoryExists() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  return attributes != kInvalidFileAttributes;
+#else
+  posix::StatStruct file_stat;
+  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns true if pathname describes a directory in the file-system
+// that exists.
+bool FilePath::DirectoryExists() const {
+  bool result = false;
+#if GTEST_OS_WINDOWS
+  // Don't strip off trailing separator if path is a root directory on
+  // Windows (like "C:\\").
+  const FilePath& path(IsRootDirectory() ? *this :
+                                           RemoveTrailingPathSeparator());
+#else
+  const FilePath& path(*this);
+#endif
+
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  if ((attributes != kInvalidFileAttributes) &&
+      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    result = true;
+  }
+#else
+  posix::StatStruct file_stat;
+  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
+      posix::IsDir(file_stat);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  return result;
+}
+
+// Returns true if pathname describes a root directory. (Windows has one
+// root directory per disk drive.)
+bool FilePath::IsRootDirectory() const {
+#if GTEST_OS_WINDOWS
+  // TODO(wan@google.com): on Windows a network share like
+  // \\server\share can be a root directory, although it cannot be the
+  // current directory.  Handle this properly.
+  return pathname_.length() == 3 && IsAbsolutePath();
+#else
+  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
+#endif
+}
+
+// Returns true if pathname describes an absolute path.
+bool FilePath::IsAbsolutePath() const {
+  const char* const name = pathname_.c_str();
+#if GTEST_OS_WINDOWS
+  return pathname_.length() >= 3 &&
+     ((name[0] >= 'a' && name[0] <= 'z') ||
+      (name[0] >= 'A' && name[0] <= 'Z')) &&
+     name[1] == ':' &&
+     IsPathSeparator(name[2]);
+#else
+  return IsPathSeparator(name[0]);
+#endif
+}
+
+// Returns a pathname for a file that does not currently exist. The pathname
+// will be directory/base_name.extension or
+// directory/base_name_<number>.extension if directory/base_name.extension
+// already exists. The number will be incremented until a pathname is found
+// that does not already exist.
+// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+// There could be a race condition if two or more processes are calling this
+// function at the same time -- they could both pick the same filename.
+FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
+                                          const FilePath& base_name,
+                                          const char* extension) {
+  FilePath full_pathname;
+  int number = 0;
+  do {
+    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
+  } while (full_pathname.FileOrDirectoryExists());
+  return full_pathname;
+}
+
+// Returns true if FilePath ends with a path separator, which indicates that
+// it is intended to represent a directory. Returns false otherwise.
+// This does NOT check that a directory (or file) actually exists.
+bool FilePath::IsDirectory() const {
+  return !pathname_.empty() &&
+         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
+}
+
+// Create directories so that path exists. Returns true if successful or if
+// the directories already exist; returns false if unable to create directories
+// for any reason.
+bool FilePath::CreateDirectoriesRecursively() const {
+  if (!this->IsDirectory()) {
+    return false;
+  }
+
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
+    return true;
+  }
+
+  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
+  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
+}
+
+// Create the directory so that path exists. Returns true if successful or
+// if the directory already exists; returns false if unable to create the
+// directory for any reason, including if the parent directory does not
+// exist. Not named "CreateDirectory" because that's a macro on Windows.
+bool FilePath::CreateFolder() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  FilePath removed_sep(this->RemoveTrailingPathSeparator());
+  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
+  int result = CreateDirectory(unicode, NULL) ? 0 : -1;
+  delete [] unicode;
+#elif GTEST_OS_WINDOWS
+  int result = _mkdir(pathname_.c_str());
+#else
+  int result = mkdir(pathname_.c_str(), 0777);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  if (result == -1) {
+    return this->DirectoryExists();  // An error is OK if the directory exists.
+  }
+  return true;  // No error.
+}
+
+// If input name has a trailing separator character, remove it and return the
+// name, otherwise return the name string unmodified.
+// On Windows platform, uses \ as the separator, other platforms use /.
+FilePath FilePath::RemoveTrailingPathSeparator() const {
+  return IsDirectory()
+      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
+      : *this;
+}
+
+// Removes any redundant separators that might be in the pathname.
+// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+// redundancies that might be in a pathname involving "." or "..".
+// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share).
+void FilePath::Normalize() {
+  if (pathname_.c_str() == NULL) {
+    pathname_ = "";
+    return;
+  }
+  const char* src = pathname_.c_str();
+  char* const dest = new char[pathname_.length() + 1];
+  char* dest_ptr = dest;
+  memset(dest_ptr, 0, pathname_.length() + 1);
+
+  while (*src != '\0') {
+    *dest_ptr = *src;
+    if (!IsPathSeparator(*src)) {
+      src++;
+    } else {
+#if GTEST_HAS_ALT_PATH_SEP_
+      if (*dest_ptr == kAlternatePathSeparator) {
+        *dest_ptr = kPathSeparator;
+      }
+#endif
+      while (IsPathSeparator(*src))
+        src++;
+    }
+    dest_ptr++;
+  }
+  *dest_ptr = '\0';
+  pathname_ = dest;
+  delete[] dest;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fstream>
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>
+# include <io.h>
+# include <sys/stat.h>
+# include <map>  // Used in ThreadLocal.
+#else
+# include <unistd.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+# include <mach/mach_init.h>
+# include <mach/task.h>
+# include <mach/vm_map.h>
+#endif  // GTEST_OS_MAC
+
+#if GTEST_OS_QNX
+# include <devctl.h>
+# include <fcntl.h>
+# include <sys/procfs.h>
+#endif  // GTEST_OS_QNX
+
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+namespace internal {
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
+const int kStdOutFileno = 1;
+const int kStdErrFileno = 2;
+#else
+const int kStdOutFileno = STDOUT_FILENO;
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // _MSC_VER
+
+#if GTEST_OS_LINUX
+
+namespace {
+template <typename T>
+T ReadProcFileField(const string& filename, int field) {
+  std::string dummy;
+  std::ifstream file(filename.c_str());
+  while (field-- > 0) {
+    file >> dummy;
+  }
+  T output = 0;
+  file >> output;
+  return output;
+}
+}  // namespace
+
+// Returns the number of active threads, or 0 when there is an error.
+size_t GetThreadCount() {
+  const string filename =
+      (Message() << "/proc/" << getpid() << "/stat").GetString();
+  return ReadProcFileField<int>(filename, 19);
+}
+
+#elif GTEST_OS_MAC
+
+size_t GetThreadCount() {
+  const task_t task = mach_task_self();
+  mach_msg_type_number_t thread_count;
+  thread_act_array_t thread_list;
+  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
+  if (status == KERN_SUCCESS) {
+    // task_threads allocates resources in thread_list and we need to free them
+    // to avoid leaks.
+    vm_deallocate(task,
+                  reinterpret_cast<vm_address_t>(thread_list),
+                  sizeof(thread_t) * thread_count);
+    return static_cast<size_t>(thread_count);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_QNX
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  const int fd = open("/proc/self/as", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+  procfs_info process_info;
+  const int status =
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
+  close(fd);
+  if (status == EOK) {
+    return static_cast<size_t>(process_info.num_threads);
+  } else {
+    return 0;
+  }
+}
+
+#else
+
+size_t GetThreadCount() {
+  // There's no portable way to detect the number of threads, so we just
+  // return 0 to indicate that we cannot detect it.
+  return 0;
+}
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+void SleepMilliseconds(int n) {
+  ::Sleep(n);
+}
+
+AutoHandle::AutoHandle()
+    : handle_(INVALID_HANDLE_VALUE) {}
+
+AutoHandle::AutoHandle(Handle handle)
+    : handle_(handle) {}
+
+AutoHandle::~AutoHandle() {
+  Reset();
+}
+
+AutoHandle::Handle AutoHandle::Get() const {
+  return handle_;
+}
+
+void AutoHandle::Reset() {
+  Reset(INVALID_HANDLE_VALUE);
+}
+
+void AutoHandle::Reset(HANDLE handle) {
+  // Resetting with the same handle we already own is invalid.
+  if (handle_ != handle) {
+    if (IsCloseable()) {
+      ::CloseHandle(handle_);
+    }
+    handle_ = handle;
+  } else {
+    GTEST_CHECK_(!IsCloseable())
+        << "Resetting a valid handle to itself is likely a programmer error "
+            "and thus not allowed.";
+  }
+}
+
+bool AutoHandle::IsCloseable() const {
+  // Different Windows APIs may use either of these values to represent an
+  // invalid handle.
+  return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
+}
+
+Notification::Notification()
+    : event_(::CreateEvent(NULL,   // Default security attributes.
+                           TRUE,   // Do not reset automatically.
+                           FALSE,  // Initially unset.
+                           NULL)) {  // Anonymous event.
+  GTEST_CHECK_(event_.Get() != NULL);
+}
+
+void Notification::Notify() {
+  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
+}
+
+void Notification::WaitForNotification() {
+  GTEST_CHECK_(
+      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
+}
+
+Mutex::Mutex()
+    : owner_thread_id_(0),
+      type_(kDynamic),
+      critical_section_init_phase_(0),
+      critical_section_(new CRITICAL_SECTION) {
+  ::InitializeCriticalSection(critical_section_);
+}
+
+Mutex::~Mutex() {
+  // Static mutexes are leaked intentionally. It is not thread-safe to try
+  // to clean them up.
+  // TODO(yukawa): Switch to Slim Reader/Writer (SRW) Locks, which requires
+  // nothing to clean it up but is available only on Vista and later.
+  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa904937.aspx
+  if (type_ == kDynamic) {
+    ::DeleteCriticalSection(critical_section_);
+    delete critical_section_;
+    critical_section_ = NULL;
+  }
+}
+
+void Mutex::Lock() {
+  ThreadSafeLazyInit();
+  ::EnterCriticalSection(critical_section_);
+  owner_thread_id_ = ::GetCurrentThreadId();
+}
+
+void Mutex::Unlock() {
+  ThreadSafeLazyInit();
+  // We don't protect writing to owner_thread_id_ here, as it's the
+  // caller's responsibility to ensure that the current thread holds the
+  // mutex when this is called.
+  owner_thread_id_ = 0;
+  ::LeaveCriticalSection(critical_section_);
+}
+
+// Does nothing if the current thread holds the mutex. Otherwise, crashes
+// with high probability.
+void Mutex::AssertHeld() {
+  ThreadSafeLazyInit();
+  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
+      << "The current thread is not holding the mutex @" << this;
+}
+
+// Initializes owner_thread_id_ and critical_section_ in static mutexes.
+void Mutex::ThreadSafeLazyInit() {
+  // Dynamic mutexes are initialized in the constructor.
+  if (type_ == kStatic) {
+    switch (
+        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
+      case 0:
+        // If critical_section_init_phase_ was 0 before the exchange, we
+        // are the first to test it and need to perform the initialization.
+        owner_thread_id_ = 0;
+        critical_section_ = new CRITICAL_SECTION;
+        ::InitializeCriticalSection(critical_section_);
+        // Updates the critical_section_init_phase_ to 2 to signal
+        // initialization complete.
+        GTEST_CHECK_(::InterlockedCompareExchange(
+                          &critical_section_init_phase_, 2L, 1L) ==
+                      1L);
+        break;
+      case 1:
+        // Somebody else is already initializing the mutex; spin until they
+        // are done.
+        while (::InterlockedCompareExchange(&critical_section_init_phase_,
+                                            2L,
+                                            2L) != 2L) {
+          // Possibly yields the rest of the thread's time slice to other
+          // threads.
+          ::Sleep(0);
+        }
+        break;
+
+      case 2:
+        break;  // The mutex is already initialized and ready for use.
+
+      default:
+        GTEST_CHECK_(false)
+            << "Unexpected value of critical_section_init_phase_ "
+            << "while initializing a static mutex.";
+    }
+  }
+}
+
+namespace {
+
+class ThreadWithParamSupport : public ThreadWithParamBase {
+ public:
+  static HANDLE CreateThread(Runnable* runnable,
+                             Notification* thread_can_start) {
+    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
+    DWORD thread_id;
+    // TODO(yukawa): Consider to use _beginthreadex instead.
+    HANDLE thread_handle = ::CreateThread(
+        NULL,    // Default security.
+        0,       // Default stack size.
+        &ThreadWithParamSupport::ThreadMain,
+        param,   // Parameter to ThreadMainStatic
+        0x0,     // Default creation flags.
+        &thread_id);  // Need a valid pointer for the call to work under Win98.
+    GTEST_CHECK_(thread_handle != NULL) << "CreateThread failed with error "
+                                        << ::GetLastError() << ".";
+    if (thread_handle == NULL) {
+      delete param;
+    }
+    return thread_handle;
+  }
+
+ private:
+  struct ThreadMainParam {
+    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
+        : runnable_(runnable),
+          thread_can_start_(thread_can_start) {
+    }
+    scoped_ptr<Runnable> runnable_;
+    // Does not own.
+    Notification* thread_can_start_;
+  };
+
+  static DWORD WINAPI ThreadMain(void* ptr) {
+    // Transfers ownership.
+    scoped_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
+    if (param->thread_can_start_ != NULL)
+      param->thread_can_start_->WaitForNotification();
+    param->runnable_->Run();
+    return 0;
+  }
+
+  // Prohibit instantiation.
+  ThreadWithParamSupport();
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
+};
+
+}  // namespace
+
+ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
+                                         Notification* thread_can_start)
+      : thread_(ThreadWithParamSupport::CreateThread(runnable,
+                                                     thread_can_start)) {
+}
+
+ThreadWithParamBase::~ThreadWithParamBase() {
+  Join();
+}
+
+void ThreadWithParamBase::Join() {
+  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
+      << "Failed to join the thread with error " << ::GetLastError() << ".";
+}
+
+// Maps a thread to a set of ThreadIdToThreadLocals that have values
+// instantiated on that thread and notifies them when the thread exits.  A
+// ThreadLocal instance is expected to persist until all threads it has
+// values on have terminated.
+class ThreadLocalRegistryImpl {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+    DWORD current_thread = ::GetCurrentThreadId();
+    MutexLock lock(&mutex_);
+    ThreadIdToThreadLocals* const thread_to_thread_locals =
+        GetThreadLocalsMapLocked();
+    ThreadIdToThreadLocals::iterator thread_local_pos =
+        thread_to_thread_locals->find(current_thread);
+    if (thread_local_pos == thread_to_thread_locals->end()) {
+      thread_local_pos = thread_to_thread_locals->insert(
+          std::make_pair(current_thread, ThreadLocalValues())).first;
+      StartWatcherThreadFor(current_thread);
+    }
+    ThreadLocalValues& thread_local_values = thread_local_pos->second;
+    ThreadLocalValues::iterator value_pos =
+        thread_local_values.find(thread_local_instance);
+    if (value_pos == thread_local_values.end()) {
+      value_pos =
+          thread_local_values
+              .insert(std::make_pair(
+                  thread_local_instance,
+                  linked_ptr<ThreadLocalValueHolderBase>(
+                      thread_local_instance->NewValueForCurrentThread())))
+              .first;
+    }
+    return value_pos->second.get();
+  }
+
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadLocalValues data structure while holding the lock, but
+    // defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      for (ThreadIdToThreadLocals::iterator it =
+          thread_to_thread_locals->begin();
+          it != thread_to_thread_locals->end();
+          ++it) {
+        ThreadLocalValues& thread_local_values = it->second;
+        ThreadLocalValues::iterator value_pos =
+            thread_local_values.find(thread_local_instance);
+        if (value_pos != thread_local_values.end()) {
+          value_holders.push_back(value_pos->second);
+          thread_local_values.erase(value_pos);
+          // This 'if' can only be successful at most once, so theoretically we
+          // could break out of the loop here, but we don't bother doing so.
+        }
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+  static void OnThreadExit(DWORD thread_id) {
+    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
+    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadIdToThreadLocals data structure while holding the
+    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      ThreadIdToThreadLocals::iterator thread_local_pos =
+          thread_to_thread_locals->find(thread_id);
+      if (thread_local_pos != thread_to_thread_locals->end()) {
+        ThreadLocalValues& thread_local_values = thread_local_pos->second;
+        for (ThreadLocalValues::iterator value_pos =
+            thread_local_values.begin();
+            value_pos != thread_local_values.end();
+            ++value_pos) {
+          value_holders.push_back(value_pos->second);
+        }
+        thread_to_thread_locals->erase(thread_local_pos);
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+ private:
+  // In a particular thread, maps a ThreadLocal object to its value.
+  typedef std::map<const ThreadLocalBase*,
+                   linked_ptr<ThreadLocalValueHolderBase> > ThreadLocalValues;
+  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
+  // thread's ID.
+  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
+
+  // Holds the thread id and thread handle that we pass from
+  // StartWatcherThreadFor to WatcherThreadFunc.
+  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
+
+  static void StartWatcherThreadFor(DWORD thread_id) {
+    // The returned handle will be kept in thread_map and closed by
+    // watcher_thread in WatcherThreadFunc.
+    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
+                                 FALSE,
+                                 thread_id);
+    GTEST_CHECK_(thread != NULL);
+    // We need to to pass a valid thread ID pointer into CreateThread for it
+    // to work correctly under Win98.
+    DWORD watcher_thread_id;
+    HANDLE watcher_thread = ::CreateThread(
+        NULL,   // Default security.
+        0,      // Default stack size
+        &ThreadLocalRegistryImpl::WatcherThreadFunc,
+        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
+        CREATE_SUSPENDED,
+        &watcher_thread_id);
+    GTEST_CHECK_(watcher_thread != NULL);
+    // Give the watcher thread the same priority as ours to avoid being
+    // blocked by it.
+    ::SetThreadPriority(watcher_thread,
+                        ::GetThreadPriority(::GetCurrentThread()));
+    ::ResumeThread(watcher_thread);
+    ::CloseHandle(watcher_thread);
+  }
+
+  // Monitors exit from a given thread and notifies those
+  // ThreadIdToThreadLocals about thread termination.
+  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
+    const ThreadIdAndHandle* tah =
+        reinterpret_cast<const ThreadIdAndHandle*>(param);
+    GTEST_CHECK_(
+        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    OnThreadExit(tah->first);
+    ::CloseHandle(tah->second);
+    delete tah;
+    return 0;
+  }
+
+  // Returns map of thread local instances.
+  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
+    mutex_.AssertHeld();
+    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals;
+    return map;
+  }
+
+  // Protects access to GetThreadLocalsMapLocked() and its return value.
+  static Mutex mutex_;
+  // Protects access to GetThreadMapLocked() and its return value.
+  static Mutex thread_map_mutex_;
+};
+
+Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
+
+ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
+      thread_local_instance);
+}
+
+void ThreadLocalRegistry::OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+#if GTEST_USES_POSIX_RE
+
+// Implements RE.  Currently only needed for death tests.
+
+RE::~RE() {
+  if (is_valid_) {
+    // regfree'ing an invalid regex might crash because the content
+    // of the regex is undefined. Since the regex's are essentially
+    // the same, one cannot be valid (or invalid) without the other
+    // being so too.
+    regfree(&partial_regex_);
+    regfree(&full_regex_);
+  }
+  free(const_cast<char*>(pattern_));
+}
+
+// Returns true iff regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
+}
+
+// Returns true iff regular expression re matches a substring of str
+// (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = posix::StrDup(regex);
+
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match.
+  const size_t full_regex_len = strlen(regex) + 10;
+  char* const full_pattern = new char[full_regex_len];
+
+  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
+  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
+  // We want to call regcomp(&partial_regex_, ...) even if the
+  // previous expression returns false.  Otherwise partial_regex_ may
+  // not be properly initialized can may cause trouble when it's
+  // freed.
+  //
+  // Some implementation of POSIX regex (e.g. on at least some
+  // versions of Cygwin) doesn't accept the empty string as a valid
+  // regex.  We change it to an equivalent form "()" to be safe.
+  if (is_valid_) {
+    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
+    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
+  }
+  EXPECT_TRUE(is_valid_)
+      << "Regular expression \"" << regex
+      << "\" is not a valid POSIX Extended regular expression.";
+
+  delete[] full_pattern;
+}
+
+#elif GTEST_USES_SIMPLE_RE
+
+// Returns true iff ch appears anywhere in str (excluding the
+// terminating '\0' character).
+bool IsInSet(char ch, const char* str) {
+  return ch != '\0' && strchr(str, ch) != NULL;
+}
+
+// Returns true iff ch belongs to the given classification.  Unlike
+// similar functions in <ctype.h>, these aren't affected by the
+// current locale.
+bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
+bool IsAsciiPunct(char ch) {
+  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
+}
+bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
+bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
+bool IsAsciiWordChar(char ch) {
+  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
+      ('0' <= ch && ch <= '9') || ch == '_';
+}
+
+// Returns true iff "\\c" is a supported escape sequence.
+bool IsValidEscape(char c) {
+  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
+}
+
+// Returns true iff the given atom (specified by escaped and pattern)
+// matches ch.  The result is undefined if the atom is invalid.
+bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
+  if (escaped) {  // "\\p" where p is pattern_char.
+    switch (pattern_char) {
+      case 'd': return IsAsciiDigit(ch);
+      case 'D': return !IsAsciiDigit(ch);
+      case 'f': return ch == '\f';
+      case 'n': return ch == '\n';
+      case 'r': return ch == '\r';
+      case 's': return IsAsciiWhiteSpace(ch);
+      case 'S': return !IsAsciiWhiteSpace(ch);
+      case 't': return ch == '\t';
+      case 'v': return ch == '\v';
+      case 'w': return IsAsciiWordChar(ch);
+      case 'W': return !IsAsciiWordChar(ch);
+    }
+    return IsAsciiPunct(pattern_char) && pattern_char == ch;
+  }
+
+  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
+}
+
+// Helper function used by ValidateRegex() to format error messages.
+std::string FormatRegexSyntaxError(const char* regex, int index) {
+  return (Message() << "Syntax error at index " << index
+          << " in simple regular expression \"" << regex << "\": ").GetString();
+}
+
+// Generates non-fatal failures and returns false if regex is invalid;
+// otherwise returns true.
+bool ValidateRegex(const char* regex) {
+  if (regex == NULL) {
+    // TODO(wan@google.com): fix the source file location in the
+    // assertion failures to match where the regex is used in user
+    // code.
+    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
+    return false;
+  }
+
+  bool is_valid = true;
+
+  // True iff ?, *, or + can follow the previous atom.
+  bool prev_repeatable = false;
+  for (int i = 0; regex[i]; i++) {
+    if (regex[i] == '\\') {  // An escape sequence
+      i++;
+      if (regex[i] == '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "'\\' cannot appear at the end.";
+        return false;
+      }
+
+      if (!IsValidEscape(regex[i])) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "invalid escape sequence \"\\" << regex[i] << "\".";
+        is_valid = false;
+      }
+      prev_repeatable = true;
+    } else {  // Not an escape sequence.
+      const char ch = regex[i];
+
+      if (ch == '^' && i > 0) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'^' can only appear at the beginning.";
+        is_valid = false;
+      } else if (ch == '$' && regex[i + 1] != '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'$' can only appear at the end.";
+        is_valid = false;
+      } else if (IsInSet(ch, "()[]{}|")) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' is unsupported.";
+        is_valid = false;
+      } else if (IsRepeat(ch) && !prev_repeatable) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' can only follow a repeatable token.";
+        is_valid = false;
+      }
+
+      prev_repeatable = !IsInSet(ch, "^$?*+");
+    }
+  }
+
+  return is_valid;
+}
+
+// Matches a repeated regex atom followed by a valid simple regular
+// expression.  The regex atom is defined as c if escaped is false,
+// or \c otherwise.  repeat is the repetition meta character (?, *,
+// or +).  The behavior is undefined if str contains too many
+// characters to be indexable by size_t, in which case the test will
+// probably time out anyway.  We are fine with this limitation as
+// std::string has it too.
+bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char c, char repeat, const char* regex,
+    const char* str) {
+  const size_t min_count = (repeat == '+') ? 1 : 0;
+  const size_t max_count = (repeat == '?') ? 1 :
+      static_cast<size_t>(-1) - 1;
+  // We cannot call numeric_limits::max() as it conflicts with the
+  // max() macro on Windows.
+
+  for (size_t i = 0; i <= max_count; ++i) {
+    // We know that the atom matches each of the first i characters in str.
+    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
+      // We have enough matches at the head, and the tail matches too.
+      // Since we only care about *whether* the pattern matches str
+      // (as opposed to *how* it matches), there is no need to find a
+      // greedy match.
+      return true;
+    }
+    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
+      return false;
+  }
+  return false;
+}
+
+// Returns true iff regex matches a prefix of str.  regex must be a
+// valid simple regular expression and not start with "^", or the
+// result is undefined.
+bool MatchRegexAtHead(const char* regex, const char* str) {
+  if (*regex == '\0')  // An empty regex matches a prefix of anything.
+    return true;
+
+  // "$" only matches the end of a string.  Note that regex being
+  // valid guarantees that there's nothing after "$" in it.
+  if (*regex == '$')
+    return *str == '\0';
+
+  // Is the first thing in regex an escape sequence?
+  const bool escaped = *regex == '\\';
+  if (escaped)
+    ++regex;
+  if (IsRepeat(regex[1])) {
+    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
+    // here's an indirect recursion.  It terminates as the regex gets
+    // shorter in each recursion.
+    return MatchRepetitionAndRegexAtHead(
+        escaped, regex[0], regex[1], regex + 2, str);
+  } else {
+    // regex isn't empty, isn't "$", and doesn't start with a
+    // repetition.  We match the first atom of regex with the first
+    // character of str and recurse.
+    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
+        MatchRegexAtHead(regex + 1, str + 1);
+  }
+}
+
+// Returns true iff regex matches any substring of str.  regex must be
+// a valid simple regular expression, or the result is undefined.
+//
+// The algorithm is recursive, but the recursion depth doesn't exceed
+// the regex length, so we won't need to worry about running out of
+// stack space normally.  In rare cases the time complexity can be
+// exponential with respect to the regex length + the string length,
+// but usually it's must faster (often close to linear).
+bool MatchRegexAnywhere(const char* regex, const char* str) {
+  if (regex == NULL || str == NULL)
+    return false;
+
+  if (*regex == '^')
+    return MatchRegexAtHead(regex + 1, str);
+
+  // A successful match can be anywhere in str.
+  do {
+    if (MatchRegexAtHead(regex, str))
+      return true;
+  } while (*str++ != '\0');
+  return false;
+}
+
+// Implements the RE class.
+
+RE::~RE() {
+  free(const_cast<char*>(pattern_));
+  free(const_cast<char*>(full_pattern_));
+}
+
+// Returns true iff regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
+}
+
+// Returns true iff regular expression re matches a substring of str
+// (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = full_pattern_ = NULL;
+  if (regex != NULL) {
+    pattern_ = posix::StrDup(regex);
+  }
+
+  is_valid_ = ValidateRegex(regex);
+  if (!is_valid_) {
+    // No need to calculate the full pattern when the regex is invalid.
+    return;
+  }
+
+  const size_t len = strlen(regex);
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match: we need space to prepend a '^', append a '$', and
+  // terminate the string with '\0'.
+  char* buffer = static_cast<char*>(malloc(len + 3));
+  full_pattern_ = buffer;
+
+  if (*regex != '^')
+    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
+
+  // We don't use snprintf or strncpy, as they trigger a warning when
+  // compiled with VC++ 8.0.
+  memcpy(buffer, regex, len);
+  buffer += len;
+
+  if (len == 0 || regex[len - 1] != '$')
+    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
+
+  *buffer = '\0';
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+const char kUnknownFile[] = "unknown file";
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
+  const std::string file_name(file == NULL ? kUnknownFile : file);
+
+  if (line < 0) {
+    return file_name + ":";
+  }
+#ifdef _MSC_VER
+  return file_name + "(" + StreamableToString(line) + "):";
+#else
+  return file_name + ":" + StreamableToString(line) + ":";
+#endif  // _MSC_VER
+}
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+// Note that FormatCompilerIndependentFileLocation() does NOT append colon
+// to the file location it produces, unlike FormatFileLocation().
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
+    const char* file, int line) {
+  const std::string file_name(file == NULL ? kUnknownFile : file);
+
+  if (line < 0)
+    return file_name;
+  else
+    return file_name + ":" + StreamableToString(line);
+}
+
+GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
+    : severity_(severity) {
+  const char* const marker =
+      severity == GTEST_INFO ?    "[  INFO ]" :
+      severity == GTEST_WARNING ? "[WARNING]" :
+      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
+  GetStream() << ::std::endl << marker << " "
+              << FormatFileLocation(file, line).c_str() << ": ";
+}
+
+// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+GTestLog::~GTestLog() {
+  GetStream() << ::std::endl;
+  if (severity_ == GTEST_FATAL) {
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+// Disable Microsoft deprecation warnings for POSIX functions called from
+// this class (creat, dup, dup2, and close)
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Object that captures an output stream (stdout/stderr).
+class CapturedStream {
+ public:
+  // The ctor redirects the stream to a temporary file.
+  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
+# if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+
+    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
+    const UINT success = ::GetTempFileNameA(temp_dir_path,
+                                            "gtest_redir",
+                                            0,  // Generate unique file name.
+                                            temp_file_path);
+    GTEST_CHECK_(success != 0)
+        << "Unable to create a temporary file in " << temp_dir_path;
+    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
+    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
+                                    << temp_file_path;
+    filename_ = temp_file_path;
+# else
+    // There's no guarantee that a test has write access to the current
+    // directory, so we create the temporary file in the /tmp directory
+    // instead. We use /tmp on most systems, and /sdcard on Android.
+    // That's because Android doesn't have /tmp.
+#  if GTEST_OS_LINUX_ANDROID
+    // Note: Android applications are expected to call the framework's
+    // Context.getExternalStorageDirectory() method through JNI to get
+    // the location of the world-writable SD Card directory. However,
+    // this requires a Context handle, which cannot be retrieved
+    // globally from native code. Doing so also precludes running the
+    // code as part of a regular standalone executable, which doesn't
+    // run in a Dalvik process (e.g. when running it through 'adb shell').
+    //
+    // The location /sdcard is directly accessible from native code
+    // and is the only location (unofficially) supported by the Android
+    // team. It's generally a symlink to the real SD Card mount point
+    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
+    // other OEM-customized locations. Never rely on these, and always
+    // use /sdcard.
+    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
+#  else
+    char name_template[] = "/tmp/captured_stream.XXXXXX";
+#  endif  // GTEST_OS_LINUX_ANDROID
+    const int captured_fd = mkstemp(name_template);
+    filename_ = name_template;
+# endif  // GTEST_OS_WINDOWS
+    fflush(NULL);
+    dup2(captured_fd, fd_);
+    close(captured_fd);
+  }
+
+  ~CapturedStream() {
+    remove(filename_.c_str());
+  }
+
+  std::string GetCapturedString() {
+    if (uncaptured_fd_ != -1) {
+      // Restores the original stream.
+      fflush(NULL);
+      dup2(uncaptured_fd_, fd_);
+      close(uncaptured_fd_);
+      uncaptured_fd_ = -1;
+    }
+
+    FILE* const file = posix::FOpen(filename_.c_str(), "r");
+    const std::string content = ReadEntireFile(file);
+    posix::FClose(file);
+    return content;
+  }
+
+ private:
+  const int fd_;  // A stream to capture.
+  int uncaptured_fd_;
+  // Name of the temporary file holding the stderr output.
+  ::std::string filename_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+static CapturedStream* g_captured_stderr = NULL;
+static CapturedStream* g_captured_stdout = NULL;
+
+// Starts capturing an output stream (stdout/stderr).
+void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
+  if (*stream != NULL) {
+    GTEST_LOG_(FATAL) << "Only one " << stream_name
+                      << " capturer can exist at a time.";
+  }
+  *stream = new CapturedStream(fd);
+}
+
+// Stops capturing the output stream and returns the captured string.
+std::string GetCapturedStream(CapturedStream** captured_stream) {
+  const std::string content = (*captured_stream)->GetCapturedString();
+
+  delete *captured_stream;
+  *captured_stream = NULL;
+
+  return content;
+}
+
+// Starts capturing stdout.
+void CaptureStdout() {
+  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
+}
+
+// Starts capturing stderr.
+void CaptureStderr() {
+  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
+}
+
+// Stops capturing stdout and returns the captured string.
+std::string GetCapturedStdout() {
+  return GetCapturedStream(&g_captured_stdout);
+}
+
+// Stops capturing stderr and returns the captured string.
+std::string GetCapturedStderr() {
+  return GetCapturedStream(&g_captured_stderr);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+std::string TempDir() {
+#if GTEST_OS_WINDOWS_MOBILE
+  return "\\temp\\";
+#elif GTEST_OS_WINDOWS
+  const char* temp_dir = posix::GetEnv("TEMP");
+  if (temp_dir == NULL || temp_dir[0] == '\0')
+    return "\\temp\\";
+  else if (temp_dir[strlen(temp_dir) - 1] == '\\')
+    return temp_dir;
+  else
+    return std::string(temp_dir) + "\\";
+#elif GTEST_OS_LINUX_ANDROID
+  return "/sdcard/";
+#else
+  return "/tmp/";
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+size_t GetFileSize(FILE* file) {
+  fseek(file, 0, SEEK_END);
+  return static_cast<size_t>(ftell(file));
+}
+
+std::string ReadEntireFile(FILE* file) {
+  const size_t file_size = GetFileSize(file);
+  char* const buffer = new char[file_size];
+
+  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
+  size_t bytes_read = 0;       // # of bytes read so far
+
+  fseek(file, 0, SEEK_SET);
+
+  // Keeps reading the file until we cannot read further or the
+  // pre-determined file size is reached.
+  do {
+    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_read += bytes_last_read;
+  } while (bytes_last_read > 0 && bytes_read < file_size);
+
+  const std::string content(buffer, bytes_read);
+  delete[] buffer;
+
+  return content;
+}
+
+#if GTEST_HAS_DEATH_TEST
+
+static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
+                                        NULL;  // Owned.
+
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
+  if (g_injected_test_argvs != argvs)
+    delete g_injected_test_argvs;
+  g_injected_test_argvs = argvs;
+}
+
+const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
+  if (g_injected_test_argvs != NULL) {
+    return *g_injected_test_argvs;
+  }
+  return GetArgvs();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+#if GTEST_OS_WINDOWS_MOBILE
+namespace posix {
+void Abort() {
+  DebugBreak();
+  TerminateProcess(GetCurrentProcess(), 1);
+}
+}  // namespace posix
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Returns the name of the environment variable corresponding to the
+// given flag.  For example, FlagToEnvVar("foo") will return
+// "GTEST_FOO" in the open-source version.
+static std::string FlagToEnvVar(const char* flag) {
+  const std::string full_flag =
+      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
+
+  Message env_var;
+  for (size_t i = 0; i != full_flag.length(); i++) {
+    env_var << ToUpper(full_flag.c_str()[i]);
+  }
+
+  return env_var.GetString();
+}
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes
+// the result to *value and returns true; otherwise leaves *value
+// unchanged and returns false.
+bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
+  // Parses the environment variable as a decimal integer.
+  char* end = NULL;
+  const long long_value = strtol(str, &end, 10);  // NOLINT
+
+  // Has strtol() consumed all characters in the string?
+  if (*end != '\0') {
+    // No - an invalid character was encountered.
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value \"" << str << "\".\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  // Is the parsed value in the range of an Int32?
+  const Int32 result = static_cast<Int32>(long_value);
+  if (long_value == LONG_MAX || long_value == LONG_MIN ||
+      // The parsed value overflows as a long.  (strtol() returns
+      // LONG_MAX or LONG_MIN when the input overflows.)
+      result != long_value
+      // The parsed value overflows as an Int32.
+      ) {
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  *value = result;
+  return true;
+}
+
+// Reads and returns the Boolean environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+//
+// The value is considered true iff it's not "0".
+bool BoolFromGTestEnv(const char* flag, bool default_value) {
+#if defined(GTEST_GET_BOOL_FROM_ENV_)
+  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
+#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  return string_value == NULL ?
+      default_value : strcmp(string_value, "0") != 0;
+}
+
+// Reads and returns a 32-bit integer stored in the environment
+// variable corresponding to the given flag; if it isn't set or
+// doesn't represent a valid 32-bit integer, returns default_value.
+Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
+#if defined(GTEST_GET_INT32_FROM_ENV_)
+  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
+#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  if (string_value == NULL) {
+    // The environment variable is not set.
+    return default_value;
+  }
+
+  Int32 result = default_value;
+  if (!ParseInt32(Message() << "Environment variable " << env_var,
+                  string_value, &result)) {
+    printf("The default value %s is used.\n",
+           (Message() << default_value).GetString().c_str());
+    fflush(stdout);
+    return default_value;
+  }
+
+  return result;
+}
+
+// Reads and returns the string environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+const char* StringFromGTestEnv(const char* flag, const char* default_value) {
+#if defined(GTEST_GET_STRING_FROM_ENV_)
+  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
+#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const value = posix::GetEnv(env_var.c_str());
+  return value == NULL ? default_value : value;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Test - The Google C++ Testing Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// It uses the << operator when possible, and prints the bytes in the
+// object otherwise.  A user can override its behavior for a class
+// type Foo by defining either operator<<(::std::ostream&, const Foo&)
+// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
+// defines Foo.
+
+#include <ctype.h>
+#include <stdio.h>
+#include <cwchar>
+#include <ostream>  // NOLINT
+#include <string>
+
+namespace testing {
+
+namespace {
+
+using ::std::ostream;
+
+// Prints a segment of bytes in the given object.
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
+                                size_t count, ostream* os) {
+  char text[5] = "";
+  for (size_t i = 0; i != count; i++) {
+    const size_t j = start + i;
+    if (i != 0) {
+      // Organizes the bytes into groups of 2 for easy parsing by
+      // human.
+      if ((j % 2) == 0)
+        *os << ' ';
+      else
+        *os << '-';
+    }
+    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
+    *os << text;
+  }
+}
+
+// Prints the bytes in the given value to the given ostream.
+void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
+                              ostream* os) {
+  // Tells the user how big the object is.
+  *os << count << "-byte object <";
+
+  const size_t kThreshold = 132;
+  const size_t kChunkSize = 64;
+  // If the object size is bigger than kThreshold, we'll have to omit
+  // some details by printing only the first and the last kChunkSize
+  // bytes.
+  // TODO(wan): let the user control the threshold using a flag.
+  if (count < kThreshold) {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
+  } else {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
+    *os << " ... ";
+    // Rounds up to 2-byte boundary.
+    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
+    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
+  }
+  *os << ">";
+}
+
+}  // namespace
+
+namespace internal2 {
+
+// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
+// given object.  The delegation simplifies the implementation, which
+// uses the << operator and thus is easier done outside of the
+// ::testing::internal namespace, which contains a << operator that
+// sometimes conflicts with the one in STL.
+void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
+                          ostream* os) {
+  PrintBytesInObjectToImpl(obj_bytes, count, os);
+}
+
+}  // namespace internal2
+
+namespace internal {
+
+// Depending on the value of a char (or wchar_t), we print it in one
+// of three formats:
+//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
+//   - as a hexidecimal escape sequence (e.g. '\x7F'), or
+//   - as a special escape sequence (e.g. '\r', '\n').
+enum CharFormat {
+  kAsIs,
+  kHexEscape,
+  kSpecialEscape
+};
+
+// Returns true if c is a printable ASCII character.  We test the
+// value of c directly instead of calling isprint(), which is buggy on
+// Windows Mobile.
+inline bool IsPrintableAscii(wchar_t c) {
+  return 0x20 <= c && c <= 0x7E;
+}
+
+// Prints a wide or narrow char c as a character literal without the
+// quotes, escaping it when necessary; returns how c was formatted.
+// The template argument UnsignedChar is the unsigned version of Char,
+// which is the type of c.
+template <typename UnsignedChar, typename Char>
+static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
+  switch (static_cast<wchar_t>(c)) {
+    case L'\0':
+      *os << "\\0";
+      break;
+    case L'\'':
+      *os << "\\'";
+      break;
+    case L'\\':
+      *os << "\\\\";
+      break;
+    case L'\a':
+      *os << "\\a";
+      break;
+    case L'\b':
+      *os << "\\b";
+      break;
+    case L'\f':
+      *os << "\\f";
+      break;
+    case L'\n':
+      *os << "\\n";
+      break;
+    case L'\r':
+      *os << "\\r";
+      break;
+    case L'\t':
+      *os << "\\t";
+      break;
+    case L'\v':
+      *os << "\\v";
+      break;
+    default:
+      if (IsPrintableAscii(c)) {
+        *os << static_cast<char>(c);
+        return kAsIs;
+      } else {
+        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
+        return kHexEscape;
+      }
+  }
+  return kSpecialEscape;
+}
+
+// Prints a wchar_t c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
+  switch (c) {
+    case L'\'':
+      *os << "'";
+      return kAsIs;
+    case L'"':
+      *os << "\\\"";
+      return kSpecialEscape;
+    default:
+      return PrintAsCharLiteralTo<wchar_t>(c, os);
+  }
+}
+
+// Prints a char c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
+  return PrintAsStringLiteralTo(
+      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
+}
+
+// Prints a wide or narrow character c and its code.  '\0' is printed
+// as "'\\0'", other unprintable characters are also properly escaped
+// using the standard C++ escape sequence.  The template argument
+// UnsignedChar is the unsigned version of Char, which is the type of c.
+template <typename UnsignedChar, typename Char>
+void PrintCharAndCodeTo(Char c, ostream* os) {
+  // First, print c as a literal in the most readable form we can find.
+  *os << ((sizeof(c) > 1) ? "L'" : "'");
+  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
+  *os << "'";
+
+  // To aid user debugging, we also print c's code in decimal, unless
+  // it's 0 (in which case c was printed as '\\0', making the code
+  // obvious).
+  if (c == 0)
+    return;
+  *os << " (" << static_cast<int>(c);
+
+  // For more convenience, we print c's code again in hexidecimal,
+  // unless c was already printed in the form '\x##' or the code is in
+  // [1, 9].
+  if (format == kHexEscape || (1 <= c && c <= 9)) {
+    // Do nothing.
+  } else {
+    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
+  }
+  *os << ")";
+}
+
+void PrintTo(unsigned char c, ::std::ostream* os) {
+  PrintCharAndCodeTo<unsigned char>(c, os);
+}
+void PrintTo(signed char c, ::std::ostream* os) {
+  PrintCharAndCodeTo<unsigned char>(c, os);
+}
+
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
+void PrintTo(wchar_t wc, ostream* os) {
+  PrintCharAndCodeTo<wchar_t>(wc, os);
+}
+
+// Prints the given array of characters to the ostream.  CharType must be either
+// char or wchar_t.
+// The array starts at begin, the length is len, it may include '\0' characters
+// and may not be NUL-terminated.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static void PrintCharsAsStringTo(
+    const CharType* begin, size_t len, ostream* os) {
+  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
+  *os << kQuoteBegin;
+  bool is_previous_hex = false;
+  for (size_t index = 0; index < len; ++index) {
+    const CharType cur = begin[index];
+    if (is_previous_hex && IsXDigit(cur)) {
+      // Previous character is of '\x..' form and this character can be
+      // interpreted as another hexadecimal digit in its number. Break string to
+      // disambiguate.
+      *os << "\" " << kQuoteBegin;
+    }
+    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
+  }
+  *os << "\"";
+}
+
+// Prints a (const) char/wchar_t array of 'len' elements, starting at address
+// 'begin'.  CharType must be either char or wchar_t.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static void UniversalPrintCharArray(
+    const CharType* begin, size_t len, ostream* os) {
+  // The code
+  //   const char kFoo[] = "foo";
+  // generates an array of 4, not 3, elements, with the last one being '\0'.
+  //
+  // Therefore when printing a char array, we don't print the last element if
+  // it's '\0', such that the output matches the string literal as it's
+  // written in the source code.
+  if (len > 0 && begin[len - 1] == '\0') {
+    PrintCharsAsStringTo(begin, len - 1, os);
+    return;
+  }
+
+  // If, however, the last element in the array is not '\0', e.g.
+  //    const char kFoo[] = { 'f', 'o', 'o' };
+  // we must print the entire array.  We also print a message to indicate
+  // that the array is not NUL-terminated.
+  PrintCharsAsStringTo(begin, len, os);
+  *os << " (no terminating NUL)";
+}
+
+// Prints a (const) char array of 'len' elements, starting at address 'begin'.
+void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints a (const) wchar_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints the given C string to the ostream.
+void PrintTo(const char* s, ostream* os) {
+  if (s == NULL) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, strlen(s), os);
+  }
+}
+
+// MSVC compiler can be configured to define whar_t as a typedef
+// of unsigned short. Defining an overload for const wchar_t* in that case
+// would cause pointers to unsigned shorts be printed as wide strings,
+// possibly accessing more memory than intended and causing invalid
+// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
+// wchar_t is implemented as a native type.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Prints the given wide C string to the ostream.
+void PrintTo(const wchar_t* s, ostream* os) {
+  if (s == NULL) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, std::wcslen(s), os);
+  }
+}
+#endif  // wchar_t is native
+
+// Prints a ::string object.
+#if GTEST_HAS_GLOBAL_STRING
+void PrintStringTo(const ::string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+void PrintStringTo(const ::std::string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+// Prints a ::wstring object.
+#if GTEST_HAS_GLOBAL_WSTRING
+void PrintWideStringTo(const ::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_WSTRING
+void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+}  // namespace internal
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+// The Google C++ Testing Framework (Google Test)
+
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+
+using internal::GetUnitTestImpl;
+
+// Gets the summary of the failure message by omitting the stack trace
+// in it.
+std::string TestPartResult::ExtractSummary(const char* message) {
+  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
+  return stack_trace == NULL ? message :
+      std::string(message, stack_trace);
+}
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
+  return os
+      << result.file_name() << ":" << result.line_number() << ": "
+      << (result.type() == TestPartResult::kSuccess ? "Success" :
+          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
+          "Non-fatal failure") << ":\n"
+      << result.message() << std::endl;
+}
+
+// Appends a TestPartResult to the array.
+void TestPartResultArray::Append(const TestPartResult& result) {
+  array_.push_back(result);
+}
+
+// Returns the TestPartResult at the given index (0-based).
+const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
+  if (index < 0 || index >= size()) {
+    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
+    internal::posix::Abort();
+  }
+
+  return array_[index];
+}
+
+// Returns the number of TestPartResult objects in the array.
+int TestPartResultArray::size() const {
+  return static_cast<int>(array_.size());
+}
+
+namespace internal {
+
+HasNewFatalFailureHelper::HasNewFatalFailureHelper()
+    : has_new_fatal_failure_(false),
+      original_reporter_(GetUnitTestImpl()->
+                         GetTestPartResultReporterForCurrentThread()) {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
+}
+
+HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
+      original_reporter_);
+}
+
+void HasNewFatalFailureHelper::ReportTestPartResult(
+    const TestPartResult& result) {
+  if (result.fatally_failed())
+    has_new_fatal_failure_ = true;
+  original_reporter_->ReportTestPartResult(result);
+}
+
+}  // namespace internal
+
+}  // namespace testing
+// Copyright 2008 Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+namespace testing {
+namespace internal {
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// Skips to the first non-space char in str. Returns an empty string if str
+// contains only whitespace characters.
+static const char* SkipSpaces(const char* str) {
+  while (IsSpace(*str))
+    str++;
+  return str;
+}
+
+static std::vector<std::string> SplitIntoTestNames(const char* src) {
+  std::vector<std::string> name_vec;
+  src = SkipSpaces(src);
+  for (; src != NULL; src = SkipComma(src)) {
+    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
+  }
+  return name_vec;
+}
+
+// Verifies that registered_tests match the test names in
+// registered_tests_; returns registered_tests if successful, or
+// aborts the program otherwise.
+const char* TypedTestCasePState::VerifyRegisteredTestNames(
+    const char* file, int line, const char* registered_tests) {
+  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
+  registered_ = true;
+
+  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
+
+  Message errors;
+
+  std::set<std::string> tests;
+  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
+       name_it != name_vec.end(); ++name_it) {
+    const std::string& name = *name_it;
+    if (tests.count(name) != 0) {
+      errors << "Test " << name << " is listed more than once.\n";
+      continue;
+    }
+
+    bool found = false;
+    for (RegisteredTestIter it = registered_tests_.begin();
+         it != registered_tests_.end();
+         ++it) {
+      if (name == it->first) {
+        found = true;
+        break;
+      }
+    }
+
+    if (found) {
+      tests.insert(name);
+    } else {
+      errors << "No test named " << name
+             << " can be found in this test case.\n";
+    }
+  }
+
+  for (RegisteredTestIter it = registered_tests_.begin();
+       it != registered_tests_.end();
+       ++it) {
+    if (tests.count(it->first) == 0) {
+      errors << "You forgot to list test " << it->first << ".\n";
+    }
+  }
+
+  const std::string& errors_str = errors.GetString();
+  if (errors_str != "") {
+    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
+            errors_str.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+
+  return registered_tests;
+}
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Google C++ Mocking Framework (Google Mock)
+//
+// This file #includes all Google Mock implementation .cc files.  The
+// purpose is to allow a user to build Google Mock by compiling this
+// file alone.
+
+// This line ensures that gmock.h can be compiled on its own, even
+// when it's fused.
+#include "gmock/gmock.h"
+
+// The following lines pull in the real gmock *.cc files.
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements cardinalities.
+
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+
+namespace testing {
+
+namespace {
+
+// Implements the Between(m, n) cardinality.
+class BetweenCardinalityImpl : public CardinalityInterface {
+ public:
+  BetweenCardinalityImpl(int min, int max)
+      : min_(min >= 0 ? min : 0),
+        max_(max >= min_ ? max : min_) {
+    std::stringstream ss;
+    if (min < 0) {
+      ss << "The invocation lower bound must be >= 0, "
+         << "but is actually " << min << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (max < 0) {
+      ss << "The invocation upper bound must be >= 0, "
+         << "but is actually " << max << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (min > max) {
+      ss << "The invocation upper bound (" << max
+         << ") must be >= the invocation lower bound (" << min
+         << ").";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    }
+  }
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return min_; }
+  virtual int ConservativeUpperBound() const { return max_; }
+
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return min_ <= call_count && call_count <= max_;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return call_count >= max_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const;
+
+ private:
+  const int min_;
+  const int max_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
+};
+
+// Formats "n times" in a human-friendly way.
+inline internal::string FormatTimes(int n) {
+  if (n == 1) {
+    return "once";
+  } else if (n == 2) {
+    return "twice";
+  } else {
+    std::stringstream ss;
+    ss << n << " times";
+    return ss.str();
+  }
+}
+
+// Describes the Between(m, n) cardinality in human-friendly text.
+void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
+  if (min_ == 0) {
+    if (max_ == 0) {
+      *os << "never called";
+    } else if (max_ == INT_MAX) {
+      *os << "called any number of times";
+    } else {
+      *os << "called at most " << FormatTimes(max_);
+    }
+  } else if (min_ == max_) {
+    *os << "called " << FormatTimes(min_);
+  } else if (max_ == INT_MAX) {
+    *os << "called at least " << FormatTimes(min_);
+  } else {
+    // 0 < min_ < max_ < INT_MAX
+    *os << "called between " << min_ << " and " << max_ << " times";
+  }
+}
+
+}  // Unnamed namespace
+
+// Describes the given call count to an ostream.
+void Cardinality::DescribeActualCallCountTo(int actual_call_count,
+                                            ::std::ostream* os) {
+  if (actual_call_count > 0) {
+    *os << "called " << FormatTimes(actual_call_count);
+  } else {
+    *os << "never called";
+  }
+}
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max) {
+  return Cardinality(new BetweenCardinalityImpl(min, max));
+}
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
+
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+
+#include <ctype.h>
+#include <ostream>  // NOLINT
+#include <string>
+
+namespace testing {
+namespace internal {
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name) {
+  string result;
+  char prev_char = '\0';
+  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
+    // We don't care about the current locale as the input is
+    // guaranteed to be a valid C++ identifier name.
+    const bool starts_new_word = IsUpper(*p) ||
+        (!IsAlpha(prev_char) && IsLower(*p)) ||
+        (!IsDigit(prev_char) && IsDigit(*p));
+
+    if (IsAlNum(*p)) {
+      if (starts_new_word && result != "")
+        result += ' ';
+      result += ToLower(*p);
+    }
+  }
+  return result;
+}
+
+// This class reports Google Mock failures as Google Test failures.  A
+// user can define another class in a similar fashion if he intends to
+// use Google Mock with a testing framework other than Google Test.
+class GoogleTestFailureReporter : public FailureReporterInterface {
+ public:
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const string& message) {
+    AssertHelper(type == kFatal ?
+                 TestPartResult::kFatalFailure :
+                 TestPartResult::kNonFatalFailure,
+                 file,
+                 line,
+                 message.c_str()) = Message();
+    if (type == kFatal) {
+      posix::Abort();
+    }
+  }
+};
+
+// Returns the global failure reporter.  Will create a
+// GoogleTestFailureReporter and return it the first time called.
+GTEST_API_ FailureReporterInterface* GetFailureReporter() {
+  // Points to the global failure reporter used by Google Mock.  gcc
+  // guarantees that the following use of failure_reporter is
+  // thread-safe.  We may need to add additional synchronization to
+  // protect failure_reporter if we port Google Mock to other
+  // compilers.
+  static FailureReporterInterface* const failure_reporter =
+      new GoogleTestFailureReporter();
+  return failure_reporter;
+}
+
+// Protects global resources (stdout in particular) used by Log().
+static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
+
+// Returns true iff a log with the given severity is visible according
+// to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity) {
+  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
+    // Always show the log if --gmock_verbose=info.
+    return true;
+  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
+    // Always hide it if --gmock_verbose=error.
+    return false;
+  } else {
+    // If --gmock_verbose is neither "info" nor "error", we treat it
+    // as "warning" (its default value).
+    return severity == kWarning;
+  }
+}
+
+// Prints the given message to stdout iff 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity,
+                    const string& message,
+                    int stack_frames_to_skip) {
+  if (!LogIsVisible(severity))
+    return;
+
+  // Ensures that logs from different threads don't interleave.
+  MutexLock l(&g_log_mutex);
+
+  // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
+  // macro.
+
+  if (severity == kWarning) {
+    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
+    std::cout << "\nGMOCK WARNING:";
+  }
+  // Pre-pends a new-line to message if it doesn't start with one.
+  if (message.empty() || message[0] != '\n') {
+    std::cout << "\n";
+  }
+  std::cout << message;
+  if (stack_frames_to_skip >= 0) {
+#ifdef NDEBUG
+    // In opt mode, we have to be conservative and skip no stack frame.
+    const int actual_to_skip = 0;
+#else
+    // In dbg mode, we can do what the caller tell us to do (plus one
+    // for skipping this function's stack frame).
+    const int actual_to_skip = stack_frames_to_skip + 1;
+#endif  // NDEBUG
+
+    // Appends a new-line to message if it doesn't end with one.
+    if (!message.empty() && *message.rbegin() != '\n') {
+      std::cout << "\n";
+    }
+    std::cout << "Stack trace:\n"
+         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
+             ::testing::UnitTest::GetInstance(), actual_to_skip);
+  }
+  std::cout << ::std::flush;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements Matcher<const string&>, Matcher<string>, and
+// utilities for defining matchers.
+
+
+#include <string.h>
+#include <sstream>
+#include <string>
+
+namespace testing {
+
+// Constructs a matcher that matches a const string& whose value is
+// equal to s.
+Matcher<const internal::string&>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const string& whose value is
+// equal to s.
+Matcher<const internal::string&>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a string whose value is equal to s.
+Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a string whose value is equal to s.
+Matcher<internal::string>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+#if GTEST_HAS_STRING_PIECE_
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(StringPiece s) {
+  *this = Eq(s.ToString());
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(StringPiece s) {
+  *this = Eq(s.ToString());
+}
+#endif  // GTEST_HAS_STRING_PIECE_
+
+namespace internal {
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ string JoinAsTuple(const Strings& fields) {
+  switch (fields.size()) {
+    case 0:
+      return "";
+    case 1:
+      return fields[0];
+    default:
+      string result = "(" + fields[0];
+      for (size_t i = 1; i < fields.size(); i++) {
+        result += ", ";
+        result += fields[i];
+      }
+      result += ")";
+      return result;
+  }
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ string FormatMatcherDescription(bool negation,
+                                           const char* matcher_name,
+                                           const Strings& param_values) {
+  string result = ConvertIdentifierNameToWords(matcher_name);
+  if (param_values.size() >= 1)
+    result += " " + JoinAsTuple(param_values);
+  return negation ? "not (" + result + ")" : result;
+}
+
+// FindMaxBipartiteMatching and its helper class.
+//
+// Uses the well-known Ford-Fulkerson max flow method to find a maximum
+// bipartite matching. Flow is considered to be from left to right.
+// There is an implicit source node that is connected to all of the left
+// nodes, and an implicit sink node that is connected to all of the
+// right nodes. All edges have unit capacity.
+//
+// Neither the flow graph nor the residual flow graph are represented
+// explicitly. Instead, they are implied by the information in 'graph' and
+// a vector<int> called 'left_' whose elements are initialized to the
+// value kUnused. This represents the initial state of the algorithm,
+// where the flow graph is empty, and the residual flow graph has the
+// following edges:
+//   - An edge from source to each left_ node
+//   - An edge from each right_ node to sink
+//   - An edge from each left_ node to each right_ node, if the
+//     corresponding edge exists in 'graph'.
+//
+// When the TryAugment() method adds a flow, it sets left_[l] = r for some
+// nodes l and r. This induces the following changes:
+//   - The edges (source, l), (l, r), and (r, sink) are added to the
+//     flow graph.
+//   - The same three edges are removed from the residual flow graph.
+//   - The reverse edges (l, source), (r, l), and (sink, r) are added
+//     to the residual flow graph, which is a directional graph
+//     representing unused flow capacity.
+//
+// When the method augments a flow (moving left_[l] from some r1 to some
+// other r2), this can be thought of as "undoing" the above steps with
+// respect to r1 and "redoing" them with respect to r2.
+//
+// It bears repeating that the flow graph and residual flow graph are
+// never represented explicitly, but can be derived by looking at the
+// information in 'graph' and in left_.
+//
+// As an optimization, there is a second vector<int> called right_ which
+// does not provide any new information. Instead, it enables more
+// efficient queries about edges entering or leaving the right-side nodes
+// of the flow or residual flow graphs. The following invariants are
+// maintained:
+//
+// left[l] == kUnused or right[left[l]] == l
+// right[r] == kUnused or left[right[r]] == r
+//
+// . [ source ]                                        .
+// .   |||                                             .
+// .   |||                                             .
+// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
+// .   ||                   |                    |     .
+// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
+// .   |                                        ||     .
+// .   \----> left[2]=2  ------> right[2]=2  --\||     .
+// .                                           |||     .
+// .         elements           matchers       vvv     .
+// .                                         [ sink ]  .
+//
+// See Also:
+//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
+//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
+//   [2] "Ford-Fulkerson algorithm", Wikipedia,
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+class MaxBipartiteMatchState {
+ public:
+  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
+      : graph_(&graph),
+        left_(graph_->LhsSize(), kUnused),
+        right_(graph_->RhsSize(), kUnused) {
+  }
+
+  // Returns the edges of a maximal match, each in the form {left, right}.
+  ElementMatcherPairs Compute() {
+    // 'seen' is used for path finding { 0: unseen, 1: seen }.
+    ::std::vector<char> seen;
+    // Searches the residual flow graph for a path from each left node to
+    // the sink in the residual flow graph, and if one is found, add flow
+    // to the graph. It's okay to search through the left nodes once. The
+    // edge from the implicit source node to each previously-visited left
+    // node will have flow if that left node has any path to the sink
+    // whatsoever. Subsequent augmentations can only add flow to the
+    // network, and cannot take away that previous flow unit from the source.
+    // Since the source-to-left edge can only carry one flow unit (or,
+    // each element can be matched to only one matcher), there is no need
+    // to visit the left nodes more than once looking for augmented paths.
+    // The flow is known to be possible or impossible by looking at the
+    // node once.
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      // Reset the path-marking vector and try to find a path from
+      // source to sink starting at the left_[ilhs] node.
+      GTEST_CHECK_(left_[ilhs] == kUnused)
+          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
+      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
+      seen.assign(graph_->RhsSize(), 0);
+      TryAugment(ilhs, &seen);
+    }
+    ElementMatcherPairs result;
+    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
+      size_t irhs = left_[ilhs];
+      if (irhs == kUnused) continue;
+      result.push_back(ElementMatcherPair(ilhs, irhs));
+    }
+    return result;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  // Perform a depth-first search from left node ilhs to the sink.  If a
+  // path is found, flow is added to the network by linking the left and
+  // right vector elements corresponding each segment of the path.
+  // Returns true if a path to sink was found, which means that a unit of
+  // flow was added to the network. The 'seen' vector elements correspond
+  // to right nodes and are marked to eliminate cycles from the search.
+  //
+  // Left nodes will only be explored at most once because they
+  // are accessible from at most one right node in the residual flow
+  // graph.
+  //
+  // Note that left_[ilhs] is the only element of left_ that TryAugment will
+  // potentially transition from kUnused to another value. Any other
+  // left_ element holding kUnused before TryAugment will be holding it
+  // when TryAugment returns.
+  //
+  bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
+    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
+      if ((*seen)[irhs])
+        continue;
+      if (!graph_->HasEdge(ilhs, irhs))
+        continue;
+      // There's an available edge from ilhs to irhs.
+      (*seen)[irhs] = 1;
+      // Next a search is performed to determine whether
+      // this edge is a dead end or leads to the sink.
+      //
+      // right_[irhs] == kUnused means that there is residual flow from
+      // right node irhs to the sink, so we can use that to finish this
+      // flow path and return success.
+      //
+      // Otherwise there is residual flow to some ilhs. We push flow
+      // along that path and call ourselves recursively to see if this
+      // ultimately leads to sink.
+      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
+        // Add flow from left_[ilhs] to right_[irhs].
+        left_[ilhs] = irhs;
+        right_[irhs] = ilhs;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const MatchMatrix* graph_;  // not owned
+  // Each element of the left_ vector represents a left hand side node
+  // (i.e. an element) and each element of right_ is a right hand side
+  // node (i.e. a matcher). The values in the left_ vector indicate
+  // outflow from that node to a node on the the right_ side. The values
+  // in the right_ indicate inflow, and specify which left_ node is
+  // feeding that right_ node, if any. For example, left_[3] == 1 means
+  // there's a flow from element #3 to matcher #1. Such a flow would also
+  // be redundantly represented in the right_ vector as right_[1] == 3.
+  // Elements of left_ and right_ are either kUnused or mutually
+  // referent. Mutually referent means that left_[right_[i]] = i and
+  // right_[left_[i]] = i.
+  ::std::vector<size_t> left_;
+  ::std::vector<size_t> right_;
+
+  GTEST_DISALLOW_ASSIGN_(MaxBipartiteMatchState);
+};
+
+const size_t MaxBipartiteMatchState::kUnused;
+
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g) {
+  return MaxBipartiteMatchState(g).Compute();
+}
+
+static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
+                                     ::std::ostream* stream) {
+  typedef ElementMatcherPairs::const_iterator Iter;
+  ::std::ostream& os = *stream;
+  os << "{";
+  const char *sep = "";
+  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
+    sep = ",";
+  }
+  os << "\n}";
+}
+
+// Tries to find a pairing, and explains the result.
+GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
+                            MatchResultListener* listener) {
+  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
+
+  size_t max_flow = matches.size();
+  bool result = (max_flow == matrix.RhsSize());
+
+  if (!result) {
+    if (listener->IsInterested()) {
+      *listener << "where no permutation of the elements can "
+                   "satisfy all matchers, and the closest match is "
+                << max_flow << " of " << matrix.RhsSize()
+                << " matchers with the pairings:\n";
+      LogElementMatcherPairVec(matches, listener->stream());
+    }
+    return false;
+  }
+
+  if (matches.size() > 1) {
+    if (listener->IsInterested()) {
+      const char *sep = "where:\n";
+      for (size_t mi = 0; mi < matches.size(); ++mi) {
+        *listener << sep << " - element #" << matches[mi].first
+                  << " is matched by matcher #" << matches[mi].second;
+        sep = ",\n";
+      }
+    }
+  }
+  return true;
+}
+
+bool MatchMatrix::NextGraph() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      if (!b) {
+        b = 1;
+        return true;
+      }
+      b = 0;
+    }
+  }
+  return false;
+}
+
+void MatchMatrix::Randomize() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      b = static_cast<char>(rand() & 1);  // NOLINT
+    }
+  }
+}
+
+string MatchMatrix::DebugString() const {
+  ::std::stringstream ss;
+  const char *sep = "";
+  for (size_t i = 0; i < LhsSize(); ++i) {
+    ss << sep;
+    for (size_t j = 0; j < RhsSize(); ++j) {
+      ss << HasEdge(i, j);
+    }
+    sep = ";";
+  }
+  return ss.str();
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
+    ::std::ostream* os) const {
+  if (matcher_describers_.empty()) {
+    *os << "is empty";
+    return;
+  }
+  if (matcher_describers_.size() == 1) {
+    *os << "has " << Elements(1) << " and that element ";
+    matcher_describers_[0]->DescribeTo(os);
+    return;
+  }
+  *os << "has " << Elements(matcher_describers_.size())
+      << " and there exists some permutation of elements such that:\n";
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep << " - element #" << i << " ";
+    matcher_describers_[i]->DescribeTo(os);
+    sep = ", and\n";
+  }
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
+    ::std::ostream* os) const {
+  if (matcher_describers_.empty()) {
+    *os << "isn't empty";
+    return;
+  }
+  if (matcher_describers_.size() == 1) {
+    *os << "doesn't have " << Elements(1)
+        << ", or has " << Elements(1) << " that ";
+    matcher_describers_[0]->DescribeNegationTo(os);
+    return;
+  }
+  *os << "doesn't have " << Elements(matcher_describers_.size())
+      << ", or there exists no permutation of elements such that:\n";
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep << " - element #" << i << " ";
+    matcher_describers_[i]->DescribeTo(os);
+    sep = ", and\n";
+  }
+}
+
+// Checks that all matchers match at least one element, and that all
+// elements match at least one matcher. This enables faster matching
+// and better error reporting.
+// Returns false, writing an explanation to 'listener', if and only
+// if the success criteria are not met.
+bool UnorderedElementsAreMatcherImplBase::
+VerifyAllElementsAndMatchersAreMatched(
+    const ::std::vector<string>& element_printouts,
+    const MatchMatrix& matrix,
+    MatchResultListener* listener) const {
+  bool result = true;
+  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
+  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
+
+  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
+    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
+      char matched = matrix.HasEdge(ilhs, irhs);
+      element_matched[ilhs] |= matched;
+      matcher_matched[irhs] |= matched;
+    }
+  }
+
+  {
+    const char* sep =
+        "where the following matchers don't match any elements:\n";
+    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
+      if (matcher_matched[mi])
+        continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << sep << "matcher #" << mi << ": ";
+        matcher_describers_[mi]->DescribeTo(listener->stream());
+        sep = ",\n";
+      }
+    }
+  }
+
+  {
+    const char* sep =
+        "where the following elements don't match any matchers:\n";
+    const char* outer_sep = "";
+    if (!result) {
+      outer_sep = "\nand ";
+    }
+    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
+      if (element_matched[ei])
+        continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << outer_sep << sep << "element #" << ei << ": "
+                  << element_printouts[ei];
+        sep = ",\n";
+        outer_sep = "";
+      }
+    }
+  }
+  return result;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the spec builder syntax (ON_CALL and
+// EXPECT_CALL).
+
+
+#include <stdlib.h>
+#include <iostream>  // NOLINT
+#include <map>
+#include <set>
+#include <string>
+
+#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
+# include <unistd.h>  // NOLINT
+#endif
+
+namespace testing {
+namespace internal {
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const string& message) {
+  ::std::ostringstream s;
+  s << file << ":" << line << ": " << message << ::std::endl;
+  Log(severity, s.str(), 0);
+}
+
+// Constructs an ExpectationBase object.
+ExpectationBase::ExpectationBase(const char* a_file,
+                                 int a_line,
+                                 const string& a_source_text)
+    : file_(a_file),
+      line_(a_line),
+      source_text_(a_source_text),
+      cardinality_specified_(false),
+      cardinality_(Exactly(1)),
+      call_count_(0),
+      retired_(false),
+      extra_matcher_specified_(false),
+      repeated_action_specified_(false),
+      retires_on_saturation_(false),
+      last_clause_(kNone),
+      action_count_checked_(false) {}
+
+// Destructs an ExpectationBase object.
+ExpectationBase::~ExpectationBase() {}
+
+// Explicitly specifies the cardinality of this expectation.  Used by
+// the subclasses to implement the .Times() clause.
+void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
+  cardinality_specified_ = true;
+  cardinality_ = a_cardinality;
+}
+
+// Retires all pre-requisites of this expectation.
+void ExpectationBase::RetireAllPreRequisites()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  if (is_retired()) {
+    // We can take this short-cut as we never retire an expectation
+    // until we have retired all its pre-requisites.
+    return;
+  }
+
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    ExpectationBase* const prerequisite = it->expectation_base().get();
+    if (!prerequisite->is_retired()) {
+      prerequisite->RetireAllPreRequisites();
+      prerequisite->Retire();
+    }
+  }
+}
+
+// Returns true iff all pre-requisites of this expectation have been
+// satisfied.
+bool ExpectationBase::AllPrerequisitesAreSatisfied() const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    if (!(it->expectation_base()->IsSatisfied()) ||
+        !(it->expectation_base()->AllPrerequisitesAreSatisfied()))
+      return false;
+  }
+  return true;
+}
+
+// Adds unsatisfied pre-requisites of this expectation to 'result'.
+void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    if (it->expectation_base()->IsSatisfied()) {
+      // If *it is satisfied and has a call count of 0, some of its
+      // pre-requisites may not be satisfied yet.
+      if (it->expectation_base()->call_count_ == 0) {
+        it->expectation_base()->FindUnsatisfiedPrerequisites(result);
+      }
+    } else {
+      // Now that we know *it is unsatisfied, we are not so interested
+      // in whether its pre-requisites are satisfied.  Therefore we
+      // don't recursively call FindUnsatisfiedPrerequisites() here.
+      *result += *it;
+    }
+  }
+}
+
+// Describes how many times a function call matching this
+// expectation has occurred.
+void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+
+  // Describes how many times the function is expected to be called.
+  *os << "         Expected: to be ";
+  cardinality().DescribeTo(os);
+  *os << "\n           Actual: ";
+  Cardinality::DescribeActualCallCountTo(call_count(), os);
+
+  // Describes the state of the expectation (e.g. is it satisfied?
+  // is it active?).
+  *os << " - " << (IsOverSaturated() ? "over-saturated" :
+                   IsSaturated() ? "saturated" :
+                   IsSatisfied() ? "satisfied" : "unsatisfied")
+      << " and "
+      << (is_retired() ? "retired" : "active");
+}
+
+// Checks the action count (i.e. the number of WillOnce() and
+// WillRepeatedly() clauses) against the cardinality if this hasn't
+// been done before.  Prints a warning if there are too many or too
+// few actions.
+void ExpectationBase::CheckActionCountIfNotDone() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  bool should_check = false;
+  {
+    MutexLock l(&mutex_);
+    if (!action_count_checked_) {
+      action_count_checked_ = true;
+      should_check = true;
+    }
+  }
+
+  if (should_check) {
+    if (!cardinality_specified_) {
+      // The cardinality was inferred - no need to check the action
+      // count against it.
+      return;
+    }
+
+    // The cardinality was explicitly specified.
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    const int upper_bound = cardinality().ConservativeUpperBound();
+    const int lower_bound = cardinality().ConservativeLowerBound();
+    bool too_many;  // True if there are too many actions, or false
+    // if there are too few.
+    if (action_count > upper_bound ||
+        (action_count == upper_bound && repeated_action_specified_)) {
+      too_many = true;
+    } else if (0 < action_count && action_count < lower_bound &&
+               !repeated_action_specified_) {
+      too_many = false;
+    } else {
+      return;
+    }
+
+    ::std::stringstream ss;
+    DescribeLocationTo(&ss);
+    ss << "Too " << (too_many ? "many" : "few")
+       << " actions specified in " << source_text() << "...\n"
+       << "Expected to be ";
+    cardinality().DescribeTo(&ss);
+    ss << ", but has " << (too_many ? "" : "only ")
+       << action_count << " WillOnce()"
+       << (action_count == 1 ? "" : "s");
+    if (repeated_action_specified_) {
+      ss << " and a WillRepeatedly()";
+    }
+    ss << ".";
+    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
+  }
+}
+
+// Implements the .Times() clause.
+void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
+  if (last_clause_ == kTimes) {
+    ExpectSpecProperty(false,
+                       ".Times() cannot appear "
+                       "more than once in an EXPECT_CALL().");
+  } else {
+    ExpectSpecProperty(last_clause_ < kTimes,
+                       ".Times() cannot appear after "
+                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
+                       "or .RetiresOnSaturation().");
+  }
+  last_clause_ = kTimes;
+
+  SpecifyCardinality(a_cardinality);
+}
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const string& msg) {
+  // Include a stack trace only if --gmock_verbose=info is specified.
+  const int stack_frames_to_skip =
+      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
+  switch (reaction) {
+    case kAllow:
+      Log(kInfo, msg, stack_frames_to_skip);
+      break;
+    case kWarn:
+      Log(kWarning,
+          msg +
+          "\nNOTE: You can safely ignore the above warning unless this "
+          "call should not happen.  Do not suppress it by blindly adding "
+          "an EXPECT_CALL() if you don't mean to enforce the call.  "
+          "See http://code.google.com/p/googlemock/wiki/CookBook#"
+          "Knowing_When_to_Expect for details.\n",
+          stack_frames_to_skip);
+      break;
+    default:  // FAIL
+      Expect(false, NULL, -1, msg);
+  }
+}
+
+UntypedFunctionMockerBase::UntypedFunctionMockerBase()
+    : mock_obj_(NULL), name_("") {}
+
+UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
+
+// Sets the mock object this mock method belongs to, and registers
+// this information in the global mock registry.  Will be called
+// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+// method.
+void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  {
+    MutexLock l(&g_gmock_mutex);
+    mock_obj_ = mock_obj;
+  }
+  Mock::Register(mock_obj, this);
+}
+
+// Sets the mock object this mock method belongs to, and sets the name
+// of the mock function.  Will be called upon each invocation of this
+// mock function.
+void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
+                                                const char* name)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // We protect name_ under g_gmock_mutex in case this mock function
+  // is called from two threads concurrently.
+  MutexLock l(&g_gmock_mutex);
+  mock_obj_ = mock_obj;
+  name_ = name;
+}
+
+// Returns the name of the function being mocked.  Must be called
+// after RegisterOwner() or SetOwnerAndName() has been called.
+const void* UntypedFunctionMockerBase::MockObject() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const void* mock_obj;
+  {
+    // We protect mock_obj_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(mock_obj_ != NULL, __FILE__, __LINE__,
+           "MockObject() must not be called before RegisterOwner() or "
+           "SetOwnerAndName() has been called.");
+    mock_obj = mock_obj_;
+  }
+  return mock_obj;
+}
+
+// Returns the name of this mock method.  Must be called after
+// SetOwnerAndName() has been called.
+const char* UntypedFunctionMockerBase::Name() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const char* name;
+  {
+    // We protect name_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(name_ != NULL, __FILE__, __LINE__,
+           "Name() must not be called before SetOwnerAndName() has "
+           "been called.");
+    name = name_;
+  }
+  return name;
+}
+
+// Calculates the result of invoking this mock function with the given
+// arguments, prints it, and returns it.  The caller is responsible
+// for deleting the result.
+UntypedActionResultHolderBase*
+UntypedFunctionMockerBase::UntypedInvokeWith(const void* const untyped_args)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  if (untyped_expectations_.size() == 0) {
+    // No expectation is set on this mock method - we have an
+    // uninteresting call.
+
+    // We must get Google Mock's reaction on uninteresting calls
+    // made on this mock object BEFORE performing the action,
+    // because the action may DELETE the mock object and make the
+    // following expression meaningless.
+    const CallReaction reaction =
+        Mock::GetReactionOnUninterestingCalls(MockObject());
+
+    // True iff we need to print this call's arguments and return
+    // value.  This definition must be kept in sync with
+    // the behavior of ReportUninterestingCall().
+    const bool need_to_report_uninteresting_call =
+        // If the user allows this uninteresting call, we print it
+        // only when he wants informational messages.
+        reaction == kAllow ? LogIsVisible(kInfo) :
+        // If the user wants this to be a warning, we print it only
+        // when he wants to see warnings.
+        reaction == kWarn ? LogIsVisible(kWarning) :
+        // Otherwise, the user wants this to be an error, and we
+        // should always print detailed information in the error.
+        true;
+
+    if (!need_to_report_uninteresting_call) {
+      // Perform the action without printing the call information.
+      return this->UntypedPerformDefaultAction(untyped_args, "");
+    }
+
+    // Warns about the uninteresting call.
+    ::std::stringstream ss;
+    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
+
+    // Calculates the function result.
+    UntypedActionResultHolderBase* const result =
+        this->UntypedPerformDefaultAction(untyped_args, ss.str());
+
+    // Prints the function result.
+    if (result != NULL)
+      result->PrintAsActionResult(&ss);
+
+    ReportUninterestingCall(reaction, ss.str());
+    return result;
+  }
+
+  bool is_excessive = false;
+  ::std::stringstream ss;
+  ::std::stringstream why;
+  ::std::stringstream loc;
+  const void* untyped_action = NULL;
+
+  // The UntypedFindMatchingExpectation() function acquires and
+  // releases g_gmock_mutex.
+  const ExpectationBase* const untyped_expectation =
+      this->UntypedFindMatchingExpectation(
+          untyped_args, &untyped_action, &is_excessive,
+          &ss, &why);
+  const bool found = untyped_expectation != NULL;
+
+  // True iff we need to print the call's arguments and return value.
+  // This definition must be kept in sync with the uses of Expect()
+  // and Log() in this function.
+  const bool need_to_report_call =
+      !found || is_excessive || LogIsVisible(kInfo);
+  if (!need_to_report_call) {
+    // Perform the action without printing the call information.
+    return
+        untyped_action == NULL ?
+        this->UntypedPerformDefaultAction(untyped_args, "") :
+        this->UntypedPerformAction(untyped_action, untyped_args);
+  }
+
+  ss << "    Function call: " << Name();
+  this->UntypedPrintArgs(untyped_args, &ss);
+
+  // In case the action deletes a piece of the expectation, we
+  // generate the message beforehand.
+  if (found && !is_excessive) {
+    untyped_expectation->DescribeLocationTo(&loc);
+  }
+
+  UntypedActionResultHolderBase* const result =
+      untyped_action == NULL ?
+      this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
+      this->UntypedPerformAction(untyped_action, untyped_args);
+  if (result != NULL)
+    result->PrintAsActionResult(&ss);
+  ss << "\n" << why.str();
+
+  if (!found) {
+    // No expectation matches this call - reports a failure.
+    Expect(false, NULL, -1, ss.str());
+  } else if (is_excessive) {
+    // We had an upper-bound violation and the failure message is in ss.
+    Expect(false, untyped_expectation->file(),
+           untyped_expectation->line(), ss.str());
+  } else {
+    // We had an expected call and the matching expectation is
+    // described in ss.
+    Log(kInfo, loc.str() + ss.str(), 2);
+  }
+
+  return result;
+}
+
+// Returns an Expectation object that references and co-owns exp,
+// which must be an expectation on this mock function.
+Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    if (it->get() == exp) {
+      return Expectation(*it);
+    }
+  }
+
+  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
+  return Expectation();
+  // The above statement is just to make the code compile, and will
+  // never be executed.
+}
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures
+// and returns false if not.
+bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  bool expectations_met = true;
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    ExpectationBase* const untyped_expectation = it->get();
+    if (untyped_expectation->IsOverSaturated()) {
+      // There was an upper-bound violation.  Since the error was
+      // already reported when it occurred, there is no need to do
+      // anything here.
+      expectations_met = false;
+    } else if (!untyped_expectation->IsSatisfied()) {
+      expectations_met = false;
+      ::std::stringstream ss;
+      ss  << "Actual function call count doesn't match "
+          << untyped_expectation->source_text() << "...\n";
+      // No need to show the source file location of the expectation
+      // in the description, as the Expect() call that follows already
+      // takes care of it.
+      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
+      untyped_expectation->DescribeCallCountTo(&ss);
+      Expect(false, untyped_expectation->file(),
+             untyped_expectation->line(), ss.str());
+    }
+  }
+
+  // Deleting our expectations may trigger other mock objects to be deleted, for
+  // example if an action contains a reference counted smart pointer to that
+  // mock object, and that is the last reference. So if we delete our
+  // expectations within the context of the global mutex we may deadlock when
+  // this method is called again. Instead, make a copy of the set of
+  // expectations to delete, clear our set within the mutex, and then clear the
+  // copied set outside of it.
+  UntypedExpectations expectations_to_delete;
+  untyped_expectations_.swap(expectations_to_delete);
+
+  g_gmock_mutex.Unlock();
+  expectations_to_delete.clear();
+  g_gmock_mutex.Lock();
+
+  return expectations_met;
+}
+
+}  // namespace internal
+
+// Class Mock.
+
+namespace {
+
+typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
+
+// The current state of a mock object.  Such information is needed for
+// detecting leaked mock objects and explicitly verifying a mock's
+// expectations.
+struct MockObjectState {
+  MockObjectState()
+      : first_used_file(NULL), first_used_line(-1), leakable(false) {}
+
+  // Where in the source file an ON_CALL or EXPECT_CALL is first
+  // invoked on this mock object.
+  const char* first_used_file;
+  int first_used_line;
+  ::std::string first_used_test_case;
+  ::std::string first_used_test;
+  bool leakable;  // true iff it's OK to leak the object.
+  FunctionMockers function_mockers;  // All registered methods of the object.
+};
+
+// A global registry holding the state of all mock objects that are
+// alive.  A mock object is added to this registry the first time
+// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
+// is removed from the registry in the mock object's destructor.
+class MockObjectRegistry {
+ public:
+  // Maps a mock object (identified by its address) to its state.
+  typedef std::map<const void*, MockObjectState> StateMap;
+
+  // This destructor will be called when a program exits, after all
+  // tests in it have been run.  By then, there should be no mock
+  // object alive.  Therefore we report any living object as test
+  // failure, unless the user explicitly asked us to ignore it.
+  ~MockObjectRegistry() {
+    // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is
+    // a macro.
+
+    if (!GMOCK_FLAG(catch_leaked_mocks))
+      return;
+
+    int leaked_count = 0;
+    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
+         ++it) {
+      if (it->second.leakable)  // The user said it's fine to leak this object.
+        continue;
+
+      // TODO(wan@google.com): Print the type of the leaked object.
+      // This can help the user identify the leaked object.
+      std::cout << "\n";
+      const MockObjectState& state = it->second;
+      std::cout << internal::FormatFileLocation(state.first_used_file,
+                                                state.first_used_line);
+      std::cout << " ERROR: this mock object";
+      if (state.first_used_test != "") {
+        std::cout << " (used in test " << state.first_used_test_case << "."
+             << state.first_used_test << ")";
+      }
+      std::cout << " should be deleted but never is. Its address is @"
+           << it->first << ".";
+      leaked_count++;
+    }
+    if (leaked_count > 0) {
+      std::cout << "\nERROR: " << leaked_count
+           << " leaked mock " << (leaked_count == 1 ? "object" : "objects")
+           << " found at program exit.\n";
+      std::cout.flush();
+      ::std::cerr.flush();
+      // RUN_ALL_TESTS() has already returned when this destructor is
+      // called.  Therefore we cannot use the normal Google Test
+      // failure reporting mechanism.
+      _exit(1);  // We cannot call exit() as it is not reentrant and
+                 // may already have been called.
+    }
+  }
+
+  StateMap& states() { return states_; }
+
+ private:
+  StateMap states_;
+};
+
+// Protected by g_gmock_mutex.
+MockObjectRegistry g_mock_object_registry;
+
+// Maps a mock object to the reaction Google Mock should have when an
+// uninteresting method is called.  Protected by g_gmock_mutex.
+std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
+
+// Sets the reaction Google Mock should have when an uninteresting
+// method of the given mock object is called.
+void SetReactionOnUninterestingCalls(const void* mock_obj,
+                                     internal::CallReaction reaction)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction[mock_obj] = reaction;
+}
+
+}  // namespace
+
+// Tells Google Mock to allow uninteresting calls on the given mock
+// object.
+void Mock::AllowUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
+}
+
+// Tells Google Mock to warn the user about uninteresting calls on the
+// given mock object.
+void Mock::WarnUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
+}
+
+// Tells Google Mock to fail uninteresting calls on the given mock
+// object.
+void Mock::FailUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
+}
+
+// Tells Google Mock the given mock object is being destroyed and its
+// entry in the call-reaction table should be removed.
+void Mock::UnregisterCallReaction(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction.erase(mock_obj);
+}
+
+// Returns the reaction Google Mock will have on uninteresting calls
+// made on the given mock object.
+internal::CallReaction Mock::GetReactionOnUninterestingCalls(
+    const void* mock_obj)
+        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
+      internal::kDefault : g_uninteresting_call_reaction[mock_obj];
+}
+
+// Tells Google Mock to ignore mock_obj when checking for leaked mock
+// objects.
+void Mock::AllowLeak(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].leakable = true;
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectations(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies all expectations on the given mock object and clears its
+// default actions and expectations.  Returns true iff the
+// verification was successful.
+bool Mock::VerifyAndClear(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  ClearDefaultActionsLocked(mock_obj);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No EXPECT_CALL() was set on the given mock object.
+    return true;
+  }
+
+  // Verifies and clears the expectations on each mock method in the
+  // given mock object.
+  bool expectations_met = true;
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    if (!(*it)->VerifyAndClearExpectationsLocked()) {
+      expectations_met = false;
+    }
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by ClearDefaultActionsLocked().
+  return expectations_met;
+}
+
+// Registers a mock object and a mock method it owns.
+void Mock::Register(const void* mock_obj,
+                    internal::UntypedFunctionMockerBase* mocker)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
+}
+
+// Tells Google Mock where in the source code mock_obj is used in an
+// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+// information helps the user identify which object it is.
+void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
+                                           const char* file, int line)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
+  if (state.first_used_file == NULL) {
+    state.first_used_file = file;
+    state.first_used_line = line;
+    const TestInfo* const test_info =
+        UnitTest::GetInstance()->current_test_info();
+    if (test_info != NULL) {
+      // TODO(wan@google.com): record the test case name when the
+      // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
+      // TearDownTestCase().
+      state.first_used_test_case = test_info->test_case_name();
+      state.first_used_test = test_info->name();
+    }
+  }
+}
+
+// Unregisters a mock method; removes the owning mock object from the
+// registry when the last mock method associated with it has been
+// unregistered.  This is called only in the destructor of
+// FunctionMockerBase.
+void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  for (MockObjectRegistry::StateMap::iterator it =
+           g_mock_object_registry.states().begin();
+       it != g_mock_object_registry.states().end(); ++it) {
+    FunctionMockers& mockers = it->second.function_mockers;
+    if (mockers.erase(mocker) > 0) {
+      // mocker was in mockers and has been just removed.
+      if (mockers.empty()) {
+        g_mock_object_registry.states().erase(it);
+      }
+      return;
+    }
+  }
+}
+
+// Clears all ON_CALL()s set on the given mock object.
+void Mock::ClearDefaultActionsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No ON_CALL() was set on the given mock object.
+    return;
+  }
+
+  // Clears the default actions for each mock method in the given mock
+  // object.
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    (*it)->ClearDefaultActionsLocked();
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by VerifyAndClearExpectationsLocked().
+}
+
+Expectation::Expectation() {}
+
+Expectation::Expectation(
+    const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
+    : expectation_base_(an_expectation_base) {}
+
+Expectation::~Expectation() {}
+
+// Adds an expectation to a sequence.
+void Sequence::AddExpectation(const Expectation& expectation) const {
+  if (*last_expectation_ != expectation) {
+    if (last_expectation_->expectation_base() != NULL) {
+      expectation.expectation_base()->immediate_prerequisites_
+          += *last_expectation_;
+    }
+    *last_expectation_ = expectation;
+  }
+}
+
+// Creates the implicit sequence if there isn't one.
+InSequence::InSequence() {
+  if (internal::g_gmock_implicit_sequence.get() == NULL) {
+    internal::g_gmock_implicit_sequence.set(new Sequence);
+    sequence_created_ = true;
+  } else {
+    sequence_created_ = false;
+  }
+}
+
+// Deletes the implicit sequence if it was created by the constructor
+// of this object.
+InSequence::~InSequence() {
+  if (sequence_created_) {
+    delete internal::g_gmock_implicit_sequence.get();
+    internal::g_gmock_implicit_sequence.set(NULL);
+  }
+}
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+namespace testing {
+
+// TODO(wan@google.com): support using environment variables to
+// control the flag values, like what Google Test does.
+
+GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
+                   "true iff Google Mock should report leaked mock objects "
+                   "as failures.");
+
+GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
+                     "Controls how verbose Google Mock's output is."
+                     "  Valid values:\n"
+                     "  info    - prints all messages.\n"
+                     "  warning - prints warnings and errors.\n"
+                     "  error   - prints errors only.");
+
+namespace internal {
+
+// Parses a string as a command line flag.  The string should have the
+// format "--gmock_flag=value".  When def_optional is true, the
+// "=value" part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseGoogleMockFlagValue(const char* str,
+                                            const char* flag,
+                                            bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == NULL || flag == NULL) return NULL;
+
+  // The flag must start with "--gmock_".
+  const std::string flag_str = std::string("--gmock_") + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return NULL;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a Google Mock bool flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
+                                    bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for a Google Mock string flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+template <typename String>
+static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
+                                      String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// The internal implementation of InitGoogleMock().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleMockImpl(int* argc, CharType** argv) {
+  // Makes sure Google Test is initialized.  InitGoogleTest() is
+  // idempotent, so it's fine if the user has already called it.
+  InitGoogleTest(argc, argv);
+  if (*argc <= 0) return;
+
+  for (int i = 1; i != *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    // Do we see a Google Mock flag?
+    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
+                                &GMOCK_FLAG(catch_leaked_mocks)) ||
+        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
+      // Yes.  Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+}
+
+}  // namespace internal
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses a command line for the flags that
+// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
+// removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+}  // namespace testing
diff --git a/opensfm/src/third_party/gtest/gmock_main.cc b/opensfm/src/third_party/gtest/gmock_main.cc
new file mode 100644
index 000000000..9b2f64d41
--- /dev/null
+++ b/opensfm/src/third_party/gtest/gmock_main.cc
@@ -0,0 +1,68 @@
+// Copyright 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include <iostream>
+#include "gflags/gflags.h"
+#include "glog/logging.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+// NOTE(keir): This flag is normally part of gtest within Google but isn't in
+// the open source Google Test, since it is build-system dependent. However for
+// Ceres this is needed for our tests. Add the new flag here.
+DEFINE_string(test_srcdir, "", "The location of the source code.");
+
+// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
+// causes a link error when _tmain is defined in a static library and UNICODE
+// is enabled. For this reason instead of _tmain, main function is used on
+// Windows. See the following link to track the current status of this bug:
+// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464  // NOLINT
+#if GTEST_OS_WINDOWS_MOBILE
+# include <tchar.h>  // NOLINT
+
+int _tmain(int argc, TCHAR** argv) {
+#else
+int main(int argc, char** argv) {
+#endif  // GTEST_OS_WINDOWS_MOBILE
+  google::InitGoogleLogging(argv[0]);
+  // Since Google Mock depends on Google Test, InitGoogleMock() is
+  // also responsible for initializing Google Test.  Therefore there's
+  // no need for calling testing::InitGoogleTest() separately.
+  testing::InitGoogleMock(&argc, argv);
+  // On Windows, gtest passes additional non-gflags command line flags to
+  // death-tests, specifically --gtest_filter & --gtest_internal_run_death_test
+  // in order that these unknown (to gflags) flags do not invoke an error in
+  // gflags, InitGoogleTest() (called by InitGoogleMock()) must be called
+  // before ParseCommandLineFlags() to handle & remove them before gflags
+  // parses the remaining flags.
+  CERES_GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
+  return RUN_ALL_TESTS();
+}

From 44e031cdac26e3996103f06549e8afb4c3e68323 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Fri, 11 Apr 2025 01:35:33 -0700
Subject: [PATCH 116/235] Back out "fbcode/mapillary/opensfm/opensfm/src"

Summary:
Original commit changeset: f646c9390378

Original Phabricator Diff: D63971477

Reviewed By: bal-a

Differential Revision: D72844843

fbshipit-source-id: 857420c62e42d43f2ec85f0c2ae22d72de79f223
---
 opensfm/src/debug_c_extension.cc | 29 +++++++++++++++++++++++++++++
 opensfm/src/testing_main.cc      | 11 +++++++++++
 2 files changed, 40 insertions(+)
 create mode 100644 opensfm/src/debug_c_extension.cc
 create mode 100644 opensfm/src/testing_main.cc

diff --git a/opensfm/src/debug_c_extension.cc b/opensfm/src/debug_c_extension.cc
new file mode 100644
index 000000000..ba0138d57
--- /dev/null
+++ b/opensfm/src/debug_c_extension.cc
@@ -0,0 +1,29 @@
+// Tool to debug c extensions with a c debugger.
+//
+// How to use it:
+//
+//   1. Write a module in python that calls the extension you want to debug.
+//      Make sure the extension code is called at import time.
+//
+//   2. Build opensfm/cmake_build in Debug mode.
+//
+//   3. Tell the debugger to run
+//
+//        ./debug_c_extension module
+//
+//      where module is the name of the module that you wrote.
+
+#include <pybind11/embed.h>
+
+#include <iostream>
+namespace py = pybind11;
+
+int main(int argc, char *argv[]) {
+  py::scoped_interpreter guard{};
+
+  if (argc != 2) {
+    std::cout << "Usage: " << argv[0] << " module" << std::endl;
+  } else {
+    py::module sys = py::module::import(argv[1]);
+  }
+}
diff --git a/opensfm/src/testing_main.cc b/opensfm/src/testing_main.cc
new file mode 100644
index 000000000..c5bfdd004
--- /dev/null
+++ b/opensfm/src/testing_main.cc
@@ -0,0 +1,11 @@
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  google::InitGoogleLogging(argv[0]);
+
+  return RUN_ALL_TESTS();
+}

From a37c683393f28b14b21542cf779fa5b1bc39285d Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Fri, 11 Apr 2025 03:10:59 -0700
Subject: [PATCH 117/235] Back out
 "fbcode/mapillary/opensfm/opensfm/src/third_party/vlfeat/vl"

Summary:
Original commit changeset: bc3487af5506

Original Phabricator Diff: D63971206

Reviewed By: xeob

Differential Revision: D72844840

fbshipit-source-id: 3d9a3477afc8696dc74d626a4a67ae8c38454ed5
---
 opensfm/src/third_party/vlfeat/vl/aib.c       |  643 ++++
 opensfm/src/third_party/vlfeat/vl/aib.h       |  134 +
 opensfm/src/third_party/vlfeat/vl/array.c     |  206 +
 opensfm/src/third_party/vlfeat/vl/array.h     |  105 +
 opensfm/src/third_party/vlfeat/vl/covdet.c    | 3400 +++++++++++++++++
 opensfm/src/third_party/vlfeat/vl/covdet.h    |  263 ++
 opensfm/src/third_party/vlfeat/vl/dsift.c     |  775 ++++
 opensfm/src/third_party/vlfeat/vl/dsift.h     |  354 ++
 opensfm/src/third_party/vlfeat/vl/fisher.c    |  586 +++
 opensfm/src/third_party/vlfeat/vl/fisher.h    |   57 +
 opensfm/src/third_party/vlfeat/vl/float.h     |  116 +
 opensfm/src/third_party/vlfeat/vl/generic.c   | 1679 ++++++++
 opensfm/src/third_party/vlfeat/vl/generic.h   |  213 ++
 .../src/third_party/vlfeat/vl/getopt_long.c   |  326 ++
 .../src/third_party/vlfeat/vl/getopt_long.h   |   43 +
 opensfm/src/third_party/vlfeat/vl/gmm.c       | 1709 +++++++++
 opensfm/src/third_party/vlfeat/vl/gmm.h       |  149 +
 opensfm/src/third_party/vlfeat/vl/heap-def.h  |  464 +++
 opensfm/src/third_party/vlfeat/vl/hikmeans.c  |  371 ++
 opensfm/src/third_party/vlfeat/vl/hikmeans.h  |   80 +
 opensfm/src/third_party/vlfeat/vl/hog.c       | 1072 ++++++
 opensfm/src/third_party/vlfeat/vl/hog.h       |   89 +
 opensfm/src/third_party/vlfeat/vl/homkermap.c |  580 +++
 opensfm/src/third_party/vlfeat/vl/homkermap.h |   86 +
 opensfm/src/third_party/vlfeat/vl/host.c      |  586 +++
 opensfm/src/third_party/vlfeat/vl/host.h      |  662 ++++
 opensfm/src/third_party/vlfeat/vl/ikmeans.c   |  297 ++
 opensfm/src/third_party/vlfeat/vl/ikmeans.h   |   87 +
 opensfm/src/third_party/vlfeat/vl/imopv.c     | 1074 ++++++
 opensfm/src/third_party/vlfeat/vl/imopv.h     |  164 +
 .../src/third_party/vlfeat/vl/imopv_sse2.c    |  289 ++
 .../src/third_party/vlfeat/vl/imopv_sse2.h    |   54 +
 opensfm/src/third_party/vlfeat/vl/kdtree.c    | 1082 ++++++
 opensfm/src/third_party/vlfeat/vl/kdtree.h    |  185 +
 opensfm/src/third_party/vlfeat/vl/kmeans.c    | 2101 ++++++++++
 opensfm/src/third_party/vlfeat/vl/kmeans.h    |  435 +++
 opensfm/src/third_party/vlfeat/vl/lbp.c       |  347 ++
 opensfm/src/third_party/vlfeat/vl/lbp.h       |   44 +
 opensfm/src/third_party/vlfeat/vl/liop.c      |  641 ++++
 opensfm/src/third_party/vlfeat/vl/liop.h      |   78 +
 opensfm/src/third_party/vlfeat/vl/mathop.c    | 1032 +++++
 opensfm/src/third_party/vlfeat/vl/mathop.h    |  719 ++++
 .../src/third_party/vlfeat/vl/mathop_avx.c    |  275 ++
 .../src/third_party/vlfeat/vl/mathop_avx.h    |   61 +
 .../src/third_party/vlfeat/vl/mathop_sse2.c   |  564 +++
 .../src/third_party/vlfeat/vl/mathop_sse2.h   |   85 +
 opensfm/src/third_party/vlfeat/vl/mser.c      | 1001 +++++
 opensfm/src/third_party/vlfeat/vl/mser.h      |  424 ++
 opensfm/src/third_party/vlfeat/vl/pgm.c       |  542 +++
 opensfm/src/third_party/vlfeat/vl/pgm.h       |   73 +
 opensfm/src/third_party/vlfeat/vl/qsort-def.h |  200 +
 .../src/third_party/vlfeat/vl/quickshift.c    |  465 +++
 .../src/third_party/vlfeat/vl/quickshift.h    |  211 +
 opensfm/src/third_party/vlfeat/vl/random.c    |  266 ++
 opensfm/src/third_party/vlfeat/vl/random.h    |  162 +
 opensfm/src/third_party/vlfeat/vl/rodrigues.c |  329 ++
 opensfm/src/third_party/vlfeat/vl/rodrigues.h |   33 +
 .../src/third_party/vlfeat/vl/scalespace.c    |  821 ++++
 .../src/third_party/vlfeat/vl/scalespace.h    |   99 +
 .../src/third_party/vlfeat/vl/shuffle-def.h   |  101 +
 opensfm/src/third_party/vlfeat/vl/sift.c      | 2197 +++++++++++
 opensfm/src/third_party/vlfeat/vl/sift.h      |  418 ++
 opensfm/src/third_party/vlfeat/vl/slic.c      |  411 ++
 opensfm/src/third_party/vlfeat/vl/slic.h      |   30 +
 opensfm/src/third_party/vlfeat/vl/stringop.c  |  462 +++
 opensfm/src/third_party/vlfeat/vl/stringop.h  |   58 +
 opensfm/src/third_party/vlfeat/vl/svm.c       | 2172 +++++++++++
 opensfm/src/third_party/vlfeat/vl/svm.h       |  195 +
 .../src/third_party/vlfeat/vl/svmdataset.c    |  407 ++
 .../src/third_party/vlfeat/vl/svmdataset.h    |   82 +
 opensfm/src/third_party/vlfeat/vl/vlad.c      |  323 ++
 opensfm/src/third_party/vlfeat/vl/vlad.h      |   53 +
 72 files changed, 35897 insertions(+)
 create mode 100644 opensfm/src/third_party/vlfeat/vl/aib.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/aib.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/array.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/array.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/covdet.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/covdet.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/dsift.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/dsift.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/fisher.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/fisher.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/float.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/generic.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/generic.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/getopt_long.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/getopt_long.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/gmm.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/gmm.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/heap-def.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/hikmeans.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/hikmeans.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/hog.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/hog.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/homkermap.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/homkermap.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/host.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/host.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/ikmeans.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/ikmeans.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/imopv.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/imopv.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/kdtree.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/kdtree.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/kmeans.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/kmeans.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/lbp.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/lbp.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/liop.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/liop.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_avx.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_avx.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mser.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/mser.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/pgm.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/pgm.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/qsort-def.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/quickshift.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/quickshift.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/random.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/random.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/rodrigues.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/rodrigues.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/scalespace.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/scalespace.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/shuffle-def.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/sift.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/sift.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/slic.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/slic.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/stringop.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/stringop.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/svm.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/svm.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/svmdataset.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/svmdataset.h
 create mode 100644 opensfm/src/third_party/vlfeat/vl/vlad.c
 create mode 100644 opensfm/src/third_party/vlfeat/vl/vlad.h

diff --git a/opensfm/src/third_party/vlfeat/vl/aib.c b/opensfm/src/third_party/vlfeat/vl/aib.c
new file mode 100644
index 000000000..1c07b7084
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/aib.c
@@ -0,0 +1,643 @@
+/** @file aib.c
+ ** @brief AIB - Definition
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page aib Agglomerative Information Bottleneck (AIB)
+@author Brian Fulkerson
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref aib.h implemens the Agglomerative Information Bottleneck (AIB)
+algorithm as first described in @cite{slonim99agglomerative}.
+
+AIB takes a discrete valued feature @f$x@f$ and a label @f$c@f$ and
+gradually compresses @f$x@f$ by iteratively merging values which
+minimize the loss in mutual information @f$I(x,c)@f$.
+
+While the algorithm is equivalent to the one described in
+@cite{slonim99agglomerative}, it has some speedups that enable
+handling much larger datasets. Let <em>N</em> be the number of feature
+values and <em>C</em> the number of labels. The algorithm of
+@cite{slonim99agglomerative} is @f$O(N^2)@f$ in space and @f$O(C
+N^3)@f$ in time. This algorithm is @f$O(N)@f$ space and @f$O(C N^2)@f$
+time in common cases (@f$O(C N^3)@f$ in the worst case).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section aib-overview Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Given a discrete feature @f$x \in \mathcal{X} = \{x_1,\dots,x_N\}@f$
+and a category label @f$c = 1,\dots,C@f$ with joint probability
+@f$p(x,c)@f$, AIB computes a compressed feature @f$[x]_{ij}@f$ by
+merging two values @f$x_i@f$ and @f$x_j@f$.  Among all the pairs
+@f$ij@f$, AIB chooses the one that yields the smallest loss in the
+mutual information
+
+@f[
+   D_{ij} = I(x,c) - I([x]_{ij},c) =
+   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   +
+   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   -
+   \sum_c (p(x_i)+p(x_j)) \log \frac {p(x_i,c)+p(x_i,c)}{(p(x_i)+p(x_j))p(c)}
+@f]
+
+AIB iterates this procedure until the desired level of
+compression is achieved.
+
+@section aib-algorithm Algorithm details
+
+Computing @f$D_{ij}@f$ requires @f$O(C)@f$ operations. For example, in
+standard AIB we need to calculate
+
+@f[
+   D_{ij} = I(x,c) - I([x]_{ij},c) =
+   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   +
+   \sum_c p(x_i) \log \frac{p(x_i,c)}{p(x_i)p(c)}   -
+   \sum_c (p(x_i)+p(x_j)) \log \frac {p(x_i,c)+p(x_i,c)}{(p(x_i)+p(x_j))p(c)}
+@f]
+
+Thus in a basic implementation of AIB, finding the optimal pair
+@f$ij@f$ of feature values requires @f$O(CN^2)@f$ operations in
+total. In order to join all the @f$N@f$ values, we repeat this
+procedure @f$O(N)@f$ times, yielding @f$O(N^3 C)@f$ time and
+@f$O(1)@f$ space complexity (this does not account for the space need
+to store the input).
+
+The complexity can be improved by reusing computations. For instance,
+we can store the matrix @f$D = [ D_{ij} ]@f$ (which requires
+@f$O(N^2)@f$ space). Then, after joining @f$ij@f$, all of the matrix
+<em>D</em> except the rows and columns (the matrix is symmetric) of
+indexes <em>i</em> and <em>j</em> is unchanged. These two rows and
+columns are deleted and a new row and column, whose computation
+requires @f$O(NC)@f$ operations, are added for the merged value
+@f$x_{ij}@f$.  Finding the minimal element of the matrix still
+requires @f$O(N^2)@f$ operations, so the complexity of this algorithm
+is @f$O(N^2C + N^3)@f$ time and @f$O(N^2)@f$ space.
+
+We can obtain a much better expected complexity as follows. First,
+instead of storing the whole matrix <em>D</em>, we store the smallest
+element (index and value) of each row as @f$(q_i, D_i)@f$ (notice that
+this is also the best element of each column since <em>D</em> is
+symmetric). This requires @f$O(N)@f$ space and finding the minimal
+element of the matrix requires @f$O(N)@f$ operations.  After joining
+@f$ij@f$, we have to efficiently update this representation. This is
+done as follows:
+
+- The entries @f$(q_i,D_i)@f$ and @f$(q_j,D_j)@f$ are deleted.
+- A new entry @f$(q_{ij},D_{ij})@f$ for the joint value @f$x_{ij}@f$
+  is added. This requires @f$O(CN)@f$ operations.
+- We test which other entries @f$(q_{k},D_{k})@f$ need to
+  be updated. Recall that @f$(q_{k},D_{k})@f$ means that, before the
+  merge, the value
+  closest to @f$x_k@f$ was @f$x_{q_k}@f$ at a distance @f$D_k@f$. Then
+  - If @f$q_k \not = i@f$, @f$q_k \not = j@f$ and @f$D_{k,ij} \geq D_k@f$, then
+    @f$q_k@f$ is still the closest element and we do not do anything.
+  - If @f$q_k \not = i@f$, @f$q_k \not = j@f$ and @f$D_{k,ij} <
+    D_k@f$, then the closest element is @f$ij@f$ and we update the
+    entry in constant time.
+  - If @f$q_k = i@f$ or @f$q_k = j@f$, then we need to re-compute
+    the closest element in @f$O(CN)@f$ operations.
+
+This algorithm requires only @f$O(N)@f$ space and @f$O(\gamma(N) C
+N^2)@f$ time, where @f$\gamma(N)@f$ is the expected number of times we
+fall in the last case. In common cases one has @f$\gamma(N) \approx
+\mathrm{const.}@f$, so the time saving is significant.
+
+**/
+
+#include "aib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <float.h>
+#include <math.h>
+
+/* The maximum value which beta may take */
+#define BETA_MAX DBL_MAX
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Normalizes an array of probabilities to sum to 1
+ **
+ ** @param P        The array of probabilities
+ ** @param nelem    The number of elements in the array
+ **
+ ** @return Modifies P to contain values which sum to 1
+ **/
+
+void vl_aib_normalize_P (double * P, vl_uint nelem)
+{
+    vl_uint i;
+    double sum = 0;
+    for(i=0; i<nelem; i++)
+        sum += P[i];
+    for(i=0; i<nelem; i++)
+        P[i] /= sum;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Allocates and creates a list of nodes
+ **
+ ** @param nentries   The size of the list which will be created
+ **
+ ** @return an array containing elements 0...nentries
+ **/
+
+vl_uint *vl_aib_new_nodelist (vl_uint nentries)
+{
+    vl_uint * nodelist = vl_malloc(sizeof(vl_uint)*nentries);
+    vl_uint n;
+    for(n=0; n<nentries; n++)
+        nodelist[n] = n;
+
+    return nodelist;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Allocates and creates the marginal distribution Px
+ **
+ ** @param Pcx   A two-dimensional array of probabilities
+ ** @param nvalues The number of rows in Pcx
+ ** @param nlabels The number of columns in Pcx
+ **
+ ** @return an array of size @a nvalues which contains the marginal
+ **         distribution over the rows.
+ **/
+
+double * vl_aib_new_Px(double * Pcx, vl_uint nvalues, vl_uint nlabels)
+{
+    double * Px = vl_malloc(sizeof(double)*nvalues);
+    vl_uint r,c;
+    for(r=0; r<nvalues; r++)
+    {
+        double sum = 0;
+        for(c=0; c<nlabels; c++)
+            sum += Pcx[r*nlabels+c];
+        Px[r] = sum;
+    }
+    return Px;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Allocates and creates the marginal distribution Pc
+ **
+ ** @param Pcx      A two-dimensional array of probabilities
+ ** @param nvalues    The number of rows in Pcx
+ ** @param nlabels    The number of columns in Pcx
+ **
+ ** @return an array of size @a nlabels which contains the marginal distribution
+ **         over the columns
+ **/
+
+double * vl_aib_new_Pc(double * Pcx, vl_uint nvalues, vl_uint nlabels)
+{
+    double * Pc = vl_malloc(sizeof(double)*nlabels);
+    vl_uint r, c;
+    for(c=0; c<nlabels; c++)
+    {
+        double sum = 0;
+        for(r=0; r<nvalues; r++)
+            sum += Pcx[r*nlabels+c];
+        Pc[c] = sum;
+    }
+    return Pc;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Find the two nodes which have minimum beta.
+ **
+ ** @param aib      A pointer to the internal data structure
+ ** @param besti    The index of one member of the pair which has mininum beta
+ ** @param bestj    The index of the other member of the pair which
+ **                 minimizes beta
+ ** @param minbeta  The minimum beta value corresponding to (@a i, @a j)
+ **
+ ** Searches @a aib->beta to find the minimum value and fills @a minbeta and
+ ** @a besti and @a bestj with this information.
+ **/
+
+void vl_aib_min_beta
+(VlAIB * aib, vl_uint * besti, vl_uint * bestj, double * minbeta)
+{
+    vl_uint i;
+    *minbeta = aib->beta[0];
+    *besti   = 0;
+    *bestj   = aib->bidx[0];
+
+    for(i=0; i<aib->nentries; i++)
+    {
+        if(aib->beta[i] < *minbeta)
+        {
+            *minbeta = aib->beta[i];
+            *besti = i;
+            *bestj = aib->bidx[i];
+        }
+    }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Merges two nodes i,j in the internal datastructure
+ **
+ ** @param aib  A pointer to the internal data structure
+ ** @param i    The index of one member of the pair to merge
+ ** @param j    The index of the other member of the pair to merge
+ ** @param new  The index of the new node which corresponds to the union of
+ **             (@a i, @a j).
+ **
+ ** Nodes are merged by replacing the entry @a i with the union of @c
+ ** ij, moving the node stored in last position (called @c lastnode)
+ ** back to jth position and the entry at the end.
+ **
+ ** After the nodes have been merged, it updates which nodes should be
+ ** considered on the next iteration based on which beta values could
+ ** potentially change. The merged node will always be part of this
+ ** list.
+ **/
+
+void
+vl_aib_merge_nodes (VlAIB * aib, vl_uint i, vl_uint j, vl_uint new)
+{
+  vl_uint last_entry = aib->nentries - 1 ;
+  vl_uint c, n ;
+
+  /* clear the list of nodes to update */
+  aib->nwhich = 0;
+
+  /* make sure that i is smaller than j */
+  if(i > j) { vl_uint tmp = j; j = i; i = tmp; }
+
+  /* -----------------------------------------------------------------
+   *                    Merge entries i and j, storing the result in i
+   * -------------------------------------------------------------- */
+
+  aib-> Px   [i] += aib->Px[j] ;
+  aib-> beta [i]  = BETA_MAX ;
+  aib-> nodes[i]  = new ;
+
+  for (c = 0; c < aib->nlabels; c++)
+    aib-> Pcx [i*aib->nlabels + c] += aib-> Pcx [j*aib->nlabels + c] ;
+
+  /* -----------------------------------------------------------------
+   *                                              Move last entry to j
+   * -------------------------------------------------------------- */
+
+  aib-> Px    [j]  = aib-> Px    [last_entry];
+  aib-> beta  [j]  = aib-> beta  [last_entry];
+  aib-> bidx  [j]  = aib-> bidx  [last_entry];
+  aib-> nodes [j]  = aib-> nodes [last_entry];
+
+  for (c = 0 ;  c < aib->nlabels ; c++)
+    aib-> Pcx[j*aib->nlabels + c] = aib-> Pcx [last_entry*aib->nlabels + c] ;
+
+  /* delete last entry */
+  aib-> nentries -- ;
+
+  /* -----------------------------------------------------------------
+   *                                        Scan for entries to update
+   * -------------------------------------------------------------- */
+
+  /*
+   * After mergin entries i and j, we need to update all other entries
+   * that had one of these two as closest match. We also need to
+   * update the renewend entry i. This is added by the loop below
+   * since bidx [i] = j exactly because i was merged.
+   *
+   * Additionaly, since we moved the last entry back to the entry j,
+   * we need to adjust the valeus of bidx to reflect this.
+   */
+
+  for (n = 0 ; n < aib->nentries; n++) {
+    if(aib->bidx[n] == i || aib->bidx[n] == j) {
+        aib->bidx  [n] = 0;
+        aib->beta  [n] = BETA_MAX;
+        aib->which [aib->nwhich++] = n ;
+      }
+    else if(aib->bidx[n] == last_entry) {
+      aib->bidx[n] = j ;
+    }
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Updates @c aib->beta and @c aib->bidx according to @c aib->which
+ **
+ ** @param aib AIB data structure.
+ **
+ ** The function calculates @c beta[i] and @c bidx[i] for the nodes @c
+ ** i listed in @c aib->which.  @c beta[i] is the minimal variation of mutual
+ ** information (or other score) caused by merging entry @c i with another entry
+ ** and @c bidx[i] is the index of this best matching entry.
+ **
+ ** Notice that for each entry @c i that we need to update, a full
+ ** scan of all the other entries must be performed.
+ **/
+
+void
+vl_aib_update_beta (VlAIB * aib)
+{
+
+#define PLOGP(x) ((x)*log((x)))
+
+  vl_uint i;
+  double * Px  = aib->Px;
+  double * Pcx = aib->Pcx;
+  double * tmp = vl_malloc(sizeof(double)*aib->nentries);
+  vl_uint a, b, c ;
+
+  /*
+   * T1 = I(x,c) - I([x]_ij) = A + B - C
+   *
+   * A  = \sum_c p(xa,c)           \log ( p(xa,c)          /  p(xa)       )
+   * B  = \sum_c p(xb,c)           \log ( p(xb,c)          /  p(xb)       )
+   * C  = \sum_c (p(xa,c)+p(xb,c)) \log ((p(xa,c)+p(xb,c)) / (p(xa)+p(xb)))
+   *
+   * C  = C1 + C2
+   * C1 = \sum_c (p(xa,c)+p(xb,c)) \log (p(xa,c)+p(xb,c))
+   * C2 = - (p(xa)+p(xb) \log (p(xa)+p(xb))
+   */
+
+  /* precalculate A and B */
+  for (a = 0; a < aib->nentries; a++) {
+    tmp[a] = 0;
+    for (c = 0; c < aib->nlabels; c++) {
+        double Pac = Pcx [a*aib->nlabels + c] ;
+        if(Pac != 0) tmp[a] += Pac * log (Pac / Px[a]) ;
+    }
+  }
+
+  /* for each entry listed in which */
+  for (i = 0 ; i < aib->nwhich; i++) {
+    a = aib->which[i];
+
+    /* for each other entry */
+    for(b = 0 ; b < aib->nentries ; b++) {
+      double T1 = 0 ;
+
+      if (a == b || Px [a] == 0 || Px [b] == 0) continue ;
+
+
+      T1 = PLOGP ((Px[a] + Px[b])) ;                  /* - C2 */
+      T1 += tmp[a] + tmp[b] ;                         /* + A + B */
+
+      for (c = 0 ; c < aib->nlabels; ++ c) {
+        double Pac = Pcx [a*aib->nlabels + c] ;
+        double Pbc = Pcx [b*aib->nlabels + c] ;
+        if (Pac == 0 && Pbc == 0) continue;
+        T1 += - PLOGP ((Pac + Pbc)) ;                 /* - C1 */
+      }
+
+      /*
+       * Now we have beta(a,b). We check wether this is the best beta
+       * for entries a and b.
+       */
+      {
+        double beta = T1 ;
+
+        if (beta < aib->beta[a])
+          {
+            aib->beta[a] = beta;
+            aib->bidx[a] = b;
+          }
+        if (beta < aib->beta[b])
+          {
+            aib->beta[b] = beta;
+            aib->bidx[b] = a;
+          }
+      }
+    }
+  }
+  vl_free(tmp);
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Calculates the current information and entropy
+ **
+ ** @param aib      A pointer to the internal data structure
+ ** @param I        The current mutual information (out).
+ ** @param H        The current entropy (out).
+ **
+ ** Calculates the current mutual information and entropy of Pcx and sets
+ ** @a I and @a H to these new values.
+ **/
+void vl_aib_calculate_information(VlAIB * aib, double * I, double * H)
+{
+    vl_uint r, c;
+    *H = 0;
+    *I = 0;
+
+    /*
+     * H(x)   = - sum_x p(x)    \ log p(x)
+     * I(x,c) =   sum_xc p(x,c) \ log (p(x,c) / p(x)p(c))
+     */
+
+    /* for each entry */
+    for(r = 0 ; r< aib->nentries ; r++) {
+
+      if (aib->Px[r] == 0) continue ;
+      *H += -log(aib->Px[r]) * aib->Px[r] ;
+
+      for(c=0; c<aib->nlabels; c++) {
+        if (aib->Pcx[r*aib->nlabels+c] == 0) continue;
+        *I += aib->Pcx[r*aib->nlabels+c] *
+          log (aib->Pcx[r*aib->nlabels+c] / (aib->Px[r]*aib->Pc[c])) ;
+      }
+    }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Allocates and initializes the internal data structure
+ **
+ ** @param Pcx      A pointer to a 2D array of probabilities
+ ** @param nvalues    The number of rows in the array
+ ** @param nlabels    The number of columns in the array
+ **
+ ** Creates a new @a VlAIB struct containing pointers to all the data that
+ ** will be used during the AIB process.
+ **
+ ** Allocates memory for the following:
+ ** - Px (nvalues*sizeof(double))
+ ** - Pc (nlabels*sizeof(double))
+ ** - nodelist (nvalues*sizeof(vl_uint))
+ ** - which (nvalues*sizeof(vl_uint))
+ ** - beta (nvalues*sizeof(double))
+ ** - bidx (nvalues*sizeof(vl_uint))
+ ** - parents ((2*nvalues-1)*sizeof(vl_uint))
+ ** - costs (nvalues*sizeof(double))
+ **
+ ** Since it simply copies to pointer to Pcx, the total additional memory
+ ** requirement is:
+ **
+ ** (3*nvalues+nlabels)*sizeof(double) + 4*nvalues*sizeof(vl_uint)
+ **
+ ** @returns An allocated and initialized @a VlAIB pointer
+ **/
+VlAIB * vl_aib_new(double * Pcx, vl_uint nvalues, vl_uint nlabels)
+{
+    VlAIB * aib = vl_malloc(sizeof(VlAIB));
+    vl_uint i ;
+
+    aib->verbosity = 0 ;
+    aib->Pcx   = Pcx ;
+    aib->nvalues = nvalues ;
+    aib->nlabels = nlabels ;
+
+    vl_aib_normalize_P (aib->Pcx, aib->nvalues * aib->nlabels) ;
+
+    aib->Px = vl_aib_new_Px (aib->Pcx, aib->nvalues, aib->nlabels) ;
+    aib->Pc = vl_aib_new_Pc (aib->Pcx, aib->nvalues, aib->nlabels) ;
+
+    aib->nentries = aib->nvalues ;
+    aib->nodes    = vl_aib_new_nodelist(aib->nentries) ;
+    aib->beta     = vl_malloc(sizeof(double) * aib->nentries) ;
+    aib->bidx     = vl_malloc(sizeof(vl_uint)   * aib->nentries) ;
+
+    for(i = 0 ; i < aib->nentries ; i++)
+      aib->beta [i] = BETA_MAX ;
+
+    /* Initially we must consider all nodes */
+    aib->nwhich = aib->nvalues;
+    aib->which  = vl_aib_new_nodelist (aib->nwhich) ;
+
+    aib->parents = vl_malloc(sizeof(vl_uint)*(aib->nvalues*2-1));
+    /* Initially, all parents point to a nonexistent node */
+    for (i = 0 ; i < 2 * aib->nvalues - 1 ; i++)
+      aib->parents [i] = 2 * aib->nvalues ;
+
+    /* Allocate cost output vector */
+    aib->costs = vl_malloc (sizeof(double) * (aib->nvalues - 1 + 1)) ;
+
+
+    return aib ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Deletes AIB data structure
+ ** @param aib data structure to delete.
+ **/
+
+void
+vl_aib_delete (VlAIB * aib)
+{
+  if (aib) {
+    if (aib-> nodes)   vl_free (aib-> nodes);
+    if (aib-> beta)    vl_free (aib-> beta);
+    if (aib-> bidx)    vl_free (aib-> bidx);
+    if (aib-> which)   vl_free (aib-> which);
+    if (aib-> Px)      vl_free (aib-> Px);
+    if (aib-> Pc)      vl_free (aib-> Pc);
+    if (aib-> parents) vl_free (aib-> parents);
+    if (aib-> costs)   vl_free (aib-> costs);
+
+    vl_free (aib) ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Runs AIB on Pcx
+ **
+ ** @param aib     AIB object to process
+ **
+ ** The function runs Agglomerative Information Bottleneck (AIB) on
+ ** the joint probability table @a aib->Pcx which has labels along the
+ ** columns and feature values along the rows. AIB iteratively merges
+ ** the two values of the feature @c x that causes the smallest
+ ** decrease in mutual information between the random variables @c x
+ ** and @c c.
+ **
+ ** Merge operations are arranged in a binary tree. The nodes of the
+ ** tree correspond to the original feature values and any other value
+ ** obtained as a result of a merge operation. The nodes are indexed
+ ** in breadth-first order, starting from the leaves. The first index
+ ** is zero. In this way, the leaves correspond directly to the
+ ** original feature values.  In total there are @c 2*nvalues-1 nodes.
+ **
+ ** The results may be accessed through vl_aib_get_parents which
+ ** returns an array with one element per tree node. Each
+ ** element is the index the parent node. The root parent is equal to
+ ** zero. The array has @c 2*nvalues-1 elements.
+ **
+ ** Feature values with null probability are ignored by the algorithm
+ ** and their nodes have parents indexing a non-existent tree node (a
+ ** value bigger than @c 2*nvalues-1).
+ **
+ ** Then the function will also compute the information level after each
+ ** merge. vl_get_costs will return a vector with the information level
+ ** after each merge. @a
+ ** cost has @c nvalues entries: The first is the value of the cost
+ ** functional before any merge, and the others are the cost after the
+ ** @c nvalues-1 merges.
+ **
+ **/
+
+VL_EXPORT
+void vl_aib_process(VlAIB *aib)
+{
+    vl_uint i, besti, bestj, newnode, nodei, nodej;
+    double I, H;
+    double minbeta;
+
+    /* Calculate initial value of cost function */
+    vl_aib_calculate_information (aib, &I, &H) ;
+    aib->costs[0] = I;
+
+    /* Initially which = all */
+
+    /* For each merge */
+    for(i = 0 ; i < aib->nvalues - 1 ; i++) {
+
+      /* update entries in aib-> which */
+      vl_aib_update_beta(aib);
+
+      /* find best pair of nodes to merge */
+      vl_aib_min_beta (aib, &besti, &bestj, &minbeta);
+
+      if(minbeta == BETA_MAX)
+        /* only null-probability entries remain */
+        break;
+
+      /* Add the parent pointers for the new node */
+      newnode = aib->nvalues + i ;
+      nodei = aib->nodes[besti];
+      nodej = aib->nodes[bestj];
+
+      aib->parents [nodei] = newnode ;
+      aib->parents [nodej] = newnode ;
+      aib->parents [newnode] = 0 ;
+
+      /* Merge the nodes which produced the minimum beta */
+      vl_aib_merge_nodes (aib, besti, bestj, newnode) ;
+      vl_aib_calculate_information (aib, &I, &H) ;
+
+      aib->costs[i+1] = I;
+
+      if (aib->verbosity > 0) {
+        VL_PRINTF ("aib: (%5d,%5d)=%5d dE: %10.3g I: %6.4g H: %6.4g updt: %5d\n",
+                   nodei,
+                   nodej,
+                   newnode,
+                   minbeta,
+                   I,
+                   H,
+                   aib->nwhich) ;
+      }
+    }
+
+    /* fill ignored entries with NaNs */
+    for(; i < aib->nvalues - 1 ; i++)
+        aib->costs[i+1] = VL_NAN_D ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/aib.h b/opensfm/src/third_party/vlfeat/vl/aib.h
new file mode 100644
index 000000000..ab7d4be21
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/aib.h
@@ -0,0 +1,134 @@
+/** @file aib.h
+ ** @brief AIB (@ref aib)
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_AIB_H
+#define VL_AIB_H
+
+#include "generic.h"
+#include "mathop.h"
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief AIB algorithm data
+ **
+ ** The implementation is quite straightforward, but the way feature
+ ** values are handled in order to support efficient joins,
+ ** deletions and re-arrangement needs to be explained. This is
+ ** achieved by adding a layer of indirection:
+ ** - Call each feature value (either original or obtained by a join
+ **   operation) a <em>node</em>. Nodes are identified by numbers.
+ ** - Call each element of the various arrays (such as VlAIB::Px)
+ **    an <em>entry</em>.
+ ** - Entries are dynamically associated to nodes as specified by
+ **   VlAIB::nodes. For example, @c Px[i] refers to the node @c
+ **   nodes[i].
+ **/
+
+typedef struct _VlAIB
+{
+  vl_uint   *nodes ;    /**< Entires to nodes */
+  vl_uint    nentries ; /**< Total number of entries (= # active nodes) */
+  double    *beta ;     /**< Minimum distance to an entry  */
+  vl_uint   *bidx ;     /**< Closest entry */
+
+
+  vl_uint   *which ;    /**< List of entries to update */
+  vl_uint    nwhich ;   /**< Number of entries to update */
+
+  double    *Pcx;       /**< Joint probability table */
+  double    *Px;        /**< Marginal. */
+  double    *Pc;        /**< Marginal. */
+  vl_uint    nvalues;   /**< Number of feature values */
+  vl_uint    nlabels;   /**< Number of labels */
+
+  vl_uint   *parents;   /**< Array of parents */
+  double    *costs;     /**< Cost of each merge */
+
+  vl_uint verbosity ; /** Verbosity level */
+} VlAIB;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT
+VlAIB * vl_aib_new(double * Pcx, vl_uint nvalues, vl_uint nlabels);
+
+VL_EXPORT
+void vl_aib_delete (VlAIB * aib);
+/** @} */
+
+/** @name Process data
+ ** @{
+ **/
+VL_EXPORT
+void vl_aib_process(VlAIB * aib);
+/** @} */
+
+/** @name Retrieve results
+ ** @{
+ **/
+VL_INLINE vl_uint * vl_aib_get_parents(VlAIB const * aib);
+VL_INLINE double  * vl_aib_get_costs(VlAIB const * aib);
+/** @} */
+
+
+/* -------------------------------------------------------------------
+ *                                     Inline functions implementation
+ * ---------------------------------------------------------------- */
+
+/** ------------------------------------------------------------------
+ ** @brief Get resulting list of parents
+ ** @param aib AIB filter.
+ ** @return An array of parents
+ **/
+VL_INLINE
+vl_uint * vl_aib_get_parents(VlAIB const * aib)
+{
+  return aib->parents;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get a list of merge costs
+ ** @param aib AIB filter.
+ ** @return An array of costs
+ **/
+VL_INLINE
+double * vl_aib_get_costs(VlAIB const * aib)
+{
+  return aib->costs;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Set the verbosity
+ ** @param self AIB object.
+ ** @param verbosity a non-negative integer.
+ **/
+VL_INLINE void
+vl_aib_set_verbosity (VlAIB * self, int verbosity)
+{
+  self->verbosity = verbosity ;
+}
+
+/** @brief Get the verbosity
+ ** @param self AIB object.
+ ** @return the verbosity level.
+ **/
+VL_INLINE int
+vl_aib_get_verbosity (VlAIB const * self)
+{
+  return self->verbosity ;
+}
+
+/* VL_AIB_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/array.c b/opensfm/src/third_party/vlfeat/vl/array.c
new file mode 100644
index 000000000..a81b438ec
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/array.c
@@ -0,0 +1,206 @@
+/** @file array.h
+ ** @brief Array
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#include "array.h"
+#include <string.h>
+
+/** @brief Get number of elements in array
+ ** @param self array.
+ ** @return number of elements.
+ **/
+
+VL_EXPORT vl_size
+vl_array_get_num_elements (VlArray const * self)
+{
+  vl_size numElements = 1 ;
+  vl_uindex k ;
+  if (self->numDimensions == 0) {
+    return 0 ;
+  }
+  for (k = 0 ; k < self->numDimensions ; ++k) {
+    numElements *= self->dimensions[k] ;
+  }
+  return numElements ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                  init &  dealloc */
+/* ---------------------------------------------------------------- */
+
+/** @brief New numeric array
+ ** @param self array to initialize.
+ ** @param type data type.
+ ** @param numDimensions number of dimensions.
+ ** @param dimensions dimensions.
+ **
+ ** The function initializes the specified array and allocates
+ ** the necessary memory for storage.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_init (VlArray* self, vl_type type,
+               vl_size numDimensions, vl_size const * dimensions)
+{
+  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
+  self->type = type ;
+  self->numDimensions = numDimensions ;
+  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
+  self->data = vl_malloc(vl_get_type_size(type) * vl_array_get_num_elements (self)) ;
+  self->isEnvelope = VL_FALSE ;
+  self->isSparse = VL_FALSE ;
+  return self ;
+}
+
+/** @brief New numeric array envelope
+ ** @param self array to initialize.
+ ** @param data data to envelople.
+ ** @param type data type.
+ ** @param numDimensions number of dimensions.
+ ** @param dimensions dimensions.
+ **
+ ** The function initializes the specified array wrapping the
+ ** specified buffer.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_init_envelope (VlArray * self, void * data, vl_type type,
+                        vl_size numDimensions, vl_size const * dimensions)
+{
+  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
+  self->type = type ;
+  self->numDimensions = numDimensions ;
+  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
+  self->data = data ;
+  self->isEnvelope = VL_TRUE ;
+  self->isSparse = VL_FALSE ;
+  return self ;
+}
+
+/** @brief New numeric array with matrix shape
+ ** @param self array to initialize.
+ ** @param type type.
+ ** @param numRows number of rows.
+ ** @param numColumns number of columns.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_init_matrix (VlArray * self, vl_type type, vl_size numRows, vl_size numColumns)
+{
+  vl_size dimensions [2] = {numRows, numColumns} ;
+  return vl_array_init (self, type, 2, dimensions) ;
+}
+
+/** @brief New numeric array envelpe with matrix shape
+ ** @param self array to initialize.
+ ** @param data data to envelope.
+ ** @param type type.
+ ** @param numRows number of rows.
+ ** @param numColumns number of columns.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_init_matrix_envelope (VlArray * self, void * data,
+                                vl_type type, vl_size numRows, vl_size numColumns)
+{
+  vl_size dimensions [2] = {numRows, numColumns} ;
+  return vl_array_init_envelope (self, data, type, 2, dimensions) ;
+}
+
+/** @brief Delete array
+ ** @param self array.
+ **/
+
+VL_EXPORT void
+vl_array_dealloc (VlArray * self)
+{
+  if (! self->isEnvelope) {
+    if (self->data) {
+      vl_free(self->data) ;
+      self->data = NULL ;
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                    new &  delete */
+/* ---------------------------------------------------------------- */
+
+
+/** @brief New numeric array
+ ** @param type data type.
+ ** @param numDimensions number of dimensions.
+ ** @param dimensions dimensions.
+ **
+ ** The function creates a new VLArray instance and allocates
+ ** the necessary memory for storage.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_new (vl_type type, vl_size numDimensions, vl_size const * dimensions)
+{
+  VlArray * self = vl_malloc(sizeof(VlArray)) ;
+  return vl_array_init(self, type, numDimensions, dimensions) ;
+}
+
+/** @brief New numeric array with matrix shape
+ ** @param type type.
+ ** @param numRows number of rows.
+ ** @param numColumns number of columns.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_new_matrix (vl_type type, vl_size numRows, vl_size numColumns)
+{
+  vl_size dimensions [2] = {numRows, numColumns} ;
+  return vl_array_new (type, 2, dimensions) ;
+}
+
+/** @brief New numeric array envelope
+ ** @param data data to envelople.
+ ** @param type data type.
+ ** @param numDimensions number of dimensions.
+ ** @param dimensions dimensions.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_new_envelope (void * data, vl_type type,
+                       vl_size numDimensions, vl_size const * dimensions)
+{
+  VlArray * self = vl_malloc(sizeof(VlArray)) ;
+  return vl_array_init_envelope(self, data, type, numDimensions, dimensions) ;
+}
+
+/** @brief New numeric array envelpe with matrix shape
+ ** @param data data to envelope.
+ ** @param type type.
+ ** @param numRows number of rows.
+ ** @param numColumns number of columns.
+ **/
+
+VL_EXPORT VlArray *
+vl_array_new_matrix_envelope (void * data, vl_type type, vl_size numRows, vl_size numColumns)
+{
+  vl_size dimensions [2] = {numRows, numColumns} ;
+  return vl_array_new_envelope (data, type, 2, dimensions) ;
+}
+
+/** @brief Delete array
+ ** @param self array.
+ **/
+
+VL_EXPORT void
+vl_array_delete (VlArray * self)
+{
+  vl_array_dealloc(self) ;
+  vl_free(self) ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/array.h b/opensfm/src/third_party/vlfeat/vl/array.h
new file mode 100644
index 000000000..d29dc483b
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/array.h
@@ -0,0 +1,105 @@
+/** @file array.h
+ ** @brief Array - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_ARRAY_H
+#define VL_ARRAY_H
+
+#include "generic.h"
+
+/** @brief Maximum number of array dimensions */
+#define VL_ARRAY_MAX_NUM_DIMENSIONS 16
+
+/** @brief Numeric array */
+typedef struct _VlArray
+{
+  vl_type type ;
+  vl_bool isEnvelope ;
+  vl_bool isSparse ;
+  vl_size numDimensions ;
+  vl_size dimensions [VL_ARRAY_MAX_NUM_DIMENSIONS] ;
+  void * data ;
+  void * rowPointers ;
+  void * columnPointers ;
+} VlArray ;
+
+
+/** @name Get data and parameters
+ ** @{ */
+
+/** @brief Get number of dimensions
+ ** @param self array.
+ ** @return number of dimensions.
+ **/
+
+VL_INLINE vl_size
+vl_array_get_num_dimensions (VlArray const * self)
+{
+  return self->numDimensions ;
+}
+
+/** @brief Get dimensions
+ ** @param self array.
+ ** @return dimensions.
+ **/
+
+VL_INLINE vl_size const *
+vl_array_get_dimensions (VlArray const * self)
+{
+  return self->dimensions ;
+}
+
+/** @brief Get data
+ ** @param self array.
+ ** @return data.
+ **/
+
+VL_INLINE void *
+vl_array_get_data (VlArray const * self)
+{
+  return self->data;
+}
+
+/** @brief Get type
+ ** @param self array.
+ ** @return type.
+ **/
+
+VL_INLINE vl_type
+vl_array_get_data_type (VlArray const * self)
+{
+  return self->type ;
+}
+
+VL_EXPORT vl_size vl_array_get_num_elements (VlArray const * self) ;
+
+/** @{ */
+
+/** @name Constructing and destroying
+ ** @{ */
+
+VL_EXPORT VlArray * vl_array_init (VlArray * self, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
+VL_EXPORT VlArray * vl_array_init_envelope (VlArray *self, void * data, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
+VL_EXPORT VlArray * vl_array_init_matrix (VlArray * self, vl_type type, vl_size numRows, vl_size numColumns) ;
+VL_EXPORT VlArray * vl_array_init_matrix_envelope (VlArray * self, void * data, vl_type type, vl_size numRows, vl_size numColumns) ;
+
+VL_EXPORT VlArray * vl_array_new (vl_type type, vl_size numDimension, vl_size const * dimensions) ;
+VL_EXPORT VlArray * vl_array_new_envelope (void * data, vl_type type, vl_size numDimension, vl_size const * dimensions) ;
+VL_EXPORT VlArray * vl_array_new_matrix (vl_type type, vl_size numRows, vl_size numColumns) ;
+VL_EXPORT VlArray * vl_array_new_matrix_envelope (void * data, vl_type type, vl_size numRows, vl_size numColumns) ;
+
+VL_EXPORT void vl_array_dealloc (VlArray * self) ;
+VL_EXPORT void vl_array_delete (VlArray * self) ;
+/** @} */
+
+/* VL_ARRAY_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/covdet.c b/opensfm/src/third_party/vlfeat/vl/covdet.c
new file mode 100644
index 000000000..0b0592f0d
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/covdet.c
@@ -0,0 +1,3400 @@
+/** @file covdet.c
+ ** @brief Covariant feature detectors - Definition
+ ** @author Karel Lenc
+ ** @author Andrea Vedaldi
+ ** @author Michal Perdoch
+ **/
+
+/*
+Copyright (C) 2013-14 Andrea Vedaldi.
+Copyright (C) 2012 Karel Lenc, Andrea Vedaldi and Michal Perdoch.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page covdet Covariant feature detectors
+@author Karel Lenc
+@author Andrea Vedaldi
+@author Michal Perdoch
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref covdet.h implements a number of covariant feature detectors, based
+on three cornerness measures (determinant of the Hessian, trace of the Hessian
+(aka Difference of Gaussians, and Harris). It supprots affine adaptation,
+orientation estimation, as well as Laplacian scale detection.
+
+- @subpage covdet-fundamentals
+- @subpage covdet-principles
+- @subpage covdet-differential
+- @subpage covdet-corner-types
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The ::VlCovDet object implements a number of covariant feature
+detectors: Difference of Gaussian, Harris, determinant of Hessian.
+Variant of the basic detectors support scale selection by maximizing
+the Laplacian measure as well as affine normalization.
+
+@code
+// create a detector object
+VlCovDet * covdet = vl_covdet_new(method) ;
+
+// set various parameters (optional)
+vl_covdet_set_first_octave(covdet, -1) ; // start by doubling the image resolution
+vl_covdet_set_octave_resolution(covdet, octaveResolution) ;
+vl_covdet_set_peak_threshold(covdet, peakThreshold) ;
+vl_covdet_set_edge_threshold(covdet, edgeThreshold) ;
+
+// process the image and run the detector
+vl_covdet_put_image(covdet, image, numRows, numCols) ;
+vl_covdet_detect(covdet) ;
+
+// drop features on the margin (optional)
+vl_covdet_drop_features_outside (covdet, boundaryMargin) ;
+
+// compute the affine shape of the features (optional)
+vl_covdet_extract_affine_shape(covdet) ;
+
+// compute the orientation of the features (optional)
+vl_covdet_extract_orientations(covdet) ;
+
+// get feature frames back
+vl_size numFeatures = vl_covdet_get_num_features(covdet) ;
+VlCovDetFeature const * feature = vl_covdet_get_features(covdet) ;
+
+// get normalized feature appearance patches (optional)
+vl_size w = 2*patchResolution + 1 ;
+for (i = 0 ; i < numFeatures ; ++i) {
+  float * patch = malloc(w*w*sizeof(*desc)) ;
+  vl_covdet_extract_patch_for_frame(covdet,
+                                    patch,
+                                    patchResolution,
+                                    patchRelativeExtent,
+                                    patchRelativeSmoothing,
+                                    feature[i].frame) ;
+  // do something with patch
+}
+@endcode
+
+This example code:
+
+- Calls ::vl_covdet_new constructs a new detector object. @ref
+  covdet.h supports a variety of different detectors (see
+  ::VlCovDetMethod).
+- Optionally calls various functions to set the detector parameters if
+  needed (e.g. ::vl_covdet_set_peak_threshold).
+- Calls ::vl_covdet_put_image to start processing a new image. It
+  causes the detector to compute the scale space representation of the
+  image, but does not compute the features yet.
+- Calls ::vl_covdet_detect runs the detector. At this point features are
+  ready to be extracted. However, one or all of the following steps
+  may be executed in order to process the features further.
+- Optionally calls ::vl_covdet_drop_features_outside to drop features
+  outside the image boundary.
+- Optionally calls ::vl_covdet_extract_affine_shape to compute the
+  affine shape of features using affine adaptation.
+- Optionally calls ::vl_covdet_extract_orientations to compute the
+  dominant orientation of features looking for the dominant gradient
+  orientation in patches.
+- Optionally calls ::vl_covdet_extract_patch_for_frame to extract a
+  normalized feature patch, for example to compute an invariant
+  feature descriptor.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@page covdet-fundamentals Covariant detectors fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+This page describes the fundamental concepts required to understand a
+covariant feature detector, the geometry of covariant features, and
+the process of feature normalization.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section covdet-covariance Covariant detection
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The purpose of a *covariant detector* is to extract from an image a
+set of local features in a manner which is consistent with spatial
+transformations of the image itself. For instance, a covariant
+detector that extracts interest points $\bx_1,\dots,\bx_n$ from image
+$\ell$ extracts the translated points $\bx_1+T,\dots,\bx_n+T$ from the
+translated image $\ell'(\bx) = \ell(\bx-T)$.
+
+More in general, consider a image $\ell$ and a transformed version
+$\ell' = \ell \circ w^{-1}$ of it, as in the following figure:
+
+@image html covdet.png "Covariant detection of local features."
+
+The transformation or <em>warp</em> $w : \real^2 \mapsto \real^2$ is a
+deformation of the image domain which may capture a change of camera
+viewpoint or similar imaging factor. Examples of warps typically
+considered are translations, scaling, rotations, and general affine
+transformations; however, in $w$ could be another type of continuous
+and invertible transformation.
+
+Given an image $\ell$, a **detector** selects features $R_1,\dots,R_n$
+(one such features is shown in the example as a green circle). The
+detector is said to be **covariant** with the warps $w$ if it extracts
+the transformed features $w[R_1],\dots, w[R_n]$ from the transformed
+image $w[\ell]$. Intuitively, this means that the &ldquo;same
+features&rdquo; are extracted in both cases up to the transformation
+$w$. This property is described more formally in @ref
+covdet-principles.
+
+Covariance is a key property of local feature detectors as it allows
+extracting corresponding features from two or more images, making it
+possible to match them in a meaningful way.
+
+The @ref covdet.h module in VLFeat implements an array of feature
+detection algorithm that have are covariant to different classes of
+transformations.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section covdet-frame Feature geometry and feature frames
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+As we have seen, local features are subject to image transformations,
+and they apply a fundamental role in matching and normalizing
+images. To operates effectively with local features is therefore
+necessary to understand their geometry.
+
+The geometry of a local feature is captured by a <b>feature frame</b>
+$R$. In VLFeat, depending on the specific detector, the frame can be
+either a point, a disc, an ellipse, an oriented disc, or an oriented
+ellipse.
+
+A frame captures both the extent of the local features, useful to know
+which portions of two images are put in correspondence, as well their
+shape.  The latter can be used to associate to diagnose the
+transformation that affects a feature and remove it through the
+process of **normalization**.
+
+More precisely, in covariant detection feature frames are constructed
+to be compatible with a certain class of transformations. For example,
+circles are compatible with similarity transformations as they are
+closed under them. Likewise, ellipses are compatible with affine
+transformations.
+
+Beyond this closure property, the key idea here is that all feature
+occurrences can be seen as transformed versions of a base or
+<b>canonical</b> feature. For example, all discs $R$ can be obtained
+by applying a similarity transformation to the unit disc $\bar R$
+centered at the origin. $\bar R$ is an example of canonical frame
+as any other disc can be written as $R = w[\bar R]$ for a suitable
+similarity $w$.
+
+@image html frame-canonical.png "The idea of canonical frame and normalization"
+
+The equation $R = w[\bar R_0]$ matching the canonical and detected
+feature frames establishes a constraint on the warp $w$, very similar
+to the way two reference frames in geometry establish a transformation
+between spaces. The transformation $w$ can be thought as a the
+**pose** of the detected feature, a generalization of its location.
+
+In the case of discs and similarity transformations, the equation $R =
+w[\bar R_0]$ fixes $w$ up to a residual rotation. This can be
+addressed by considering oriented discs instead. An **oriented disc**
+is a disc with a radius highlighted to represent the feature
+orientation.
+
+While discs are appropriate for similarity transformations, they are
+not closed under general affine transformations. In this case, one
+should consider the more general class of (oriented) ellipses. The
+following image illustrates the five types of feature frames used in
+VLFeat:
+
+@image html frame-types.png "Types of local feature frames: points, discs, oriented discs, ellipses, oriented ellipses."
+
+Note that these frames are described respectively by 2, 3, 4, 5 and 6
+parameters. The most general type are the oriented ellipses, which can
+be used to represent all the other frame types as well.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section covdet-frame-transformation Transforming feature frames
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+Consider a warp $w$ mapping image $\ell$ into image $\ell'$ as in the
+figure below. A feature $R$ in the first image co-variantly transform
+into a feature $R'=w[R]$ in the second image:
+
+@image html covdet-normalization.png "Normalization removes the effect of an image deformation."
+
+The poses $u,u'$ of $R=u[R_0]$ and $R' = u'[R_0]$ are then related by
+the simple expression:
+
+\[
+  u' = w \circ u.
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section covdet-frame-normalization Normalizing feature frames
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+In the example above, the poses $u$ and $u'$ relate the two
+occurrences $R$ and $R'$ of the feature to its canonical version
+$R_0$. If the pose $u$ of the feature in image $\ell$ is known, the
+canonical feature appearance can be computed by un-warping it:
+
+\[
+ \ell_0 = u^{-1}[\ell] = \ell \circ u.
+\]
+
+This process is known as **normalization** and is the key in the
+computation of invariant feature descriptors as well as in the
+construction of most co-variant detectors.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@page covdet-principles Principles of covariant detection
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The goals of a co-variant detector were discussed in @ref
+covdet-fundamentals. This page introduces a few general principles
+that are at the basis of most covariant detection algorithms. Consider
+an input image $\ell$ and a two dimensional continuous and invertible
+warp $w$. The *warped image* $w[\ell]$ is defined to be
+
+\[
+ w[\ell] = \ell \circ w^{-1},
+\]
+
+or, equivalently,
+
+\[
+ w[\ell](x,y) =  \ell(w^{-1}(x,y)), \qquad \forall (x,y)\in\real^2.
+\]
+
+Note that, while $w$ pushes pixels forward, from the original to the
+transformed image domain, defining the transformed image $\ell'$
+requires inverting the warp and composing $\ell$ with $w^{-1}$.
+
+The goal a covariant detector is to extract the same local features
+irregardless of image transformations. The detector is said to be
+<b>covariant</b> or <b>equivariant</b> with a class of warps
+$w\in\mathcal{W}$ if, when the feature $R$ is detected in image
+$\ell$, then the transformed feature $w[R]$ is detected in the
+transformed image $w[\ell]$.
+
+The net effect is that a covariant feature detector appears to
+&ldquo;track&rdquo; image transformations; however, it is important to
+note that a detector *is not a tracker* because it processes images
+individually rather than jointly as part of a sequence.
+
+An intuitive way to construct a covariant feature detector is to
+extract features in correspondence of images structures that are
+easily identifiable even after a transformation. Example of specific
+structures include dots, corners, and blobs. These will be generically
+indicated as **corners** in the followup.
+
+A covariant detector faces two challenges. First, corners have, in
+practice, an infinite variety of individual appearances and the
+detector must be able to capture them to be of general applicability.
+Second, the way corners are identified and detected must remain stable
+under transformations of the image. These two problems are addressed
+in @ref covdet-cornerness-localmax and @ref
+covdet-cornerness-normalization respectively.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-cornerness Detection using a cornerness measure
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+One way to decide whether an image region $R$ contains a corner is to
+compare the local appearance to a model or template of the corner; the
+result of this comparisons produces a *cornerness score* at that
+location. This page describe general theoretical properties of the
+cornerness and the detection process. Concrete examples of cornerness
+are given in @ref covdet-corner-types.
+
+A **cornerness measure** associate a score to all possible feature
+locations in an image $\ell$. As described in @ref covdet-frame, the
+location or, more in general, pose $u$ of a feature $R$ is the warp
+$w$ that maps the canonical feature frame $R_0$ to $R$:
+
+\[
+    R = u[R_0].
+\]
+
+The goal of a cornerness measure is to associate a score $F(u;\ell)$
+to all possible feature poses $u$ and use this score to extract a
+finite number of co-variant features from any image.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-cornerness-localmax Local maxima of a cornerness measure
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Given the cornerness of each candidate feature, the detector must
+extract a finite number of them. However, the cornerness of features
+with nearly identical pose must be similar (otherwise the cornerness
+measure would be unstable). As such, simply thresholding $F(w;\ell)$
+would detect an infinite number of nearly identical features rather
+than a finite number.
+
+The solution is to detect features in correspondence of the local
+maxima of the score measure:
+
+\[
+ \{w_1,\dots,w_n\} = \operatorname{localmax}_{w\in\mathcal{W}} F(w;\ell).
+\]
+
+This also means that features are never detected in isolation, but by
+comparing neighborhoods of them.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-cornerness-normalization Covariant detection by normalization
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The next difficulty is to guarantee that detection is co-variant with
+image transformations. Hence, if $u$ is the pose of a feature
+extracted from image $\ell$, then the transformed pose $u' = w[u]$
+must be detected in the transformed image $\ell' = w[\ell]$.
+
+Since features are extracted in correspondence of the local maxima of
+the cornerness score, a sufficient condition is that corresponding
+features attain the same score in the two images:
+
+\[
+\forall u\in\mathcal{W}: \quad F(u;\ell) = F(w[u];w[\ell]),
+\qquad\text{or}\qquad
+F(u;\ell) = F(w \circ u ;\ell \circ w^{-1}).
+\]
+
+One simple way to satisfy this equation is to compute a cornerness
+score *after normalizing the image* by the inverse of the candidate
+feature pose warp $u$, as follows:
+
+\[
+  F(u;\ell) = F(1;u^{-1}[\ell]) = F(1;\ell \circ u) = \mathcal{F}(\ell \circ u),
+\]
+
+where $1 = u^{-1} \circ u$ is the identity transformation and
+$\mathcal{F}$ is an arbitrary functional. Intuitively, co-variant
+detection is obtained by looking if the appearance of the feature
+resembles a corner only *after normalization*. Formally:
+
+@f{align*}
+F(w[u];w[\ell])
+&=
+F(w \circ u ;\ell \circ w^{-1})
+\\
+&=
+F(1; \ell \circ w^{-1} \circ w \circ u)
+\\
+&=
+\mathcal{F}(\ell\circ u)
+\\
+&=
+F(u;\ell).
+@f}
+
+Concrete examples of the functional $\mathcal{F}$ are given in @ref
+covdet-corner-types.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-locality Locality of the detected features
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In the definition above, the cornenress functional $\mathcal{F}$ is an
+arbitrary functional of the entire normalized image $u^{-1}[\ell]$.
+In practice, one is always interested in detecting **local features**
+(at the very least because the image extent is finite).
+
+This is easily obtained by considering a cornerness $\mathcal{F}$
+which only looks in a small region of the normalized image, usually
+corresponding to the extent of the canonical feature $R_0$ (e.g. a
+unit disc centered at the origin).
+
+In this case the extent of the local feature in the original image is
+simply given by $R = u[R_0]$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-partial Partial and iterated normalization
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Practical detectors implement variants of the ideas above. Very often,
+for instance, detection is an iterative process, in which successive
+parameters of the pose of a feature are determined. For instance, it
+is typical to first detect the location and scale of a feature using a
+rotation-invariant cornerness score $\mathcal{F}$. Once these two
+parameters are known, the rotation can be determined using a different
+score, sensitive to the orientation of the local image structures.
+
+Certain detectors (such as Harris-Laplace and Hessian-Laplace) use
+even more sophisticated schemes, in which different scores are used to
+jointly (rather than in succession) different parameters of the pose
+of a feature, such as its translation and scale. While a formal
+treatment of these cases is possible as well, we point to the original
+papers.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page covdet-differential Differential and integral image operations
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Dealing with covariant interest point detector requires working a good
+deal with derivatives, convolutions, and transformations of images.
+The notation and fundamental properties of interest here are discussed
+next.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-derivatives Derivative operations: gradients
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+For the derivatives, we borrow the notation of
+@cite{kinghorn96integrals}. Let $f: \mathbb{R}^m \rightarrow
+\mathbb{R}^n, \bx \mapsto f(\bx)$ be a vector function. The derivative
+of the function with respect to $\bx$ is given by its *Jacobian
+matrix* denoted by the symbol:
+
+\[
+\frac{\partial f}{\partial \bx^\top}
+=
+\begin{bmatrix}
+  \frac{\partial f_1}{x_1} & \frac{\partial f_1}{x_2} & \dots \\
+  \frac{\partial f_2}{x_1} & \frac{\partial f_2}{x_2} & \dots \\
+  \vdots & \vdots & \ddots \\
+\end{bmatrix}.
+\]
+
+When the function $ f $ is scalar ($n=1$), the Jacobian is the same as
+the gradient of the function (or, in fact, its transpose). More
+precisely, the <b>gradient</b> $\nabla f $ of $ f $ denotes the column
+vector of partial derivatives:
+
+\[
+\nabla f
+ = \frac{\partial f}{\partial \bx}
+ =
+ \begin{bmatrix}
+  \frac{\partial f}{\partial x_1} \\
+  \frac{\partial f}{\partial x_2} \\
+  \vdots
+\end{bmatrix}.
+\]
+
+The second derivative $H_f $ of a scalar function $ f $, or
+<b>Hessian</b>, is denoted as
+
+\[
+H_f
+= \frac{\partial f}{\partial \bx \partial \bx^\top}
+= \frac{\partial \nabla f}{\partial \bx^\top}
+=
+\begin{bmatrix}
+  \frac{\partial f}{\partial x_1 \partial x_1} & \frac{\partial f}{\partial x_1 \partial x_2} & \dots \\
+  \frac{\partial f}{\partial x_2 \partial x_1} & \frac{\partial f}{\partial x_2 \partial x_2} & \dots \\
+  \vdots & \vdots & \ddots \\
+\end{bmatrix}.
+\]
+
+The determinant of the Hessian is also known as <b>Laplacian</b> and denoted as
+
+\[
+ \Delta f = \operatorname{det} H_f =
+\frac{\partial f}{\partial x_1^2} +
+\frac{\partial f}{\partial x_2^2} +
+\dots
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-derivative-transformations Derivative and image warps
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In the following, we will often been interested in domain warpings $u:
+\mathbb{R}^m \rightarrow \mathbb{R}^n, \bx \mapsto u(\bx)$ of a
+function $f(\bar\bx) $ and its effect on the derivatives of the
+function. The key transformation is the chain rule:
+
+\[
+\frac{\partial f \circ u}{\partial \bx^\top}
+=
+\left(\frac{\partial f}{\partial \bar\bx^\top} \circ u\right)
+\frac{\partial u}{\partial \bx^\top}
+\]
+
+In particular, for an affine transformation $u = (A,T) : \bx \mapsto
+A\bx + T$, one obtains the transformation rules:
+
+\[
+\begin{align*}
+\frac{\partial f \circ (A,T)}{\partial \bx^\top}
+&=
+\left(\frac{\partial f}{\partial \bar\bx^\top} \circ (A,T)\right)A,
+\\
+\nabla (f \circ (A,T))
+&= A^\top (\nabla f) \circ (A,T),
+\\
+H_{f \circ(A,T)}
+&= A^\top (H_f \circ (A,T)) A,
+\\
+\Delta (f \circ(A,T))
+&= \det(A)^2\, (\Delta f) \circ (A,T).
+\end{align*}
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-smoothing Integral operations: smoothing
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In practice, given an image $\ell$ expressed in digital format, good
+derivative approximations can be computed only if the bandwidth of the
+image is limited and, in particular, compatible with the sampling
+density. Since it is unreasonable to expect real images to be
+band-limited, the bandwidth is artificially constrained by suitably
+smoothing the image prior to computing its derivatives. This is also
+interpreted as a form of regularization or as a way of focusing on the
+image content at a particular scale.
+
+Formally, we will focus on Gaussian smoothing kernels. For the 2D case
+$\bx\in\real^2$, the Gaussian kernel of covariance $\Sigma$ is given
+by
+
+\[
+g_{\Sigma}(\bx) = \frac{1}{2\pi \sqrt{\det\Sigma}}
+  \exp\left(
+  - \frac{1}{2} \bx^\top \Sigma^{-1} \bx
+  \right).
+\]
+
+The symbol $g_{\sigma^2}$ will be used to denote a Gaussian kernel
+with isotropic standard deviation $\sigma$, i.e. $\Sigma = \sigma^2
+I$. Given an image $\ell$, the symbol $\ell_\Sigma$ will be used to
+denote the image smoothed by the Gaussian kernel of parameter
+$\Sigma$:
+
+\[
+\ell_\Sigma(\bx) = (g_\Sigma * \ell)(\bx)
+=
+\int_{\real^m}
+g_\Sigma(\bx - \by) \ell(\by)\,d\by.
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-smoothing-transformations Smoothing and image warps
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+One advantage of Gaussian kernels is that they are (up to
+renormalization) closed under a linear warp:
+
+\[
+ |A|\, g_\Sigma \circ A = g_{A^{-1} \Sigma A^{-\top}}
+\]
+
+This also means that smoothing a warped image is the same as warping
+the result of smoothing the original image by a suitably adjusted
+Gaussian kernel:
+
+\[
+g_{\Sigma} * (\ell \circ (A,T))
+=
+(g_{A\Sigma A^\top} * \ell) \circ (A,T).
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page covdet-corner-types Cornerness measures
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The goal of a cornerness measure (@ref covdet-cornerness) is to
+associate to an image patch a score proportional to how strongly the
+patch contain a certain strucuture, for example a corner or a
+blob. This page reviews the most important cornerness measures as
+implemented in VLFeat:
+
+- @ref covdet-harris
+- @ref covdet-laplacian
+- @ref covdet-hessian
+
+This page makes use of notation introduced in @ref
+covdet-differential.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-harris Harris corners
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This section introduces the fist of the cornerness measure
+$\mathcal{F}[\ell]$. Recall (@ref covdet-cornerness) that the goal of
+this functional is to respond strongly to images $\ell$ of corner-like
+structure.
+
+Rather than explicitly encoding the appearance of corners, the idea of
+the Harris measure is to label as corner *any* image patch whose
+appearance is sufficiently distinctive to allow accurate
+localization. In particular, consider an image patch $\ell(\bx),
+\bx\in\Omega$, where $\Omega$ is a smooth circular window of radius
+approximately $\sigma_i$; at necessary condition for the patch to
+allow accurate localization is that even a small translation
+$\ell(\bx+\delta)$ causes the appearance to vary significantly (if not
+the origin and location $\delta$ would not be distinguishable from the
+image alone). This variation is measured by the sum of squared
+differences
+
+\[
+E(\delta) = \int g_{\sigma_i^2}(\bx)
+(\ell_{\sigma_d^2}(\bx+\delta) -
+ \ell_{\sigma_d^2}(\bx))^2 \,d\bx
+\]
+
+Note that images are compared at scale $\sigma_d$, known as
+ *differentiation scale* for reasons that will be clear in a moment,
+and that the squared differences are summed over a window softly
+defined by $\sigma_i$, also known as *integration scale*. This
+function can be approximated as $E(\delta)\approx \delta^\top
+M[\ell;\sigma_i^2,\sigma_d^2] \delta$ where
+
+\[
+  M[\ell;\sigma_i^2,\sigma_d^2]
+= \int  g_{\sigma_i^2}(\bx)
+ (\nabla \ell_{\sigma_d^2}(\bx))
+ (\nabla \ell_{\sigma_d^2}(\bx))^\top \, d\bx.
+\]
+
+is the so called **structure tensor**.
+
+A corner is identified when the sum of squared differences $E(\delta)$
+is large for displacements $\delta$ in all directions. This condition
+is obtained when both the eignenvalues $\lambda_1,\lambda_2$ of the
+structure tensor $M$ are large. The **Harris cornerness measure**
+captures this fact:
+
+\[
+ \operatorname{Harris}[\ell;\sigma_i^2,\sigma_d^2] =
+ \det M - \kappa \operatorname{trace}^2 M =
+ \lambda_1\lambda_2 - \kappa (\lambda_1+\lambda_2)^2
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-harris-warped Harris in the warped domain
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The cornerness measure of a feature a location $u$ (recall that
+locations $u$ are in general defined as image warps) should be
+computed after normalizing the image (by applying to it the warp
+$u^{-1}$). This section shows that, for affine warps, the Harris
+cornerness measure can be computed directly in the Gaussian affine
+scale space of the image. In particular, for similarities, it can be
+computed in the standard Gaussian scale space.
+
+To this end, let $u=(A,T)$ be an affine warp identifying a feature
+location in image $\ell(\bx)$. Let $\bar\ell(\bar\bx) =
+\ell(A\bar\bx+T)$ be the normalized image and rewrite the structure
+tensor of the normalized image as follows:
+
+\[
+ M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d]
+=
+ M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
+=
+\left[
+g_{\bar\Sigma_i} *
+(\nabla\bar\ell_{\bar\Sigma_d})
+(\nabla\bar\ell_{\bar\Sigma_d})^\top
+\right](\mathbf{0})
+\]
+
+This notation emphasizes that the structure tensor is obtained by
+taking derivatives and convolutions of the image. Using the fact that
+$\nabla g_{\bar\Sigma_d} * \bar\ell = A^\top (\nabla g_{A\bar\Sigma
+A^\top} * \ell) \circ (A,T)$ and that $g_{\bar\Sigma} * \bar \ell =
+(g_{A\bar\Sigma A^\top} * \ell) \circ (A,T)$, we get the equivalent
+expression:
+
+\[
+ M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
+ =
+A^\top
+\left[
+g_{A\bar\Sigma_i A^\top} *
+(\nabla\ell_{A\bar\Sigma_dA^\top})(\nabla\ell_{A\bar\Sigma_d A^\top})^\top
+\right](A\mathbf{0}+T)
+A.
+\]
+
+In other words, the structure tensor of the normalized image can be
+computed as:
+
+\[
+M[\bar\ell; \bar\Sigma_i, \bar\Sigma_d](\mathbf{0})
+=
+A^\top M[\ell; \Sigma_i, \Sigma_d](T) A,
+\quad
+\Sigma_{i} = A\bar\Sigma_{i}A^\top,
+\quad
+\Sigma_{d} = A\bar\Sigma_{d}A^\top.
+\]
+
+This equation allows to compute the structure tensor for feature at
+all locations directly in the original image. In particular, features
+at all translations $T$ can be evaluated efficiently by computing
+convolutions and derivatives of the image
+$\ell_{A\bar\Sigma_dA^\top}$.
+
+A case of particular instance is when $\bar\Sigma_i= \bar\sigma_i^2 I$
+and $\bar\Sigma_d = \bar\sigma_d^2$ are both isotropic covariance
+matrices and the affine transformation is a similarity $A=sR$.  Using
+the fact that $\det\left( s^2 R^\top M R \right)= s^4 \det M$ and
+$\operatorname{tr}\left(s^2 R^\top M R\right) = s^2 \operatorname{tr}
+M$, one obtains the relation
+
+\[
+ \operatorname{Harris}[\bar \ell;\bar\sigma_i^2,\bar\sigma_d^2] =
+ s^4 \operatorname{Harris}[\ell;s^2\bar\sigma_i^2,s^2\bar\sigma_d^2](T).
+\]
+
+This equation indicates that, for similarity transformations, not only
+the structure tensor, but directly the Harris cornerness measure can
+be computed on the original image and then be transferred back to the
+normalized domain. Note, however, that this requires rescaling the
+measure by the factor $s^4$.
+
+Another important consequence of this relation is that the Harris
+measure is invariant to pure image rotations. It cannot, therefore, be
+used to associate an orientation to the detected features.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-hessian Hessian blobs
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The *(determinant of the) Hessian* cornerness measure is given
+determinant of the Hessian of the image:
+
+\[
+ \operatorname{DetHess}[\ell;\sigma_d^2]
+ =
+ \det H_{g_{\sigma_d^2} * \ell}(\mathbf{0})
+\]
+
+This number is large and positive if the image is locally curved
+(peaked), roughly corresponding to blob-like structures in the image.
+In particular, a large score requires the product of the eigenvalues
+of the Hessian to be large, which requires both of them to have the
+same sign and are large in absolute value.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection covdet-hessian-warped Hessian in the warped domain
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Similarly to the Harris measure, it is possible to work with the
+Hessian measure on the original unnormalized image. As before, let
+$\bar\ell(\bar\bx) = \ell(A\bar\bx+T)$ be the normalized image and
+rewrite the Hessian of the normalized image as follows:
+
+\[
+H_{g_{\bar\Sigma_d} * \bar\ell}(\mathbf{0}) = A^\top \left(H_{g_{\Sigma_d} * \ell}(T)\right) A.
+\]
+
+Then
+
+\[
+ \operatorname{DetHess}[\bar\ell;\bar\Sigma_d]
+ =
+ (\det A)^2 \operatorname{DetHess}[\ell;A\bar\Sigma_d A^\top](T).
+\]
+
+In particular, for isotropic covariance matrices and similarity
+transformations $A=sR$:
+
+\[
+ \operatorname{DetHess}[\bar\ell;\bar\sigma_d^2]
+ =
+ s^4 \operatorname{DetHess}[\ell;s^2\bar\sigma_d^2](T)
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section covdet-laplacian Laplacian and Difference of Gaussians blobs
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The **Laplacian of Gaussian (LoG)** or **trace of the Hessian**
+cornerness measure is given by the trace of the Hessian of the image:
+
+\[
+ \operatorname{Lap}[\ell;\sigma_d^2]
+ =
+ \operatorname{tr} H_{g_{\sigma_d}^2 * \ell}
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection covdet-laplacian-warped Laplacian in the warped domain
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+Similarly to the Hessian measure, the Laplacian cornenress can often
+be efficiently computed for features at all locations in the original
+unnormalized image domain. In particular, if the derivative covariance
+matrix $\Sigma_d$ is isotropic and one considers as warpings
+similarity transformations $A=sR$, where $R$ is a rotatin and $s$ a
+rescaling, one has
+
+\[
+ \operatorname{Lap}[\bar\ell;\bar\sigma_d^2]
+ =
+ s^2 \operatorname{Lap}[\ell;s^2\bar\sigma_d^2](T)
+\]
+
+Note that, comparing to the Harris and determinant of Hessian
+measures, the scaling for the Laplacian is $s^2$ rather than $s^4$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection covdet-laplacian-matched Laplacian as a matched filter
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The Laplacian is given by the trace of the Hessian
+operator. Differently from the determinant of the Hessian, this is a
+linear operation. This means that computing the Laplacian cornerness
+measure can be seen as applying a linear filtering operator to the
+image. This filter can then be interpreted as a *template* of a corner
+being matched to the image. Hence, the Laplacian cornerness measure
+can be interpreted as matching this corner template at all possible
+image locations.
+
+To see this formally, compute the Laplacian score in the input image domain:
+
+\[
+ \operatorname{Lap}[\bar\ell;\bar\sigma_d^2]
+ =
+ s^2 \operatorname{Lap}[\ell;s^2\bar\sigma_d^2](T)
+ =
+ s^2 (\Delta g_{s^2\bar\sigma_d^2} * \ell)(T)
+\]
+
+The Laplacian fitler is obtained by moving the Laplacian operator from
+the image to the Gaussian smoothing kernel:
+
+\[
+ s^2 (\Delta g_{s^2\bar\sigma_d^2} * \ell)
+=
+ (s^2 \Delta g_{s^2\bar\sigma_d^2}) * \ell
+\]
+
+Note that the filter is rescaled by the $s^2$; sometimes, this factor
+is incorporated in the Laplacian operator, yielding the so-called
+normalized Laplacian.
+
+The Laplacian of Gaussian is also called *top-hat function* and has
+the expression:
+
+\[
+\Delta g_{\sigma^2}(x,y)
+=
+\frac{x^2+y^2 - 2 \sigma^2}{\sigma^4} g_{\sigma^2}(x,y).
+\]
+
+This filter, which acts as corner template, resembles a blob (a dark
+disk surrounded by a bright ring).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection covdet-laplacian-dog Difference of Gaussians
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The **Difference of Gaussian** (DoG) cornerness measure can be
+interpreted as an approximation of the Laplacian that is easy to
+obtain once a scalespace of the input image has been computed.
+
+As noted above, the Laplacian cornerness of the normalized feature can
+be computed directly from the input image by convolving the image by
+the normalized Laplacian of Gaussian filter $s^2 \Delta
+g_{s^2\bar\sigma_d^2}$.
+
+Like the other derivative operators, this filter is simpe to
+discriteize. However, it is often approximated by computing the the
+*Difference of Gaussians* (DoG) approximation instead. This
+approximation is obtained from the easily-proved identity:
+
+\[
+  \frac{\partial}{\partial \sigma} g_{\sigma^2} =
+  \sigma \Delta g_{\sigma^2}.
+\]
+
+This indicates that computing the normalized Laplacian of a Gaussian
+filter is, in the limit, the same as taking the difference between
+Gaussian filters of slightly increasing standard deviation $\sigma$
+and $\kappa\sigma$, where $\kappa \approx 1$:
+
+\[
+\sigma^2 \Delta g_{\sigma^2}
+\approx
+\sigma \frac{g_{(\kappa\sigma)^2} - g_{\sigma^2}}{\kappa\sigma - \sigma}
+=
+\frac{1}{\kappa - 1}
+(g_{(\kappa\sigma)^2} - g_{\sigma^2}).
+\]
+
+One nice propery of this expression is that the factor $\sigma$
+cancels out in the right-hand side. Usually, scales $\sigma$ and
+$\kappa\sigma$ are pre-computed in the image scale-space and
+successive scales are sampled with uniform geometric spacing, meaning
+that the factor $\kappa$ is the same for all scales. Then, up to a
+overall scaling factor, the LoG cornerness measure can be obtained by
+taking the difference of successive scale space images
+$\ell_{(\kappa\sigma)^2}$ and $\ell_{\sigma^2}$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page covdet-affine-adaptation Affine adaptation
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page covdet-dominant-orientation Dominant orientation
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+**/
+
+#include "covdet.h"
+#include <string.h>
+
+/** @brief Reallocate buffer
+ ** @param buffer
+ ** @param bufferSize
+ ** @param targetSize
+ ** @return error code
+ **/
+
+static int
+_vl_resize_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
+  void * newBuffer ;
+  if (*buffer == NULL) {
+    *buffer = vl_malloc(targetSize) ;
+    if (*buffer) {
+      *bufferSize = targetSize ;
+      return VL_ERR_OK ;
+    } else {
+      *bufferSize = 0 ;
+      return VL_ERR_ALLOC ;
+    }
+  }
+  newBuffer = vl_realloc(*buffer, targetSize) ;
+  if (newBuffer) {
+    *buffer = newBuffer ;
+    *bufferSize = targetSize ;
+    return VL_ERR_OK ;
+  } else {
+    return VL_ERR_ALLOC ;
+  }
+}
+
+/** @brief Enlarge buffer
+ ** @param buffer
+ ** @param bufferSize
+ ** @param targetSize
+ ** @return error code
+ **/
+
+static int
+_vl_enlarge_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
+  if (*bufferSize >= targetSize) return VL_ERR_OK ;
+  return _vl_resize_buffer(buffer,bufferSize,targetSize) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                            Finding local extrema */
+/* ---------------------------------------------------------------- */
+
+/* Todo: make this generally available in the library */
+
+typedef struct _VlCovDetExtremum2
+{
+  vl_index xi ;
+  vl_index yi ;
+  float x ;
+  float y ;
+  float peakScore ;
+  float edgeScore ;
+} VlCovDetExtremum2 ;
+
+typedef struct _VlCovDetExtremum3
+{
+  vl_index xi ;
+  vl_index yi ;
+  vl_index zi ;
+  float x ;
+  float y ;
+  float z ;
+  float peakScore ;
+  float edgeScore ;
+} VlCovDetExtremum3 ;
+
+VL_EXPORT vl_size
+vl_find_local_extrema_3 (vl_index ** extrema, vl_size * bufferSize,
+                         float const * map,
+                         vl_size width, vl_size height, vl_size depth,
+                         double threshold) ;
+
+VL_EXPORT vl_size
+vl_find_local_extrema_2 (vl_index ** extrema, vl_size * bufferSize,
+                         float const * map,
+                         vl_size width, vl_size height,
+                         double threshold) ;
+
+VL_EXPORT vl_bool
+vl_refine_local_extreum_3 (VlCovDetExtremum3 * refined,
+                           float const * map,
+                           vl_size width, vl_size height, vl_size depth,
+                           vl_index x, vl_index y, vl_index z) ;
+
+VL_EXPORT vl_bool
+vl_refine_local_extreum_2 (VlCovDetExtremum2 * refined,
+                           float const * map,
+                           vl_size width, vl_size height,
+                           vl_index x, vl_index y) ;
+
+/** @internal
+ ** @brief Find the extrema of a 3D function
+ ** @param extrema buffer containing the extrema found (in/out).
+ ** @param bufferSize size of the @a extrema buffer in bytes (in/out).
+ ** @param map a 3D array representing the map.
+ ** @param width of the map.
+ ** @param height of the map.
+ ** @param depth of the map.
+ ** @param threshold minumum extremum value.
+ ** @return number of extrema found.
+ ** @see @ref ::vl_refine_local_extreum_2.
+ **/
+
+vl_size
+vl_find_local_extrema_3 (vl_index ** extrema, vl_size * bufferSize,
+                         float const * map,
+                         vl_size width, vl_size height, vl_size depth,
+                         double threshold)
+{
+  vl_index x, y, z ;
+  vl_size const xo = 1 ;
+  vl_size const yo = width ;
+  vl_size const zo = width * height ;
+  float const *pt = map + xo + yo + zo ;
+
+  vl_size numExtrema = 0 ;
+  vl_size requiredSize = 0 ;
+
+#define CHECK_NEIGHBORS_3(v,CMP,SGN)     (\
+v CMP ## = SGN threshold &&               \
+v CMP *(pt + xo) &&                       \
+v CMP *(pt - xo) &&                       \
+v CMP *(pt + zo) &&                       \
+v CMP *(pt - zo) &&                       \
+v CMP *(pt + yo) &&                       \
+v CMP *(pt - yo) &&                       \
+\
+v CMP *(pt + yo + xo) &&                  \
+v CMP *(pt + yo - xo) &&                  \
+v CMP *(pt - yo + xo) &&                  \
+v CMP *(pt - yo - xo) &&                  \
+\
+v CMP *(pt + xo      + zo) &&             \
+v CMP *(pt - xo      + zo) &&             \
+v CMP *(pt + yo      + zo) &&             \
+v CMP *(pt - yo      + zo) &&             \
+v CMP *(pt + yo + xo + zo) &&             \
+v CMP *(pt + yo - xo + zo) &&             \
+v CMP *(pt - yo + xo + zo) &&             \
+v CMP *(pt - yo - xo + zo) &&             \
+\
+v CMP *(pt + xo      - zo) &&             \
+v CMP *(pt - xo      - zo) &&             \
+v CMP *(pt + yo      - zo) &&             \
+v CMP *(pt - yo      - zo) &&             \
+v CMP *(pt + yo + xo - zo) &&             \
+v CMP *(pt + yo - xo - zo) &&             \
+v CMP *(pt - yo + xo - zo) &&             \
+v CMP *(pt - yo - xo - zo) )
+
+  for (z = 1 ; z < (signed)depth - 1 ; ++z) {
+    for (y = 1 ; y < (signed)height - 1 ; ++y) {
+      for (x = 1 ; x < (signed)width - 1 ; ++x) {
+        float value = *pt ;
+        if (CHECK_NEIGHBORS_3(value,>,+) || CHECK_NEIGHBORS_3(value,<,-)) {
+          numExtrema ++ ;
+          requiredSize += sizeof(vl_index) * 3 ;
+          if (*bufferSize < requiredSize) {
+            int err = _vl_resize_buffer((void**)extrema, bufferSize,
+                                        requiredSize + 2000 * 3 * sizeof(vl_index)) ;
+            if (err != VL_ERR_OK) abort() ;
+          }
+          (*extrema) [3 * (numExtrema - 1) + 0] = x ;
+          (*extrema) [3 * (numExtrema - 1) + 1] = y ;
+          (*extrema) [3 * (numExtrema - 1) + 2] = z ;
+        }
+        pt += xo ;
+      }
+      pt += 2*xo ;
+    }
+    pt += 2*yo ;
+  }
+  return numExtrema ;
+}
+
+/** @internal
+ ** @brief Find extrema in a 2D function
+ ** @param extrema buffer containing the found extrema (in/out).
+ ** @param bufferSize size of the @a extrema buffer in bytes (in/out).
+ ** @param map a 3D array representing the map.
+ ** @param width of the map.
+ ** @param height of the map.
+ ** @param threshold minumum extremum value.
+ ** @return number of extrema found.
+ **
+ ** An extremum contains 2 ::vl_index values; they are arranged
+ ** sequentially.
+ **
+ ** The function can reuse an already allocated buffer if
+ ** @a extrema and @a bufferSize are initialized on input.
+ ** It may have to @a realloc the memory if the buffer is too small.
+ **/
+
+vl_size
+vl_find_local_extrema_2 (vl_index ** extrema, vl_size * bufferSize,
+                         float const* map,
+                         vl_size width, vl_size height,
+                         double threshold)
+{
+  vl_index x, y ;
+  vl_size const xo = 1 ;
+  vl_size const yo = width ;
+  float const *pt = map + xo + yo ;
+
+  vl_size numExtrema = 0 ;
+  vl_size requiredSize = 0 ;
+#define CHECK_NEIGHBORS_2(v,CMP,SGN)     (\
+v CMP ## = SGN threshold &&               \
+v CMP *(pt + xo) &&                       \
+v CMP *(pt - xo) &&                       \
+v CMP *(pt + yo) &&                       \
+v CMP *(pt - yo) &&                       \
+\
+v CMP *(pt + yo + xo) &&                  \
+v CMP *(pt + yo - xo) &&                  \
+v CMP *(pt - yo + xo) &&                  \
+v CMP *(pt - yo - xo) )
+
+  for (y = 1 ; y < (signed)height - 1 ; ++y) {
+    for (x = 1 ; x < (signed)width - 1 ; ++x) {
+      float value = *pt ;
+      if (CHECK_NEIGHBORS_2(value,>,+) || CHECK_NEIGHBORS_2(value,<,-)) {
+        numExtrema ++ ;
+        requiredSize += sizeof(vl_index) * 2 ;
+        if (*bufferSize < requiredSize) {
+          int err = _vl_resize_buffer((void**)extrema, bufferSize,
+                                      requiredSize + 2000 * 2 * sizeof(vl_index)) ;
+          if (err != VL_ERR_OK) abort() ;
+        }
+        (*extrema) [2 * (numExtrema - 1) + 0] = x ;
+        (*extrema) [2 * (numExtrema - 1) + 1] = y ;
+      }
+      pt += xo ;
+    }
+    pt += 2*xo ;
+  }
+  return numExtrema ;
+}
+
+/** @internal
+ ** @brief Refine the location of a local extremum of a 3D map
+ ** @param refined refined extremum (out).
+ ** @param map a 3D array representing the map.
+ ** @param width of the map.
+ ** @param height of the map.
+ ** @param depth of the map.
+ ** @param x initial x position.
+ ** @param y initial y position.
+ ** @param z initial z position.
+ ** @return a flat indicating whether the extrema refinement was stable.
+ **/
+
+VL_EXPORT vl_bool
+vl_refine_local_extreum_3 (VlCovDetExtremum3 * refined,
+                           float const * map,
+                           vl_size width, vl_size height, vl_size depth,
+                           vl_index x, vl_index y, vl_index z)
+{
+  vl_size const xo = 1 ;
+  vl_size const yo = width ;
+  vl_size const zo = width * height ;
+
+  double Dx=0,Dy=0,Dz=0,Dxx=0,Dyy=0,Dzz=0,Dxy=0,Dxz=0,Dyz=0 ;
+  double A [3*3], b [3] ;
+
+#define at(dx,dy,dz) (*(pt + (dx)*xo + (dy)*yo + (dz)*zo))
+#define Aat(i,j) (A[(i)+(j)*3])
+
+  float const * pt ;
+  vl_index dx = 0 ;
+  vl_index dy = 0 ;
+  /*vl_index dz = 0 ;*/
+  vl_index iter ;
+  int err ;
+
+  assert (map) ;
+  assert (1 <= x && x <= (signed)width - 2) ;
+  assert (1 <= y && y <= (signed)height - 2) ;
+  assert (1 <= z && z <= (signed)depth - 2) ;
+
+  for (iter = 0 ; iter < 5 ; ++iter) {
+    x += dx ;
+    y += dy ;
+    pt = map + x*xo + y*yo + z*zo ;
+
+    /* compute the gradient */
+    Dx = 0.5 * (at(+1,0,0) - at(-1,0,0)) ;
+    Dy = 0.5 * (at(0,+1,0) - at(0,-1,0));
+    Dz = 0.5 * (at(0,0,+1) - at(0,0,-1)) ;
+
+    /* compute the Hessian */
+    Dxx = (at(+1,0,0) + at(-1,0,0) - 2.0 * at(0,0,0)) ;
+    Dyy = (at(0,+1,0) + at(0,-1,0) - 2.0 * at(0,0,0)) ;
+    Dzz = (at(0,0,+1) + at(0,0,-1) - 2.0 * at(0,0,0)) ;
+
+    Dxy = 0.25 * (at(+1,+1,0) + at(-1,-1,0) - at(-1,+1,0) - at(+1,-1,0)) ;
+    Dxz = 0.25 * (at(+1,0,+1) + at(-1,0,-1) - at(-1,0,+1) - at(+1,0,-1)) ;
+    Dyz = 0.25 * (at(0,+1,+1) + at(0,-1,-1) - at(0,-1,+1) - at(0,+1,-1)) ;
+
+    /* solve linear system */
+    Aat(0,0) = Dxx ;
+    Aat(1,1) = Dyy ;
+    Aat(2,2) = Dzz ;
+    Aat(0,1) = Aat(1,0) = Dxy ;
+    Aat(0,2) = Aat(2,0) = Dxz ;
+    Aat(1,2) = Aat(2,1) = Dyz ;
+
+    b[0] = - Dx ;
+    b[1] = - Dy ;
+    b[2] = - Dz ;
+
+    err = vl_solve_linear_system_3(b, A, b) ;
+
+    if (err != VL_ERR_OK) {
+      b[0] = 0 ;
+      b[1] = 0 ;
+      b[2] = 0 ;
+      break ;
+    }
+
+    /* Keep going if there is sufficient translation */
+
+    dx = (b[0] > 0.6 && x < (signed)width - 2 ?  1 : 0)
+    + (b[0] < -0.6 && x > 1 ? -1 : 0) ;
+
+    dy = (b[1] > 0.6 && y < (signed)height - 2 ?  1 : 0)
+    + (b[1] < -0.6 && y > 1 ? -1 : 0) ;
+
+    if (dx == 0 && dy == 0) break ;
+  }
+
+  /* check threshold and other conditions */
+  {
+    double peakScore = at(0,0,0)
+    + 0.5 * (Dx * b[0] + Dy * b[1] + Dz * b[2]) ;
+    double alpha = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
+    double edgeScore ;
+
+    if (alpha < 0) {
+      /* not an extremum */
+      edgeScore = VL_INFINITY_D ;
+    } else {
+      edgeScore = (0.5*alpha - 1) + sqrt(VL_MAX(0.25*alpha - 1,0)*alpha) ;
+    }
+
+    refined->xi = x ;
+    refined->yi = y ;
+    refined->zi = z ;
+    refined->x = x + b[0] ;
+    refined->y = y + b[1] ;
+    refined->z = z + b[2] ;
+    refined->peakScore = peakScore ;
+    refined->edgeScore = edgeScore ;
+
+    return
+    err == VL_ERR_OK &&
+    vl_abs_d(b[0]) < 1.5 &&
+    vl_abs_d(b[1]) < 1.5 &&
+    vl_abs_d(b[2]) < 1.5 &&
+    0 <= refined->x && refined->x <= (signed)width - 1 &&
+    0 <= refined->y && refined->y <= (signed)height - 1 &&
+    0 <= refined->z && refined->z <= (signed)depth - 1 ;
+  }
+#undef Aat
+#undef at
+}
+
+/** @internal
+ ** @brief Refine the location of a local extremum of a 2D map
+ ** @param refined refined extremum (out).
+ ** @param map a 2D array representing the map.
+ ** @param width of the map.
+ ** @param height of the map.
+ ** @param x initial x position.
+ ** @param y initial y position.
+ ** @return a flat indicating whether the extrema refinement was stable.
+ **/
+
+VL_EXPORT vl_bool
+vl_refine_local_extreum_2 (VlCovDetExtremum2 * refined,
+                           float const * map,
+                           vl_size width, vl_size height,
+                           vl_index x, vl_index y)
+{
+  vl_size const xo = 1 ;
+  vl_size const yo = width ;
+
+  double Dx=0,Dy=0,Dxx=0,Dyy=0,Dxy=0;
+  double A [2*2], b [2] ;
+
+#define at(dx,dy) (*(pt + (dx)*xo + (dy)*yo ))
+#define Aat(i,j) (A[(i)+(j)*2])
+
+  float const * pt ;
+  vl_index dx = 0 ;
+  vl_index dy = 0 ;
+  vl_index iter ;
+  int err ;
+
+  assert (map) ;
+  assert (1 <= x && x <= (signed)width - 2) ;
+  assert (1 <= y && y <= (signed)height - 2) ;
+
+  for (iter = 0 ; iter < 5 ; ++iter) {
+    x += dx ;
+    y += dy ;
+    pt = map + x*xo + y*yo  ;
+
+    /* compute the gradient */
+    Dx = 0.5 * (at(+1,0) - at(-1,0)) ;
+    Dy = 0.5 * (at(0,+1) - at(0,-1));
+
+    /* compute the Hessian */
+    Dxx = (at(+1,0) + at(-1,0) - 2.0 * at(0,0)) ;
+    Dyy = (at(0,+1) + at(0,-1) - 2.0 * at(0,0)) ;
+    Dxy = 0.25 * (at(+1,+1) + at(-1,-1) - at(-1,+1) - at(+1,-1)) ;
+
+    /* solve linear system */
+    Aat(0,0) = Dxx ;
+    Aat(1,1) = Dyy ;
+    Aat(0,1) = Aat(1,0) = Dxy ;
+
+    b[0] = - Dx ;
+    b[1] = - Dy ;
+
+    err = vl_solve_linear_system_2(b, A, b) ;
+
+    if (err != VL_ERR_OK) {
+      b[0] = 0 ;
+      b[1] = 0 ;
+      break ;
+    }
+
+    /* Keep going if there is sufficient translation */
+
+    dx = (b[0] > 0.6 && x < (signed)width - 2 ?  1 : 0)
+    + (b[0] < -0.6 && x > 1 ? -1 : 0) ;
+
+    dy = (b[1] > 0.6 && y < (signed)height - 2 ?  1 : 0)
+    + (b[1] < -0.6 && y > 1 ? -1 : 0) ;
+
+    if (dx == 0 && dy == 0) break ;
+  }
+
+  /* check threshold and other conditions */
+  {
+    double peakScore = at(0,0) + 0.5 * (Dx * b[0] + Dy * b[1]) ;
+    double alpha = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
+    double edgeScore ;
+
+    if (alpha < 0) {
+      /* not an extremum */
+      edgeScore = VL_INFINITY_D ;
+    } else {
+      edgeScore = (0.5*alpha - 1) + sqrt(VL_MAX(0.25*alpha - 1,0)*alpha) ;
+    }
+
+    refined->xi = x ;
+    refined->yi = y ;
+    refined->x = x + b[0] ;
+    refined->y = y + b[1] ;
+    refined->peakScore = peakScore ;
+    refined->edgeScore = edgeScore ;
+
+    return
+    err == VL_ERR_OK &&
+    vl_abs_d(b[0]) < 1.5 &&
+    vl_abs_d(b[1]) < 1.5 &&
+    0 <= refined->x && refined->x <= (signed)width - 1 &&
+    0 <= refined->y && refined->y <= (signed)height - 1 ;
+  }
+#undef Aat
+#undef at
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                Covarant detector */
+/* ---------------------------------------------------------------- */
+
+#define VL_COVDET_MAX_NUM_ORIENTATIONS 4
+#define VL_COVDET_MAX_NUM_LAPLACIAN_SCALES 4
+#define VL_COVDET_AA_PATCH_RESOLUTION 20
+#define VL_COVDET_AA_MAX_NUM_ITERATIONS 15
+#define VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS 36
+#define VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA 3
+#define VL_COVDET_AA_RELATIVE_DERIVATIVE_SIGMA 1
+#define VL_COVDET_AA_MAX_ANISOTROPY 5
+#define VL_COVDET_AA_CONVERGENCE_THRESHOLD 1.001
+#define VL_COVDET_AA_ACCURATE_SMOOTHING VL_FALSE
+#define VL_COVDET_AA_PATCH_EXTENT (3*VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA)
+#define VL_COVDET_OR_ADDITIONAL_PEAKS_RELATIVE_SIZE 0.8
+#define VL_COVDET_LAP_NUM_LEVELS 10
+#define VL_COVDET_LAP_PATCH_RESOLUTION 16
+#define VL_COVDET_LAP_DEF_PEAK_THRESHOLD 0.01
+#define VL_COVDET_DOG_DEF_PEAK_THRESHOLD VL_COVDET_LAP_DEF_PEAK_THRESHOLD
+#define VL_COVDET_DOG_DEF_EDGE_THRESHOLD 10.0
+#define VL_COVDET_HARRIS_DEF_PEAK_THRESHOLD 0.000002
+#define VL_COVDET_HARRIS_DEF_EDGE_THRESHOLD 10.0
+#define VL_COVDET_HESSIAN_DEF_PEAK_THRESHOLD 0.003
+#define VL_COVDET_HESSIAN_DEF_EDGE_THRESHOLD 10.0
+
+/** @brief Covariant feature detector */
+struct _VlCovDet
+{
+  VlScaleSpace *gss ;        /**< Gaussian scale space. */
+  VlScaleSpace *css ;        /**< Cornerness scale space. */
+  VlCovDetMethod method ;    /**< feature extraction method. */
+  double peakThreshold ;     /**< peak threshold. */
+  double edgeThreshold ;     /**< edge threshold. */
+  double lapPeakThreshold;   /**< peak threshold for Laplacian scale selection. */
+  vl_size octaveResolution ; /**< resolution of each octave. */
+  vl_index firstOctave ;     /**< index of the first octave. */
+
+  double nonExtremaSuppression ;
+  vl_size numNonExtremaSuppressed ;
+
+  VlCovDetFeature *features ;
+  vl_size numFeatures ;
+  vl_size numFeatureBufferSize ;
+
+  float * patch ;
+  vl_size patchBufferSize ;
+
+  vl_bool transposed ;
+  VlCovDetFeatureOrientation orientations [VL_COVDET_MAX_NUM_ORIENTATIONS] ;
+  VlCovDetFeatureLaplacianScale scales [VL_COVDET_MAX_NUM_LAPLACIAN_SCALES] ;
+
+  vl_bool aaAccurateSmoothing ;
+  float aaPatch [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
+  float aaPatchX [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
+  float aaPatchY [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
+  float aaMask [(2*VL_COVDET_AA_PATCH_RESOLUTION+1)*(2*VL_COVDET_AA_PATCH_RESOLUTION+1)] ;
+
+  float lapPatch [(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)] ;
+  float laplacians [(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*(2*VL_COVDET_LAP_PATCH_RESOLUTION+1)*VL_COVDET_LAP_NUM_LEVELS] ;
+  vl_size numFeaturesWithNumScales [VL_COVDET_MAX_NUM_LAPLACIAN_SCALES + 1] ;
+}  ;
+
+VlEnumerator vlCovdetMethods [VL_COVDET_METHOD_NUM] = {
+  {"DoG" ,              (vl_index)VL_COVDET_METHOD_DOG               },
+  {"Hessian",           (vl_index)VL_COVDET_METHOD_HESSIAN           },
+  {"HessianLaplace",    (vl_index)VL_COVDET_METHOD_HESSIAN_LAPLACE   },
+  {"HarrisLaplace",     (vl_index)VL_COVDET_METHOD_HARRIS_LAPLACE    },
+  {"MultiscaleHessian", (vl_index)VL_COVDET_METHOD_MULTISCALE_HESSIAN},
+  {"MultiscaleHarris",  (vl_index)VL_COVDET_METHOD_MULTISCALE_HARRIS },
+  {0,                   0                                            }
+} ;
+
+/** @brief Create a new object instance
+ ** @param method method for covariant feature detection.
+ ** @return new covariant detector.
+ **/
+
+VlCovDet *
+vl_covdet_new (VlCovDetMethod method)
+{
+  VlCovDet * self = vl_calloc(sizeof(VlCovDet),1) ;
+  self->method = method ;
+  self->octaveResolution = 3 ;
+  self->firstOctave = -1 ;
+  switch (self->method) {
+    case VL_COVDET_METHOD_DOG :
+      self->peakThreshold = VL_COVDET_DOG_DEF_PEAK_THRESHOLD ;
+      self->edgeThreshold = VL_COVDET_DOG_DEF_EDGE_THRESHOLD ;
+      self->lapPeakThreshold = 0  ; /* not used */
+      break ;
+    case VL_COVDET_METHOD_HARRIS_LAPLACE:
+    case VL_COVDET_METHOD_MULTISCALE_HARRIS:
+      self->peakThreshold = VL_COVDET_HARRIS_DEF_PEAK_THRESHOLD ;
+      self->edgeThreshold = VL_COVDET_HARRIS_DEF_EDGE_THRESHOLD ;
+      self->lapPeakThreshold = VL_COVDET_LAP_DEF_PEAK_THRESHOLD ;
+      break ;
+    case VL_COVDET_METHOD_HESSIAN :
+    case VL_COVDET_METHOD_HESSIAN_LAPLACE:
+    case VL_COVDET_METHOD_MULTISCALE_HESSIAN:
+      self->peakThreshold = VL_COVDET_HESSIAN_DEF_PEAK_THRESHOLD ;
+      self->edgeThreshold = VL_COVDET_HESSIAN_DEF_EDGE_THRESHOLD ;
+      self->lapPeakThreshold = VL_COVDET_LAP_DEF_PEAK_THRESHOLD ;
+      break;
+    default:
+      assert(0) ;
+  }
+
+  self->nonExtremaSuppression = 0.5 ;
+  self->features = NULL ;
+  self->numFeatures = 0 ;
+  self->numFeatureBufferSize = 0 ;
+  self->patch = NULL ;
+  self->patchBufferSize = 0 ;
+  self->transposed = VL_FALSE ;
+  self->aaAccurateSmoothing = VL_COVDET_AA_ACCURATE_SMOOTHING ;
+
+  {
+    vl_index const w = VL_COVDET_AA_PATCH_RESOLUTION ;
+    vl_index i,j ;
+    double step = (2.0 * VL_COVDET_AA_PATCH_EXTENT) / (2*w+1) ;
+    double sigma = VL_COVDET_AA_RELATIVE_INTEGRATION_SIGMA ;
+    for (j = -w ; j <= w ; ++j) {
+      for (i = -w ; i <= w ; ++i) {
+        double dx = i*step/sigma ;
+        double dy = j*step/sigma ;
+        self->aaMask[(i+w) + (2*w+1)*(j+w)] = exp(-0.5*(dx*dx+dy*dy)) ;
+      }
+    }
+  }
+
+  {
+    /*
+     Covers one octave of Laplacian filters, from sigma=1 to sigma=2.
+     The spatial sampling step is 0.5.
+     */
+    vl_index s ;
+    for (s = 0 ; s < VL_COVDET_LAP_NUM_LEVELS ; ++s) {
+      double sigmaLap = pow(2.0, -0.5 +
+                            (double)s / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
+      double const sigmaImage = 1.0 / sqrt(2.0) ;
+      double const step = 0.5 * sigmaImage ;
+      double const sigmaDelta = sqrt(sigmaLap*sigmaLap - sigmaImage*sigmaImage) ;
+      vl_size const w = VL_COVDET_LAP_PATCH_RESOLUTION ;
+      vl_size const num = 2 * w + 1  ;
+      float * pt = self->laplacians + s * (num * num) ;
+
+      memset(pt, 0, num * num * sizeof(float)) ;
+
+#define at(x,y) pt[(x+w)+(y+w)*(2*w+1)]
+      at(0,0) = - 4.0 ;
+      at(-1,0) = 1.0 ;
+      at(+1,0) = 1.0 ;
+      at(0,1) = 1.0 ;
+      at(0,-1) = 1.0 ;
+#undef at
+
+      vl_imsmooth_f(pt, num,
+                    pt, num, num, num,
+                    sigmaDelta / step, sigmaDelta / step) ;
+
+#if 0
+      {
+        char name [200] ;
+        snprintf(name, 200, "/tmp/%f-lap.pgm", sigmaDelta) ;
+        vl_pgm_write_f(name, pt, num, num) ;
+      }
+#endif
+
+    }
+  }
+  return self ;
+}
+
+/** @brief Reset object
+ ** @param self object.
+ **
+ ** This function removes any buffered features and frees other
+ ** internal buffers.
+ **/
+
+void
+vl_covdet_reset (VlCovDet * self)
+{
+  if (self->features) {
+    vl_free(self->features) ;
+    self->features = NULL ;
+  }
+  if (self->css) {
+    vl_scalespace_delete(self->css) ;
+    self->css = NULL ;
+  }
+  if (self->gss) {
+    vl_scalespace_delete(self->gss) ;
+    self->gss = NULL ;
+  }
+}
+
+/** @brief Delete object instance
+ ** @param self object.
+ **/
+
+void
+vl_covdet_delete (VlCovDet * self)
+{
+  vl_covdet_reset(self) ;
+  if (self->patch) vl_free (self->patch) ;
+  vl_free(self) ;
+}
+
+/** @brief Append a feature to the internal buffer.
+ ** @param self object.
+ ** @param feature a pointer to the feature to append.
+ ** @return status.
+ **
+ ** The feature is copied. The function may fail with @c status
+ ** equal to ::VL_ERR_ALLOC if there is insufficient memory.
+ **/
+
+int
+vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature)
+{
+  vl_size requiredSize ;
+  assert(self) ;
+  assert(feature) ;
+  self->numFeatures ++ ;
+  requiredSize = self->numFeatures * sizeof(VlCovDetFeature) ;
+  if (requiredSize > self->numFeatureBufferSize) {
+    int err = _vl_resize_buffer((void**)&self->features, &self->numFeatureBufferSize,
+                                (self->numFeatures + 1000) * sizeof(VlCovDetFeature)) ;
+    if (err) {
+      self->numFeatures -- ;
+      return err ;
+    }
+  }
+  self->features[self->numFeatures - 1] = *feature ;
+  return VL_ERR_OK ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Process a new image */
+/* ---------------------------------------------------------------- */
+
+/** @brief Detect features in an image
+ ** @param self object.
+ ** @param image image to process.
+ ** @param width image width.
+ ** @param height image height.
+ ** @return status.
+ **
+ ** @a width and @a height must be at least one pixel. The function
+ ** fails by returing ::VL_ERR_ALLOC if the memory is insufficient.
+ **/
+
+int
+vl_covdet_put_image (VlCovDet * self,
+                     float const * image,
+                     vl_size width, vl_size height)
+{
+  vl_size const minOctaveSize = 16 ;
+  vl_index lastOctave ;
+  vl_index octaveFirstSubdivision ;
+  vl_index octaveLastSubdivision ;
+  VlScaleSpaceGeometry geom = vl_scalespace_get_default_geometry(width,height) ;
+
+  assert (self) ;
+  assert (image) ;
+  assert (width >= 1) ;
+  assert (height >= 1) ;
+
+  /* (minOctaveSize - 1) 2^lastOctave <= min(width,height) - 1 */
+  lastOctave = vl_floor_d(vl_log2_d(VL_MIN((double)width-1,(double)height-1) / (minOctaveSize - 1))) ;
+
+  if (self->method == VL_COVDET_METHOD_DOG) {
+    octaveFirstSubdivision = -1 ;
+    octaveLastSubdivision = self->octaveResolution + 1 ;
+  } else if (self->method == VL_COVDET_METHOD_HESSIAN) {
+    octaveFirstSubdivision = -1 ;
+    octaveLastSubdivision = self->octaveResolution ;
+  } else {
+    octaveFirstSubdivision = 0 ;
+    octaveLastSubdivision = self->octaveResolution - 1 ;
+  }
+
+  geom.width = width ;
+  geom.height = height ;
+  geom.firstOctave = self->firstOctave ;
+  geom.lastOctave = lastOctave ;
+  geom.octaveResolution = self->octaveResolution ;
+  geom.octaveFirstSubdivision = octaveFirstSubdivision ;
+  geom.octaveLastSubdivision = octaveLastSubdivision ;
+
+  if (self->gss == NULL ||
+      ! vl_scalespacegeometry_is_equal (geom,
+                                        vl_scalespace_get_geometry(self->gss)))
+  {
+    if (self->gss) vl_scalespace_delete(self->gss) ;
+    self->gss = vl_scalespace_new_with_geometry(geom) ;
+    if (self->gss == NULL) return VL_ERR_ALLOC ;
+  }
+  vl_scalespace_put_image(self->gss, image) ;
+  return VL_ERR_OK ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Cornerness measures */
+/* ---------------------------------------------------------------- */
+
+/** @brief Scaled derminant of the Hessian filter
+ ** @param hessian output image.
+ ** @param image input image.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param step image sampling step (pixel size).
+ ** @param sigma Gaussian smoothing of the input image.
+ **/
+
+static void
+_vl_det_hessian_response (float * hessian,
+                          float const * image,
+                          vl_size width, vl_size height,
+                          double step, double sigma)
+{
+  float factor = (float) pow(sigma/step, 4.0) ;
+  vl_index const xo = 1 ; /* x-stride */
+  vl_index const yo = width;  /* y-stride */
+  vl_size r, c;
+
+  float p11, p12, p13, p21, p22, p23, p31, p32, p33;
+
+  /* setup input pointer to be centered at 0,1 */
+  float const *in = image + yo ;
+
+  /* setup output pointer to be centered at 1,1 */
+  float *out = hessian + xo + yo;
+
+  /* move 3x3 window and convolve */
+  for (r = 1; r < height - 1; ++r)
+  {
+    /* fill in shift registers at the beginning of the row */
+    p11 = in[-yo]; p12 = in[xo - yo];
+    p21 = in[  0]; p22 = in[xo     ];
+    p31 = in[+yo]; p32 = in[xo + yo];
+    /* setup input pointer to (2,1) of the 3x3 square */
+    in += 2;
+    for (c = 1; c < width - 1; ++c)
+    {
+      float Lxx, Lyy, Lxy;
+      /* fetch remaining values (last column) */
+      p13 = in[-yo]; p23 = *in; p33 = in[+yo];
+
+      /* Compute 3x3 Hessian values from pixel differences. */
+      Lxx = (-p21 + 2*p22 - p23);
+      Lyy = (-p12 + 2*p22 - p32);
+      Lxy = ((p11 - p31 - p13 + p33)/4.0f);
+
+      /* normalize and write out */
+      *out = (Lxx * Lyy - Lxy * Lxy) * factor ;
+
+      /* move window */
+      p11=p12; p12=p13;
+      p21=p22; p22=p23;
+      p31=p32; p32=p33;
+
+      /* move input/output pointers */
+      in++; out++;
+    }
+    out += 2;
+  }
+
+  /* Copy the computed values to borders */
+  in = hessian + yo + xo ;
+  out = hessian + xo ;
+
+  /* Top row without corners */
+  memcpy(out, in, (width - 2)*sizeof(float));
+  out--;
+  in -= yo;
+
+  /* Left border columns without last row */
+  for (r = 0; r < height - 1; r++){
+    *out = *in;
+    *(out + yo - 1) = *(in + yo - 3);
+    in += yo;
+    out += yo;
+  }
+
+  /* Bottom corners */
+  in -= yo;
+  *out = *in;
+  *(out + yo - 1) = *(in + yo - 3);
+
+  /* Bottom row without corners */
+  out++;
+  memcpy(out, in, (width - 2)*sizeof(float));
+}
+
+/** @brief Scale-normalised Harris response
+ ** @param harris output image.
+ ** @param image input image.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param step image sampling step (pixel size).
+ ** @param sigma Gaussian smoothing of the input image.
+ ** @param sigmaI integration scale.
+ ** @param alpha factor in the definition of the Harris score.
+ **/
+
+static void
+_vl_harris_response (float * harris,
+                     float const * image,
+                     vl_size width, vl_size height,
+                     double step, double sigma,
+                     double sigmaI, double alpha)
+{
+  float factor = (float) pow(sigma/step, 4.0) ;
+  vl_index k ;
+
+  float * LxLx ;
+  float * LyLy ;
+  float * LxLy ;
+
+  LxLx = vl_malloc(sizeof(float) * width * height) ;
+  LyLy = vl_malloc(sizeof(float) * width * height) ;
+  LxLy = vl_malloc(sizeof(float) * width * height) ;
+
+  vl_imgradient_f (LxLx, LyLy, 1, width, image, width, height, width) ;
+
+  for (k = 0 ; k < (signed)(width * height) ; ++k) {
+    float dx = LxLx[k] ;
+    float dy = LyLy[k] ;
+    LxLx[k] = dx*dx ;
+    LyLy[k] = dy*dy ;
+    LxLy[k] = dx*dy ;
+  }
+
+  vl_imsmooth_f(LxLx, width, LxLx, width, height, width,
+                sigmaI / step, sigmaI / step) ;
+
+  vl_imsmooth_f(LyLy, width, LyLy, width, height, width,
+                sigmaI / step, sigmaI / step) ;
+
+  vl_imsmooth_f(LxLy, width, LxLy, width, height, width,
+                sigmaI / step, sigmaI / step) ;
+
+  for (k = 0 ; k < (signed)(width * height) ; ++k) {
+    float a = LxLx[k] ;
+    float b = LyLy[k] ;
+    float c = LxLy[k] ;
+
+    float determinant = a * b - c * c ;
+    float trace = a + b ;
+
+    harris[k] = factor * (determinant - alpha * (trace * trace)) ;
+  }
+
+  vl_free(LxLy) ;
+  vl_free(LyLy) ;
+  vl_free(LxLx) ;
+}
+
+/** @brief Difference of Gaussian
+ ** @param dog output image.
+ ** @param level1 input image at the smaller Gaussian scale.
+ ** @param level2 input image at the larger Gaussian scale.
+ ** @param width image width.
+ ** @param height image height.
+ **/
+
+static void
+_vl_dog_response (float * dog,
+                  float const * level1,
+                  float const * level2,
+                  vl_size width, vl_size height)
+{
+  vl_index k ;
+  for (k = 0 ; k < (signed)(width*height) ; ++k) {
+    dog[k] = level2[k] - level1[k] ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                  Detect features */
+/* ---------------------------------------------------------------- */
+
+/** @brief Detect scale-space features
+ ** @param self object.
+ **
+ ** This function runs the configured feature detector on the image
+ ** that was passed by using ::vl_covdet_put_image.
+ **/
+
+void
+vl_covdet_detect (VlCovDet * self, vl_size max_num_features)
+{
+  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
+  VlScaleSpaceGeometry cgeom ;
+  float * levelxx = NULL ;
+  float * levelyy = NULL ;
+  float * levelxy = NULL ;
+  vl_index o, s ;
+
+  assert (self) ;
+  assert (self->gss) ;
+
+  /* clear previous detections if any */
+  self->numFeatures = 0 ;
+
+  /* prepare buffers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+  cgeom = geom ;
+  if (self->method == VL_COVDET_METHOD_DOG) {
+    cgeom.octaveLastSubdivision -= 1 ;
+  }
+  if (!self->css ||
+      !vl_scalespacegeometry_is_equal(cgeom,
+                                      vl_scalespace_get_geometry(self->css)))
+  {
+    if (self->css) vl_scalespace_delete(self->css) ;
+    self->css = vl_scalespace_new_with_geometry(cgeom) ;
+  }
+  if (self->method == VL_COVDET_METHOD_HARRIS_LAPLACE ||
+      self->method == VL_COVDET_METHOD_MULTISCALE_HARRIS) {
+    VlScaleSpaceOctaveGeometry oct = vl_scalespace_get_octave_geometry(self->gss, geom.firstOctave) ;
+    levelxx = vl_malloc(oct.width * oct.height * sizeof(float)) ;
+    levelyy = vl_malloc(oct.width * oct.height * sizeof(float)) ;
+    levelxy = vl_malloc(oct.width * oct.height * sizeof(float)) ;
+  }
+
+  /* compute cornerness ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+  for (o = cgeom.firstOctave ; o <= cgeom.lastOctave ; ++o) {
+    VlScaleSpaceOctaveGeometry oct = vl_scalespace_get_octave_geometry(self->css, o) ;
+
+    for (s = cgeom.octaveFirstSubdivision ; s <= cgeom.octaveLastSubdivision ; ++s) {
+      float * level = vl_scalespace_get_level(self->gss, o, s) ;
+      float * clevel = vl_scalespace_get_level(self->css, o, s) ;
+      double sigma = vl_scalespace_get_level_sigma(self->css, o, s) ;
+      switch (self->method) {
+        case VL_COVDET_METHOD_DOG:
+          _vl_dog_response(clevel,
+                           vl_scalespace_get_level(self->gss, o, s + 1),
+                           level,
+                           oct.width, oct.height) ;
+          break ;
+
+        case VL_COVDET_METHOD_HARRIS_LAPLACE:
+        case VL_COVDET_METHOD_MULTISCALE_HARRIS:
+          _vl_harris_response(clevel,
+                              level, oct.width, oct.height, oct.step,
+                              sigma, 1.4 * sigma, 0.05) ;
+          break ;
+
+        case VL_COVDET_METHOD_HESSIAN:
+        case VL_COVDET_METHOD_HESSIAN_LAPLACE:
+        case VL_COVDET_METHOD_MULTISCALE_HESSIAN:
+          _vl_det_hessian_response(clevel, level, oct.width, oct.height, oct.step, sigma) ;
+          break ;
+
+        default:
+          assert(0) ;
+      }
+    }
+  }
+
+  /* find and refine local maxima ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+  {
+    vl_index * extrema = NULL ;
+    vl_size extremaBufferSize = 0 ;
+    vl_size numExtrema ;
+    vl_size index ;
+    for (o = cgeom.lastOctave; o >= cgeom.firstOctave; --o) {
+      VlScaleSpaceOctaveGeometry octgeom = vl_scalespace_get_octave_geometry(self->css, o) ;
+      double step = octgeom.step ;
+      vl_size width = octgeom.width ;
+      vl_size height = octgeom.height ;
+      vl_size depth = cgeom.octaveLastSubdivision - cgeom.octaveFirstSubdivision + 1 ;
+
+      switch (self->method) {
+        case VL_COVDET_METHOD_DOG:
+        case VL_COVDET_METHOD_HESSIAN:
+        {
+          /* scale-space extrema */
+          float const * octave =
+          vl_scalespace_get_level(self->css, o, cgeom.octaveFirstSubdivision) ;
+          numExtrema = vl_find_local_extrema_3(&extrema, &extremaBufferSize,
+                                               octave, width, height, depth,
+                                               0.8 * self->peakThreshold);
+          for (index = 0 ; index < numExtrema ; ++index) {
+            VlCovDetExtremum3 refined ;
+            VlCovDetFeature feature ;
+            vl_bool ok ;
+            memset(&feature, 0, sizeof(feature)) ;
+            ok = vl_refine_local_extreum_3(&refined,
+                                           octave, width, height, depth,
+                                           extrema[3*index+0],
+                                           extrema[3*index+1],
+                                           extrema[3*index+2]) ;
+            ok &= fabs(refined.peakScore) > self->peakThreshold ;
+            ok &= refined.edgeScore < self->edgeThreshold ;
+            if (ok) {
+              double sigma = cgeom.baseScale *
+              pow(2.0, o + (refined.z + cgeom.octaveFirstSubdivision)
+                  / cgeom.octaveResolution) ;
+              feature.frame.x = refined.x * step ;
+              feature.frame.y = refined.y * step ;
+              feature.frame.a11 = sigma ;
+              feature.frame.a12 = 0.0 ;
+              feature.frame.a21 = 0.0 ;
+              feature.frame.a22 = sigma ;
+              feature.o = o ;
+              feature.s = round(refined.z) ;
+              feature.peakScore = refined.peakScore ;
+              feature.edgeScore = refined.edgeScore ;
+              vl_covdet_append_feature(self, &feature) ;
+            }
+          }
+          break ;
+        }
+
+        default:
+        {
+          for (s = cgeom.octaveFirstSubdivision ; s < cgeom.octaveLastSubdivision ; ++s) {
+            /* space extrema */
+            float const * level = vl_scalespace_get_level(self->css,o,s) ;
+            numExtrema = vl_find_local_extrema_2(&extrema, &extremaBufferSize,
+                                                 level,
+                                                 width, height,
+                                                 0.8 * self->peakThreshold);
+            for (index = 0 ; index < numExtrema ; ++index) {
+              VlCovDetExtremum2 refined ;
+              VlCovDetFeature feature ;
+              vl_bool ok ;
+              memset(&feature, 0, sizeof(feature)) ;
+              ok = vl_refine_local_extreum_2(&refined,
+                                             level, width, height,
+                                             extrema[2*index+0],
+                                             extrema[2*index+1]);
+              ok &= fabs(refined.peakScore) > self->peakThreshold ;
+              ok &= refined.edgeScore < self->edgeThreshold ;
+              if (ok) {
+                double sigma = cgeom.baseScale *
+                pow(2.0, o + (double)s / cgeom.octaveResolution) ;
+                feature.frame.x = refined.x * step ;
+                feature.frame.y = refined.y * step ;
+                feature.frame.a11 = sigma ;
+                feature.frame.a12 = 0.0 ;
+                feature.frame.a21 = 0.0 ;
+                feature.frame.a22 = sigma ;
+                feature.o = o ;
+                feature.s = s ;
+                feature.peakScore = refined.peakScore ;
+                feature.edgeScore = refined.edgeScore ;
+                vl_covdet_append_feature(self, &feature) ;
+              }
+            }
+          }
+          break ;
+        }
+      }
+      if (self->numFeatures >= max_num_features) {
+        break;
+      }
+    } /* next octave */
+
+    if (extrema) { vl_free(extrema) ; extrema = 0 ; }
+  }
+
+  /* Laplacian scale selection for certain methods */
+  switch (self->method) {
+    case VL_COVDET_METHOD_HARRIS_LAPLACE :
+    case VL_COVDET_METHOD_HESSIAN_LAPLACE :
+      vl_covdet_extract_laplacian_scales (self) ;
+      break ;
+    default:
+      break ;
+  }
+
+  if (self->nonExtremaSuppression) {
+    vl_index i, j ;
+    double tol = self->nonExtremaSuppression ;
+    self->numNonExtremaSuppressed = 0 ;
+    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
+      double x = self->features[i].frame.x ;
+      double y = self->features[i].frame.y ;
+      double sigma = self->features[i].frame.a11 ;
+      double score = self->features[i].peakScore ;
+      if (score == 0) continue ;
+
+      for (j = 0 ; j < (signed)self->numFeatures ; ++j) {
+        double dx_ = self->features[j].frame.x - x ;
+        double dy_ = self->features[j].frame.y - y ;
+        double sigma_ = self->features[j].frame.a11 ;
+        double score_ = self->features[j].peakScore ;
+        if (score_ == 0) continue ;
+        if (sigma < (1+tol) * sigma_ &&
+            sigma_ < (1+tol) * sigma &&
+            vl_abs_d(dx_) < tol * sigma &&
+            vl_abs_d(dy_) < tol * sigma &&
+            vl_abs_d(score) > vl_abs_d(score_)) {
+          self->features[j].peakScore = 0 ;
+          self->numNonExtremaSuppressed ++ ;
+        }
+      }
+    }
+    j = 0 ;
+    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
+      VlCovDetFeature feature = self->features[i] ;
+      if (self->features[i].peakScore != 0) {
+        self->features[j++] = feature ;
+      }
+    }
+    self->numFeatures = j ;
+  }
+
+  if (levelxx) vl_free(levelxx) ;
+  if (levelyy) vl_free(levelyy) ;
+  if (levelxy) vl_free(levelxy) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                  Extract patches */
+/* ---------------------------------------------------------------- */
+
+/** @internal
+ ** @brief Helper for extracting patches
+ ** @param self object.
+ ** @param[out] sigma1 actual patch smoothing along the first axis.
+ ** @param[out] sigma2 actual patch smoothing along the second axis.
+ ** @param patch buffer.
+ ** @param resolution patch resolution.
+ ** @param extent patch extent.
+ ** @param sigma desired smoothing in the patch frame.
+ ** @param A_ linear transfomration from patch to image.
+ ** @param T_ translation from patch to image.
+ ** @param d1 first singular value @a A.
+ ** @param d2 second singular value of @a A.
+ **/
+
+vl_bool
+vl_covdet_extract_patch_helper (VlCovDet * self,
+                                double * sigma1,
+                                double * sigma2,
+                                float * patch,
+                                vl_size resolution,
+                                double extent,
+                                double sigma,
+                                double A_ [4],
+                                double T_ [2],
+                                double d1, double d2)
+{
+  vl_index o, s ;
+  double factor ;
+  double sigma_ ;
+  float const * level ;
+  vl_size width, height ;
+  double step ;
+
+  double A [4] = {A_[0], A_[1], A_[2], A_[3]} ;
+  double T [2] = {T_[0], T_[1]} ;
+
+  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
+  VlScaleSpaceOctaveGeometry oct ;
+
+  /* Starting from a pre-smoothed image at scale sigma_
+     because of the mapping A the resulting smoothing in
+     the warped patch is S, where
+
+        sigma_^2 I = A S A',
+
+        S = sigma_^2 inv(A) inv(A)' = sigma_^2 V D^-2 V',
+
+        A = U D V'.
+
+     Thus we rotate A by V to obtain an axis-aligned smoothing:
+
+        A = U*D,
+
+        S = sigma_^2 D^-2.
+
+     Then we search the scale-space for the best sigma_ such
+     that the target smoothing is approximated from below:
+
+        max sigma_(o,s) :    simga_(o,s) factor <= sigma,
+        factor = max{abs(D11), abs(D22)}.
+   */
+
+
+  /*
+   Determine the best level (o,s) such that sigma_(o,s) factor <= sigma.
+   This can be obtained by scanning octaves from smallest to largest
+   and stopping when no level in the octave satisfies the relation.
+
+   Given the range of octave availables, do the best you can.
+   */
+
+  factor = 1.0 / VL_MIN(d1, d2) ;
+
+  for (o = geom.firstOctave + 1 ; o <= geom.lastOctave ; ++o) {
+    s = vl_floor_d(vl_log2_d(sigma / (factor * geom.baseScale)) - o) ;
+    s = VL_MAX(s, geom.octaveFirstSubdivision) ;
+    s = VL_MIN(s, geom.octaveLastSubdivision) ;
+    sigma_ = geom.baseScale * pow(2.0, o + (double)s / geom.octaveResolution) ;
+    /*VL_PRINTF(".. %d D=%g %g; sigma_=%g factor*sigma_=%g\n", o, d1, d2, sigma_, factor* sigma_) ;*/
+    if (factor * sigma_ > sigma) {
+      o -- ;
+      break ;
+    }
+  }
+  o = VL_MIN(o, geom.lastOctave) ;
+  s = vl_floor_d(vl_log2_d(sigma / (factor * geom.baseScale)) - o) ;
+  s = VL_MAX(s, geom.octaveFirstSubdivision) ;
+  s = VL_MIN(s, geom.octaveLastSubdivision) ;
+  sigma_ = geom.baseScale * pow(2.0, o + (double)s / geom.octaveResolution) ;
+  if (sigma1) *sigma1 = sigma_ / d1 ;
+  if (sigma2) *sigma2 = sigma_ / d2 ;
+
+  /*VL_PRINTF("%d %d %g %g %g %g\n", o, s, factor, sigma_, factor * sigma_, sigma) ;*/
+
+  /*
+   Now the scale space level to be used for this warping has been
+   determined.
+
+   If the patch is partially or completely out of the image boundary,
+   create a padded copy of the required region first.
+   */
+
+  level = vl_scalespace_get_level(self->gss, o, s) ;
+  oct = vl_scalespace_get_octave_geometry(self->gss, o) ;
+  width = oct.width ;
+  height = oct.height ;
+  step = oct.step ;
+
+  A[0] /= step ;
+  A[1] /= step ;
+  A[2] /= step ;
+  A[3] /= step ;
+  T[0] /= step ;
+  T[1] /= step ;
+
+  {
+    /*
+     Warp the patch domain [x0hat,y0hat,x1hat,y1hat] to the image domain/
+     Obtain a box [x0,y0,x1,y1] enclosing that wrapped box, and then
+     an integer vertexes version [x0i, y0i, x1i, y1i], making room
+     for one pixel at the boundary to simplify bilinear interpolation
+     later on.
+     */
+    vl_index x0i, y0i, x1i, y1i ;
+    double x0 = +VL_INFINITY_D ;
+    double x1 = -VL_INFINITY_D ;
+    double y0 = +VL_INFINITY_D ;
+    double y1 = -VL_INFINITY_D ;
+    double boxx [4] = {extent, extent, -extent, -extent} ;
+    double boxy [4] = {-extent, extent, extent, -extent} ;
+    int i ;
+    for (i = 0 ; i < 4 ; ++i) {
+      double x = A[0] * boxx[i] + A[2] * boxy[i] + T[0] ;
+      double y = A[1] * boxx[i] + A[3] * boxy[i] + T[1] ;
+      x0 = VL_MIN(x0, x) ;
+      x1 = VL_MAX(x1, x) ;
+      y0 = VL_MIN(y0, y) ;
+      y1 = VL_MAX(y1, y) ;
+    }
+
+    /* Leave one pixel border for bilinear interpolation. */
+    x0i = floor(x0) - 1 ;
+    y0i = floor(y0) - 1 ;
+    x1i = ceil(x1) + 1 ;
+    y1i = ceil(y1) + 1 ;
+
+    /*
+     If the box [x0i,y0i,x1i,y1i] is not fully contained in the
+     image domain, then create a copy of this region by padding
+     the image. The image is extended by continuity.
+     */
+
+    if (x0i < 0 || x1i > (signed)width-1 ||
+        y0i < 0 || y1i > (signed)height-1) {
+      vl_index xi, yi ;
+
+      /* compute the amount of l,r,t,b padding needed to complete the patch */
+      vl_index padx0 = VL_MAX(0, - x0i) ;
+      vl_index pady0 = VL_MAX(0, - y0i) ;
+      vl_index padx1 = VL_MAX(0, x1i - ((signed)width - 1)) ;
+      vl_index pady1 = VL_MAX(0, y1i - ((signed)height - 1)) ;
+
+      /* make enough room for the patch */
+      vl_index patchWidth = x1i - x0i + 1 ;
+      vl_index patchHeight = y1i - y0i + 1 ;
+      vl_size patchBufferSize = patchWidth * patchHeight * sizeof(float) ;
+      if (patchBufferSize > self->patchBufferSize) {
+        int err = _vl_resize_buffer((void**)&self->patch, &self->patchBufferSize, patchBufferSize) ;
+        if (err) return vl_set_last_error(VL_ERR_ALLOC, NULL) ;
+      }
+
+      if (pady0 < patchHeight - pady1) {
+        /* start by filling the central horizontal band */
+        for (yi = y0i + pady0 ; yi < y0i + patchHeight - pady1 ; ++ yi) {
+          float *dst = self->patch + (yi - y0i) * patchWidth ;
+          float const *src = level + yi * width + VL_MIN(VL_MAX(0, x0i),(signed)width-1) ;
+          for (xi = x0i ; xi < x0i + padx0 ; ++xi) *dst++ = *src ;
+          for ( ; xi < x0i + patchWidth - padx1 - 2 ; ++xi) *dst++ = *src++ ;
+          for ( ; xi < x0i + patchWidth ; ++xi) *dst++ = *src ;
+        }
+        /* now extend the central band up and down */
+        for (yi = 0 ; yi < pady0 ; ++yi) {
+          memcpy(self->patch + yi * patchWidth,
+                 self->patch + pady0 * patchWidth,
+                 patchWidth * sizeof(float)) ;
+        }
+        for (yi = patchHeight - pady1 ; yi < patchHeight ; ++yi) {
+          memcpy(self->patch + yi * patchWidth,
+                 self->patch + (patchHeight - pady1 - 1) * patchWidth,
+                 patchWidth * sizeof(float)) ;
+        }
+      } else {
+        /* should be handled better! */
+        memset(self->patch, 0, self->patchBufferSize) ;
+      }
+#if 0
+      {
+        char name [200] ;
+        snprintf(name, 200, "/tmp/%20.0f-ext.pgm", 1e10*vl_get_cpu_time()) ;
+        vl_pgm_write_f(name, patch, patchWidth, patchWidth) ;
+      }
+#endif
+
+      level = self->patch ;
+      width = patchWidth ;
+      height = patchHeight ;
+      T[0] -= x0i ;
+      T[1] -= y0i ;
+    }
+  }
+
+  /*
+   Resample by using bilinear interpolation.
+   */
+  {
+    float * pt = patch ;
+    double yhat = -extent ;
+    vl_index xxi ;
+    vl_index yyi ;
+    double stephat = extent / resolution ;
+
+    for (yyi = 0 ; yyi < 2 * (signed)resolution + 1 ; ++yyi) {
+      double xhat = -extent ;
+      double rx = A[2] * yhat + T[0] ;
+      double ry = A[3] * yhat + T[1] ;
+      for (xxi = 0 ; xxi < 2 * (signed)resolution + 1 ; ++xxi) {
+        double x = A[0] * xhat + rx ;
+        double y = A[1] * xhat + ry ;
+        vl_index xi = vl_floor_d(x) ;
+        vl_index yi = vl_floor_d(y) ;
+        double i00 = level[yi * width + xi] ;
+        double i10 = level[yi * width + xi + 1] ;
+        double i01 = level[(yi + 1) * width + xi] ;
+        double i11 = level[(yi + 1) * width + xi + 1] ;
+        double wx = x - xi ;
+        double wy = y - yi ;
+
+        assert(xi >= 0 && xi <= (signed)width - 1) ;
+        assert(yi >= 0 && yi <= (signed)height - 1) ;
+
+        *pt++ =
+        (1.0 - wy) * ((1.0 - wx) * i00 + wx * i10) +
+        wy * ((1.0 - wx) * i01 + wx * i11) ;
+
+        xhat += stephat ;
+      }
+      yhat += stephat ;
+    }
+  }
+#if 0
+    {
+      char name [200] ;
+      snprintf(name, 200, "/tmp/%20.0f.pgm", 1e10*vl_get_cpu_time()) ;
+      vl_pgm_write_f(name, patch, 2*resolution+1, 2*resolution+1) ;
+    }
+#endif
+  return VL_ERR_OK ;
+}
+
+/** @brief Helper for extracting patches
+ ** @param self object.
+ ** @param patch buffer.
+ ** @param resolution patch resolution.
+ ** @param extent patch extent.
+ ** @param sigma desired smoothing in the patch frame.
+ ** @param frame feature frame.
+ **
+ ** The function considers a patch of extent <code>[-extent,extent]</code>
+ ** on each side, with a side counting <code>2*resolution+1</code> pixels.
+ ** In attempts to extract from the scale space a patch
+ ** based on the affine warping specified by @a frame in such a way
+ ** that the resulting smoothing of the image is @a sigma (in the
+ ** patch frame).
+ **
+ ** The transformation is specified by the matrices @c A and @c T
+ ** embedded in the feature @a frame. Note that this transformation maps
+ ** pixels from the patch frame to the image frame.
+ **/
+
+vl_bool
+vl_covdet_extract_patch_for_frame (VlCovDet * self,
+                                   float * patch,
+                                   vl_size resolution,
+                                   double extent,
+                                   double sigma,
+                                   VlFrameOrientedEllipse frame)
+{
+  double A[2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
+  double T[2] = {frame.x, frame.y} ;
+  double D[4], U[4], V[4] ;
+
+  vl_svd2(D, U, V, A) ;
+
+  return vl_covdet_extract_patch_helper
+  (self, NULL, NULL, patch, resolution, extent, sigma, A, T, D[0], D[3]) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                     Affine shape */
+/* ---------------------------------------------------------------- */
+
+/** @brief Extract the affine shape for a feature frame
+ ** @param self object.
+ ** @param adapted the shape-adapted frame.
+ ** @param frame the input frame.
+ ** @return ::VL_ERR_OK if affine adaptation is successful.
+ **
+ ** This function may fail if adaptation is unsuccessful or if
+ ** memory is insufficient.
+ **/
+
+int
+vl_covdet_extract_affine_shape_for_frame (VlCovDet * self,
+                                          VlFrameOrientedEllipse * adapted,
+                                          VlFrameOrientedEllipse frame)
+{
+  vl_index iter = 0 ;
+
+  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
+  double T [2] = {frame.x, frame.y} ;
+  double U [2*2] ;
+  double V [2*2] ;
+  double D [2*2] ;
+  double M [2*2] ;
+  double P [2*2] ;
+  double P_ [2*2] ;
+  double Q [2*2] ;
+  double sigma1, sigma2 ;
+  double sigmaD = VL_COVDET_AA_RELATIVE_DERIVATIVE_SIGMA ;
+  double factor ;
+  double anisotropy ;
+  double referenceScale ;
+  vl_size const resolution = VL_COVDET_AA_PATCH_RESOLUTION ;
+  vl_size const side = 2*VL_COVDET_AA_PATCH_RESOLUTION + 1 ;
+  double const extent = VL_COVDET_AA_PATCH_EXTENT ;
+
+
+  *adapted = frame ;
+
+  while (1) {
+    double lxx = 0, lxy = 0, lyy = 0 ;
+    vl_index k ;
+    int err ;
+
+    /* A = U D V' */
+    vl_svd2(D, U, V, A) ;
+    anisotropy = VL_MAX(D[0]/D[3], D[3]/D[0]) ;
+
+    /* VL_PRINTF("anisot: %g\n", anisotropy); */
+
+    if (anisotropy > VL_COVDET_AA_MAX_ANISOTROPY) {
+      /* diverged, give up with current solution */
+      break ;
+    }
+
+    /* make sure that the smallest singluar value stays fixed
+       after the first iteration */
+    if (iter == 0) {
+      referenceScale = VL_MIN(D[0], D[3]) ;
+      factor = 1.0 ;
+    } else {
+      factor = referenceScale / VL_MIN(D[0],D[3]) ;
+    }
+
+    D[0] *= factor ;
+    D[3] *= factor ;
+
+    A[0] = U[0] * D[0] ;
+    A[1] = U[1] * D[0] ;
+    A[2] = U[2] * D[3] ;
+    A[3] = U[3] * D[3] ;
+
+    adapted->a11 = A[0] ;
+    adapted->a21 = A[1] ;
+    adapted->a12 = A[2] ;
+    adapted->a22 = A[3] ;
+
+    if (++iter >= VL_COVDET_AA_MAX_NUM_ITERATIONS) break ;
+
+    err = vl_covdet_extract_patch_helper(self,
+                                         &sigma1, &sigma2,
+                                         self->aaPatch,
+                                         resolution,
+                                         extent,
+                                         sigmaD,
+                                         A, T, D[0], D[3]) ;
+    if (err) return err ;
+
+    if (self->aaAccurateSmoothing ) {
+      double deltaSigma1 = sqrt(VL_MAX(sigmaD*sigmaD - sigma1*sigma1,0)) ;
+      double deltaSigma2 = sqrt(VL_MAX(sigmaD*sigmaD - sigma2*sigma2,0)) ;
+      double stephat = extent / resolution ;
+      vl_imsmooth_f(self->aaPatch, side,
+                    self->aaPatch, side, side, side,
+                    deltaSigma1 / stephat, deltaSigma2 / stephat) ;
+    }
+
+    /* compute second moment matrix */
+    vl_imgradient_f (self->aaPatchX, self->aaPatchY, 1, side,
+                     self->aaPatch, side, side, side) ;
+
+    for (k = 0 ; k < (signed)(side*side) ; ++k) {
+      double lx = self->aaPatchX[k] ;
+      double ly = self->aaPatchY[k] ;
+      lxx += lx * lx * self->aaMask[k] ;
+      lyy += ly * ly * self->aaMask[k] ;
+      lxy += lx * ly * self->aaMask[k] ;
+    }
+    M[0] = lxx ;
+    M[1] = lxy ;
+    M[2] = lxy ;
+    M[3] = lyy ;
+
+    if (lxx == 0 || lyy == 0) {
+      *adapted = frame ;
+      break ;
+    }
+
+    /* decompose M = P * Q * P' */
+    vl_svd2 (Q, P, P_, M) ;
+
+    /*
+     Setting A <- A * dA results in M to change approximatively as
+
+     M --> dA'  M dA = dA' P Q P dA
+
+     To make this proportional to the identity, we set
+
+     dA ~= P Q^1/2
+
+     we also make it so the smallest singular value of A is unchanged.
+     */
+
+    if (Q[3]/Q[0] < VL_COVDET_AA_CONVERGENCE_THRESHOLD &&
+        Q[0]/Q[3] < VL_COVDET_AA_CONVERGENCE_THRESHOLD) {
+      break ;
+    }
+
+    {
+      double Ap [4] ;
+      double q0 = sqrt(Q[0]) ;
+      double q1 = sqrt(Q[3]) ;
+      Ap[0] = (A[0] * P[0] + A[2] * P[1]) / q0 ;
+      Ap[1] = (A[1] * P[0] + A[3] * P[1]) / q0 ;
+      Ap[2] = (A[0] * P[2] + A[2] * P[3]) / q1 ;
+      Ap[3] = (A[1] * P[2] + A[3] * P[3]) / q1 ;
+      memcpy(A,Ap,4*sizeof(double)) ;
+    }
+
+  } /* next iteration */
+
+  /*
+   Make upright.
+
+   Shape adaptation does not estimate rotation. This is fixed by default
+   so that a selected axis is not rotated at all (usually this is the
+   vertical axis for upright features). To do so, the frame is rotated
+   as follows.
+   */
+  {
+    double A [2*2] = {adapted->a11, adapted->a21, adapted->a12, adapted->a22} ;
+    double ref [2] ;
+    double ref_ [2] ;
+    double angle ;
+    double angle_ ;
+    double dangle ;
+    double r1, r2 ;
+
+    if (self->transposed) {
+      /* up is the x axis */
+      ref[0] = 1 ;
+      ref[1] = 0 ;
+    } else {
+      /* up is the y axis */
+      ref[0] = 0 ;
+      ref[1] = 1 ;
+    }
+
+    vl_solve_linear_system_2 (ref_, A, ref) ;
+    angle = atan2(ref[1], ref[0]) ;
+    angle_ = atan2(ref_[1], ref_[0]) ;
+    dangle = angle_ - angle ;
+    r1 = cos(dangle) ;
+    r2 = sin(dangle) ;
+    adapted->a11 = + A[0] * r1 + A[2] * r2 ;
+    adapted->a21 = + A[1] * r1 + A[3] * r2 ;
+    adapted->a12 = - A[0] * r2 + A[2] * r1 ;
+    adapted->a22 = - A[1] * r2 + A[3] * r1 ;
+  }
+
+  return VL_ERR_OK ;
+}
+
+/** @brief Extract the affine shape for the stored features
+ ** @param self object.
+ **
+ ** This function may discard features for which no affine
+ ** shape can reliably be detected.
+ **/
+
+void
+vl_covdet_extract_affine_shape (VlCovDet * self)
+{
+  vl_index i, j = 0 ;
+  vl_size numFeatures = vl_covdet_get_num_features(self) ;
+  VlCovDetFeature * feature = vl_covdet_get_features(self);
+  for (i = 0 ; i < (signed)numFeatures ; ++i) {
+    int status ;
+    VlFrameOrientedEllipse adapted ;
+    status = vl_covdet_extract_affine_shape_for_frame(self, &adapted, feature[i].frame) ;
+    if (status == VL_ERR_OK) {
+      feature[j] = feature[i] ;
+      feature[j].frame = adapted ;
+      ++ j ;
+    }
+  }
+  self->numFeatures = j ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                      Orientation */
+/* ---------------------------------------------------------------- */
+
+static int
+_vl_covdet_compare_orientations_descending (void const * a_,
+                                            void const * b_)
+{
+  VlCovDetFeatureOrientation const * a = a_ ;
+  VlCovDetFeatureOrientation const * b = b_ ;
+  if (a->score > b->score) return -1 ;
+  if (a->score < b->score) return +1 ;
+  return 0 ;
+}
+
+/** @brief Extract the orientation(s) for a feature
+ ** @param self object.
+ ** @param numOrientations the number of detected orientations.
+ ** @param frame pose of the feature.
+ ** @return an array of detected orientations with their scores.
+ **
+ ** The returned array is a matrix of size @f$ 2 \times n @f$
+ ** where <em>n</em> is the number of detected orientations.
+ **
+ ** The function returns @c NULL if memory is insufficient.
+ **/
+
+VlCovDetFeatureOrientation *
+vl_covdet_extract_orientations_for_frame (VlCovDet * self,
+                                          vl_size * numOrientations,
+                                          VlFrameOrientedEllipse frame)
+{
+  int err ;
+  vl_index k, i ;
+  vl_index iter ;
+
+  double extent = VL_COVDET_AA_PATCH_EXTENT ;
+  vl_size resolution = VL_COVDET_AA_PATCH_RESOLUTION ;
+  vl_size side = 2 * resolution + 1  ;
+
+  vl_size const numBins = VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS ;
+  double hist [VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS] ;
+  double const binExtent = 2 * VL_PI / VL_COVDET_OR_NUM_ORIENTATION_HISTOGAM_BINS ;
+  double const peakRelativeSize = VL_COVDET_OR_ADDITIONAL_PEAKS_RELATIVE_SIZE ;
+  double maxPeakValue ;
+
+  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
+  double T [2] = {frame.x, frame.y} ;
+  double U [2*2] ;
+  double V [2*2] ;
+  double D [2*2] ;
+  double sigma1, sigma2 ;
+  double sigmaD = 1.0 ;
+  double theta0 ;
+
+  assert(self);
+  assert(numOrientations) ;
+
+  /*
+   The goal is to estimate a rotation R(theta) such that the patch given
+   by the transformation A R(theta) has the strongest average
+   gradient pointing right (or down for transposed conventions).
+
+   To compensate for tha anisotropic smoothing due to warping,
+   A is decomposed as A = U D V' and the patch is warped by
+   U D only, meaning that the matrix R_(theta) will be estimated instead,
+   where:
+
+      A R(theta) = U D V' R(theta) = U D R_(theta)
+
+   such that R(theta) = V R(theta). That is an extra rotation of
+   theta0 = atan2(V(2,1),V(1,1)).
+   */
+
+  /* axis aligned anisotropic smoothing for easier compensation */
+  vl_svd2(D, U, V, A) ;
+
+  A[0] = U[0] * D[0] ;
+  A[1] = U[1] * D[0] ;
+  A[2] = U[2] * D[3] ;
+  A[3] = U[3] * D[3] ;
+
+  theta0 = atan2(V[1],V[0]) ;
+
+  err = vl_covdet_extract_patch_helper(self,
+                                       &sigma1, &sigma2,
+                                       self->aaPatch,
+                                       resolution,
+                                       extent,
+                                       sigmaD,
+                                       A, T, D[0], D[3]) ;
+
+  if (err) {
+    *numOrientations = 0 ;
+    return NULL ;
+  }
+
+  if (1) {
+    double deltaSigma1 = sqrt(VL_MAX(sigmaD*sigmaD - sigma1*sigma1,0)) ;
+    double deltaSigma2 = sqrt(VL_MAX(sigmaD*sigmaD - sigma2*sigma2,0)) ;
+    double stephat = extent / resolution ;
+    vl_imsmooth_f(self->aaPatch, side,
+                  self->aaPatch, side, side, side,
+                  deltaSigma1 / stephat, deltaSigma2 / stephat) ;
+  }
+
+  /* histogram of oriented gradients */
+  vl_imgradient_polar_f (self->aaPatchX, self->aaPatchY, 1, side,
+                         self->aaPatch, side, side, side) ;
+
+  memset (hist, 0, sizeof(double) * numBins) ;
+
+  for (k = 0 ; k < (signed)(side*side) ; ++k) {
+    double modulus = self->aaPatchX[k] ;
+    double angle = self->aaPatchY[k] ;
+    double weight = self->aaMask[k] ;
+
+    double x = angle / binExtent ;
+    vl_index bin = vl_floor_d(x) ;
+    double w2 = x - bin ;
+    double w1 = 1.0 - w2 ;
+
+    hist[(bin + numBins) % numBins] += w1 * (modulus * weight) ;
+    hist[(bin + numBins + 1) % numBins] += w2 * (modulus * weight) ;
+  }
+
+  /* smooth histogram */
+  for (iter = 0; iter < 6; iter ++) {
+    double prev = hist [numBins - 1] ;
+    double first = hist [0] ;
+    vl_index i ;
+    for (i = 0; i < (signed)numBins - 1; ++i) {
+      double curr = (prev + hist[i] + hist[(i + 1) % numBins]) / 3.0 ;
+      prev = hist[i] ;
+      hist[i] = curr ;
+    }
+    hist[i] = (prev + hist[i] + first) / 3.0 ;
+  }
+
+  /* find the histogram maximum */
+  maxPeakValue = 0 ;
+  for (i = 0 ; i < (signed)numBins ; ++i) {
+    maxPeakValue = VL_MAX (maxPeakValue, hist[i]) ;
+  }
+
+  /* find peaks within 80% from max */
+  *numOrientations = 0 ;
+  for(i = 0 ; i < (signed)numBins ; ++i) {
+    double h0 = hist [i] ;
+    double hm = hist [(i - 1 + numBins) % numBins] ;
+    double hp = hist [(i + 1 + numBins) % numBins] ;
+
+    /* is this a peak? */
+    if (h0 > peakRelativeSize * maxPeakValue && h0 > hm && h0 > hp) {
+      /* quadratic interpolation */
+      double di = - 0.5 * (hp - hm) / (hp + hm - 2 * h0) ;
+      double th = binExtent * (i + di) + theta0 ;
+      if (self->transposed) {
+        /* the axis to the right is y, measure orientations from this */
+        th = th - VL_PI/2 ;
+      }
+      self->orientations[*numOrientations].angle = th ;
+      self->orientations[*numOrientations].score = h0 ;
+      *numOrientations += 1 ;
+      //VL_PRINTF("%d %g\n", *numOrientations, th) ;
+
+      if (*numOrientations >= VL_COVDET_MAX_NUM_ORIENTATIONS) break ;
+    }
+  }
+
+  /* sort the orientations by decreasing scores */
+  qsort(self->orientations,
+        *numOrientations,
+        sizeof(VlCovDetFeatureOrientation),
+        _vl_covdet_compare_orientations_descending) ;
+
+  return self->orientations ;
+}
+
+/** @brief Extract the orientation(s) for the stored features.
+ ** @param self object.
+ **
+ ** Note that, since more than one orientation can be detected
+ ** for each feature, this function may create copies of them,
+ ** one for each orientation.
+ **/
+
+void
+vl_covdet_extract_orientations (VlCovDet * self)
+{
+  vl_index i, j  ;
+  vl_size numFeatures = vl_covdet_get_num_features(self) ;
+  for (i = 0 ; i < (signed)numFeatures ; ++i) {
+    vl_size numOrientations ;
+    VlCovDetFeature feature = self->features[i] ;
+    VlCovDetFeatureOrientation* orientations =
+    vl_covdet_extract_orientations_for_frame(self, &numOrientations, feature.frame) ;
+
+    for (j = 0 ; j < (signed)numOrientations ; ++j) {
+      double A [2*2] = {
+        feature.frame.a11,
+        feature.frame.a21,
+        feature.frame.a12,
+        feature.frame.a22} ;
+      double r1 = cos(orientations[j].angle) ;
+      double r2 = sin(orientations[j].angle) ;
+      VlCovDetFeature * oriented ;
+
+      if (j == 0) {
+        oriented = & self->features[i] ;
+      } else {
+        vl_covdet_append_feature(self, &feature) ;
+        oriented = & self->features[self->numFeatures -1] ;
+      }
+
+      oriented->orientationScore = orientations[j].score ;
+      oriented->frame.a11 = + A[0] * r1 + A[2] * r2 ;
+      oriented->frame.a21 = + A[1] * r1 + A[3] * r2 ;
+      oriented->frame.a12 = - A[0] * r2 + A[2] * r1 ;
+      oriented->frame.a22 = - A[1] * r2 + A[3] * r1 ;
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 Laplacian scales */
+/* ---------------------------------------------------------------- */
+
+/** @brief Extract the Laplacian scale(s) for a feature frame.
+ ** @param self object.
+ ** @param numScales the number of detected scales.
+ ** @param frame pose of the feature.
+ ** @return an array of detected scales.
+ **
+ ** The function returns @c NULL if memory is insufficient.
+ **/
+
+VlCovDetFeatureLaplacianScale *
+vl_covdet_extract_laplacian_scales_for_frame (VlCovDet * self,
+                                              vl_size * numScales,
+                                              VlFrameOrientedEllipse frame)
+{
+  /*
+   We try to explore one octave, with the nominal detection scale 1.0
+   (in the patch reference frame) in the middle. Thus the goal is to sample
+   the response of the tr-Laplacian operator at logarithmically
+   spaced scales in 1/sqrt(2), sqrt(2).
+
+   To this end, the patch is warped with a smoothing of at most
+   sigmaImage = 1 / sqrt(2) (beginning of the scale), sampled at
+   roughly twice the Nyquist frequency (so step = 1 / (2*sqrt(2))).
+   This maes it possible to approximate the Laplacian operator at
+   that scale by simple finite differences.
+
+   */
+  int err ;
+  double const sigmaImage = 1.0 / sqrt(2.0) ;
+  double const step = 0.5 * sigmaImage ;
+  double actualSigmaImage ;
+  vl_size const resolution = VL_COVDET_LAP_PATCH_RESOLUTION ;
+  vl_size const num = 2 * resolution + 1 ;
+  double extent = step * resolution ;
+  double scores [VL_COVDET_LAP_NUM_LEVELS] ;
+  double factor = 1.0 ;
+  float const * pt ;
+  vl_index k ;
+
+  double A[2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
+  double T[2] = {frame.x, frame.y} ;
+  double D[4], U[4], V[4] ;
+  double sigma1, sigma2 ;
+
+  assert(self) ;
+  assert(numScales) ;
+
+  *numScales = 0 ;
+
+  vl_svd2(D, U, V, A) ;
+
+  err = vl_covdet_extract_patch_helper
+  (self, &sigma1, &sigma2, self->lapPatch, resolution, extent, sigmaImage, A, T, D[0], D[3]) ;
+  if (err) return NULL ;
+
+  /* the actual smoothing after warping is never the target one */
+  if (sigma1 == sigma2) {
+    actualSigmaImage = sigma1 ;
+  } else {
+    /* here we could compensate */
+    actualSigmaImage = sqrt(sigma1*sigma2) ;
+  }
+
+  /* now multiply by the bank of Laplacians */
+  pt = self->laplacians ;
+  for (k = 0 ; k < VL_COVDET_LAP_NUM_LEVELS ; ++k) {
+    vl_index q ;
+    double score = 0 ;
+    double sigmaLap = pow(2.0, -0.5 + (double)k / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
+    /* note that the sqrt argument cannot be negative since by construction
+     sigmaLap >= sigmaImage */
+    sigmaLap = sqrt(sigmaLap*sigmaLap
+                    - sigmaImage*sigmaImage
+                    + actualSigmaImage*actualSigmaImage) ;
+
+    for (q = 0 ; q < (signed)(num * num) ; ++q) {
+      score += (*pt++) * self->lapPatch[q] ;
+    }
+    scores[k] = score * sigmaLap * sigmaLap ;
+  }
+
+  /* find and interpolate maxima */
+  for (k = 1 ; k < VL_COVDET_LAP_NUM_LEVELS - 1 ; ++k) {
+    double a = scores[k-1] ;
+    double b = scores[k] ;
+    double c = scores[k+1] ;
+    double t = self->lapPeakThreshold ;
+
+    if ((((b > a) && (b > c)) || ((b < a) && (b < c))) && (vl_abs_d(b) >= t)) {
+      double dk = - 0.5 * (c - a) / (c + a - 2 * b) ;
+      double s = k + dk ;
+      double sigmaLap = pow(2.0, -0.5 + s / (VL_COVDET_LAP_NUM_LEVELS - 1)) ;
+      double scale ;
+      sigmaLap = sqrt(sigmaLap*sigmaLap
+                      - sigmaImage*sigmaImage
+                      + actualSigmaImage*actualSigmaImage) ;
+      scale = sigmaLap / 1.0 ;
+      /*
+       VL_PRINTF("** k:%d, s:%f, sigmaLapFilter:%f, sigmaLap%f, scale:%f (%f %f %f)\n",
+       k,s,sigmaLapFilter,sigmaLap,scale,a,b,c) ;
+       */
+      if (*numScales < VL_COVDET_MAX_NUM_LAPLACIAN_SCALES) {
+        self->scales[*numScales].scale = scale * factor ;
+        self->scales[*numScales].score = b + 0.5 * (c - a) * dk ;
+        *numScales += 1 ;
+      }
+    }
+  }
+  return self->scales ;
+}
+
+/** @brief Extract the Laplacian scales for the stored features
+ ** @param self object.
+ **
+ ** Note that, since more than one orientation can be detected
+ ** for each feature, this function may create copies of them,
+ ** one for each orientation.
+ **/
+void
+vl_covdet_extract_laplacian_scales (VlCovDet * self)
+{
+  vl_index i, j  ;
+  vl_bool dropFeaturesWithoutScale = VL_TRUE ;
+  vl_size numFeatures = vl_covdet_get_num_features(self) ;
+  memset(self->numFeaturesWithNumScales, 0,
+         sizeof(self->numFeaturesWithNumScales)) ;
+
+  for (i = 0 ; i < (signed)numFeatures ; ++i) {
+    vl_size numScales ;
+    VlCovDetFeature feature = self->features[i] ;
+    VlCovDetFeatureLaplacianScale const * scales =
+    vl_covdet_extract_laplacian_scales_for_frame(self, &numScales, feature.frame) ;
+
+    self->numFeaturesWithNumScales[numScales] ++ ;
+
+    if (numScales == 0 && dropFeaturesWithoutScale) {
+      self->features[i].peakScore = 0 ;
+    }
+
+    for (j = 0 ; j < (signed)numScales ; ++j) {
+      VlCovDetFeature * scaled ;
+
+      if (j == 0) {
+        scaled = & self->features[i] ;
+      } else {
+        vl_covdet_append_feature(self, &feature) ;
+        scaled = & self->features[self->numFeatures -1] ;
+      }
+
+      scaled->laplacianScaleScore = scales[j].score ;
+      scaled->frame.a11 *= scales[j].scale ;
+      scaled->frame.a21 *= scales[j].scale ;
+      scaled->frame.a12 *= scales[j].scale ;
+      scaled->frame.a22 *= scales[j].scale ;
+    }
+  }
+  if (dropFeaturesWithoutScale) {
+    j = 0 ;
+    for (i = 0 ; i < (signed)self->numFeatures ; ++i) {
+      VlCovDetFeature feature = self->features[i] ;
+      if (feature.peakScore) {
+        self->features[j++] = feature ;
+      }
+    }
+    self->numFeatures = j ;
+  }
+
+}
+
+/* ---------------------------------------------------------------- */
+/*                       Checking that features are inside an image */
+/* ---------------------------------------------------------------- */
+
+vl_bool
+_vl_covdet_check_frame_inside (VlCovDet * self, VlFrameOrientedEllipse frame, double margin)
+{
+  double extent = margin ;
+  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
+  double T[2] = {frame.x, frame.y} ;
+  double x0 = +VL_INFINITY_D ;
+  double x1 = -VL_INFINITY_D ;
+  double y0 = +VL_INFINITY_D ;
+  double y1 = -VL_INFINITY_D ;
+  double boxx [4] = {extent, extent, -extent, -extent} ;
+  double boxy [4] = {-extent, extent, extent, -extent} ;
+  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
+  int i ;
+  for (i = 0 ; i < 4 ; ++i) {
+    double x = A[0] * boxx[i] + A[2] * boxy[i] + T[0] ;
+    double y = A[1] * boxx[i] + A[3] * boxy[i] + T[1] ;
+    x0 = VL_MIN(x0, x) ;
+    x1 = VL_MAX(x1, x) ;
+    y0 = VL_MIN(y0, y) ;
+    y1 = VL_MAX(y1, y) ;
+  }
+
+  return
+  0 <= x0 && x1 <= geom.width-1 &&
+  0 <= y0 && y1 <= geom.height-1 ;
+}
+
+/** @brief Drop features (partially) outside the image
+ ** @param self object.
+ ** @param margin geometric marging.
+ **
+ ** The feature extent is defined by @c maring. A bounding box
+ ** in the normalised feature frame containin a circle of radius
+ ** @a maring is created and mapped to the image by
+ ** the feature frame transformation. Then the feature
+ ** is dropped if the bounding box is not contained in the image.
+ **
+ ** For example, setting @c margin to zero drops a feature only
+ ** if its center is not contained.
+ **
+ ** Typically a valua of @c margin equal to 1 or 2 is used.
+ **/
+
+void
+vl_covdet_drop_features_outside (VlCovDet * self, double margin)
+{
+  vl_index i, j = 0 ;
+  vl_size numFeatures = vl_covdet_get_num_features(self) ;
+  for (i = 0 ; i < (signed)numFeatures ; ++i) {
+    vl_bool inside =
+    _vl_covdet_check_frame_inside (self, self->features[i].frame, margin) ;
+    if (inside) {
+      self->features[j] = self->features[i] ;
+      ++j ;
+    }
+  }
+  self->numFeatures = j ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Setters and getters */
+/* ---------------------------------------------------------------- */
+
+/* ---------------------------------------------------------------- */
+/** @brief Get wether images are passed in transposed
+ ** @param self object.
+ ** @return whether images are transposed.
+ **/
+vl_bool
+vl_covdet_get_transposed (VlCovDet const  * self)
+{
+  return self->transposed ;
+}
+
+/** @brief Set the index of the first octave
+ ** @param self object.
+ ** @param t whether images are transposed.
+ **/
+void
+vl_covdet_set_transposed (VlCovDet * self, vl_bool t)
+{
+  self->transposed = t ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the edge threshold
+ ** @param self object.
+ ** @return the edge threshold.
+ **/
+double
+vl_covdet_get_edge_threshold (VlCovDet const * self)
+{
+  return self->edgeThreshold ;
+}
+
+/** @brief Set the edge threshold
+ ** @param self object.
+ ** @param edgeThreshold the edge threshold.
+ **
+ ** The edge threshold must be non-negative.
+ **/
+void
+vl_covdet_set_edge_threshold (VlCovDet * self, double edgeThreshold)
+{
+  assert(edgeThreshold >= 0) ;
+  self->edgeThreshold = edgeThreshold ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the peak threshold
+ ** @param self object.
+ ** @return the peak threshold.
+ **/
+double
+vl_covdet_get_peak_threshold (VlCovDet const * self)
+{
+  return self->peakThreshold ;
+}
+
+/** @brief Set the peak threshold
+ ** @param self object.
+ ** @param peakThreshold the peak threshold.
+ **
+ ** The peak threshold must be non-negative.
+ **/
+void
+vl_covdet_set_peak_threshold (VlCovDet * self, double peakThreshold)
+{
+  assert(peakThreshold >= 0) ;
+  self->peakThreshold = peakThreshold ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the Laplacian peak threshold
+ ** @param self object.
+ ** @return the Laplacian peak threshold.
+ **
+ ** This parameter affects only the detecors using the Laplacian
+ ** scale selectino method such as Harris-Laplace.
+ **/
+double
+vl_covdet_get_laplacian_peak_threshold (VlCovDet const * self)
+{
+  return self->lapPeakThreshold ;
+}
+
+/** @brief Set the Laplacian peak threshold
+ ** @param self object.
+ ** @param peakThreshold the Laplacian peak threshold.
+ **
+ ** The peak threshold must be non-negative.
+ **/
+void
+vl_covdet_set_laplacian_peak_threshold (VlCovDet * self, double peakThreshold)
+{
+  assert(peakThreshold >= 0) ;
+  self->lapPeakThreshold = peakThreshold ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the index of the first octave
+ ** @param self object.
+ ** @return index of the first octave.
+ **/
+vl_index
+vl_covdet_get_first_octave (VlCovDet const * self)
+{
+  return self->firstOctave ;
+}
+
+/** @brief Set the index of the first octave
+ ** @param self object.
+ ** @param o index of the first octave.
+ **
+ ** Calling this function resets the detector.
+ **/
+void
+vl_covdet_set_first_octave (VlCovDet * self, vl_index o)
+{
+  self->firstOctave = o ;
+  vl_covdet_reset(self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the octave resolution.
+ ** @param self object.
+ ** @return octave resolution.
+ **/
+
+vl_size
+vl_covdet_get_octave_resolution (VlCovDet const * self)
+{
+  return self->octaveResolution ;
+}
+
+/** @brief Set the octave resolutuon.
+ ** @param self object.
+ ** @param r octave resoltuion.
+ **
+ ** Calling this function resets the detector.
+ **/
+
+void
+vl_covdet_set_octave_resolution (VlCovDet * self, vl_size r)
+{
+  self->octaveResolution = r ;
+  vl_covdet_reset(self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get whether affine adaptation uses accurate smoothing.
+ ** @param self object.
+ ** @return @c true if accurate smoothing is used.
+ **/
+
+vl_bool
+vl_covdet_get_aa_accurate_smoothing (VlCovDet const * self)
+{
+  return self->aaAccurateSmoothing ;
+}
+
+/** @brief Set whether affine adaptation uses accurate smoothing.
+ ** @param self object.
+ ** @param x whether accurate smoothing should be usd.
+ **/
+
+void
+vl_covdet_set_aa_accurate_smoothing (VlCovDet * self, vl_bool x)
+{
+  self->aaAccurateSmoothing = x ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the non-extrema suppression threshold
+ ** @param self object.
+ ** @return threshold.
+ **/
+
+double
+vl_covdet_get_non_extrema_suppression_threshold (VlCovDet const * self)
+{
+  return self->nonExtremaSuppression ;
+}
+
+/** @brief Set the non-extrema suppression threshod
+ ** @param self object.
+ ** @param x threshold.
+ **/
+
+void
+vl_covdet_set_non_extrema_suppression_threshold (VlCovDet * self, double x)
+{
+  self->nonExtremaSuppression = x ;
+}
+
+/** @brief Get the number of non-extrema suppressed
+ ** @param self object.
+ ** @return number.
+ **/
+
+vl_size
+vl_covdet_get_num_non_extrema_suppressed (VlCovDet const * self)
+{
+  return self->numNonExtremaSuppressed ;
+}
+
+
+/* ---------------------------------------------------------------- */
+/** @brief Get number of stored frames
+ ** @return number of frames stored in the detector.
+ **/
+vl_size
+vl_covdet_get_num_features (VlCovDet const * self)
+{
+  return self->numFeatures ;
+}
+
+/** @brief Get the stored frames
+ ** @return frames stored in the detector.
+ **/
+VlCovDetFeature *
+vl_covdet_get_features (VlCovDet * self)
+{
+  return self->features ;
+}
+
+/** @brief Get the Gaussian scale space
+ ** @return Gaussian scale space.
+ **
+ ** A Gaussian scale space exists only after calling ::vl_covdet_put_image.
+ ** Otherwise the function returns @c NULL.
+ **/
+
+VlScaleSpace *
+vl_covdet_get_gss (VlCovDet const * self)
+{
+  return self->gss ;
+}
+
+/** @brief Get the cornerness measure scale space
+ ** @return cornerness measure scale space.
+ **
+ ** A cornerness measure scale space exists only after calling
+ ** ::vl_covdet_detect. Otherwise the function returns @c NULL.
+ **/
+
+VlScaleSpace *
+vl_covdet_get_css (VlCovDet const * self)
+{
+  return self->css ;
+}
+
+/** @brief Get the number of features found with a certain number of scales
+ ** @param self object.
+ ** @param numScales length of the histogram (out).
+ ** @return histogram.
+ **
+ ** Calling this function makes sense only after running a detector
+ ** that uses the Laplacian as a secondary measure for scale
+ ** detection
+ **/
+
+vl_size const *
+vl_covdet_get_laplacian_scales_statistics (VlCovDet const * self,
+                                           vl_size * numScales)
+{
+  *numScales = VL_COVDET_MAX_NUM_LAPLACIAN_SCALES ;
+  return self->numFeaturesWithNumScales ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/covdet.h b/opensfm/src/third_party/vlfeat/vl/covdet.h
new file mode 100644
index 000000000..c0fdabb72
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/covdet.h
@@ -0,0 +1,263 @@
+/** @file covdet.h
+ ** @brief Covariant feature detectors (@ref covdet)
+ ** @author Karel Lenc
+ ** @author Andrea Vedaldi
+ ** @author Michal Perdoch
+ **/
+
+/*
+Copyright (C) 2013-14 Andrea Vedaldi.
+Copyright (C) 2012 Karel Lenc, Andrea Vedaldi and Michal Perdoch.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_COVDET_H
+#define VL_COVDET_H
+
+#include "generic.h"
+#include "stringop.h"
+#include "scalespace.h"
+
+#include <stdio.h>
+
+/* ---------------------------------------------------------------- */
+/*                                                   Feature Frames */
+/* ---------------------------------------------------------------- */
+
+/** @name Feature frames
+ ** @{ */
+
+/** @brief Types of feature frames */
+typedef enum _VlFrameType {
+  VL_FRAMETYPE_DISC = 1,         /**< A disc. */
+  VL_FRAMETYPE_ORIENTED_DISC,    /**< An oriented disc. */
+  VL_FRAMETYPE_ELLIPSE,          /**< An ellipse. */
+  VL_FRAMETYPE_ORIENTED_ELLIPSE, /**< An oriented ellipse. */
+  VL_FRAMETYPE_NUM
+} VlFrameType ;
+
+/** @brief Names of the frame types */
+VL_EXPORT const char* vlFrameNames [VL_FRAMETYPE_NUM] ;
+
+/** @brief Mapping between string values and VlFrameType values */
+VL_EXPORT VlEnumerator vlFrameTypes [VL_FRAMETYPE_NUM] ;
+
+/** @brief Disc feature frame */
+typedef struct _VlFrameDisc
+{
+  float x ;     /**< center x-coordinate */
+  float y ;     /**< center y-coordinate */
+  float sigma ; /**< radius or scale */
+} VlFrameDisc ;
+
+/** @brief Oriented disc feature frame
+ ** An upright frame has @c angle equal to zero.
+ **/
+typedef struct _VlFrameOrientedDisc {
+  float x ;     /**< center x-coordinate */
+  float y ;     /**< center y-coordinate */
+  float sigma ; /**< radius or scale */
+  float angle ; /**< rotation angle (rad) */
+} VlFrameOrientedDisc ;
+
+/** @brief Ellipse feature frame */
+typedef struct _VlFrameEllipse {
+  float x ;     /**< center x-coordinate */
+  float y ;     /**< center y-coordinate */
+  float e11 ;   /**< */
+  float e12 ;
+  float e22 ;
+} VlFrameEllipse ;
+
+/** @brief Oriented ellipse feature frame
+ ** The affine transformation transforms the ellipse shape into
+ ** a circular region. */
+typedef struct _VlFrameOrientedEllipse {
+  float x ;     /**< center x-coordinate */
+  float y ;     /**< center y-coordinate */
+  float a11 ;   /**< */
+  float a12 ;
+  float a21 ;
+  float a22 ;
+} VlFrameOrientedEllipse;
+
+/** @brief Get the size of a frame structure
+ ** @param frameType identifier of the type of frame.
+ ** @return size of the corresponding frame structure in bytes.
+ **/
+VL_INLINE vl_size
+vl_get_frame_size (VlFrameType frameType) {
+  switch (frameType) {
+    case VL_FRAMETYPE_DISC: return sizeof(VlFrameDisc);
+    case VL_FRAMETYPE_ORIENTED_DISC: return sizeof(VlFrameOrientedDisc);
+    case VL_FRAMETYPE_ELLIPSE: return sizeof(VlFrameEllipse);
+    case VL_FRAMETYPE_ORIENTED_ELLIPSE: return sizeof(VlFrameOrientedEllipse);
+    default:
+      assert(0);
+      break;
+  }
+  return 0;
+}
+
+/** @brief Get the size of a frame structure
+ ** @param affineAdaptation whether the detector use affine adaptation.
+ ** @param orientation whether the detector estimates the feature orientation.
+ ** @return the type of extracted frame.
+ **
+ ** Depedning on whether the detector estimate the affine shape
+ ** and orientation of a feature, different frame types
+ ** are extracted. */
+
+VL_INLINE VlFrameType
+vl_get_frame_type (vl_bool affineAdaptation, vl_bool orientation)
+{
+  if (affineAdaptation) {
+    if (orientation) {
+      return VL_FRAMETYPE_ORIENTED_ELLIPSE;
+    } else {
+      return VL_FRAMETYPE_ELLIPSE;
+    }
+  } else {
+    if (orientation) {
+      return VL_FRAMETYPE_ORIENTED_DISC;
+    } else {
+      return VL_FRAMETYPE_DISC;
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                       Covariant Feature Detector */
+/* ---------------------------------------------------------------- */
+
+/** @brief A detected feature shape and location */
+typedef struct _VlCovDetFeature
+{
+  VlFrameOrientedEllipse frame ; /**< feature frame. */
+  int o ; /**< Detected octave. */
+  int s ; /**< Octave subdivision. */
+  float peakScore ; /**< peak score. */
+  float edgeScore ; /**< edge score. */
+  float orientationScore ; /**< orientation score. */
+  float laplacianScaleScore ; /**< Laplacian scale score. */
+} VlCovDetFeature ;
+
+/** @brief A detected feature orientation */
+typedef struct _VlCovDetFeatureOrientation
+{
+  double angle ;
+  double score ;
+} VlCovDetFeatureOrientation ;
+
+/** @brief A detected feature Laplacian scale */
+typedef struct _VlCovDetFeatureLaplacianScale
+{
+  double scale ;
+  double score ;
+} VlCovDetFeatureLaplacianScale ;
+
+/** @brief Covariant feature detection method */
+typedef enum _VlCovDetMethod
+{
+  VL_COVDET_METHOD_DOG = 1,
+  VL_COVDET_METHOD_HESSIAN,
+  VL_COVDET_METHOD_HESSIAN_LAPLACE,
+  VL_COVDET_METHOD_HARRIS_LAPLACE,
+  VL_COVDET_METHOD_MULTISCALE_HESSIAN,
+  VL_COVDET_METHOD_MULTISCALE_HARRIS,
+  VL_COVDET_METHOD_NUM
+} VlCovDetMethod;
+
+/** @brief Mapping between strings and ::VlCovDetMethod values */
+VL_EXPORT VlEnumerator vlCovdetMethods [VL_COVDET_METHOD_NUM] ;
+
+#ifdef __DOXYGEN__
+/** @brief Covariant feature detector
+ ** @see @ref covdet */
+struct _VlCovDet { }
+#endif
+
+/** @brief Covariant feature detector
+ ** @see @ref covdet */
+typedef struct _VlCovDet VlCovDet ;
+
+/** @name Create and destroy
+ ** @{ */
+VL_EXPORT VlCovDet * vl_covdet_new (VlCovDetMethod method) ;
+VL_EXPORT void vl_covdet_delete (VlCovDet * self) ;
+VL_EXPORT void vl_covdet_reset (VlCovDet * self) ;
+/** @} */
+
+/** @name Process data
+ ** @{ */
+VL_EXPORT int vl_covdet_put_image (VlCovDet * self,
+                                    float const * image,
+                                    vl_size width, vl_size height) ;
+
+VL_EXPORT void vl_covdet_detect (VlCovDet * self, vl_size max_num_features) ;
+VL_EXPORT int vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature) ;
+VL_EXPORT void vl_covdet_extract_orientations (VlCovDet * self) ;
+VL_EXPORT void vl_covdet_extract_laplacian_scales (VlCovDet * self) ;
+VL_EXPORT void vl_covdet_extract_affine_shape (VlCovDet * self) ;
+
+VL_EXPORT VlCovDetFeatureOrientation *
+vl_covdet_extract_orientations_for_frame (VlCovDet * self,
+                                          vl_size *numOrientations,
+                                          VlFrameOrientedEllipse frame) ;
+
+VL_EXPORT VlCovDetFeatureLaplacianScale *
+vl_covdet_extract_laplacian_scales_for_frame (VlCovDet * self,
+                                              vl_size * numScales,
+                                              VlFrameOrientedEllipse frame) ;
+VL_EXPORT int
+vl_covdet_extract_affine_shape_for_frame (VlCovDet * self,
+                                          VlFrameOrientedEllipse * adapted,
+                                          VlFrameOrientedEllipse frame) ;
+
+VL_EXPORT vl_bool
+vl_covdet_extract_patch_for_frame (VlCovDet * self, float * patch,
+                                   vl_size resolution,
+                                   double extent,
+                                   double sigma,
+                                   VlFrameOrientedEllipse frame) ;
+
+VL_EXPORT void
+vl_covdet_drop_features_outside (VlCovDet * self, double margin) ;
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{ */
+VL_EXPORT vl_size vl_covdet_get_num_features (VlCovDet const * self) ;
+VL_EXPORT VlCovDetFeature * vl_covdet_get_features (VlCovDet * self) ;
+VL_EXPORT vl_index vl_covdet_get_first_octave (VlCovDet const * self) ;
+VL_EXPORT vl_size vl_covdet_get_octave_resolution (VlCovDet const * self) ;
+VL_EXPORT double vl_covdet_get_peak_threshold (VlCovDet const * self) ;
+VL_EXPORT double vl_covdet_get_edge_threshold (VlCovDet const * self) ;
+VL_EXPORT double vl_covdeg_get_laplacian_peak_threshold (VlCovDet const * self) ;
+VL_EXPORT vl_bool vl_covdet_get_transposed (VlCovDet const * self) ;
+VL_EXPORT VlScaleSpace *  vl_covdet_get_gss (VlCovDet const * self) ;
+VL_EXPORT VlScaleSpace *  vl_covdet_get_css (VlCovDet const * self) ;
+VL_EXPORT vl_bool vl_covdet_get_aa_accurate_smoothing (VlCovDet const * self) ;
+VL_EXPORT vl_size const * vl_covdet_get_laplacian_scales_statistics (VlCovDet const * self, vl_size * numScales) ;
+VL_EXPORT double vl_covdet_get_non_extrema_suppression_threshold (VlCovDet const * self) ;
+VL_EXPORT vl_size vl_covdet_get_num_non_extrema_suppressed (VlCovDet const * self) ;
+
+/** @} */
+
+/** @name Set parameters
+ ** @{ */
+VL_EXPORT void vl_covdet_set_first_octave (VlCovDet * self, vl_index o) ;
+VL_EXPORT void vl_covdet_set_octave_resolution (VlCovDet * self, vl_size r) ;
+VL_EXPORT void vl_covdet_set_peak_threshold (VlCovDet * self, double peakThreshold) ;
+VL_EXPORT void vl_covdet_set_edge_threshold (VlCovDet * self, double edgeThreshold) ;
+VL_EXPORT void vl_covdet_set_laplacian_peak_threshold (VlCovDet * self, double peakThreshold) ;
+VL_EXPORT void vl_covdet_set_transposed (VlCovDet * self, vl_bool t) ;
+VL_EXPORT void vl_covdet_set_aa_accurate_smoothing (VlCovDet * self, vl_bool x) ;
+VL_EXPORT void vl_covdet_set_non_extrema_suppression_threshold (VlCovDet * self, double x) ;
+/** @} */
+
+/* VL_COVDET_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/dsift.c b/opensfm/src/third_party/vlfeat/vl/dsift.c
new file mode 100644
index 000000000..b76c6184d
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/dsift.c
@@ -0,0 +1,775 @@
+/** @file dsift.c
+ ** @brief Dense SIFT - Definition
+ ** @author Andrea Vedaldi
+ ** @author Brian Fulkerson
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#include "dsift.h"
+#include "pgm.h"
+#include "mathop.h"
+#include "imopv.h"
+#include <math.h>
+#include <string.h>
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page dsift Dense Scale Invariant Feature Transform (DSIFT)
+@author Andrea Vedaldi
+@author Brian Fulkerson
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref dsift.h implements a dense version of @ref sift.h "SIFT". This is
+an object that can quickly compute descriptors for densely sampled
+keypoints with identical size and orientation. It can be reused for
+multiple images of the same size.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section dsift-intro Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@sa @ref sift "The SIFT module", @ref dsift-tech "Technical details"
+
+This module implements a fast algorithm for the calculation of a large
+number of SIFT descriptors of densely sampled features of the same
+scale and orientation. See the @ref sift "SIFT module" for an
+overview of SIFT.
+
+The feature frames (keypoints) are indirectly specified by the
+sampling steps (::vl_dsift_set_steps) and the sampling bounds
+(::vl_dsift_set_bounds).  The descriptor geometry (number and size of
+the spatial bins and number of orientation bins) can be customized
+(::vl_dsift_set_geometry, ::VlDsiftDescriptorGeometry).
+
+@image html dsift-geom.png "Dense SIFT descriptor geometry"
+
+By default, SIFT uses a Gaussian windowing function that discounts
+contributions of gradients further away from the descriptor
+centers. This function can be changed to a flat window by invoking
+::vl_dsift_set_flat_window. In this case, gradients are accumulated
+using only bilinear interpolation, but instad of being reweighted by a
+Gassuain window, they are all weighted equally. However, after
+gradients have been accumulated into a spatial bin, the whole bin is
+reweighted by the average of the Gaussian window over the spatial
+support of that bin. This &ldquo;approximation&rdquo; substantially
+improves speed with little or no loss of performance in applications.
+
+Keypoints are sampled in such a way that the centers of the spatial
+bins are at integer coordinates within the image boundaries. For
+instance, the top-left bin of the top-left descriptor is centered on
+the pixel (0,0). The bin immediately to the right at
+(<code>binSizeX</code>,0), where <code>binSizeX</code> is a paramtere
+in the ::VlDsiftDescriptorGeometry structure. ::vl_dsift_set_bounds
+can be used to further restrict sampling to the keypoints in an image.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+ @section dsift-usage Usage
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+DSIFT is implemented by a ::VlDsiftFilter object that can be used
+to process a sequence of images of a given geometry.
+To use the <b>DSIFT filter</b>:
+
+- Initialize a new DSIFT filter object by ::vl_dsift_new (or the simplified
+::vl_dsift_new_basic). Customize the descriptor parameters by
+::vl_dsift_set_steps, ::vl_dsift_set_geometry, etc.
+- Process an image by ::vl_dsift_process.
+- Retrieve the number of keypoints (::vl_dsift_get_keypoint_num), the
+  keypoints (::vl_dsift_get_keypoints), and their descriptors
+  (::vl_dsift_get_descriptors).
+- Optionally repeat for more images.
+- Delete the DSIFT filter by ::vl_dsift_delete.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section dsift-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This section extends the @ref sift-tech-descriptor "SIFT descriptor section"
+and specialzies it to the case of dense keypoints.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection dsift-tech-descriptor-dense Dense descriptors
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+When computing descriptors for many keypoints differing only by their
+position (and with null rotation), further simplifications are
+possible. In this case, in fact,
+
+@f{eqnarray*}
+     \mathbf{x} &=& m \sigma \hat{\mathbf{x}} + T,\\
+ h(t,i,j)
+ &=&
+ m \sigma \int
+ g_{\sigma_\mathrm{win}}(\mathbf{x} - T)\,
+ w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,
+ w\left(\frac{x - T_x}{m\sigma} - \hat{x}_i\right)\,
+ w\left(\frac{y - T_y}{m\sigma} - \hat{y}_j\right)\,
+ |J(\mathbf{x})|\,
+ d\mathbf{x}.
+@f}
+
+Since many different values of @e T are sampled, this is conveniently
+expressed as a separable convolution. First, we translate by @f$
+\mathbf{x}_{ij} = m\sigma(\hat x_i,\ \hat y_i)^\top @f$ and we use the
+symmetry of the various binning and windowing functions to write
+
+@f{eqnarray*}
+ h(t,i,j)
+ &=&
+ m \sigma \int
+ g_{\sigma_\mathrm{win}}(T' - \mathbf{x} - \mathbf{x}_{ij})\,
+ w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,
+ w\left(\frac{T'_x - x}{m\sigma}\right)\,
+ w\left(\frac{T'_y - y}{m\sigma}\right)\,
+ |J(\mathbf{x})|\,
+ d\mathbf{x},
+\\
+T' &=& T + m\sigma
+\left[\begin{array}{cc} x_i \\ y_j \end{array}\right].
+@f}
+
+Then we define kernels
+
+@f{eqnarray*}
+ k_i(x) &=&
+ \frac{1}{\sqrt{2\pi} \sigma_{\mathrm{win}}}
+ \exp\left(
+ -\frac{1}{2}
+ \frac{(x-x_i)^2}{\sigma_{\mathrm{win}}^2}
+ \right)
+ w\left(\frac{x}{m\sigma}\right),
+ \\
+ k_j(y) &=&
+ \frac{1}{\sqrt{2\pi} \sigma_{\mathrm{win}}}
+ \exp\left(
+ -\frac{1}{2}
+ \frac{(y-y_j)^2}{\sigma_{\mathrm{win}}^2}
+ \right)
+ w\left(\frac{y}{m\sigma}\right),
+@f}
+
+and obtain
+
+@f{eqnarray*}
+ h(t,i,j) &=& (k_ik_j * \bar J_t)\left( T + m\sigma
+\left[\begin{array}{cc} x_i \\ y_j \end{array}\right] \right),
+\\
+\bar J_t(\mathbf{x}) &=&  w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta_t)\,|J(\mathbf{x})|.
+@f}
+
+Furthermore, if we use a flat rather than Gaussian windowing function,
+the kernels do not depend on the bin, and we have
+
+@f{eqnarray*}
+ k(z) &=&
+ \frac{1}{\sigma_{\mathrm{win}}}
+ w\left(\frac{z}{m\sigma}\right),
+\\
+ h(t,i,j) &=& (k(x)k(y) * \bar J_t)\left( T + m\sigma
+\left[\begin{array}{cc} x_i \\ y_j \end{array}\right] \right),
+@f}
+
+(here @f$ \sigma_\mathrm{win} @f$ is the side of the flat window).
+
+@note In this case the binning functions @f$ k(z) @f$ are triangular
+and the convolution can be computed in time independent on the filter
+(i.e. descriptor bin) support size by integral signals.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection dsift-tech-sampling Sampling
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+To avoid resampling and dealing with special boundary conditions, we
+impose some mild restrictions on the geometry of the descriptors that
+can be computed. In particular, we impose that the bin centers @f$ T +
+m\sigma (x_i,\ y_j) @f$ are always at integer coordinates within the
+image boundaries. This eliminates the need for costly interpolation.
+This condition amounts to (expressed in terms of the @e x coordinate,
+and equally applicable to @e y)
+
+@f[
+ \{0,\dots, W-1\} \ni T_x + m\sigma x_i =
+ T_x + m\sigma i - \frac{N_x-1}{2}
+ = \bar T_x + m\sigma i,
+ \qquad i = 0,\dots,N_x-1.
+@f]
+
+Notice that for this condition to be satisfied, the @em descriptor
+center @f$ T_x @f$ needs to be either fractional or integer depending
+on @f$ N_x @f$ being even or odd. To eliminate this complication,
+it is simpler to use as a reference not the descriptor center @e T,
+but the coordinates of the upper-left bin @f$ \bar T @f$. Thus we
+sample the latter on a regular (integer) grid
+
+@f[
+ \left[\begin{array}{cc}
+   0 \\
+   0
+ \end{array}\right]
+ \leq
+ \bar T =
+ \left[\begin{array}{cc}
+   \bar T_x^{\min} + p \Delta_x \\
+   \bar T_y^{\min} + q \Delta_y \\
+ \end{array}\right]
+ \leq
+ \left[\begin{array}{cc}
+   W - 1 - m\sigma N_x \\
+   H - 1 - m\sigma N_y
+ \end{array}\right],
+ \quad
+ \bar T =
+ \left[\begin{array}{cc}
+   T_x - \frac{N_x - 1}{2} \\
+   T_y - \frac{N_y - 1}{2} \\
+  \end{array}\right]
+@f]
+
+and we impose that the bin size @f$ m \sigma @f$ is integer as well.
+
+**/
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Initialize new convolution kernel
+ ** @param binSize
+ ** @param numBins
+ ** @param binIndex negative to use flat window.
+ ** @param windowSize
+ ** @return a pointer to new filter.
+ **/
+
+float *
+_vl_dsift_new_kernel (int binSize, int numBins, int binIndex, double windowSize)
+{
+  int filtLen = 2 * binSize - 1 ;
+  float * ker = vl_malloc (sizeof(float) * filtLen) ;
+  float * kerIter = ker ;
+  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
+  /*
+  float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;
+  float sigma = 0.5F * ((numBins) * binSize) ;
+  */
+  float sigma = (float) binSize * (float) windowSize ;
+  int x ;
+
+  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
+    float z = (x - delta) / sigma ;
+    *kerIter++ = (1.0F - fabsf(x) / binSize) *
+      ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
+  }
+  return ker ;
+}
+
+static float
+_vl_dsift_get_bin_window_mean
+(int binSize, int numBins, int binIndex, double windowSize)
+{
+  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
+  /*float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;*/
+  float sigma = (float) binSize * (float) windowSize ;
+  int x ;
+
+  float acc = 0.0 ;
+  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
+    float z = (x - delta) / sigma ;
+    acc += ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
+  }
+  return acc /= (2 * binSize - 1) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Normalize histogram
+ ** @param begin first element of the histogram.
+ ** @param end last plus one element of the histogram.
+ **
+ ** The function divides the specified histogram by its l2 norm.
+ **/
+
+VL_INLINE float
+_vl_dsift_normalize_histogram (float * begin, float * end)
+{
+  float * iter ;
+  float  norm = 0.0F ;
+
+  for (iter = begin ; iter < end ; ++ iter) {
+    norm += (*iter) * (*iter) ;
+  }
+  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;
+
+  for (iter = begin; iter < end ; ++ iter) {
+    *iter /= norm ;
+  }
+  return norm ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Free internal buffers
+ ** @param self DSIFT filter.
+ **/
+
+static void
+_vl_dsift_free_buffers (VlDsiftFilter* self)
+{
+  if (self->frames) {
+    vl_free(self->frames) ;
+    self->frames = NULL ;
+  }
+  if (self->descrs) {
+    vl_free(self->descrs) ;
+    self->descrs = NULL ;
+  }
+  if (self->grads) {
+    int t ;
+    for (t = 0 ; t < self->numGradAlloc ; ++t)
+      if (self->grads[t]) vl_free(self->grads[t]) ;
+    vl_free(self->grads) ;
+    self->grads = NULL ;
+  }
+  self->numFrameAlloc = 0 ;
+  self->numBinAlloc = 0 ;
+  self->numGradAlloc = 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Updates internal buffers to current geometry
+ **/
+
+VL_EXPORT void
+_vl_dsift_update_buffers (VlDsiftFilter * self)
+{
+  int x1 = self->boundMinX ;
+  int x2 = self->boundMaxX ;
+  int y1 = self->boundMinY ;
+  int y2 = self->boundMaxY ;
+
+  int rangeX = x2 - x1 - (self->geom.numBinX - 1) * self->geom.binSizeX ;
+  int rangeY = y2 - y1 - (self->geom.numBinY - 1) * self->geom.binSizeY ;
+
+  int numFramesX = (rangeX >= 0) ? rangeX / self->stepX + 1 : 0 ;
+  int numFramesY = (rangeY >= 0) ? rangeY / self->stepY + 1 : 0 ;
+
+  self->numFrames = numFramesX * numFramesY ;
+  self->descrSize = self->geom.numBinT *
+                    self->geom.numBinX *
+                    self->geom.numBinY ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Allocate internal buffers
+ ** @param self DSIFT filter.
+ **
+ ** The function (re)allocates the internal buffers in accordance with
+ ** the current image and descriptor geometry.
+ **/
+
+static void
+_vl_dsift_alloc_buffers (VlDsiftFilter* self)
+{
+  _vl_dsift_update_buffers (self) ;
+  {
+    int numFrameAlloc = vl_dsift_get_keypoint_num (self) ;
+    int numBinAlloc   = vl_dsift_get_descriptor_size (self) ;
+    int numGradAlloc  = self->geom.numBinT ;
+
+    /* see if we need to update the buffers */
+    if (numBinAlloc != self->numBinAlloc ||
+        numGradAlloc != self->numGradAlloc ||
+        numFrameAlloc != self->numFrameAlloc) {
+
+      int t ;
+
+      _vl_dsift_free_buffers(self) ;
+
+      self->frames = vl_malloc(sizeof(VlDsiftKeypoint) * numFrameAlloc) ;
+      self->descrs = vl_malloc(sizeof(float) * numBinAlloc * numFrameAlloc) ;
+      self->grads  = vl_malloc(sizeof(float*) * numGradAlloc) ;
+      for (t = 0 ; t < numGradAlloc ; ++t) {
+        self->grads[t] =
+          vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
+      }
+      self->numBinAlloc = numBinAlloc ;
+      self->numGradAlloc = numGradAlloc ;
+      self->numFrameAlloc = numFrameAlloc ;
+    }
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new DSIFT filter
+ **
+ ** @param imWidth width of the image.
+ ** @param imHeight height of the image
+ **
+ ** @return new filter.
+ **/
+
+VL_EXPORT VlDsiftFilter *
+vl_dsift_new (int imWidth, int imHeight)
+{
+  VlDsiftFilter * self = vl_malloc (sizeof(VlDsiftFilter)) ;
+  self->imWidth  = imWidth ;
+  self->imHeight = imHeight ;
+
+  self->stepX = 5 ;
+  self->stepY = 5 ;
+
+  self->boundMinX = 0 ;
+  self->boundMinY = 0 ;
+  self->boundMaxX = imWidth - 1 ;
+  self->boundMaxY = imHeight - 1 ;
+
+  self->geom.numBinX = 4 ;
+  self->geom.numBinY = 4 ;
+  self->geom.numBinT = 8 ;
+  self->geom.binSizeX = 5 ;
+  self->geom.binSizeY = 5 ;
+
+  self->useFlatWindow = VL_FALSE ;
+  self->windowSize = 2.0 ;
+
+  self->convTmp1 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
+  self->convTmp2 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
+
+  self->numBinAlloc = 0 ;
+  self->numFrameAlloc = 0 ;
+  self->numGradAlloc = 0 ;
+
+  self->descrSize = 0 ;
+  self->numFrames = 0 ;
+  self->grads = NULL ;
+  self->frames = NULL ;
+  self->descrs = NULL ;
+
+  _vl_dsift_update_buffers(self) ;
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new DSIFT filter (basic interface)
+ ** @param imWidth width of the image.
+ ** @param imHeight height of the image.
+ ** @param step sampling step.
+ ** @param binSize bin size.
+ ** @return new filter.
+ **
+ ** The descriptor geometry matches the standard SIFT descriptor.
+ **/
+
+VL_EXPORT VlDsiftFilter *
+vl_dsift_new_basic (int imWidth, int imHeight, int step, int binSize)
+{
+  VlDsiftFilter* self = vl_dsift_new(imWidth, imHeight) ;
+  VlDsiftDescriptorGeometry geom = *vl_dsift_get_geometry(self) ;
+  geom.binSizeX = binSize ;
+  geom.binSizeY = binSize ;
+  vl_dsift_set_geometry(self, &geom) ;
+  vl_dsift_set_steps(self, step, step) ;
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Delete DSIFT filter
+ ** @param self DSIFT filter.
+ **/
+
+VL_EXPORT void
+vl_dsift_delete (VlDsiftFilter * self)
+{
+  _vl_dsift_free_buffers (self) ;
+  if (self->convTmp2) vl_free (self->convTmp2) ;
+  if (self->convTmp1) vl_free (self->convTmp1) ;
+  vl_free (self) ;
+}
+
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Process with Gaussian window
+ ** @param self DSIFT filter.
+ **/
+
+VL_INLINE void
+_vl_dsift_with_gaussian_window (VlDsiftFilter * self)
+{
+  int binx, biny, bint ;
+  int framex, framey ;
+  float *xker, *yker ;
+
+  int Wx = self->geom.binSizeX - 1 ;
+  int Wy = self->geom.binSizeY - 1 ;
+
+  for (biny = 0 ; biny < self->geom.numBinY ; ++biny) {
+
+    yker = _vl_dsift_new_kernel (self->geom.binSizeY,
+                                 self->geom.numBinY,
+                                 biny,
+                                 self->windowSize) ;
+
+    for (binx = 0 ; binx < self->geom.numBinX ; ++binx) {
+
+      xker = _vl_dsift_new_kernel(self->geom.binSizeX,
+                                  self->geom.numBinX,
+                                  binx,
+                                  self->windowSize) ;
+
+      for (bint = 0 ; bint < self->geom.numBinT ; ++bint) {
+
+        vl_imconvcol_vf (self->convTmp1, self->imHeight,
+                         self->grads[bint], self->imWidth, self->imHeight,
+                         self->imWidth,
+                         yker, -Wy, +Wy, 1,
+                         VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
+
+        vl_imconvcol_vf (self->convTmp2, self->imWidth,
+                         self->convTmp1, self->imHeight, self->imWidth,
+                         self->imHeight,
+                         xker, -Wx, +Wx, 1,
+                         VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
+
+        {
+          float *dst = self->descrs
+            + bint
+            + binx * self->geom.numBinT
+            + biny * (self->geom.numBinX * self->geom.numBinT)  ;
+
+          float *src = self->convTmp2 ;
+
+          int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
+          int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
+          int descrSize = vl_dsift_get_descriptor_size (self) ;
+
+          for (framey  = self->boundMinY ;
+               framey <= self->boundMaxY - frameSizeY + 1 ;
+               framey += self->stepY) {
+            for (framex  = self->boundMinX ;
+                 framex <= self->boundMaxX - frameSizeX + 1 ;
+                 framex += self->stepX) {
+              *dst = src [(framex + binx * self->geom.binSizeX) * 1 +
+                          (framey + biny * self->geom.binSizeY) * self->imWidth]  ;
+              dst += descrSize ;
+            } /* framex */
+          } /* framey */
+        }
+
+      } /* for bint */
+      vl_free (xker) ;
+    } /* for binx */
+    vl_free (yker) ;
+  } /* for biny */
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Process with flat window.
+ ** @param self DSIFT filter object.
+ **/
+
+VL_INLINE void
+_vl_dsift_with_flat_window (VlDsiftFilter* self)
+{
+  int binx, biny, bint ;
+  int framex, framey ;
+
+  /* for each orientation bin */
+  for (bint = 0 ; bint < self->geom.numBinT ; ++bint) {
+
+    vl_imconvcoltri_f (self->convTmp1, self->imHeight,
+                       self->grads [bint], self->imWidth, self->imHeight,
+                       self->imWidth,
+                       self->geom.binSizeY, /* filt size */
+                       1, /* subsampling step */
+                       VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
+
+    vl_imconvcoltri_f (self->convTmp2, self->imWidth,
+                       self->convTmp1, self->imHeight, self->imWidth,
+                       self->imHeight,
+                       self->geom.binSizeX,
+                       1,
+                       VL_PAD_BY_CONTINUITY|VL_TRANSPOSE) ;
+
+    for (biny = 0 ; biny < self->geom.numBinY ; ++biny) {
+
+      /*
+      This fast version of DSIFT does not use a proper Gaussian
+      weighting scheme for the gradiens that are accumulated on the
+      spatial bins. Instead each spatial bins is accumulated based on
+      the triangular kernel only, equivalent to bilinear interpolation
+      plus a flat, rather than Gaussian, window. Eventually, however,
+      the magnitude of the spatial bins in the SIFT descriptor is
+      reweighted by the average of the Gaussian window on each bin.
+      */
+
+      float wy = _vl_dsift_get_bin_window_mean
+        (self->geom.binSizeY, self->geom.numBinY, biny,
+         self->windowSize) ;
+
+      /* The convolution functions vl_imconvcoltri_* convolve by a
+       * triangular kernel with unit integral. Instead for SIFT the
+       * triangular kernel should have unit height. This is
+       * compensated for by multiplying by the bin size:
+       */
+
+      wy *= self->geom.binSizeY ;
+
+      for (binx = 0 ; binx < self->geom.numBinX ; ++binx) {
+        float w ;
+        float wx = _vl_dsift_get_bin_window_mean (self->geom.binSizeX,
+                                                  self->geom.numBinX,
+                                                  binx,
+                                                  self->windowSize) ;
+
+        float *dst = self->descrs
+          + bint
+          + binx * self->geom.numBinT
+          + biny * (self->geom.numBinX * self->geom.numBinT)  ;
+
+        float *src = self->convTmp2 ;
+
+        int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
+        int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
+        int descrSize = vl_dsift_get_descriptor_size (self) ;
+
+        wx *= self->geom.binSizeX ;
+        w = wx * wy ;
+
+        for (framey  = self->boundMinY ;
+             framey <= self->boundMaxY - frameSizeY + 1 ;
+             framey += self->stepY) {
+          for (framex  = self->boundMinX ;
+               framex <= self->boundMaxX - frameSizeX + 1 ;
+               framex += self->stepX) {
+            *dst = w * src [(framex + binx * self->geom.binSizeX) * 1 +
+                            (framey + biny * self->geom.binSizeY) * self->imWidth]  ;
+            dst += descrSize ;
+          } /* framex */
+        } /* framey */
+      } /* binx */
+    } /* biny */
+  } /* bint */
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Compute keypoints and descriptors
+ **
+ ** @param self DSIFT filter.
+ ** @param im   image data.
+ **/
+
+void vl_dsift_process (VlDsiftFilter* self, float const* im)
+{
+  int t, x, y ;
+
+  /* update buffers */
+  _vl_dsift_alloc_buffers (self) ;
+
+  /* clear integral images */
+  for (t = 0 ; t < self->geom.numBinT ; ++t)
+    memset (self->grads[t], 0,
+            sizeof(float) * self->imWidth * self->imHeight) ;
+
+#undef at
+#define at(x,y) (im[(y)*self->imWidth+(x)])
+
+  /* Compute gradients, their norm, and their angle */
+
+  for (y = 0 ; y < self->imHeight ; ++ y) {
+    for (x = 0 ; x < self->imWidth ; ++ x) {
+      float gx, gy ;
+      float angle, mod, nt, rbint ;
+      int bint ;
+
+      /* y derivative */
+      if (y == 0) {
+        gy = at(x,y+1) - at(x,y) ;
+      } else if (y == self->imHeight - 1) {
+        gy = at(x,y) - at(x,y-1) ;
+      } else {
+        gy = 0.5F * (at(x,y+1) - at(x,y-1)) ;
+      }
+
+      /* x derivative */
+      if (x == 0) {
+        gx = at(x+1,y) - at(x,y) ;
+      } else if (x == self->imWidth - 1) {
+        gx = at(x,y) - at(x-1,y) ;
+      } else {
+        gx = 0.5F * (at(x+1,y) - at(x-1,y)) ;
+      }
+
+      /* angle and modulus */
+      angle = vl_fast_atan2_f (gy,gx) ;
+      mod = vl_fast_sqrt_f (gx*gx + gy*gy) ;
+
+      /* quantize angle */
+      nt = vl_mod_2pi_f (angle) * (self->geom.numBinT / (2*VL_PI)) ;
+      bint = (int) vl_floor_f (nt) ;
+      rbint = nt - bint ;
+
+      /* write it back */
+      self->grads [(bint    ) % self->geom.numBinT][x + y * self->imWidth] = (1 - rbint) * mod ;
+      self->grads [(bint + 1) % self->geom.numBinT][x + y * self->imWidth] = (    rbint) * mod ;
+    }
+  }
+
+  if (self->useFlatWindow) {
+    _vl_dsift_with_flat_window(self) ;
+  } else {
+    _vl_dsift_with_gaussian_window(self) ;
+  }
+
+  {
+    VlDsiftKeypoint* frameIter = self->frames ;
+    float * descrIter = self->descrs ;
+    int framex, framey, bint ;
+
+    int frameSizeX = self->geom.binSizeX * (self->geom.numBinX - 1) + 1 ;
+    int frameSizeY = self->geom.binSizeY * (self->geom.numBinY - 1) + 1 ;
+    int descrSize = vl_dsift_get_descriptor_size (self) ;
+
+    float deltaCenterX = 0.5F * self->geom.binSizeX * (self->geom.numBinX - 1) ;
+    float deltaCenterY = 0.5F * self->geom.binSizeY * (self->geom.numBinY - 1) ;
+
+    float normConstant = frameSizeX * frameSizeY ;
+
+    for (framey  = self->boundMinY ;
+         framey <= self->boundMaxY - frameSizeY + 1 ;
+         framey += self->stepY) {
+
+      for (framex  = self->boundMinX ;
+           framex <= self->boundMaxX - frameSizeX + 1 ;
+           framex += self->stepX) {
+
+        frameIter->x    = framex + deltaCenterX ;
+        frameIter->y    = framey + deltaCenterY ;
+
+        /* mass */
+        {
+          float mass = 0 ;
+          for (bint = 0 ; bint < descrSize ; ++ bint)
+            mass += descrIter[bint] ;
+          mass /= normConstant ;
+          frameIter->norm = mass ;
+        }
+
+        /* L2 normalize */
+        _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ;
+
+        /* clamp */
+        for(bint = 0 ; bint < descrSize ; ++ bint)
+          if (descrIter[bint] > 0.2F) descrIter[bint] = 0.2F ;
+
+        /* L2 normalize */
+        _vl_dsift_normalize_histogram (descrIter, descrIter + descrSize) ;
+
+        frameIter ++ ;
+        descrIter += descrSize ;
+      } /* for framex */
+    } /* for framey */
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/dsift.h b/opensfm/src/third_party/vlfeat/vl/dsift.h
new file mode 100644
index 000000000..8bb301b7e
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/dsift.h
@@ -0,0 +1,354 @@
+/** @file dsift.h
+ ** @brief Dense SIFT (@ref dsift)
+ ** @author Andrea Vedaldi
+ ** @author Brian Fulkerson
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_DSIFT_H
+#define VL_DSIFT_H
+
+#include "generic.h"
+
+/** @brief Dense SIFT keypoint */
+typedef struct VlDsiftKeypoint_
+{
+  double x ; /**< x coordinate */
+  double y ; /**< y coordinate */
+  double s ; /**< scale */
+  double norm ; /**< SIFT descriptor norm */
+} VlDsiftKeypoint ;
+
+/** @brief Dense SIFT descriptor geometry */
+typedef struct VlDsiftDescriptorGeometry_
+{
+  int numBinT ;  /**< number of orientation bins */
+  int numBinX ;  /**< number of bins along X */
+  int numBinY ;  /**< number of bins along Y */
+  int binSizeX ; /**< size of bins along X */
+  int binSizeY ; /**< size of bins along Y */
+} VlDsiftDescriptorGeometry ;
+
+/** @brief Dense SIFT filter */
+typedef struct VlDsiftFilter_
+{
+  int imWidth ;            /**< @internal @brief image width */
+  int imHeight ;           /**< @internal @brief image height */
+
+  int stepX ;              /**< frame sampling step X */
+  int stepY ;              /**< frame sampling step Y */
+
+  int boundMinX ;          /**< frame bounding box min X */
+  int boundMinY ;          /**< frame bounding box min Y */
+  int boundMaxX ;          /**< frame bounding box max X */
+  int boundMaxY ;          /**< frame bounding box max Y */
+
+  /** descriptor parameters */
+  VlDsiftDescriptorGeometry geom ;
+
+  int useFlatWindow ;      /**< flag: whether to approximate the Gaussian window with a flat one */
+  double windowSize ;      /**< size of the Gaussian window */
+
+  int numFrames ;          /**< number of sampled frames */
+  int descrSize ;          /**< size of a descriptor */
+  VlDsiftKeypoint *frames ; /**< frame buffer */
+  float *descrs ;          /**< descriptor buffer */
+
+  int numBinAlloc ;        /**< buffer allocated: descriptor size */
+  int numFrameAlloc ;      /**< buffer allocated: number of frames  */
+  int numGradAlloc ;       /**< buffer allocated: number of orientations */
+
+  float **grads ;          /**< gradient buffer */
+  float *convTmp1 ;        /**< temporary buffer */
+  float *convTmp2 ;        /**< temporary buffer */
+}  VlDsiftFilter ;
+
+VL_EXPORT VlDsiftFilter *vl_dsift_new (int width, int height) ;
+VL_EXPORT VlDsiftFilter *vl_dsift_new_basic (int width, int height, int step, int binSize) ;
+VL_EXPORT void vl_dsift_delete (VlDsiftFilter *self) ;
+VL_EXPORT void vl_dsift_process (VlDsiftFilter *self, float const* im) ;
+VL_INLINE void vl_dsift_transpose_descriptor (float* dst,
+                                             float const* src,
+                                             int numBinT,
+                                             int numBinX,
+                                             int numBinY) ;
+
+/** @name Setting parameters
+ ** @{
+ **/
+VL_INLINE void vl_dsift_set_steps (VlDsiftFilter *self,
+                                  int stepX,
+                                  int stepY) ;
+VL_INLINE void vl_dsift_set_bounds (VlDsiftFilter *self,
+                                   int minX,
+                                   int minY,
+                                   int maxX,
+                                   int maxY) ;
+VL_INLINE void vl_dsift_set_geometry (VlDsiftFilter *self,
+                                      VlDsiftDescriptorGeometry const* geom) ;
+VL_INLINE void vl_dsift_set_flat_window (VlDsiftFilter *self, vl_bool useFlatWindow) ;
+VL_INLINE void vl_dsift_set_window_size (VlDsiftFilter *self, double windowSize) ;
+/** @} */
+
+/** @name Retrieving data and parameters
+ ** @{
+ **/
+VL_INLINE float const    *vl_dsift_get_descriptors     (VlDsiftFilter const *self) ;
+VL_INLINE int             vl_dsift_get_descriptor_size (VlDsiftFilter const *self) ;
+VL_INLINE int             vl_dsift_get_keypoint_num    (VlDsiftFilter const *self) ;
+VL_INLINE VlDsiftKeypoint const *vl_dsift_get_keypoints (VlDsiftFilter const *self) ;
+VL_INLINE void            vl_dsift_get_bounds          (VlDsiftFilter const *self,
+                                                       int* minX,
+                                                       int* minY,
+                                                       int* maxX,
+                                                       int* maxY) ;
+VL_INLINE void            vl_dsift_get_steps           (VlDsiftFilter const* self,
+                                                       int* stepX,
+                                                       int* stepY) ;
+VL_INLINE VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self) ;
+VL_INLINE vl_bool         vl_dsift_get_flat_window     (VlDsiftFilter const *self) ;
+VL_INLINE double          vl_dsift_get_window_size     (VlDsiftFilter const *self) ;
+/** @} */
+
+VL_EXPORT
+void _vl_dsift_update_buffers (VlDsiftFilter *self) ;
+
+/** ------------------------------------------------------------------
+ ** @brief Get descriptor size.
+ ** @param self DSIFT filter object.
+ ** @return size of a descriptor.
+ **/
+
+int
+vl_dsift_get_descriptor_size (VlDsiftFilter const *self)
+{
+  return self->descrSize ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get descriptors.
+ ** @param self DSIFT filter object.
+ ** @return descriptors.
+ **/
+
+float const *
+vl_dsift_get_descriptors (VlDsiftFilter const *self)
+{
+  return self->descrs ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get keypoints
+ ** @param self DSIFT filter object.
+ **/
+
+VlDsiftKeypoint const *
+vl_dsift_get_keypoints (VlDsiftFilter const *self)
+{
+  return self->frames ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get number of keypoints
+ ** @param self DSIFT filter object.
+ **/
+
+int
+vl_dsift_get_keypoint_num (VlDsiftFilter const *self)
+{
+  return self->numFrames ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get SIFT descriptor geometry
+ ** @param self DSIFT filter object.
+ ** @return DSIFT descriptor geometry.
+ **/
+
+VlDsiftDescriptorGeometry const* vl_dsift_get_geometry (VlDsiftFilter const *self)
+{
+  return &self->geom ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get bounds
+ ** @param self DSIFT filter object.
+ ** @param minX bounding box minimum X coordinate.
+ ** @param minY bounding box minimum Y coordinate.
+ ** @param maxX bounding box maximum X coordinate.
+ ** @param maxY bounding box maximum Y coordinate.
+ **/
+
+void
+vl_dsift_get_bounds (VlDsiftFilter const* self,
+                    int *minX, int *minY, int *maxX, int *maxY)
+{
+  *minX = self->boundMinX ;
+  *minY = self->boundMinY ;
+  *maxX = self->boundMaxX ;
+  *maxY = self->boundMaxY ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get flat window flag
+ ** @param self DSIFT filter object.
+ ** @return @c TRUE if the DSIFT filter uses a flat window.
+ **/
+
+int
+vl_dsift_get_flat_window (VlDsiftFilter const* self)
+{
+  return self->useFlatWindow ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get steps
+ ** @param self DSIFT filter object.
+ ** @param stepX sampling step along X.
+ ** @param stepY sampling step along Y.
+ **/
+
+void
+vl_dsift_get_steps (VlDsiftFilter const* self,
+                   int* stepX,
+                   int* stepY)
+{
+  *stepX = self->stepX ;
+  *stepY = self->stepY ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set steps
+ ** @param self DSIFT filter object.
+ ** @param stepX sampling step along X.
+ ** @param stepY sampling step along Y.
+ **/
+
+void
+vl_dsift_set_steps (VlDsiftFilter* self,
+                   int stepX,
+                   int stepY)
+{
+  self->stepX = stepX ;
+  self->stepY = stepY ;
+  _vl_dsift_update_buffers(self) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set bounds
+ ** @param self DSIFT filter object.
+ ** @param minX bounding box minimum X coordinate.
+ ** @param minY bounding box minimum Y coordinate.
+ ** @param maxX bounding box maximum X coordinate.
+ ** @param maxY bounding box maximum Y coordinate.
+ **/
+
+void
+vl_dsift_set_bounds (VlDsiftFilter* self,
+                    int minX, int minY, int maxX, int maxY)
+{
+  self->boundMinX = minX ;
+  self->boundMinY = minY ;
+  self->boundMaxX = maxX ;
+  self->boundMaxY = maxY ;
+  _vl_dsift_update_buffers(self) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set SIFT descriptor geometry
+ ** @param self DSIFT filter object.
+ ** @param geom descriptor geometry parameters.
+ **/
+
+void
+vl_dsift_set_geometry (VlDsiftFilter *self,
+                       VlDsiftDescriptorGeometry const *geom)
+{
+  self->geom = *geom ;
+  _vl_dsift_update_buffers(self) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set flat window flag
+ ** @param self DSIFT filter object.
+ ** @param useFlatWindow @c true if the DSIFT filter should use a flat window.
+ **/
+
+void
+vl_dsift_set_flat_window (VlDsiftFilter* self,
+                         vl_bool useFlatWindow)
+{
+  self->useFlatWindow = useFlatWindow ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Transpose descriptor
+ **
+ ** @param dst destination buffer.
+ ** @param src source buffer.
+ ** @param numBinT
+ ** @param numBinX
+ ** @param numBinY
+ **
+ ** The function writes to @a dst the transpose of the SIFT descriptor
+ ** @a src. Let <code>I</code> be an image. The transpose operator
+ ** satisfies the equation <code>transpose(dsift(I,x,y)) =
+ ** dsift(transpose(I),y,x)</code>
+ **/
+
+VL_INLINE void
+vl_dsift_transpose_descriptor (float* dst,
+                              float const* src,
+                              int numBinT,
+                              int numBinX,
+                              int numBinY)
+{
+  int t, x, y ;
+
+  for (y = 0 ; y < numBinY ; ++y) {
+    for (x = 0 ; x < numBinX ; ++x) {
+      int offset  = numBinT * (x + y * numBinX) ;
+      int offsetT = numBinT * (y + x * numBinY) ;
+
+      for (t = 0 ; t < numBinT ; ++t) {
+        int tT = numBinT / 4 - t ;
+        dst [offsetT + (tT + numBinT) % numBinT] = src [offset + t] ;
+      }
+    }
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set SIFT descriptor Gaussian window size
+ ** @param self DSIFT filter object.
+ ** @param windowSize window size.
+ **/
+
+void
+vl_dsift_set_window_size(VlDsiftFilter * self, double windowSize)
+{
+  assert(windowSize >= 0.0) ;
+  self->windowSize = windowSize ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get SIFT descriptor Gaussian window size
+ ** @param self DSIFT filter object.
+ ** @return window size.
+ **/
+
+VL_INLINE double
+vl_dsift_get_window_size(VlDsiftFilter const * self)
+{
+  return self->windowSize ;
+}
+
+/*  VL_DSIFT_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/fisher.c b/opensfm/src/third_party/vlfeat/vl/fisher.c
new file mode 100644
index 000000000..480e29fc6
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/fisher.c
@@ -0,0 +1,586 @@
+/** @file fisher.c
+ ** @brief Fisher - Declaration
+ ** @author David Novotny
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page fisher Fisher Vector encoding (FV)
+@author David Novotny
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref fisher.h implements the Fisher Vectors (FV) image representation
+@cite{perronnin06fisher} @cite{perronnin10improving}. A FV is a
+statistics capturing the distribution of a set of vectors, usually a
+set of local image descriptors.
+
+@ref fisher-starting demonstrates how to use the C API to compute the
+FV representation of an image. For further details refer to:
+
+- @subpage fisher-fundamentals - Fisher Vector definition.
+- @subpage fisher-derivation - Deriving the Fisher Vectors as a Fisher Kernel.
+- @subpage fisher-kernel - The Fisher Kernel in general.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section fisher-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The Fisher Vector encoding of a set of features is obtained by using
+the function ::vl_fisher_encode. Note that the function requires a
+@ref gmm "Gaussian Mixture Model" (GMM) of the encoded feature
+distribution. In the following code, the result of the coding process
+is stored in the @c enc array and the improved fisher vector
+normalization is used.
+
+@code
+float * means ;
+float * covariances ;
+float * priors ;
+float * posteriors ;
+float * enc;
+
+// create a GMM object and cluster input data to get means, covariances
+// and priors of the estimated mixture
+gmm = vl_gmm_new (VL_TYPE_FLOAT) ;
+vl_gmm_cluster (gmm, data, dimension, numData, numClusters);
+
+// allocate space for the encoding
+enc = vl_malloc(sizeof(float) * 2 * dimension * numClusters);
+
+// run fisher encoding
+vl_fisher_encode
+    (enc, VL_F_TYPE,
+     vl_gmm_get_means(gmm), dimension, numClusters,
+     vl_gmm_get_covariances(gmm),
+     vl_gmm_get_priors(gmm),
+     dataToEncode, numDataToEncode,
+     VL_FISHER_FLAG_IMPROVED
+     ) ;
+@endcode
+
+The performance of the standard Fisher Vector can be significantly
+improved @cite{perronnin10improving} by using appropriate @ref
+fisher-normalization normalizations. These are controlled by the @c
+flag parameter of ::vl_fisher_encode.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page fisher-fundamentals Fisher vector fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page describes the *Fisher Vector* (FV) of
+@cite{perronnin06fisher} @cite{perronnin10improving}. See @ref fisher
+for an overview of the C API and @ref fisher-kernel for its relation
+to the more general notion of Fisher kernel.
+
+The FV is an image representation obtained by pooling local image
+features. It is frequently used as a global image descriptor in visual
+classification.
+
+While the FV can be @ref fisher-kernel "derived" as a special,
+approximate, and improved case of the general Fisher Kernel framework,
+it is easy to describe directly. Let $I = (\bx_1,\dots,\bx_N)$ be a
+set of $D$ dimensional feature vectors (e.g. SIFT descriptors)
+extracted from an image. Let
+$\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$ be the parameters of a
+@ref gmm "Gaussian Mixture Model" fitting the distribution of
+descriptors. The GMM associates each vector $\bx_i$ to a mode $k$ in
+the mixture with a strength given by the posterior probability:
+
+\[
+  q_{ik} =
+  \frac
+  {\exp\left[-\frac{1}{2}(\bx_i - \mu_k)^T \Sigma_k^{-1} (\bx_i - \mu_k)\right]}
+  {\sum_{t=1}^K \exp\left[-\frac{1}{2}(\bx_i - \mu_t)^T \Sigma_k^{-1} (\bx_i - \mu_t)\right]}.
+\]
+
+For each mode $k$, consider the mean and covariance deviation vectors
+
+@f{align*}
+u_{jk} &=
+{1 \over {N \sqrt{\pi_k}}}
+\sum_{i=1}^{N}
+q_{ik} \frac{x_{ji} - \mu_{jk}}{\sigma_{jk}},
+\\
+v_{jk} &=
+{1 \over {N \sqrt{2 \pi_k}}}
+\sum_{i=1}^{N}
+q_{ik} \left[ \left(\frac{x_{ji} - \mu_{jk}}{\sigma_{jk}}\right)^2 - 1 \right].
+@f}
+
+where $j=1,2,\dots,D$ spans the vector dimensions. The FV of image $I$
+is the stacking of the vectors $\bu_k$ and then of the vectors
+$\bv_k$ for each of the $K$ modes in the Gaussian mixtures:
+
+\[
+ \Phi(I) = \begin{bmatrix} \vdots \\ \bu_k \\ \vdots \\ \bv_k \\ \vdots \end{bmatrix}.
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section fisher-normalization Normalization and improved Fisher vectors
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The *improved* Fisher Vector @cite{perronnin10improving} (IFV) improves the
+classification performance of the representation by using to ideas:
+
+1. *Non-linear additive kernel.* The Hellinger's kernel (or
+   Bhattacharya coefficient) can be used instead of the linear one at
+   no cost by signed squared rooting. This is obtained by applying the
+   function $|z| \sign z$ to each dimension of the vector $\Phi(I)$.
+   Other @ref homkermap "additive kernels" can also be used at an
+   increased space or time cost.
+2. *Normalization.* Before using the representation in a linear model
+   (e.g. a @ref svm "support vector machine"), the vector $\Phi(I)$ is
+   further normalized by the $l^2$ norm (note that the standard Fisher
+   vector is normalized by the number of encoded feature vectors).
+
+After square-rooting and normalization, the IFV is often used in a
+linear classifier such as an @ref svm "SVM".
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section fisher-fast Faster computations
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In practice, several data to cluster assignments $q_{ik}$ are likely
+to be very small or even negligible. The *fast* version of the FV sets
+to zero all but the largest assignment for each input feature $\bx_i$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page fisher-derivation Fisher vector derivation
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The FV of @cite{perronnin06fisher} is a special case of the @ref
+fisher-kernel "Fisher kernel" construction. It is designed to encode
+local image features in a format that is suitable for learning and
+comparison with simple metrics such as the Euclidean. In this
+construction, an image is modeled as a collection of $D$-dimensional
+feature vectors $I=(\bx_1,\dots,\bx_n)$ generated by a GMM with $K$
+components $\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$. The covariance
+matrices are assumed to be diagonal, i.e. $\Sigma_k = \diag
+\bsigma_k^2$, $\bsigma_k \in \real^D_+$.
+
+The generative model of *one* feature vector $\bx$ is given by the GMM
+density function:
+
+\[
+ p(\bx|\Theta) =
+\sum_{k=1}^K \pi_k p(\bx|\Theta_k),
+\quad
+p(\bx|\Theta_k)
+=
+\frac{1}{(2\pi)^\frac{D}{2} (\det \Sigma_k)^{\frac{1}{2}}}
+\exp
+\left[
+-\frac{1}{2}
+(\bx - \mu_k)^\top \Sigma_k^{-1} (\bx - \mu_k)
+\right]
+\]
+
+where $\Theta_k = (\mu_k,\Sigma_k)$. The Fisher Vector requires
+computing the derivative of the log-likelihood function with respect
+to the various model parameters. Consider in particular the parameters
+$\Theta_k$ of a mode. Due to the exponent in the Gaussian density
+function, the derivative can be written as
+
+\[
+\nabla_{\Theta_k} p(\bx|\Theta_k) =
+p(\bx|\Theta_k)
+g(\bx|\Theta_k)
+\]
+
+for a simple vector function $g$. The derivative of the log-likelihood
+function is then
+
+\[
+\nabla_{\Theta_k} \log p(\bx|\Theta)
+=
+\frac{\pi_k p(\bx|\Theta_k)}{\sum_{t=1}^K \pi_k p(\bx|\Theta_k)}
+g(\bx|\Theta_k)
+=
+q_k(\bx) g(\bx|\Theta_k)
+\]
+
+where $q_k(\bx)$ is the soft-assignment of the point $\bx$ to the mode
+$k$. We make the approximation that $q_k(\bx)\approx 1$ if $\bx$ is
+sampled from mode $k$ and $\approx 0$ otherwise
+@cite{perronnin06fisher}. Hence one gets:
+
+\[
+E_{\bx \sim p(\bx|\Theta)}
+[
+\nabla_{\Theta_k} \log p(\bx|\Theta)
+\nabla_{\Theta_t} \log p(\bx|\Theta)^\top
+]
+\approx
+\begin{cases}
+\pi_k E_{\bx \sim p(\bx|\Theta_k)} [ g(\bx|\Theta_k) g(\bx|\Theta_k)^\top], & t = k, \\
+0, & t\not=k.
+\end{cases}
+\]
+
+Thus under this approximation there is no correlation between the
+parameters of the various Gaussian modes.
+
+The function $g$ can be further broken down as the stacking of the
+derivative w.r.t. the mean and the diagonal covariance.
+
+\[
+g(\bx|\Theta_k)
+=
+\begin{bmatrix}
+g(\bx|\mu_k) \\
+g(\bx|\bsigma_k)
+\end{bmatrix},
+\quad
+[g(\bx|\mu_k)]_j
+=
+\frac{x_j - \mu_{jk}}{\sigma_{jk}^2},
+\quad
+[g(\bx|\bsigma_k^2)]_j
+=
+\frac{1}{2\sigma_{jk}^2}
+\left(
+\left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2
+-
+1
+\right)
+\]
+
+Thus the covariance of the model (Fisher information) is diagonal and
+the diagonal entries are given by
+
+\[
+ H_{\mu_{jk}} = \pi_k E[g(\bx|\mu_{jk})g(\bx|\mu_{jk})]
+ = \frac{\pi_k}{\sigma_{jk}^2},
+ \quad
+ H_{\sigma_{jk}^2} = \frac{\pi_k}{2 \sigma_{jk}^4}.
+\]
+
+where in the calculation it was used the fact that the fourth moment
+of the standard Gaussian distribution is 3. Multiplying the inverse
+square root of the matrix $H$ by the derivative of the log-likelihood
+function results in the Fisher vector encoding of one image feature
+$\bx$:
+
+\[
+ \Phi_{\mu_{jk}}(\bx) = H_{\mu_{jk}}^{-\frac{1}{2}} q_k(\bx) g(\bx|\mu_{jk})
+= q_k(\bx) \frac{x_j - \mu_{jk}}{\sqrt{\pi_k}\sigma_{jk}},
+\qquad
+ \Phi_{\sigma^2_{jk}}(\bx) =
+\frac{q_k(\bx)}{\sqrt{2 \pi_k}}
+\left(
+\left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2
+-
+1
+\right)
+\]
+
+Assuming that features are sampled i.i.d. from the GMM results in the
+formulas given in @ref fisher-fundamentals (note the normalization
+factor). Note that:
+
+* The Fisher components relative to the prior probabilities $\pi_k$
+  have been ignored. This is because they have little effect on the
+  representation @cite{perronnin10improving}.
+
+* Technically, the derivation of the Fisher Vector for multiple image
+  features requires the number of features to be the same in both
+  images. Ultimately, however, the representation can be computed by
+  using any number of features.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page fisher-kernel Fisher kernel
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page discusses the Fisher Kernels (FK) of
+@cite{jaakkola98exploiting} and shows how the FV of
+@cite{perronnin06fisher} can be derived from it as a special case. The
+FK induces a similarity measures between data points $\bx$ and $\bx'$
+from a parametric generative model $p(\bx|\Theta)$ of the data. The
+parameter $\Theta$ of the model is selected to fit the a-priori
+distribution of the data, and is usually the Maximum Likelihood (MLE)
+estimate obtained from a set of training examples. Once the generative
+model is learned, each particular datum $\bx$ is represented by
+looking at how it affects the MLE parameter estimate. This effect is
+measured by computing the gradient of the log-likelihood term
+corresponding to $\bx$:
+
+\[
+  \hat\Phi(\bx) = \nabla_\Theta \log p(\bx|\Theta)
+\]
+
+The vectors $\hat\Phi(\bx)$ should be appropriately scaled before they
+can be meaningfully compared. This is obtained by *whitening* the data
+by multiplying the vectors by the inverse of the square root of their
+*covariance matrix*. The covariance matrix can be obtained from the
+generative model $p(\bx|\Theta)$ itself. Since $\Theta$ is the ML
+parameter and $\hat\Phi(\bx)$ is the gradient of the log-likelihood
+function, its expected value $E[\hat\Phi(\bx)]$ is zero. Thus, since
+the vectors are already centered, their covariance matrix is simply:
+
+\[
+H = E_{\bx \sim p(\bx|\Theta)} [\hat\Phi(\bx) \hat\Phi(\bx)^\top]
+\]
+
+Note that $H$ is also the *Fisher information matrix* of the
+model. The final FV encoding $\Phi(\bx)$ is given by the whitened
+gradient of the log-likelihood function, i.e.:
+
+\[
+ \Phi(\bx) = H^{-\frac{1}{2}}  \nabla_\Theta \log p(\bx|\Theta).
+\]
+
+Taking the inner product of two such vectors yields the *Fisher
+kernel*:
+
+\[
+ K(\bx,\bx')
+= \langle \Phi(\bx),\Phi(\bx') \rangle
+= \nabla_\Theta \log p(\bx|\Theta)^\top H^{-1} \nabla_\Theta \log p(\bx'|\Theta).
+\]
+
+**/
+
+#include "fisher.h"
+#include "gmm.h"
+#include "mathop.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef VL_FISHER_INSTANTIATING
+
+static vl_size
+VL_XCAT(_vl_fisher_encode_, SFX)
+(TYPE * enc,
+ TYPE const * means, vl_size dimension, vl_size numClusters,
+ TYPE const * covariances,
+ TYPE const * priors,
+ TYPE const * data, vl_size numData,
+ int flags)
+{
+  vl_size dim;
+  vl_index i_cl, i_d;
+  vl_size numTerms = 0 ;
+  TYPE * posteriors ;
+  TYPE * sqrtInvSigma;
+
+  assert(numClusters >= 1) ;
+  assert(dimension >= 1) ;
+
+  posteriors = vl_malloc(sizeof(TYPE) * numClusters * numData);
+  sqrtInvSigma = vl_malloc(sizeof(TYPE) * dimension * numClusters);
+
+  memset(enc, 0, sizeof(TYPE) * 2 * dimension * numClusters) ;
+
+  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+    for(dim = 0; dim < dimension; dim++) {
+      sqrtInvSigma[i_cl*dimension + dim] = sqrt(1.0 / covariances[i_cl*dimension + dim]);
+    }
+  }
+
+  VL_XCAT(vl_get_gmm_data_posteriors_, SFX)(posteriors, numClusters, numData,
+                                            priors,
+                                            means, dimension,
+                                            covariances,
+                                            data) ;
+
+  /* sparsify posterior assignments with the FAST option */
+  if (flags & VL_FISHER_FLAG_FAST) {
+    for(i_d = 0; i_d < (signed)numData; i_d++) {
+      /* find largest posterior assignment for datum i_d */
+      vl_index best = 0 ;
+      TYPE bestValue = posteriors[i_d * numClusters] ;
+      for (i_cl = 1 ; i_cl < (signed)numClusters; ++ i_cl) {
+        TYPE p = posteriors[i_cl + i_d * numClusters] ;
+        if (p > bestValue) {
+          bestValue = p ;
+          best = i_cl ;
+        }
+      }
+      /* make all posterior assignments zero but the best one */
+      for (i_cl = 0 ; i_cl < (signed)numClusters; ++ i_cl) {
+        posteriors[i_cl + i_d * numClusters] =
+        (TYPE)(i_cl == best) ;
+      }
+    }
+  }
+
+#if defined(_OPENMP)
+#pragma omp parallel for default(shared) private(i_cl, i_d, dim) num_threads(vl_get_max_threads()) reduction(+:numTerms)
+#endif
+  for(i_cl = 0; i_cl < (signed)numClusters; ++ i_cl) {
+    TYPE uprefix;
+    TYPE vprefix;
+
+    TYPE * uk = enc + i_cl*dimension ;
+    TYPE * vk = enc + i_cl*dimension + numClusters * dimension ;
+
+    /*
+    If the GMM component is degenerate and has a null prior, then it
+    must have null posterior as well. Hence it is safe to skip it.  In
+    practice, we skip over it even if the prior is very small; if by
+    any chance a feature is assigned to such a mode, then its weight
+    would be very high due to the division by priors[i_cl] below.
+    */
+    if (priors[i_cl] < 1e-6) { continue ; }
+
+    for(i_d = 0; i_d < (signed)numData; i_d++) {
+      TYPE p = posteriors[i_cl + i_d * numClusters] ;
+      if (p < 1e-6) continue ;
+      numTerms += 1;
+      for(dim = 0; dim < dimension; dim++) {
+        TYPE diff = data[i_d*dimension + dim] - means[i_cl*dimension + dim] ;
+        diff *= sqrtInvSigma[i_cl*dimension + dim] ;
+        *(uk + dim) += p * diff ;
+        *(vk + dim) += p * (diff * diff - 1);
+      }
+    }
+
+    if (numData > 0) {
+      uprefix = 1/(numData*sqrt(priors[i_cl]));
+      vprefix = 1/(numData*sqrt(2*priors[i_cl]));
+      for(dim = 0; dim < dimension; dim++) {
+        *(uk + dim) = *(uk + dim) * uprefix;
+        *(vk + dim) = *(vk + dim) * vprefix;
+      }
+    }
+  }
+
+  vl_free(posteriors);
+  vl_free(sqrtInvSigma) ;
+
+  if (flags & VL_FISHER_FLAG_SQUARE_ROOT) {
+    for(dim = 0; dim < 2 * dimension * numClusters ; dim++) {
+      TYPE z = enc [dim] ;
+      if (z >= 0) {
+        enc[dim] = VL_XCAT(vl_sqrt_, SFX)(z) ;
+      } else {
+        enc[dim] = - VL_XCAT(vl_sqrt_, SFX)(- z) ;
+      }
+    }
+  }
+
+  if (flags & VL_FISHER_FLAG_NORMALIZED) {
+    TYPE n = 0 ;
+    for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) {
+      TYPE z = enc [dim] ;
+      n += z * z ;
+    }
+    n = VL_XCAT(vl_sqrt_, SFX)(n) ;
+    n = VL_MAX(n, 1e-12) ;
+    for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) {
+      enc[dim] /= n ;
+    }
+  }
+
+  return numTerms ;
+}
+
+#else
+/* not VL_FISHER_INSTANTIATING */
+
+#ifndef __DOXYGEN__
+#define FLT VL_TYPE_FLOAT
+#define TYPE float
+#define SFX f
+#define VL_FISHER_INSTANTIATING
+#include "fisher.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define TYPE double
+#define SFX d
+#define VL_FISHER_INSTANTIATING
+#include "fisher.c"
+#endif
+
+/* not VL_FISHER_INSTANTIATING */
+#endif
+
+/* ================================================================ */
+#ifndef VL_FISHER_INSTANTIATING
+
+/** @brief Fisher vector encoding of a set of vectors.
+ ** @param dataType the type of the input data (::VL_TYPE_DOUBLE or ::VL_TYPE_FLOAT).
+ ** @param enc Fisher vector (output).
+ ** @param means Gaussian mixture means.
+ ** @param dimension dimension of the data.
+ ** @param numClusters number of Gaussians mixture components.
+ ** @param covariances Gaussian mixture diagonal covariances.
+ ** @param priors Gaussian mixture prior probabilities.
+ ** @param data vectors to encode.
+ ** @param numData number of vectors to encode.
+ ** @param flags options.
+ ** @return number of averaging operations.
+ **
+ ** @a means and @a covariances have @a dimension rows and @a
+ ** numCluster columns.  @a priors is a vector of size @a
+ ** numCluster. @a data has @a dimension rows and @a numData
+ ** columns. @a enc is a vecotr of size equal to twice the product of
+ ** @a dimension and @a numClusters. All these vectors and matrices
+ ** have the same class, as specified by @a dataType, and must be
+ ** stored in column-major format.
+ **
+ ** @a flag can be used to control several options:
+ ** ::VL_FISHER_FLAG_SQUARE_ROOT, ::VL_FISHER_FLAG_NORMALIZED,
+ ** ::VL_FISHER_FLAG_IMPROVED, and ::VL_FISHER_FLAG_FAST.
+ **
+ ** The function returns the number of averaging operations actually
+ ** performed. The upper bound is the number of input features by the
+ ** number of GMM modes; however, assignments are usually failry
+ ** sparse, so this number is often much smaller. In particular, with
+ ** the ::VL_FISHER_FLAG_FAST, is equal to the number of input
+ ** features. This information can be used for diagnostic purposes.
+ **
+ ** @sa @ref fisher
+ **/
+
+VL_EXPORT vl_size
+vl_fisher_encode
+(void * enc, vl_type dataType,
+ void const * means, vl_size dimension, vl_size numClusters,
+ void const * covariances,
+ void const * priors,
+ void const * data,  vl_size numData,
+ int flags
+)
+{
+  switch(dataType) {
+    case VL_TYPE_FLOAT:
+      return _vl_fisher_encode_f
+      ((float *) enc,
+       (float const *) means, dimension, numClusters,
+       (float const *) covariances,
+       (float const *) priors,
+       (float const *) data, numData,
+       flags);
+    case VL_TYPE_DOUBLE:
+      return _vl_fisher_encode_d
+      ((double *) enc,
+       (double const *) means, dimension, numClusters,
+       (double const *) covariances,
+       (double const *) priors,
+       (double const *) data, numData,
+       flags);
+      break;
+    default:
+      abort();
+  }
+}
+/* not VL_FISHER_INSTANTIATING */
+#endif
+
+#undef SFX
+#undef TYPE
+#undef FLT
+#undef VL_FISHER_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/fisher.h b/opensfm/src/third_party/vlfeat/vl/fisher.h
new file mode 100644
index 000000000..907e66a48
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/fisher.h
@@ -0,0 +1,57 @@
+/** @file fisher.h
+ ** @brief Fisher encoding (@ref fisher)
+ ** @author David Novotny
+ ** @author Andrea Vedaldi
+ ** @see @ref fisher
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_FISHER_H
+#define VL_FISHER_H
+
+#include "generic.h"
+
+/** @name Fisher vector options
+ ** @{ */
+#define VL_FISHER_FLAG_SQUARE_ROOT          (0x1 << 0)
+#define VL_FISHER_FLAG_NORMALIZED           (0x1 << 1)
+#define VL_FISHER_FLAG_IMPROVED             (VL_FISHER_FLAG_NORMALIZED|VL_FISHER_FLAG_SQUARE_ROOT)
+#define VL_FISHER_FLAG_FAST                 (0x1 << 2)
+
+/** @def VL_FISHER_FLAG_SQUARE_ROOT
+ ** @brief Use signed squared-root (@ref fisher-normalization).
+ **/
+
+/** @def VL_FISHER_FLAG_NORMALIZED
+ ** @brief Gobally normalize the Fisher vector in L2 norm (@ref fisher-normalization).
+ **/
+
+/** @def VL_FISHER_FLAG_IMPROVED
+ ** @brief Improved Fisher vector.
+ ** This is the same as @c VL_FISHER_FLAG_SQUARE_ROOT|VL_FISHER_FLAG_NORMALIZED.
+ **/
+
+/** @def VL_FISHER_FLAG_FAST
+ ** @brief Fast but more approximate calculations (@ref fisher-fast).
+ ** Keep only the larges data to cluster assignment (posterior).
+ **/
+
+/** @} */
+
+VL_EXPORT vl_size vl_fisher_encode
+(void * enc, vl_type dataType,
+ void const * means, vl_size dimension, vl_size numClusters,
+ void const * covariances,
+ void const * priors,
+ void const * data, vl_size numData,
+ int flags) ;
+
+/* VL_FISHER_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/float.h b/opensfm/src/third_party/vlfeat/vl/float.h
new file mode 100644
index 000000000..267ca98f8
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/float.h
@@ -0,0 +1,116 @@
+/** @file float.h
+ ** @brief Float - Template
+ ** @author Andrea Vedaldi
+ ** @author David Novotny
+ **/
+
+/*
+Copyright (C) 2014 Andrea Vedaldi.
+Copyright (C) 2013 David Novotny.
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#include "generic.h"
+
+#undef  T
+#undef  SFX
+#undef  VSIZE
+#undef  VSFX
+#undef  VTYPE
+#undef  VSIZEavx
+#undef  VSFXavx
+#undef  VTYPEavx
+
+#if (FLT == VL_TYPE_FLOAT)
+#  define T float
+#  define SFX f
+#elif (FLT == VL_TYPE_DOUBLE)
+#  define T double
+#  define SFX d
+#elif (FLT == VL_TYPE_UINT32)
+#  define T vl_uint32
+#  define SFX ui32
+#elif (FLT == VL_TYPE_INT32)
+#  define T vl_int32
+#  define SFX i32
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                                              AVX */
+/* ---------------------------------------------------------------- */
+
+#ifdef __AVX__
+
+#if (FLT == VL_TYPE_FLOAT)
+#  define VSIZEavx  8
+#  define VSFXavx   s
+#  define VTYPEavx  __m256
+#elif (FLT == VL_TYPE_DOUBLE)
+#  define VSIZEavx  4
+#  define VSFXavx   d
+#  define VTYPEavx  __m256d
+#endif
+
+#define VALIGNEDavx(x) (! (((vl_uintptr)(x)) & 0x1F))
+
+#define VMULavx  VL_XCAT(_mm256_mul_p,     VSFX)
+#define VDIVavx  VL_XCAT(_mm256_div_p,     VSFX)
+#define VADDavx  VL_XCAT(_mm256_add_p,     VSFX)
+#define VHADDavx  VL_XCAT(_mm_hadd_p,     VSFX)
+#define VHADD2avx  VL_XCAT(_mm256_hadd_p,     VSFX)
+#define VSUBavx  VL_XCAT(_mm256_sub_p,     VSFX)
+#define VSTZavx  VL_XCAT(_mm256_setzero_p, VSFX)
+#define VLD1avx  VL_XCAT(_mm256_broadcast_s,   VSFX)
+#define VLDUavx  VL_XCAT(_mm256_loadu_p,   VSFX)
+#define VST1avx  VL_XCAT(_mm256_store_s,   VSFX)
+#define VST2avx  VL_XCAT(_mm256_store_p,   VSFX)
+#define VST2Uavx VL_XCAT(_mm256_storeu_p,  VSFX)
+#define VPERMavx VL_XCAT(_mm256_permute2f128_p,  VSFX)
+//#define VCSTavx VL_XCAT( _mm256_castps256_ps128,  VSFX)
+#define VCSTavx  VL_XCAT5(_mm256_castp,VSFX,256_p,VSFX,128)
+
+/* __AVX__ */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                                             SSE2 */
+/* ---------------------------------------------------------------- */
+
+#ifdef __SSE2__
+
+#if (FLT == VL_TYPE_FLOAT)
+#  define VSIZE  4
+#  define VSFX   s
+#  define VTYPE  __m128
+#elif (FLT == VL_TYPE_DOUBLE)
+#  define VSIZE  2
+#  define VSFX   d
+#  define VTYPE  __m128d
+#endif
+
+#define VALIGNED(x) (! (((vl_uintptr)(x)) & 0xF))
+
+#define VMAX  VL_XCAT(_mm_max_p,     VSFX)
+#define VMUL  VL_XCAT(_mm_mul_p,     VSFX)
+#define VDIV  VL_XCAT(_mm_div_p,     VSFX)
+#define VADD  VL_XCAT(_mm_add_p,     VSFX)
+#define VSUB  VL_XCAT(_mm_sub_p,     VSFX)
+#define VSTZ  VL_XCAT(_mm_setzero_p, VSFX)
+#define VLD1  VL_XCAT(_mm_load1_p,   VSFX)
+#define VLDU  VL_XCAT(_mm_loadu_p,   VSFX)
+#define VST1  VL_XCAT(_mm_store_s,   VSFX)
+#define VSET1 VL_XCAT(_mm_set_s,     VSFX)
+#define VSHU  VL_XCAT(_mm_shuffle_p, VSFX)
+#define VNEQ  VL_XCAT(_mm_cmpneq_p,  VSFX)
+#define VAND  VL_XCAT(_mm_and_p,     VSFX)
+#define VANDN VL_XCAT(_mm_andnot_p,  VSFX)
+#define VST2  VL_XCAT(_mm_store_p,   VSFX)
+#define VST2U VL_XCAT(_mm_storeu_p,  VSFX)
+
+/* __SSE2__ */
+#endif
+
diff --git a/opensfm/src/third_party/vlfeat/vl/generic.c b/opensfm/src/third_party/vlfeat/vl/generic.c
new file mode 100644
index 000000000..d4982e43b
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/generic.c
@@ -0,0 +1,1679 @@
+/** @file generic.c
+ ** @brief Generic - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@mainpage Vision Lab Features Library (VLFeat)
+@version __VLFEAT_VERSION__
+@author The VLFeat Team
+@par Copyright &copy; 2012-14 The VLFeat Authors
+@par Copyright &copy; 2007-11 Andrea Vedaldi and Brian Fulkerson
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The VLFeat C library implements common computer
+vision algorithms, with a special focus on visual features, as used
+in state-of-the-art object recognition and image
+matching applications.
+
+VLFeat strives to be clutter-free, simple, portable, and well documented.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section main-contents Contents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+- **Visual feature detectors and descriptors**
+  - @subpage sift
+  - @subpage dsift
+  - @subpage mser
+  - @subpage covdet
+  - @subpage scalespace
+  - @subpage hog
+  - @subpage fisher
+  - @subpage vlad
+  - @subpage liop
+  - @subpage lbp
+
+- **Clustering and indexing**
+  - @subpage kmeans
+  - @subpage ikmeans.h  "Integer K-means (IKM)"
+  - @subpage hikmeans.h "Hierarchical Integer K-means (HIKM)"
+  - @subpage gmm
+  - @subpage aib
+  - @subpage kdtree
+
+- **Segmentation**
+  - @subpage slic
+  - @subpage quickshift
+
+- **Statistical methods**
+  - @subpage aib
+  - @subpage homkermap
+  - @subpage svm
+
+- **Utilities**
+  - @subpage random
+  - @subpage mathop
+  - @subpage stringop.h  "String operations"
+  - @subpage imopv.h     "Image operations"
+  - @subpage pgm.h       "PGM image format"
+  - @subpage heap-def.h  "Generic heap object (priority queue)"
+  - @subpage rodrigues.h "Rodrigues formula"
+  - @subpage mexutils.h  "MATLAB MEX helper functions"
+  - @subpage getopt_long.h "Drop-in @c getopt_long replacement"
+
+- **General information**
+  - @subpage conventions
+  - @subpage generic
+  - @subpage portability
+  - @ref resources
+  - @subpage objects
+  - @ref threads
+  - @subpage matlab
+  - @subpage metaprogram
+
+- @subpage dev
+- @subpage glossary
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page resources Memory and resource handling
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Some VLFeat functions return pointers to memory blocks or
+objects. Only ::vl_malloc, ::vl_calloc, ::vl_realloc and functions
+whose name contains either the keywords @c new or @c copy transfer the
+ownership of the memory block or object to the caller. The caller must
+dispose explicitly of all the resources it owns (by calling ::vl_free
+for a memory block, or the appropriate deletion function for an
+object).
+
+The memory allocation functions can be customized by
+::vl_set_alloc_func (which sets the implementations of ::vl_malloc,
+::vl_realloc, ::vl_calloc and ::vl_free). Remapping the memory
+allocation functions can be done only if there are no currently
+allocated VLFeat memory blocks or objects -- thus typically at the
+very beginning of a program. The memory allocation functions are a
+global property, shared by all threads.
+
+VLFeat uses three rules that simplify handling exceptions when used in
+combination which certain environment such as MATLAB.
+
+- The library allocates local memory only through the re-programmable
+  ::vl_malloc, ::vl_calloc, and ::vl_realloc functions.
+
+- The only resource referenced by VLFeat objects is memory (for
+  instance, it is illegal for an object to reference an open file).
+  Other resources such as files or threads may be allocated within a
+  VLFeat function call, but they are all released before the function
+  ends, or their ownership is directly transferred to the caller.
+
+- The global library state is an exception. It cannot reference any
+  local object created by the caller and uses the standard C memory
+  allocation functions.
+
+In this way, the VLFeat local state can be reset at any time simply by
+disposing of all the memory allocated by the library so far. The
+latter can be done easily by mapping the memory allocation functions
+to implementations that track the memory blocks allocated, and then
+disposing of all such blocks. Since the global state does not
+reference any local object nor uses the remapped memory functions, it
+is unaffected by such an operation; conversely, since no VLFeat object
+references anything but memory, this guarantees that all allocated
+resources are properly disposed (avoiding leaking resource). This is
+used extensively in the design of MATLAB MEX files (see @ref
+matlab).
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page conventions Conventions
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page summarizes some of the conventions used by the library.
+
+@section conventions-storage Matrix and image storage conventions
+
+If not otherwise specified, matrices in VLFeat are stored in memory in
+<em>column major</em> order. Given a matrix $[A_{ij}] \in \real^{m
+\times n}$, this amounts of enumerating the elements one column per
+time: $A_{11}, A_{21}, \dots, A_{m1}, A_{12}, \dots, A_{mn}$. This
+convention is compatible with Fortran, MATLAB, and popular numerical
+libraries.
+
+Matrices are often used in the library to pack a number data vectors
+$\bx_1,\dots,\bx_n \in \real^m$ of equal dimension together. These are
+normally stored as the columns of the matrix:
+
+\[
+X = \begin{bmatrix} \bx_1, \dots, \bx_n \end{bmatrix},
+\qquad
+X \in \real_{m\times n}
+\]
+
+In this manner, consecutive elements of each data vector $\bx_i$ is
+stored in consecutive memory locations, improving memory access
+locality in most algorithms.
+
+Images $I(x,y)$ are stored instead in <em>row-major</em> order,
+i.e. one row after the other. Note that an image can be naturally
+identified as a matrix $I_{yx}$, where the vertical coordinate $y$
+indexes the rows and the horizontal coordinate $x$ the columns. The
+image convention amounts to storing this matrix in row-major rather
+than column-major order, which is in conflict with the rule given
+above. The reason for this choice is that most image processing and
+graphical libraries assume this convention; it is, however,
+<em>not</em> the same as MATLAB's.
+
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page objects Objects
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Many VLFeat algorithms are available in the form of *objects*. The C
+language, used by VLFeat, does not support objects explicitly. Here an
+object is intended a C structure along with a number of functions (the
+object member functions or methods) operating on it. Ideally, the
+object data structure is kept opaque to the user, for example by
+defining it in the @c .c implementation files which are not accessible
+to the library user.
+
+Object names are capitalized and start with the <code>Vl</code> prefix
+(for example @c VlExampleObject). Object methods are lowercase and
+start with the <code>vl_<object_name>_</code> suffix
+(e.g. @c vl_example_object_new).
+
+<!-- ------------------------------------------------------------  -->
+@section objects-lifecycle Object lifecycle
+<!-- ------------------------------------------------------------  -->
+
+Conceptually, an object undergoes four phases during its lifecycle:
+allocation, initialization, finalization, and deallocation:
+
+- **Allocation.** The memory to hold the object structure is allocated.
+  This is usually done by calling a memory allocation function such as
+  ::vl_calloc to reserve an object of the required size @c
+  sizeof(VlExampleObject). Alternatively, the object can simply by
+  allocated on the stack by declaring a local variable of type
+  VlExampleObject.
+- **Initialization.** The object is initialized by assigning a value to
+  its data members and potentially allocating a number of resources,
+  including other objects or memory buffers. Initialization is
+  done by methods containing the @c init keyword, e.g.  @c
+  vl_example_object_init. Several such methods may be provided.
+- **Finalization.** Initialization is undone by finalization, whose main
+  purpose is to release any resource allocated and still owned by the
+  object. Finalization is done by the @c vl_example_object_finalize
+  method.
+- **Deallocation.** The memory holding the object structure is
+  disposed of, for example by calling ::vl_free or automatically when
+  the corresponding local variable is popped from the stack.
+
+In practice, most VlFeat object are supposed to be created on the
+heap. To this end, allocation/initialization and
+finalization/deallocation are combined into two operations:
+
+- **Creating a new object.** This allocates a new object on the heap
+  and initializes it, combining allocation and initialization in a
+  single operation. It is done by methods containing the @c new keyword,
+  e.g. @c vl_example_object_new.
+- **Deleting an object.** This disposes of an object created by a @c
+  new method, combining finalization and deallocation, for example
+  @c vl_example_object_delete.
+
+<!-- ------------------------------------------------------------  -->
+@section objects-getters-setters Getters and setters
+<!-- ------------------------------------------------------------  -->
+
+Most objects contain a number of methods to get (getters) and set
+(setters) properties. These should contain the @c get and @c set
+keywords in their name, for example
+
+@code
+double x = vl_example_object_get_property () ;
+vl_example_object_set_property(x) ;
+@endcode
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page matlab MATLAB integration
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The VLFeat C library is designed to integrate seamlessly with MATLAB.
+Binary compatibility is simplified by the use of the C language
+(rather than C++). In addition, the library design follows certain
+restrictions that make it compatible with the MATLAB MEX interface.
+
+The main issue in calling a library function from a MATLAB MEX
+function is that MATLAB can abort the execution of the MEX function
+at any point, either due to an error, or directly upon a user request
+(Ctrl-C) (empirically, however, a MEX function seems to be
+incorruptible only during the invocation of certain functions of the
+MEX API such as @c mexErrMsgTxt).
+
+When a MEX function is interrupted, resources (memory blocks or
+objects) whose ownership was transferred from VLFeat to the MEX
+function may be leaked. Notice that interrupting a MEX function would
+similarly leak any memory block allocated within the MEX function. To
+solve this issue, MATLAB provides his own memory manager (@c
+mxMalloc, @c mxRealloc, ...). When a MEX file is interrupted or ends,
+all memory blocks allocated by using one of such functions are
+released, preventing leakage.
+
+In order to integrate VLFeat with this model in the most seamless
+way, VLFeat memory allocation functions (::vl_malloc, ::vl_realloc,
+::vl_calloc) are mapped to the corresponding MEX memory allocation
+functions. Such functions automatically dispose of all the memory
+allocated by a MEX function when the function ends (even because of
+an exception). Because of the restrictions of the library design
+illustrated in @ref resources, this operation is safe and
+correctly dispose of VLFeat local state. As a consequence, it is
+possible to call @c mexErrMsgTxt at any point in the MEX function
+without worrying about leaking resources.
+
+This however comes at the price of some limitations. Beyond the
+restrictions illustrated in @ref resources, here we note that no
+VLFeat local resource (memory blocks or objects) can persist across
+MEX file invocations. This implies that any result produced by a
+VLFeat MEX function must be converted back to a MATLAB object such as
+a vector or a structure. In particular, there is no direct way of
+creating an object within a MEX file, returning it to MATLAB, and
+passing it again to another MEX file.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page metaprogram Preprocessor metaprogramming
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Part of VLFeat code uses a simple form of preprocessor metaprogramming.
+This technique is used, similarly to C++ templates, to instantiate
+multiple version of a given algorithm for different data types
+(e.g. @c float and @c double).
+
+In most cases preprocessor metaprogramming is invisible to the library
+user, as it is used only internally.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page glossary Glossary
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+ - <b>Column-major.</b> A <em>M x N </em> matrix <em>A</em> is
+ stacked with column-major order as the sequence \f$(A_{11}, A_{21},
+ \dots, A_{12}, \dots)\f$. More in general, when stacking a multi
+ dimensional array this indicates that the first index is the one
+ varying most quickly, with the other followed in the natural order.
+ - <b>Opaque structure.</b> A structure is opaque if the user is not supposed
+ to access its member directly, but through appropriate interface functions.
+ Opaque structures are commonly used to define objects.
+ - <b>Row-major.</b> A <em>M x N </em> matrix <em>A</em> is
+ stacked with row-major order as the sequence \f$(A_{11}, A_{12},
+ \dots, A_{21}, \dots)\f$. More in general, when stacking a multi
+ dimensional array this indicates that the last index is the one
+ varying most quickly, with the other followed in reverse order.
+ - <b>Feature frame.</b> A <em>feature frame</em> is the geometrical
+ description of a visual features. For instance, the frame of
+ a @ref sift.h "SIFT feature" is oriented disk and the frame of
+ @ref mser.h "MSER feature" is either a compact and connected set or
+ a disk.
+ - <b>Feature descriptor.</b> A <em>feature descriptor</em> is a quantity
+ (usually a vector) which describes compactly the appearance of an
+ image region (usually corresponding to a feature frame).
+**/
+
+/**
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page dev Developing the library
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page contains information useful to the developer of VLFeat.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section dev-copy Copyright
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A short copyright notice is added at the beginning of each file. For
+example:
+
+<pre>
+Copyright (C) 2013 Milan Sulc
+Copyright (C) 2012 Daniele Perrone.
+Copyright (C) 2011-13 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+</pre>
+
+The copyright of each file is assigned to the authors of the file.
+Every author making a substantial contribution to a file should
+note its copyright by adding a line to the copyright list with the year
+of the modification. Year ranges are acceptable. Lines are never
+deleted, only appended, or potentially modified to list
+more years.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section dev-style Coding style
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<ul>
+
+<li><b>Look at existing code before you start.</b> The general rule
+is: try to match the style of the existing code as much as
+possible.</li>
+
+<li><b>No white spaces at the end of lines.</b> White spaces introduce
+invisible changes in the code that are however picked up by control
+version systems such as Git.</li>
+
+<li><b>Descriptive variable names.</b> Most variable names start with
+a lower case letter and are capitalized, e.g., @c numElements. Only
+the following abbreviations are considered acceptable: @c num. The @c
+dimension of a vector is the number of elements it contains (for other
+objects that could be a @c size, a @c length, or a @c
+numElements). For multi-dimensional arrays, @c dimensions could
+indicate the array with each of the @c numDimensions dimensions.</li>
+
+<li><b>Short variable names.</b> For indexes in short for loops it is
+fine to use short index names such as @c i, @c j, and @c k. For example:
+<pre>
+for (i = 0 ; i < numEntries ; ++i) values[i] ++ ;
+</pre>
+is considered acceptable.</li>
+
+<li><b>Function arguments.</b> VLFeat functions that operate on an
+object (member functions) should be passed the object address as first
+argument; this argument should be called @c self. For example:
+<pre>
+   void vl_object_do_something(VlObject *self) ;
+</pre>
+Multi-dimensional arrays should be specified first by their address,
+and then by their dimensions. For example
+<pre>
+  void vl_use_array (float * array, vl_size numColumns, vl_size numRows) ; // good
+  void vl_use_array (vl_size numColumns, vl_size numRows, float * array) ; // bad
+</pre>
+Arguments that are used as outputs should be specified first (closer to
+the left-hand side of an expression). For example
+<pre>
+ void vl_sum_numbers (float * output, float input1, float input2) ; // good
+ void vl_sum_numbers (float input1, float input2, float * output) ; // bad
+</pre>
+These rules can be combined. For example
+<pre>
+ void vl_object_sum_to_array (VlObject * self, float * outArray,
+        vl_size numColumns, vl_size numRows, float * inArray) ; // good
+</pre>
+Note that in this case no dimension for @c inArray is specified as it
+is assumed that @c numColumns and @c numRows are the dimensions of
+both arrays.
+</li>
+</ul>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection dev-style-matlab MATLAB coding style
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<ul>
+<li><b>Help messages.</b> Each @c .m file should include a standard
+help comment block (accessible from MATLAB @c help() command).
+The first line of the block has a space, the name of the function,
+4 spaces, and a brief command description. The body of the help
+message is indented with 4 spaces. For example
+@code
+% VL_FUNCTION    An example function
+%    VL_FUNCTION() does nothing.
+@endcode
+The content HELP message itself should follow MATLAB default style.
+For example, rather than giving a list of formal input and output
+arguments as often done, one simply shows how to use the function, explaining
+along the way the different ways the function can be called and
+the format of the parameters.
+</li>
+</ul>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section dev-doc Documenting the code
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The VLFeat C library code contains its own in documentation <a
+href='http://www.stack.nl/~dimitri/doxygen/'>Doxygen</a> format. The
+documentation consists in generic pages, such as the @ref index
+"index" and the page you are reading, and documentations for each
+library module, usually corresponding to a certain header file.
+
+- **Inline comments.** Inline Doxygen comments are discouraged except
+  in the documentation of data members of structures. They start with
+  a capital letter and end with a period. For example:
+  @code
+  struct VlExampleStructure {
+    int aMember ; /\*\*< A useful data member.
+  }
+  @endcode
+
+- **Brief comments.** Brief Doxygen comments starts by a capital
+  and end with a period. The documentation of all functions start
+  with a brief comment.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection devl-doc-modules Documenting the library modules
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A library module groups a number of data types and functions that
+implement a certain functionality of VLFeat. The documentation of a
+library module is generally organized as follows:
+
+1. A page introducing the module and including a getting started
+   section (3.g. @ref svm-starting) containing a short tutorial to
+   quickly familiarize the user with the module (e.g. @ref svm).
+2. One or more pages of detailed technical background discussing the
+   algorithms implemented. These sections are used not just as part of
+   the C API, but also as documentation for other APIs such as MATLAB
+   (e.g. @ref svm-fundamentals).
+3. One or more pages with the structure and function documentation
+   (e.g. @ref svm.h).
+
+More in detail, consider a module called <em>Example Module</em>. Then one would
+typically have:
+
+<ul>
+<li>A header or declaration file @c example-module.h. Such a file has an
+heading of the type:
+
+@verbinclude example-module-doc.h
+
+This comment block contains a file directive, causing the file to be
+included in the documentation, a brief directive, specifying a short
+description of what the file is, and a list of authors. A
+(non-Doxygen) comment block with a short the copyright notice follows.
+The brief directive should include a <code>@@ref</code> directive to point
+to the main documentation page describing the module, if there is one.
+</li>
+
+<li> An implementation or definition file @c example-module.c. This file
+has an heading of the type:
+
+@verbinclude example-module-doc.c
+
+This is similar to the declaration file, except for the content of the
+brief comment.
+</li>
+</ul>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection devl-doc-functions Documenting functions
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection devl-doc-structures Documenting structures
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection devl-doc-structures Documenting objects
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+As seen in @ref objects, VLFeat treats certain structures with
+an object-like semantics. Usually, a module defines exactly one such
+objects. In this case, the object member functions should be grouped
+(by using Doxygen grouping functionality) as
+
+- **Construct and destroy** for the @c vl_object_new, @c
+    vl_object_delete and similar member functions.
+- **Set parameters** for setter functions.
+- **Retrieve parameters and data** for getter functions.
+- **Process data** for functions processing data.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection devl-doc-bib Bibliographic references
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Since version 0.9.14, the VLFeat C library documentation makes use of
+a proper bibliographic reference in BibTeX format (see the file @c
+docsrc/vlfeat.bib). Doxygen uses this file when it sees instances of
+the <code>@@cite{xyz}</code> command.  Here @c xyz is a BibTeX
+key. For example, @c vlfeat.bib file contains the entry:
+
+<pre>
+@@inproceedings{martin97the-det-curve,
+	Author = {A. Martin and G. Doddington and T. Kamm and M. Ordowski and M. Przybocki},
+	Booktitle = {Proc. Conf. on Speech Communication and Technology},
+	Title = {The {DET} curve in assessment of detection task performance},
+	Year = {1997}}
+</pre>
+
+For example, the Doxygen directive
+<code>@@cite{martin97the-det-curve}</code> generates the output
+@cite{martin97the-det-curve}, which is a link to the corresponding
+entry in the bibliography.
+
+**/
+
+/**
+
+@file generic.h
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page generic General support functionalities
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat contains several support functionalities addressing the C
+preprocessors, using multiple threads (including parallel computations),
+handling errors, allocating memory, etc. These are described in
+the following pages:
+
+- @subpage resources
+- @subpage threads
+- @subpage misc
+**/
+
+/**
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page misc Preprocssor, library state, etc.
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-preproc C preprocessor helpers
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat provides a few C preprocessor macros of general
+utility. These include stringification (::VL_STRINGIFY,
+::VL_XSTRINGIFY) and concatenation (::VL_CAT, ::VL_XCAT) of symbols.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-state VLFeat state and configuration parameters
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat has some global configuration parameters that can
+changed. Changing the configuration is thread unsave
+(@ref threads). Use ::vl_set_simd_enabled to toggle the use of
+a SIMD unit (Intel SSE code), ::vl_set_alloc_func to change
+the memory allocation functions, and ::vl_set_printf_func
+to change the logging function.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-error Error handling
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Some VLFeat functions signal errors in a way similar to the
+standard C library. In case of error, a VLFeat function
+may return an error code directly,
+or an invalid result (for instance a negative file descriptor or a null
+pointer). Then ::vl_get_last_error and ::vl_get_last_error_message can be used
+to retrieve further details about the error (these functions should be
+used right after an error has occurred, before any other VLFeat call).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-memory Memory allocation
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat uses the ::vl_malloc, ::vl_realloc, ::vl_calloc and ::vl_free
+functions to allocate memory. Normally these functions are mapped to
+the underlying standard C library implementations. However
+::vl_set_alloc_func can be used to map them to other
+implementations.  For instance, in MATALB MEX files these functions
+are mapped to the MATLAB equivalent which has a garbage collection
+mechanism to cope with interruptions during execution.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-logging Logging
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat uses the macros ::VL_PRINT and ::VL_PRINTF to print progress
+or debug informations. These functions are normally mapped to the @c
+printf function of the underlying standard C library. However
+::vl_set_printf_func can be used to map it to a different
+implementation. For instance, in MATLAB MEX files this function is
+mapped to @c mexPrintf. Setting the function to @c NULL disables
+logging.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section misc-time Measuring time
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat provides ::vl_tic and ::vl_toc as an easy way of measuring
+elapsed time.
+
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page threads Threading
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat supports for threaded computations can be used to take advantage
+of multi-core architectures. Threading support includes:
+
+- Supporting using VLFeat functions and objects from multiple threads
+  simultaneously. This is discussed in @ref threads-multiple.
+- Using multiple cores to accelerate computations. This is
+  discussed in @ref threads-parallel.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section threads-multiple Using VLFeat from multiple threads
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat can be used from multiple threads simultaneously if proper
+rules are followed.
+
+- <b>A VLFeat object instance is accessed only from one thread at any
+  given time.</b> Functions operating on objects (member functions)
+  are conditionally thread safe: the same function may be called
+  simultaneously from multiple threads provided that it operates on
+  different, independent objects. However, modifying the same object
+  from multiple threads (using the same or different member functions)
+  is possible only from one thread at any given time, and should
+  therefore be synchronized. Certain VLFeat objects may contain
+  features specific to simplify multi-threaded operations
+  (e.g. ::VlKDForest).
+- <b>Thread-safe global functions are used.</b> These include
+  thread-specific operations such as retrieving the last error by
+  ::vl_get_last_error and obtaining the thread-specific random number
+  generator instance by ::vl_get_rand. In these cases, the functions
+  operate on thread-specific data that VLFeat creates and
+  maintains. Note in particular that each thread has an independent
+  default random number generator (as returned by
+  ::vl_get_rand). VLFeat objects that involve using random numbers
+  will typically use the random number generator of the thread
+  currently accessing the object (although an object-specific
+  generator can be often be specified instead).
+- <b>Any other global function is considered non-thread safe and is
+  accessed exclusively by one thread at a time.</b> A small number of
+  operations are non-reentrant <em>and</em> affect all threads
+  simultaneously. These are restricted to changing certain global
+  configuration parameters, such as the memory allocation functions by
+  ::vl_set_alloc_func. These operations are <em>not</em> thread safe
+  and are preferably executed before multiple threads start to operate
+  with the library.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section threads-parallel Parallel computations
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat uses OpenMP to implement parallel computations. Generally, this
+means that multiple cores are uses appropriately and transparently,
+provided that other multi-threaded parts of the application use OpenMP
+and that VLFeat and the application link to the same OpenMP library.
+If finer control is required, read on.
+
+VLFeat functions avoids affecting OpenMP global state, including the
+desired number of computational threads, in order to minimize side
+effects to the linked application (e.g. MATLAB). Instead, VLFeat
+duplicates a few OpenMP control parameters when needed (this approach
+is similar to the method used by other libraries such as Intel MKL).
+
+The maximum number of threads available to the application can be
+obtained by ::vl_get_thread_limit (for OpenMP version 3.0 and
+greater). This limit is controlled by the OpenMP library (the function
+is a wrapper around @c omp_get_thread_limit), which in turn may
+determined that based on the number of computational cores or the
+value of the @c OMP_THREAD_LIMIT variable when the program is
+launched. This value is an upper bound on the number of computation
+threads that can be used at any time.
+
+The maximum number of computational thread that VLFeat should use is
+set by ::vl_set_num_threads() and retrieved by ::vl_get_max_threads().
+This number is a target value as well as an upper bound to the number
+of threads used by VLFeat. This value is stored in the VLFeat private
+state and is not necessarily equal to the corresponding OpenMP state
+variable retrieved by calling @c omp_get_max_threads(). @c
+vl_set_num_threads(1) disables the use of multiple threads and @c
+vl_set_num_threads(0) uses the value returned by the OpenMP call @c
+omp_get_max_threads(). The latter value is controlled, for example, by
+calling @c omp_set_num_threads() in the application. Note that:
+
+- @c vl_set_num_threads(0) determines the number of treads using @c
+  omp_get_max_threads() *when it is called*. Subsequent calls to @c
+  omp_set_num_threads() will therefore *not* affect the number of
+  threads used by VLFeat.
+- @c vl_set_num_threads(vl_get_thread_limit()) causes VLFeat use all
+  the available threads, regardless on the number of threads set
+  within the application by calls to @c omp_set_num_threads().
+- OpenMP may still dynamically decide to use a smaller number of
+  threads in any specific parallel computation.
+
+@sa http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_userguide_win/GUID-C2295BC8-DD22-466B-94C9-5FAA79D4F56D.htm
+ http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_userguide_win/index.htm#GUID-DEEF0363-2B34-4BAB-87FA-A75DBE842040.htm
+ http://software.intel.com/sites/products/documentation/hpc/mkl/lin/MKL_UG_managing_performance/Using_Additional_Threading_Control.htm
+
+**/
+
+#include "generic.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <math.h>
+
+#if defined(VL_OS_WIN)
+#include <Windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#if ! defined(VL_DISABLE_THREADS) && defined(VL_THREADS_POSIX)
+#include <pthread.h>
+#endif
+
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                         Global and thread states */
+/* ---------------------------------------------------------------- */
+
+/* Thread state */
+typedef struct _VlThreadState
+{
+  /* errors */
+  int lastError ;
+  char lastErrorMessage [VL_ERR_MSG_LEN] ;
+
+  /* random number generator */
+  VlRand rand ;
+
+  /* time */
+#if defined(VL_OS_WIN)
+  LARGE_INTEGER ticFreq ;
+  LARGE_INTEGER ticMark ;
+#else
+  clock_t ticMark ;
+#endif
+} VlThreadState ;
+
+/* Gobal state */
+typedef struct _VlState
+{
+  /* The thread state uses either a mutex (POSIX)
+    or a critical section (Win) */
+#if defined(VL_DISABLE_THREADS)
+  VlThreadState * threadState ;
+#else
+#if defined(VL_THREADS_POSIX)
+  pthread_key_t threadKey ;
+  pthread_mutex_t mutex ;
+  pthread_t mutexOwner ;
+  pthread_cond_t mutexCondition ;
+  size_t mutexCount ;
+#elif defined(VL_THREADS_WIN)
+  DWORD tlsIndex ;
+  CRITICAL_SECTION mutex ;
+#endif
+#endif /* VL_DISABLE_THREADS */
+
+  /* Configurable functions */
+  int   (*printf_func)  (char const * format, ...) ;
+  void *(*malloc_func)  (size_t) ;
+  void *(*realloc_func) (void*,size_t) ;
+  void *(*calloc_func)  (size_t, size_t) ;
+  void  (*free_func)    (void*) ;
+
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  VlX86CpuInfo cpuInfo ;
+#endif
+  vl_size numCPUs ;
+  vl_bool simdEnabled ;
+  vl_size numThreads ;
+} VlState ;
+
+/* Global state instance */
+VlState _vl_state ;
+
+/* ----------------------------------------------------------------- */
+VL_INLINE VlState * vl_get_state () ;
+VL_INLINE VlThreadState * vl_get_thread_specific_state () ;
+static void vl_lock_state (void) ;
+static void vl_unlock_state (void) ;
+static VlThreadState * vl_thread_specific_state_new (void) ;
+static void vl_thread_specific_state_delete (VlThreadState * self) ;
+
+/** @brief Get VLFeat version string
+ ** @return the library version string.
+ **/
+
+char const *
+vl_get_version_string ()
+{
+  return VL_VERSION_STRING ;
+}
+
+/** @brief Get VLFeat configuration string.
+ ** @return a new configuration string.
+ **
+ ** The function returns a new string containing a human readable
+ ** description of the library configuration.
+ **/
+
+char *
+vl_configuration_to_string_copy ()
+{
+  char * string = 0 ;
+  int length = 0 ;
+  char * staticString = vl_static_configuration_to_string_copy() ;
+  char * cpuString =
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  _vl_x86cpu_info_to_string_copy(&vl_get_state()->cpuInfo) ;
+#else
+  "Generic CPU" ;
+#endif
+#if defined(DEBUG)
+  int const debug = 1 ;
+#else
+  int const debug = 0 ;
+#endif
+
+  while (string == 0) {
+    if (length > 0) {
+      string = vl_malloc(sizeof(char) * length) ;
+      if (string == NULL) break ;
+    }
+    length = snprintf(string, length,
+                      "VLFeat version %s\n"
+                      "    Static config: %s\n"
+                      "    %" VL_FMT_SIZE " CPU(s): %s\n"
+#if defined(_OPENMP)
+                      "    OpenMP: max threads: %d (library: %" VL_FMT_SIZE ")\n"
+#endif
+                      "    Debug: %s\n",
+                      vl_get_version_string (),
+                      staticString,
+                      vl_get_num_cpus(), cpuString,
+#if defined(_OPENMP)
+                      omp_get_max_threads(), vl_get_max_threads(),
+#endif
+                      VL_YESNO(debug)) ;
+    length += 1 ;
+  }
+
+  if (staticString) vl_free(staticString) ;
+  if (cpuString) vl_free(cpuString) ;
+  return string ;
+}
+
+/** @internal @brief A printf that does not do anything */
+static int
+do_nothing_printf (char const* format VL_UNUSED, ...)
+{
+  return 0 ;
+}
+
+/** @internal
+ ** @brief Lock VLFeat state
+ **
+ ** The function locks VLFeat global state mutex.
+ **
+ ** The mutex is recursive: locking multiple times from the same thread
+ ** is a valid operations, but requires an equivalent number
+ ** of calls to ::vl_unlock_state.
+ **
+ ** @sa ::vl_unlock_state
+ **/
+
+static void
+vl_lock_state (void)
+{
+#if ! defined(VL_DISABLE_THREADS)
+#if   defined(VL_THREADS_POSIX)
+  VlState * state = vl_get_state () ;
+  pthread_t thisThread = pthread_self () ;
+  pthread_mutex_lock (&state->mutex) ;
+  if (state->mutexCount >= 1 &&
+      pthread_equal (state->mutexOwner, thisThread)) {
+    state->mutexCount ++ ;
+  } else {
+    while (state->mutexCount >= 1) {
+      pthread_cond_wait (&state->mutexCondition, &state->mutex) ;
+    }
+    state->mutexOwner = thisThread ;
+    state->mutexCount = 1 ;
+  }
+  pthread_mutex_unlock (&state->mutex) ;
+#elif defined(VL_THREADS_WIN)
+  EnterCriticalSection (&vl_get_state()->mutex) ;
+#endif
+#endif
+}
+
+/** @internal
+ ** @brief Unlock VLFeat state
+ **
+ ** The function unlocks VLFeat global state mutex.
+ **
+ ** @sa ::vl_lock_state
+ **/
+
+static void
+vl_unlock_state (void)
+{
+#if ! defined(VL_DISABLE_THREADS)
+#if   defined(VL_THREADS_POSIX)
+  VlState * state = vl_get_state () ;
+  pthread_mutex_lock (&state->mutex) ;
+  -- state->mutexCount ;
+  if (state->mutexCount == 0) {
+    pthread_cond_signal (&state->mutexCondition) ;
+  }
+  pthread_mutex_unlock (&state->mutex) ;
+#elif defined(VL_THREADS_WIN)
+  LeaveCriticalSection (&vl_get_state()->mutex) ;
+#endif
+#endif
+}
+
+/** @internal
+ ** @brief Return VLFeat global state
+ **
+ ** The function returns a pointer to VLFeat global state.
+ **
+ ** @return pointer to the global state structure.
+ **/
+
+VL_INLINE VlState *
+vl_get_state (void)
+{
+  return &_vl_state ;
+}
+
+/** @internal@brief Get VLFeat thread state
+ ** @return pointer to the thread state structure.
+ **
+ ** The function returns a pointer to VLFeat thread state.
+ **/
+
+VL_INLINE VlThreadState *
+vl_get_thread_specific_state (void)
+{
+#ifdef VL_DISABLE_THREADS
+  return vl_get_state()->threadState ;
+#else
+  VlState * state ;
+  VlThreadState * threadState ;
+
+  vl_lock_state() ;
+  state = vl_get_state() ;
+
+#if defined(VL_THREADS_POSIX)
+  threadState = (VlThreadState *) pthread_getspecific(state->threadKey) ;
+#elif defined(VL_THREADS_WIN)
+  threadState = (VlThreadState *) TlsGetValue(state->tlsIndex) ;
+#endif
+
+  if (! threadState) {
+    threadState = vl_thread_specific_state_new () ;
+  }
+
+#if defined(VL_THREADS_POSIX)
+  pthread_setspecific(state->threadKey, threadState) ;
+#elif defined(VL_THREADS_WIN)
+  TlsSetValue(state->tlsIndex, threadState) ;
+#endif
+
+  vl_unlock_state() ;
+  return threadState ;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the number of CPU cores of the host
+ ** @return number of CPU cores.
+ **/
+
+vl_size
+vl_get_num_cpus (void)
+{
+  return vl_get_state()->numCPUs ;
+}
+
+/** @fn ::vl_set_simd_enabled(vl_bool)
+ ** @brief Toggle usage of SIMD instructions
+ ** @param x @c true if SIMD instructions are used.
+ **
+ ** Notice that SIMD instructions are used only if the CPU model
+ ** supports them. Note also that data alignment may restrict the use
+ ** of such instructions.
+ **
+ ** @see ::vl_cpu_has_sse2(), ::vl_cpu_has_sse3(), etc.
+ **/
+
+void
+vl_set_simd_enabled (vl_bool x)
+{
+  vl_get_state()->simdEnabled = x ;
+}
+
+/** @brief Are SIMD instructons enabled?
+ ** @return @c true if SIMD instructions are enabled.
+ **/
+
+vl_bool
+vl_get_simd_enabled (void)
+{
+  return vl_get_state()->simdEnabled ;
+}
+
+/** @brief Check for AVX instruction set
+ ** @return @c true if AVX is present.
+ **/
+
+vl_bool
+vl_cpu_has_avx (void)
+{
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  return vl_get_state()->cpuInfo.hasAVX ;
+#else
+  return VL_FALSE ;
+#endif
+}
+
+/** @brief Check for SSE3 instruction set
+ ** @return @c true if SSE3 is present.
+ **/
+
+vl_bool
+vl_cpu_has_sse3 (void)
+{
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  return vl_get_state()->cpuInfo.hasSSE3 ;
+#else
+  return VL_FALSE ;
+#endif
+}
+
+/** @brief Check for SSE2 instruction set
+ ** @return @c true if SSE2 is present.
+ **/
+
+vl_bool
+vl_cpu_has_sse2 (void)
+{
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  return vl_get_state()->cpuInfo.hasSSE2 ;
+#else
+  return VL_FALSE ;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Get the number of computational threads available to the application
+ ** @return number of threads.
+ **
+ ** This function wraps the OpenMP function @c
+ ** omp_get_thread_limit(). If VLFeat was compiled without OpenMP
+ ** support, this function returns 1. If VLFeat was compiled with
+ ** OpenMP prior to version 3.0 (2008/05), it returns 0.
+ **
+ ** @sa @ref threads-parallel
+ **/
+
+vl_size
+vl_get_thread_limit (void)
+{
+#if defined(_OPENMP)
+#if _OPENMP >= 200805
+  /* OpenMP version >= 3.0 */
+  return omp_get_thread_limit() ;
+#else
+  return 0 ;
+#endif
+#else
+  return 1 ;
+#endif
+}
+
+/** @brief Get the maximum number of computational threads used by VLFeat.
+ ** @return number of threads.
+ **
+ ** This function returns the maximum number of thread used by
+ ** VLFeat. VLFeat will try to use this number of computational
+ ** threads and never exceed it.
+ **
+ ** This is similar to the OpenMP function @c omp_get_max_threads();
+ ** however, it reads a parameter private to VLFeat which is
+ ** independent of the value used by the OpenMP library.
+ **
+ ** If VLFeat was compiled without OpenMP support, this function
+ ** returns 1.
+ **
+ ** @sa vl_set_num_threads(), @ref threads-parallel
+ **/
+
+vl_size
+vl_get_max_threads (void)
+{
+#if defined(_OPENMP)
+  return vl_get_state()->numThreads ;
+#else
+  return 1 ;
+#endif
+}
+
+/** @brief Set the maximum number of threads used by VLFeat.
+ ** @param numThreads number of threads to use.
+ **
+ ** This function sets the maximum number of computational threads
+ ** that will be used by VLFeat. VLFeat may in practice use fewer
+ ** threads (for example because @a numThreads is larger than the
+ ** number of computational cores in the host, or because the number
+ ** of threads exceeds the limit available to the application).
+ **
+ ** If @c numThreads is set to 0, then VLFeat sets the number of
+ ** threads to the OpenMP current maximum, obtained by calling @c
+ ** omp_get_max_threads().
+ **
+ ** This function is similar to @c omp_set_num_threads() but changes a
+ ** parameter internal to VLFeat rather than affecting OpenMP global
+ ** state.
+ **
+ ** If VLFeat was compiled without, this function does nothing.
+ **
+ ** @sa vl_get_max_threads(), @ref threads-parallel
+ **/
+
+#if defined(_OPENMP)
+void
+vl_set_num_threads (vl_size numThreads)
+{
+  if (numThreads == 0) {
+    numThreads = omp_get_max_threads() ;
+  }
+  vl_get_state()->numThreads = numThreads ;
+}
+#else
+void
+vl_set_num_threads (vl_size numThreads VL_UNUSED) { }
+#endif
+
+/* ---------------------------------------------------------------- */
+/** @brief Set last VLFeat error
+ ** @param error error code.
+ ** @param errorMessage error message format string.
+ ** @param ... format string arguments.
+ ** @return error code.
+ **
+ ** The function sets the code and optionally the error message
+ ** of the last encountered error. @a errorMessage is the message
+ ** format. It uses the @c printf convention and is followed by
+ ** the format arguments. The maximum length of the error message is
+ ** given by ::VL_ERR_MSG_LEN (longer messages are truncated).
+ **
+ ** Passing @c NULL as @a errorMessage
+ ** sets the error message to the empty string.
+ **/
+
+int
+vl_set_last_error (int error, char const * errorMessage, ...)
+{
+  VlThreadState * state = vl_get_thread_specific_state() ;
+  va_list args;
+  va_start(args, errorMessage) ;
+  if (errorMessage) {
+#ifdef VL_COMPILER_LCC
+    vsprintf(state->lastErrorMessage, errorMessage, args) ;
+#else
+    vsnprintf(state->lastErrorMessage,
+              sizeof(state->lastErrorMessage)/sizeof(char),
+              errorMessage, args) ;
+#endif
+  } else {
+    state->lastErrorMessage[0] = 0 ;
+  }
+  state->lastError = error ;
+  va_end(args) ;
+  return error ;
+}
+
+/** @brief Get the code of the last error
+ ** @return error code.
+ ** @sa ::vl_get_last_error_message.
+ **/
+
+int
+vl_get_last_error (void) {
+  return vl_get_thread_specific_state()->lastError ;
+}
+
+/** @brief Get the last error message
+ ** @return pointer to the error message.
+ ** @sa ::vl_get_last_error.
+ **/
+
+char const *
+vl_get_last_error_message (void)
+{
+  return vl_get_thread_specific_state()->lastErrorMessage ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Set memory allocation functions
+ ** @param malloc_func  pointer to @c malloc.
+ ** @param realloc_func pointer to @c realloc.
+ ** @param calloc_func  pointer to @c calloc.
+ ** @param free_func    pointer to @c free.
+ **/
+
+void
+vl_set_alloc_func (void *(*malloc_func)  (size_t),
+                   void *(*realloc_func) (void*, size_t),
+                   void *(*calloc_func)  (size_t, size_t),
+                   void  (*free_func)    (void*))
+{
+  VlState * state ;
+  vl_lock_state () ;
+  state = vl_get_state() ;
+  state->malloc_func  = malloc_func ;
+  state->realloc_func = realloc_func ;
+  state->calloc_func  = calloc_func ;
+  state->free_func    = free_func ;
+  vl_unlock_state () ;
+}
+
+/** @brief Allocate a memory block
+ ** @param n size in bytes of the new block.
+ ** @return pointer to the allocated block.
+ **
+ ** This function allocates a memory block of the specified size.
+ ** The synopsis is the same as the POSIX @c malloc function.
+ **/
+
+void *
+vl_malloc (size_t n)
+{
+  return (vl_get_state()->malloc_func)(n) ;
+  //return (memalign)(32,n) ;
+}
+
+
+/** @brief Reallocate a memory block
+ ** @param ptr pointer to a memory block previously allocated.
+ ** @param n size in bytes of the new block.
+ ** @return pointer to the new block.
+ **
+ ** This function reallocates a memory block to change its size.
+ ** The synopsis is the same as the POSIX @c realloc function.
+ **/
+
+void *
+vl_realloc (void* ptr, size_t n)
+{
+  return (vl_get_state()->realloc_func)(ptr, n) ;
+}
+
+/** @brief Free and clear a memory block
+ ** @param n number of items to allocate.
+ ** @param size size in bytes of an item.
+ ** @return pointer to the new block.
+ **
+ ** This function allocates and clears a memory block.
+ ** The synopsis is the same as the POSIX @c calloc function.
+ **/
+
+void *
+vl_calloc (size_t n, size_t size)
+{
+  return (vl_get_state()->calloc_func)(n, size) ;
+}
+
+/** @brief Free a memory block
+ ** @param ptr pointer to the memory block.
+ **
+ ** This function frees a memory block allocated by ::vl_malloc,
+ ** ::vl_calloc, or ::vl_realloc. The synopsis is the same as the POSIX
+ ** @c malloc function.
+ **/
+
+void
+vl_free (void *ptr)
+{
+  (vl_get_state()->free_func)(ptr) ;
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Set the printf function
+ ** @param printf_func pointer to a @c printf implementation.
+ ** Set @c print_func to NULL to disable printf.
+ **/
+
+void
+vl_set_printf_func (printf_func_t printf_func)
+{
+  vl_get_state()->printf_func = printf_func ? printf_func : do_nothing_printf ;
+}
+
+/** @brief Get the printf function
+ ** @return printf_func pointer to the @c printf implementation.
+ ** @sa ::vl_set_printf_func.
+ **/
+
+printf_func_t
+vl_get_printf_func (void) {
+  return vl_get_state()->printf_func ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get processor time
+ ** @return processor time in seconds.
+ ** @sa ::vl_tic, ::vl_toc
+ **/
+
+double
+vl_get_cpu_time ()
+{
+  #ifdef VL_OS_WIN
+  VlThreadState * threadState = vl_get_thread_specific_state() ;
+  LARGE_INTEGER mark ;
+  QueryPerformanceCounter (&mark) ;
+  return (double)mark.QuadPart / (double)threadState->ticFreq.QuadPart ;
+#else
+  return (double)clock() / (double)CLOCKS_PER_SEC ;
+#endif
+}
+
+/** @brief Reset processor time reference
+ ** The function resets VLFeat TIC/TOC time reference. There is one
+ ** such reference per thread.
+ ** @sa ::vl_get_cpu_time, ::vl_toc.
+ **/
+
+void
+vl_tic (void)
+{
+  VlThreadState * threadState = vl_get_thread_specific_state() ;
+#ifdef VL_OS_WIN
+  QueryPerformanceCounter (&threadState->ticMark) ;
+#else
+  threadState->ticMark = clock() ;
+#endif
+}
+
+/** @brief Get elapsed time since tic
+ ** @return elapsed time in seconds.
+ **
+ ** The function
+ ** returns the processor time elapsed since ::vl_tic was called last.
+ **
+ ** @remark In multi-threaded applications, there is an independent
+ ** timer for each execution thread.
+ **
+ ** @remark On UNIX, this function uses the @c clock() system call.
+ ** On Windows, it uses the @c QueryPerformanceCounter() system call,
+ ** which is more accurate than @c clock() on this platform.
+ **/
+
+double
+vl_toc (void)
+{
+  VlThreadState * threadState = vl_get_thread_specific_state() ;
+#ifdef VL_OS_WIN
+  LARGE_INTEGER tocMark ;
+  QueryPerformanceCounter(&tocMark) ;
+  return (double) (tocMark.QuadPart - threadState->ticMark.QuadPart) /
+    threadState->ticFreq.QuadPart ;
+#else
+  return (double) (clock() - threadState->ticMark) / CLOCKS_PER_SEC ;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the default random number generator.
+ ** @return random number generator.
+ **
+ ** The function returns a pointer to the default
+ ** random number generator.
+ ** There is one such generator per thread.
+ **/
+
+VL_EXPORT VlRand *
+vl_get_rand (void)
+{
+  return &vl_get_thread_specific_state()->rand ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                    Library construction and destruction routines */
+/*  --------------------------------------------------------------- */
+
+/** @internal@brief Construct a new thread state object
+ ** @return new state structure.
+ **/
+
+static VlThreadState *
+vl_thread_specific_state_new (void)
+{
+  VlThreadState * self ;
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: thread constructor begins.\n") ;
+#endif
+  self = malloc(sizeof(VlThreadState)) ;
+  self->lastError = 0 ;
+  self->lastErrorMessage[0] = 0 ;
+#if defined(VL_OS_WIN)
+  QueryPerformanceFrequency (&self->ticFreq) ;
+  self->ticMark.QuadPart = 0 ;
+#else
+  self->ticMark = 0 ;
+#endif
+  vl_rand_init (&self->rand) ;
+
+  return self ;
+}
+
+/** @internal@brief Delete a thread state structure
+ ** @param self thread state object.
+ **/
+
+static void
+vl_thread_specific_state_delete (VlThreadState * self)
+{
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: thread destructor begins.\n") ;
+#endif
+  free (self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                               Library constructor and destructor */
+/* ---------------------------------------------------------------- */
+
+/** @internal @brief Initialize VLFeat state */
+void
+vl_constructor (void)
+{
+  VlState * state ;
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: constructor begins.\n") ;
+#endif
+
+  state = vl_get_state() ;
+
+#if ! defined(VL_DISABLE_THREADS)
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: constructing thread specific state.\n") ;
+#endif
+#if defined(VL_THREADS_POSIX)
+  {
+    typedef void (*destructorType)(void * );
+    pthread_key_create (&state->threadKey,
+                        (destructorType)
+                          vl_thread_specific_state_delete) ;
+    pthread_mutex_init (&state->mutex, NULL) ;
+    pthread_cond_init (&state->mutexCondition, NULL) ;
+  }
+#elif defined(VL_THREADS_WIN)
+  InitializeCriticalSection (&state->mutex) ;
+  state->tlsIndex = TlsAlloc () ;
+#endif
+#else
+
+/* threading support disabled */
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: constructing the generic thread state instance (threading support disabled).\n") ;
+#endif
+  vl_get_state()->threadState = vl_thread_specific_state_new() ;
+#endif
+
+  state->malloc_func  = malloc ;
+  state->realloc_func = realloc ;
+  state->calloc_func  = calloc ;
+  state->free_func    = free ;
+  state->printf_func  = printf ;
+
+  /* on x86 platforms read the CPUID register */
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
+  _vl_x86cpu_info_init (&state->cpuInfo) ;
+#endif
+
+  /* get the number of CPUs */
+#if defined(VL_OS_WIN)
+  {
+    SYSTEM_INFO info;
+    GetSystemInfo (&info) ;
+    state->numCPUs = info.dwNumberOfProcessors ;
+  }
+#elif defined(_SC_NPROCESSORS_ONLN)
+  state->numCPUs = sysconf(_SC_NPROCESSORS_ONLN) ;
+#else
+  state->numCPUs = 1 ;
+#endif
+  state->simdEnabled = VL_TRUE ;
+
+  /* get the number of (OpenMP) threads used by the library */
+#if defined(_OPENMP)
+  state->numThreads = omp_get_max_threads() ;
+#else
+  state->numThreads = 1 ;
+#endif
+
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: constructor ends.\n") ;
+#endif
+}
+
+/** @internal @brief Destruct VLFeat */
+void
+vl_destructor ()
+{
+  VlState * state ;
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: destructor begins.\n") ;
+#endif
+
+  state = vl_get_state() ;
+
+#if ! defined(VL_DISABLE_THREADS)
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: destroying a thread specific state instance.\n") ;
+#endif
+#if   defined(VL_THREADS_POSIX)
+  {
+    /* Delete the thread state of this thread as the
+       destructor is not called by pthread_key_delete or after
+       the key is deleted. When the library
+       is unloaded, this thread should also be the last one
+       using the library, so this is fine.
+     */
+    VlThreadState * threadState =
+       pthread_getspecific(state->threadKey) ;
+    if (threadState) {
+      vl_thread_specific_state_delete (threadState) ;
+      pthread_setspecific(state->threadKey, NULL) ;
+    }
+  }
+  pthread_cond_destroy (&state->mutexCondition) ;
+  pthread_mutex_destroy (&state->mutex) ;
+  pthread_key_delete (state->threadKey) ;
+#elif defined(VL_THREADS_WIN)
+ {
+    /* Delete the thread state of this thread as the
+       destructor is not called by pthread_key_delete or after
+       the key is deleted. When the library
+       is unloaded, this thread should also be the last one
+       using the library, so this is fine.
+     */
+    VlThreadState * threadState =
+       TlsGetValue(state->tlsIndex) ;
+    if (threadState) {
+      vl_thread_specific_state_delete (threadState) ;
+      TlsSetValue(state->tlsIndex, NULL) ;
+    }
+  }
+  TlsFree (state->tlsIndex) ;
+  DeleteCriticalSection (&state->mutex) ;
+#endif
+#else
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: destroying the generic thread state instance (threading support disabled).\n") ;
+#endif
+  vl_thread_specific_state_delete(vl_get_state()->threadState) ;
+#endif
+
+#if defined(DEBUG)
+  printf("VLFeat DEBUG: destructor ends.\n") ;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+/*                    Cross-platform call to constructor/destructor */
+/* ---------------------------------------------------------------- */
+
+#ifdef __cplusplus
+    #define INITIALIZER(f) \
+        static void f(void); \
+        struct f##_t_ { f##_t_(void) { f(); } }; static f##_t_ f##_; \
+        static void f(void)
+#elif defined(_MSC_VER)
+    #pragma section(".CRT$XCU",read)
+    #define INITIALIZER2_(f,p) \
+        static void f(void); \
+        __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
+        __pragma(comment(linker,"/include:" p #f "_")) \
+        static void f(void)
+    #ifdef _WIN64
+        #define INITIALIZER(f) INITIALIZER2_(f,"")
+    #else
+        #define INITIALIZER(f) INITIALIZER2_(f,"_")
+    #endif
+#else
+    #define INITIALIZER(f) \
+        static void f(void) __attribute__((constructor)); \
+        static void f(void)
+#endif
+
+INITIALIZER(vl_initialize)
+{
+    vl_constructor();
+    atexit(vl_destructor);
+}
+
diff --git a/opensfm/src/third_party/vlfeat/vl/generic.h b/opensfm/src/third_party/vlfeat/vl/generic.h
new file mode 100644
index 000000000..4a6296e8c
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/generic.h
@@ -0,0 +1,213 @@
+/** @file generic.h
+ ** @brief Generic (@ref generic)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 Andrea Vedaldi.
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_GENERIC_H
+#define VL_GENERIC_H
+
+#include "host.h"
+#include "random.h"
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <time.h>
+#include <assert.h>
+
+/** @brief Library version string */
+#define VL_VERSION_STRING "0.9.20"
+
+/** @brief Maximum length (in characters) of an error message */
+#define VL_ERR_MSG_LEN 1024
+
+/** @name Type identifiers for atomic data types
+ ** @{ */
+
+#define VL_TYPE_FLOAT   1     /**< @c float type */
+#define VL_TYPE_DOUBLE  2     /**< @c double type */
+#define VL_TYPE_INT8    3     /**< @c ::vl_int8 type */
+#define VL_TYPE_UINT8   4     /**< @c ::vl_uint8 type */
+#define VL_TYPE_INT16   5     /**< @c ::vl_int16 type */
+#define VL_TYPE_UINT16  6     /**< @c ::vl_uint16 type */
+#define VL_TYPE_INT32   7     /**< @c ::vl_int32 type */
+#define VL_TYPE_UINT32  8     /**< @c ::vl_uint32 type */
+#define VL_TYPE_INT64   9     /**< @c ::vl_int64 type */
+#define VL_TYPE_UINT64  10    /**< @c ::vl_uint64 type */
+
+typedef vl_uint32 vl_type ;
+
+/** @brief Get the name of a data type.
+ ** @param type data type.
+ ** @return data name of the data type.
+ **
+ ** @c type is one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE,
+ ** ::VL_TYPE_INT8, ::VL_TYPE_INT16, ::VL_TYPE_INT32, ::VL_TYPE_INT64,
+ ** ::VL_TYPE_UINT8, ::VL_TYPE_UINT16, ::VL_TYPE_UINT32, ::VL_TYPE_UINT64.
+ **/
+
+void vl_constructor();
+void vl_destructor();
+
+VL_INLINE char const *
+vl_get_type_name (vl_type type)
+{
+  switch (type) {
+    case VL_TYPE_FLOAT   : return "float"  ;
+    case VL_TYPE_DOUBLE  : return "double" ;
+    case VL_TYPE_INT8    : return "int8"   ;
+    case VL_TYPE_INT16   : return "int16"  ;
+    case VL_TYPE_INT32   : return "int32"  ;
+    case VL_TYPE_INT64   : return "int64"  ;
+    case VL_TYPE_UINT8   : return "int8"   ;
+    case VL_TYPE_UINT16  : return "int16"  ;
+    case VL_TYPE_UINT32  : return "int32"  ;
+    case VL_TYPE_UINT64  : return "int64"  ;
+    default: return NULL ;
+  }
+}
+
+/** @brief Get data type size.
+ ** @param type data type.
+ ** @return size (in byte)
+ **
+ ** @c type is one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE,
+ ** ::VL_TYPE_INT8, ::VL_TYPE_INT16, ::VL_TYPE_INT32, ::VL_TYPE_INT64,
+ ** ::VL_TYPE_UINT8, ::VL_TYPE_UINT16, ::VL_TYPE_UINT32, ::VL_TYPE_UINT64.
+ **/
+
+VL_INLINE vl_size
+vl_get_type_size (vl_type type)
+{
+  vl_size dataSize = 0 ;
+  switch (type) {
+    case VL_TYPE_DOUBLE : dataSize = sizeof(double) ; break ;
+    case VL_TYPE_FLOAT  : dataSize = sizeof(float) ; break ;
+    case VL_TYPE_INT64  : case VL_TYPE_UINT64 : dataSize = sizeof(vl_int64) ; break ;
+    case VL_TYPE_INT32  : case VL_TYPE_UINT32 : dataSize = sizeof(vl_int32) ; break ;
+    case VL_TYPE_INT16  : case VL_TYPE_UINT16 : dataSize = sizeof(vl_int16) ; break ;
+    case VL_TYPE_INT8   : case VL_TYPE_UINT8  : dataSize = sizeof(vl_int8)  ; break ;
+    default:
+      abort() ;
+  }
+  return dataSize ;
+}
+/** @} */
+
+VL_EXPORT char const * vl_get_version_string (void) ;
+VL_EXPORT char * vl_configuration_to_string_copy (void) ;
+VL_EXPORT void vl_set_simd_enabled (vl_bool x) ;
+VL_EXPORT vl_bool vl_get_simd_enabled (void) ;
+VL_EXPORT vl_bool vl_cpu_has_avx (void) ;
+VL_EXPORT vl_bool vl_cpu_has_sse3 (void) ;
+VL_EXPORT vl_bool vl_cpu_has_sse2 (void) ;
+VL_EXPORT vl_size vl_get_num_cpus (void) ;
+VL_EXPORT VlRand * vl_get_rand (void) ;
+
+/** @name Multi-thread computations
+ ** @{ */
+VL_EXPORT vl_size vl_get_max_threads (void) ;
+VL_EXPORT void vl_set_num_threads (vl_size n) ;
+VL_EXPORT vl_size vl_get_thread_limit (void) ;
+/** @} (*/
+
+/** ------------------------------------------------------------------
+ ** @name Error handling
+ ** @{ */
+#define VL_ERR_OK       0  /**< No error */
+#define VL_ERR_OVERFLOW 1  /**< Buffer overflow error */
+#define VL_ERR_ALLOC    2  /**< Resource allocation error */
+#define VL_ERR_BAD_ARG  3  /**< Bad argument or illegal data error */
+#define VL_ERR_IO       4  /**< Input/output error */
+#define VL_ERR_EOF      5  /**< End-of-file or end-of-sequence error */
+#define VL_ERR_NO_MORE  5  /**< End-of-sequence @deprecated */
+
+VL_EXPORT int vl_get_last_error (void) ;
+VL_EXPORT char const *  vl_get_last_error_message (void) ;
+VL_EXPORT int vl_set_last_error (int error, char const * errorMessage, ...) ;
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Memory allocation
+ ** @{ */
+VL_EXPORT void
+vl_set_alloc_func (void *(*malloc_func)  (size_t),
+                   void *(*realloc_func) (void*,size_t),
+                   void *(*calloc_func)  (size_t, size_t),
+                   void  (*free_func)    (void*)) ;
+VL_EXPORT void *vl_malloc (size_t n) ;
+VL_EXPORT void *vl_realloc (void *ptr, size_t n) ;
+VL_EXPORT void *vl_calloc (size_t n, size_t size) ;
+VL_EXPORT void *vl_memalign (size_t n, size_t size) ;
+VL_EXPORT void  vl_free (void* ptr) ;
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Logging
+ ** @{ */
+/** @brief Customizable printf function pointer type */
+typedef int(*printf_func_t) (char const *format, ...) ;
+VL_EXPORT void vl_set_printf_func (printf_func_t printf_func) ;
+VL_EXPORT printf_func_t vl_get_printf_func (void) ;
+
+/** @def VL_PRINTF
+ ** @brief Call user-customizable @c printf function
+ **
+ ** The function calls the user customizable @c printf.
+ **/
+
+/** @def VL_PRINT
+ ** @brief Same as ::VL_PRINTF (legacy code)
+ **/
+
+#define VL_PRINTF (*vl_get_printf_func())
+#define VL_PRINT (*vl_get_printf_func())
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Common operations
+ ** @{ */
+
+/** @brief Compute the minimum between two values
+ ** @param x value
+ ** @param y value
+ ** @return the minimum of @a x and @a y.
+ **/
+#define VL_MIN(x,y) (((x)<(y))?(x):(y))
+
+/** @brief Compute the maximum between two values
+ ** @param x value.
+ ** @param y value.
+ ** @return the maximum of @a x and @a y.
+ **/
+#define VL_MAX(x,y) (((x)>(y))?(x):(y))
+
+/** @brief Signed left shift operation
+ ** @param x value.
+ ** @param n number of shift positions.
+ ** @return @c x << n .
+ ** The macro is equivalent to the builtin @c << operator, but it
+ ** supports negative shifts too.
+ **/
+#define VL_SHIFT_LEFT(x,n) (((n)>=0)?((x)<<(n)):((x)>>-(n)))
+/* @} */
+
+/** ------------------------------------------------------------------
+ ** @name Measuring time
+ ** @{
+ **/
+VL_EXPORT void vl_tic (void) ;
+VL_EXPORT double vl_toc (void) ;
+VL_EXPORT double vl_get_cpu_time (void) ;
+/** @} */
+
+/* VL_GENERIC_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/getopt_long.c b/opensfm/src/third_party/vlfeat/vl/getopt_long.c
new file mode 100644
index 000000000..0e860f386
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/getopt_long.c
@@ -0,0 +1,326 @@
+/** @file getopt_long.c
+ ** @brief getopt_long - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+@file   getopt_long.h
+@brief  getopt_long
+@author Andrea Vedaldi
+
+This is a drop-in replacament of GNU getopt_long meant to be used
+on platforms that do not support such functionality.
+**/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "generic.h"
+#include "getopt_long.h"
+
+int    opterr = 1 ;
+int    optind = 1 ;
+int    optopt ;
+char * optarg ;
+int    optreset ;
+
+#define BADCH	'?'
+#define BADARG	':'
+#define EEND    -1
+#define EMSG	""
+
+/** @brief Parse long options (BSD style)
+ ** @param argc number of arguments.
+ ** @param argv pointer to the vector of arguments.
+ ** @param optstring list of abbreviated options
+ ** @param longopts list of long options.
+ ** @param longindex index of current option in @a longopts.
+ ** @return the code of the next option.
+ **
+ ** This function extract long and short options from the argument
+ ** list @a argv of @a argc entries.
+ **
+ ** A short options sequence is introduced by a single dash character
+ ** @c -. Each short option is described by a single character in the
+ ** string @a optstring, possibly followed by a @c : character to
+ ** denote a (mandatory) argument of the short option. A short option
+ ** with an argument cannot appear in the middle of a short option
+ ** sequence, but only at the end.
+ **
+ ** A long option is introduced by a double dash @c --. Each long
+ ** option is described by an instance of the ::option structure in
+ ** the @a longopts table (the last entry must be filled with zeroes
+ ** to denote the end).
+ **
+ ** Illegal options and missing arguments cause the function to skip
+ ** the option and return '?'. If ::opterr is @c true (default), the
+ ** function prints an error message to @a stderr. Finally, if @a
+ ** optstring has a leading @c :, then error messages are suppressed
+ ** and a missing argument causes @a : to be returned.
+ **
+ ** @remark The function is currently <em>not</em> thread safe.
+ **/
+
+VL_EXPORT int
+getopt_long(int argc, char *const argv[],
+            const char *optstring,
+            const struct option * longopts,
+            int *longindex)
+{
+  static char *place = EMSG;	/* option letter processing */
+  static int   optbegin  = 0 ;
+  static int   optend    = 0 ;
+  char        *oli;		/* option letter list index */
+  int          has_colon = 0 ;
+  int          ret_val   = 0 ;
+
+  /*
+     A semicolon at the beginning of optstring has a special meaning.
+     If we find one, we annote and remove it.
+  */
+  has_colon = optstring && optstring[0] == ':' ;
+  if (has_colon) ++ optstring ;
+
+  /*
+   Here we are either processing a short option sequence or
+   we start processing a new option. This is indicated by optreset.
+  */
+
+  if (optreset || *place == '\0') {
+
+    /* ---------------------------------------------------------------
+     *                                 Look for next short/long option
+     * ------------------------------------------------------------ */
+    optreset = 0 ;
+
+    /* no more arguments ? */
+    if (optind >= argc) {
+      place = EMSG ;
+      return -1 ;
+    }
+
+    /* next argument that may hold an option */
+    optbegin = optind ;
+
+    /* ---------------------------------------------------------------
+     *                                     Look for an option to parse
+     * ------------------------------------------------------------ */
+
+  parse_option_at_optbegin :
+
+    /* place points to the candidate option */
+    place = argv [optbegin] ;
+
+    /* an option is introduced by '-' */
+    if (place [0] != '-') {
+      /* this argument is not an option: try next argument */
+      ++ optbegin ;
+      if (optbegin >= argc) {
+        /* no more arguments to look for options */
+        place = EMSG ;
+        return -1 ;
+      }
+      goto parse_option_at_optbegin ;
+    }
+
+    /* consume leading `-' */
+    ++ place ;
+
+    /* assume the option is composed of one argument only */
+    optend = optbegin + 1 ;
+
+    /* assume no argument */
+    optarg = 0 ;
+
+    /* ---------------------------------------------------------------
+     *                                                     option `--'
+     * ------------------------------------------------------------ */
+
+    /* this special option (void long option) ends the option processing */
+    if (place[0]        &&
+        place[0] == '-' &&
+        place[1] == '\0') {
+
+      optind  = optend ;
+      place   = EMSG ;
+      ret_val = -1 ;
+      goto done_option ;
+    }
+
+    /* ---------------------------------------------------------------
+     *                                                     long option
+     * ------------------------------------------------------------ */
+
+    if (place[0]        &&
+        place[0] == '-' &&
+        place[1] ) {
+
+      size_t namelen ;
+      int i ;
+
+      /* consume second `-' */
+      ++ place ;
+
+      /* count characters before `=' */
+      namelen = strcspn(place, "=") ;
+
+      /* scan longopts for this option */
+      for (i = 0 ; longopts[i].name != NULL ; ++ i) {
+
+        if (strlen  (       longopts[i].name) == namelen &&
+            strncmp (place, longopts[i].name, namelen) == 0 ) {
+
+          /* save back long option index */
+          if (longindex) *longindex = i ;
+
+          /* process long option argument */
+          if (longopts[i].has_arg == required_argument ||
+              longopts[i].has_arg == optional_argument) {
+
+            /* --option=value style */
+            if (place[namelen] == '=') {
+              optarg = place + namelen + 1 ;
+            }
+
+            /* --option value style (only required_argument) */
+            else if (longopts[i].has_arg == required_argument) {
+              /* missing argument ? */
+              if (optbegin >= argc - 1) {
+                if (! has_colon && opterr)
+                  fprintf(stderr,
+                          "%s: option requires an argument -- %s\n",
+                          argv[0], place);
+                place   = EMSG ;
+                ret_val = has_colon ? BADARG : BADCH ;
+                goto done_option ;
+              }
+              optarg = argv [optend] ;
+              ++ optend ;
+            }
+          }
+
+          /* determine return value */
+          if (longopts[i].flag == NULL) {
+            ret_val = longopts[i].val ;
+          }
+          else {
+            *longopts[i].flag = longopts[i].val;
+            ret_val = 0 ;
+          }
+
+          /* mark sequence closed */
+          place = EMSG ;
+          goto done_option ;
+        } /* if match */
+
+      } /* scan longoptions */
+
+      /* no matching option found */
+      if (! has_colon && opterr)
+        fprintf(stderr,
+                "%s: illegal option -- %s\n", argv[0], place) ;
+      place   = EMSG ;
+      ret_val = BADCH ;
+      goto done_option ;
+    }
+  } /* end new option */
+
+  /* -----------------------------------------------------------------
+   *                                      Finish short option sequence
+   * -------------------------------------------------------------- */
+  optopt = (int) *place++ ;
+
+  /* search charcater in option list */
+  oli = strchr(optstring, optopt);
+
+  /* short option not found */
+  if (!oli) {
+
+    if (! has_colon && opterr)
+      fprintf(stderr,
+              "%s: illegal option -- %c\n",
+              argv[0], optopt);
+
+    if (*place) {
+      /* more short options in the list */
+      return BADCH ;
+    }
+
+    else {
+      /* error occured as last option in the list */
+      place   = EMSG ;
+      ret_val = BADCH ;
+      goto done_option ;
+    }
+  } /* end short option not found */
+
+  if (oli[1] != ':') {
+    /* short option with no argument */
+
+    if (*place) {
+      /* more short options in the list */
+      return optopt ;
+    }
+    else {
+      /* last option in the list */
+      place   = EMSG ;
+      ret_val = optopt ;
+      goto done_option ;
+    }
+
+  } else {
+    /* short option with argument */
+
+    /* -ovalue style */
+    if (*place) {
+      optarg  = place ;
+      place   = EMSG ;
+      ret_val = optopt ;
+      goto done_option ;
+    }
+    /* -o value style: missing argument */
+    else if (optbegin >= argc - 1) {
+      if (! has_colon && opterr)
+        fprintf(stderr,
+                "%s: option requires an argument -- %c\n",
+                argv[0], optopt);
+      place   = EMSG ;
+      ret_val = has_colon ? BADARG : BADCH ;
+      goto done_option ;
+    }
+
+    /* -o value style: process argument */
+    optarg = argv [optend] ;
+    ++ optend ;
+    place   = EMSG ;
+    ret_val = optopt ;
+    goto done_option ;
+  } /* short with argument */
+
+ done_option :
+  {
+    int pos = optend - optbegin ;  /* n of circular shifts */
+    int c   = pos ;
+
+    while (c --) {
+      int i ;
+      char *tmp = argv [optend - 1] ;
+      for (i = optend - 1 ; i > optind ; -- i) {
+        ((char**)argv) [i] = argv [i-1] ;
+      }
+      ((char**)argv) [optind] = tmp ;
+    }
+    optind += pos ;
+  }
+
+  return ret_val ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/getopt_long.h b/opensfm/src/third_party/vlfeat/vl/getopt_long.h
new file mode 100644
index 000000000..421213546
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/getopt_long.h
@@ -0,0 +1,43 @@
+/** @file getopt_long.h
+ ** @brief getopt_long
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_GETOPT_LONG_H
+#define VL_GETOPT_LONG_H
+
+#include "generic.h"
+
+VL_EXPORT int    opterr ;   /**< code of the last error occured while parsing an option */
+VL_EXPORT int    optind ;   /**< index of the next option to process in @c argv */
+VL_EXPORT int    optopt ;   /**< current option */
+VL_EXPORT char * optarg ;   /**< argument of the current option */
+VL_EXPORT int    optreset ; /**< reset flag */
+
+/** @brief ::getopt_long option */
+struct option
+{
+  const char *name ;  /**< option long name */
+  int	      has_arg ; /**< flag indicating whether the option has no, required or optional argument */
+  int	     *flag ;    /**< pointer to a variable to set (if @c NULL, the value is returned instead) */
+  int	      val ;     /**< value to set or to return */
+} ;
+
+#define no_argument       0 /**< ::option with no argument */
+#define required_argument 1 /**< ::option with required argument */
+#define optional_argument 2 /**< ::option with optional argument */
+
+VL_EXPORT int getopt_long(int argc, char * const argv[],
+                          const char * optstring,
+                          const struct option * longopts, int * longindex);
+
+/* VL_GETOPT_LONG_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/gmm.c b/opensfm/src/third_party/vlfeat/vl/gmm.c
new file mode 100644
index 000000000..585044576
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/gmm.c
@@ -0,0 +1,1709 @@
+/** @file gmm.c
+ ** @brief Gaussian Mixture Models - Implementation
+ ** @author David Novotny
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page gmm Gaussian Mixture Models (GMM)
+@author David Novotny
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref gmm.h is an implementation of *Gaussian Mixture Models* (GMMs).
+The main functionality provided by this module is learning GMMs from
+data by maximum likelihood. Model optimization uses the Expectation
+Maximization (EM) algorithm @cite{dempster77maximum}. The
+implementation supports @c float or @c double data types, is
+parallelized, and is tuned to work reliably and effectively on
+datasets of visual features. Stability is obtained in part by
+regularizing and restricting the parameters of the GMM.
+
+@ref gmm-starting demonstreates how to use the C API to compute the FV
+representation of an image. For further details refer to:
+
+- @subpage gmm-fundamentals
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section gmm-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In order to use @ref gmm.h to learn a GMM from training data, create a
+new ::VlGMM object instance, set the parameters as desired, and run
+the training code. The following example learns @c numClusters
+Gaussian components from @c numData vectors of dimension @c dimension
+and storage class @c float using at most 100 EM iterations:
+
+@code
+float * means ;
+float * covariances ;
+float * priors ;
+float * posteriors ;
+
+double loglikelihood ;
+
+// create a new instance of a GMM object for float data
+gmm = vl_gmm_new (VL_TYPE_FLOAT, dimension, numClusters) ;
+
+// set the maximum number of EM iterations to 100
+vl_gmm_set_max_num_iterations (gmm, 100) ;
+
+// set the initialization to random selection
+vl_gmm_set_initialization (gmm,VlGMMRand);
+
+// cluster the data, i.e. learn the GMM
+vl_gmm_cluster (gmm, data, numData);
+
+// get the means, covariances, and priors of the GMM
+means = vl_gmm_get_means(gmm);
+covariances = vl_gmm_get_covariances(gmm);
+priors = vl_gmm_get_priors(gmm);
+
+// get loglikelihood of the estimated GMM
+loglikelihood = vl_gmm_get_loglikelihood(gmm) ;
+
+// get the soft assignments of the data points to each cluster
+posteriors = vl_gmm_get_posteriors(gmm) ;
+@endcode
+
+@note ::VlGMM assumes that the covariance matrices of the GMM are
+diagonal. This reduces significantly the number of parameters to learn
+and is usually an acceptable compromise in vision applications. If the
+data is significantly correlated, it can be beneficial to de-correlate
+it by PCA rotation or projection in pre-processing.
+
+::vl_gmm_get_loglikelihood is used to get the final loglikelihood of
+the estimated mixture, ::vl_gmm_get_means and ::vl_gmm_get_covariances
+to obtain the means and the diagonals of the covariance matrices of
+the estimated Gaussian modes, and ::vl_gmm_get_posteriors to get the
+posterior probabilities that a given point is associated to each of
+the modes (soft assignments).
+
+The learning algorithm, which uses EM, finds a local optimum of the
+objective function. Therefore the initialization is crucial in
+obtaining a good model, measured in term of the final
+loglikelihood. ::VlGMM supports a few methods (use
+::vl_gmm_set_initialization to choose one) as follows:
+
+Method                | ::VlGMMInitialization enumeration       | Description
+----------------------|-----------------------------------------|-----------------------------------------------
+Random initialization | ::VlGMMRand                             | Random initialization of the mixture parameters
+KMeans                | ::VlGMMKMeans                           | Initialization of the mixture parameters using ::VlKMeans
+Custom                | ::VlGMMCustom                           | User specified initialization
+
+Note that in the case of ::VlGMMKMeans initialization, an object of
+type ::VlKMeans object must be created and passed to the ::VlGMM
+instance (see @ref kmeans to see how to correctly set up this object).
+
+When a user wants to use the ::VlGMMCustom method, the initial means,
+covariances and priors have to be specified using the
+::vl_gmm_set_means, ::vl_gmm_set_covariances and ::vl_gmm_set_priors
+methods.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page gmm-fundamentals GMM fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A *Gaussian Mixture Model* (GMM) is a mixture of $K$ multivariate
+Gaussian distributions. In order to sample from a GMM, one samples
+first the component index $k \in \{1,\dots,K\}$ with *prior
+probability* $\pi_k$, and then samples the vector $\bx \in
+\mathbb{R}^d$ from the $k$-th Gaussian distribution
+$p(\bx|\mu_k,\Sigma_k)$. Here $\mu_k$ and $\Sigma_k$ are respectively
+the *mean* and *covariance* of the distribution. The GMM is completely
+specified by the parameters $\Theta=\{\pi_k,\mu_k,\Sigma_k; k =
+1,\dots,K\}$
+
+The density $p(\bx|\Theta)$ induced on the training data is obtained
+by marginalizing the component selector $k$, obtaining
+\[
+p(\bx|\Theta)
+= \sum_{k=1}^{K} \pi_k p( \bx_i |\mu_k,\Sigma_k),
+\qquad
+p( \bx |\mu_k,\Sigma_k)
+=
+\frac{1}{\sqrt{(2\pi)^d\det\Sigma_k}}
+\exp\left[
+-\frac{1}{2} (\bx-\mu_k)^\top\Sigma_k^{-1}(\bx-\mu_k)
+\right].
+\]
+Learning a GMM to fit a dataset $X=(\bx_1, \dots, \bx_n)$ is usually
+done by maximizing the log-likelihood of the data:
+@f[
+ \ell(\Theta;X)
+ = E_{\bx\sim\hat p} [ \log p(\bx|\Theta) ]
+ = \frac{1}{n}\sum_{i=1}^{n} \log \sum_{k=1}^{K} \pi_k p(\bx_i|\mu_k, \Sigma_k)
+@f]
+where $\hat p$ is the empirical distribution of the data. An algorithm
+to solve this problem is introduced next.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section gmm-em Learning a GMM by expectation maximization
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The direct maximization of the log-likelihood function of a GMM is
+difficult due to the fact that the assignments of points to Gaussian
+mode is not observable and, as such, must be treated as a latent
+variable.
+
+Usually, GMMs are learned by using the *Expectation Maximization* (EM)
+algorithm @cite{dempster77maximum}. Consider in general the problem of
+estimating to the maximum likelihood a distribution $p(x|\Theta) =
+\int p(x,h|\Theta)\,dh$, where $x$ is a measurement, $h$ is a *latent
+variable*, and $\Theta$ are the model parameters. By introducing an
+auxiliary distribution $q(h|x)$ on the latent variable, one can use
+Jensen inequality to obtain the following lower bound on the
+log-likelihood:
+
+@f{align*}
+\ell(\Theta;X) =
+E_{x\sim\hat p} \log p(x|\Theta)
+&= E_{x\sim\hat p} \log \int p(x,h|\Theta) \,dh \\
+&= E_{x\sim\hat p} \log \int \frac{p(x,h|\Theta)}{q(h|x)} q(h|x)\,dh \\
+&\geq E_{x\sim\hat p} \int q(h) \log \frac{p(x,h|\Theta)}{q(h|x)}\,dh \\
+&= E_{(x,q) \sim q(h|x) \hat p(x)} \log p(x,h|\Theta) -
+   E_{(x,q) \sim q(h|x) \hat p(x)} \log q(h|x)
+@f}
+
+The first term of the last expression is the log-likelihood of the
+model where both the $x$ and $h$ are observed and joinlty distributed
+as $q(x|h)\hat p(x)$; the second term is the a average entropy of the
+latent variable, which does not depend on $\Theta$. This lower bound
+is maximized and becomes tight by setting $q(h|x) = p(h|x,\Theta)$ to
+be the posterior distribution on the latent variable $h$ (given the
+current estimate of the parameters $\Theta$). In fact:
+
+\[
+E_{x \sim \hat p} \log p(x|\Theta)
+=
+E_{(x,h) \sim p(h|x,\Theta) \hat p(x)}\left[ \log \frac{p(x,h|\Theta)}{p(h|x,\Theta)} \right]
+=
+E_{(x,h) \sim p(h|x,\Theta) \hat p(x)} [ \log p(x|\Theta) ]
+=
+\ell(\Theta;X).
+\]
+
+EM alternates between updating the latent variable auxiliary
+distribution $q(h|x) = p(h|x,\Theta_t)$ (*expectation step*) given the
+current estimate of the parameters $\Theta_t$, and then updating the
+model parameters $\Theta_{t+1}$ by maximizing the log-likelihood lower
+bound derived (*maximization step*). The simplification is that in the
+maximization step both $x$ and $h$ are now ``observed'' quantities.
+This procedure converges to a local optimum of the model
+log-likelihood.
+
+@subsection gmm-expectation-step Expectation step
+
+In the case of a GMM, the latent variables are the point-to-cluster
+assignments $k_i, i=1,\dots,n$, one for each of $n$ data points. The
+auxiliary distribution $q(k_i|\bx_i) = q_{ik}$ is a matrix with $n
+\times K$ entries. Each row $q_{i,:}$ can be thought of as a vector of
+soft assignments of the data points $\bx_i$ to each of the Gaussian
+modes. Setting $q_{ik} = p(k_i | \bx_i, \Theta)$ yields
+
+\[
+ q_{ik} =
+\frac
+{\pi_k p(\bx_i|\mu_k,\Sigma_k)}
+{\sum_{l=1}^K \pi_l p(\bx_i|\mu_l,\Sigma_l)}
+\]
+
+where the Gaussian density $p(\bx_i|\mu_k,\Sigma_k)$ was given above.
+
+One important point to keep in mind when these probabilities are
+computed is the fact that the Gaussian densities may attain very low
+values and underflow in a vanilla implementation. Furthermore, VLFeat
+GMM implementation restricts the covariance matrices to be
+diagonal. In this case, the computation of the determinant of
+$\Sigma_k$ reduces to computing the trace of the matrix and the
+inversion of $\Sigma_k$ could be obtained by inverting the elements on
+the diagonal of the covariance matrix.
+
+@subsection gmm-maximization-step  Maximization step
+
+The M step estimates the parameters of the Gaussian mixture components
+and the prior probabilities $\pi_k$ given the auxiliary distribution
+on the point-to-cluster assignments computed in the E step. Since all
+the variables are now ``observed'', the estimate is quite simple. For
+example, the mean $\mu_k$ of a Gaussian mode is obtained as the mean
+of the data points assigned to it (accounting for the strength of the
+soft assignments). The other quantities are obtained in a similar
+manner, yielding to:
+
+@f{align*}
+ \mu_k &= { { \sum_{i=1}^n q_{ik} \bx_{i} } \over { \sum_{i=1}^n q_{ik} } },
+\\
+ \Sigma_k &= { { \sum_{i=1}^n { q_{ik} (\bx_{i} - \mu_{k}) {(\bx_{i} - \mu_{k})}^T } } \over { \sum_{i=1}^n q_{ik} } },
+\\
+ \pi_k &= { \sum_{i=1}^n { q_{ik} } \over { \sum_{i=1}^n \sum_{l=1}^K q_{il} } }.
+@f}
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section gmm-fundamentals-init Initialization algorithms
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The EM algorithm is a local optimization method. As such, the quality
+of the solution strongly depends on the quality of the initial values
+of the parameters (i.e.  of the locations and shapes of the Gaussian
+modes).
+
+@ref gmm.h supports the following cluster initialization algorithms:
+
+- <b>Random data points.</b> (::vl_gmm_init_with_rand_data) This method
+  sets the means of the modes by sampling at random a corresponding
+  number of data points, sets the covariance matrices of all the modes
+  are to the covariance of the entire dataset, and sets the prior
+  probabilities of the Gaussian modes to be uniform. This
+  initialization method is the fastest, simplest, as well as the one
+  most likely to end in a bad local minimum.
+
+- <b>KMeans initialization</b> (::vl_gmm_init_with_kmeans) This
+  method uses KMeans to pre-cluster the points. It then sets the means
+  and covariances of the Gaussian distributions the sample means and
+  covariances of each KMeans cluster. It also sets the prior
+  probabilities to be proportional to the mass of each cluster. In
+  order to use this initialization method, a user can specify an
+  instance of ::VlKMeans by using the function
+  ::vl_gmm_set_kmeans_init_object, or let ::VlGMM create one
+  automatically.
+
+Alternatively, one can manually specify a starting point
+(::vl_gmm_set_priors, ::vl_gmm_set_means, ::vl_gmm_set_covariances).
+**/
+
+#include "gmm.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#ifndef VL_DISABLE_SSE2
+#include "mathop_sse2.h"
+#endif
+
+#ifndef VL_DISABLE_AVX
+#include "mathop_avx.h"
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_GMM_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+#define VL_GMM_MIN_VARIANCE 1e-6
+#define VL_GMM_MIN_POSTERIOR 1e-2
+#define VL_GMM_MIN_PRIOR 1e-6
+
+struct _VlGMM
+{
+  vl_type dataType ;                  /**< Data type. */
+  vl_size dimension ;                 /**< Data dimensionality. */
+  vl_size numClusters ;               /**< Number of clusters  */
+  vl_size numData ;                   /**< Number of last time clustered data points.  */
+  vl_size maxNumIterations ;          /**< Maximum number of refinement iterations. */
+  vl_size numRepetitions   ;          /**< Number of clustering repetitions. */
+  int     verbosity ;                 /**< Verbosity level. */
+  void *  means;                      /**< Means of Gaussian modes. */
+  void *  covariances;                /**< Diagonals of covariance matrices of Gaussian modes. */
+  void *  priors;                     /**< Weights of Gaussian modes. */
+  void *  posteriors;                 /**< Probabilities of correspondences of points to clusters. */
+  double * sigmaLowBound ;            /**< Lower bound on the diagonal covariance values. */
+  VlGMMInitialization initialization; /**< Initialization option */
+  VlKMeans * kmeansInit;              /**< Kmeans object for initialization of gaussians */
+  double LL ;                         /**< Current solution loglikelihood */
+  vl_bool kmeansInitIsOwner; /**< Indicates whether a user provided the kmeans initialization object */
+} ;
+
+/* ---------------------------------------------------------------- */
+/*                                                       Life-cycle */
+/* ---------------------------------------------------------------- */
+
+static void
+_vl_gmm_prepare_for_data (VlGMM* self, vl_size numData)
+{
+  if (self->numData < numData) {
+    vl_free(self->posteriors) ;
+    self->posteriors = vl_malloc(vl_get_type_size(self->dataType) * numData * self->numClusters) ;
+  }
+  self->numData = numData ;
+}
+
+/** @brief Create a new GMM object
+ ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
+ ** @param dimension dimension of the data.
+ ** @param numComponents number of Gaussian mixture components.
+ ** @return new GMM object instance.
+ **/
+
+VlGMM *
+vl_gmm_new (vl_type dataType, vl_size dimension, vl_size numComponents)
+{
+  vl_index i ;
+  vl_size size = vl_get_type_size(dataType) ;
+  VlGMM * self = vl_calloc(1, sizeof(VlGMM)) ;
+  self->dataType = dataType;
+  self->numClusters = numComponents ;
+  self->numData = 0;
+  self->dimension = dimension ;
+  self->initialization = VlGMMRand;
+  self->verbosity = 0 ;
+  self->maxNumIterations = 50;
+  self->numRepetitions = 1;
+  self->sigmaLowBound =  NULL ;
+  self->priors = NULL ;
+  self->covariances = NULL ;
+  self->means = NULL ;
+  self->posteriors = NULL ;
+  self->kmeansInit = NULL ;
+  self->kmeansInitIsOwner = VL_FALSE;
+
+  self->priors = vl_calloc (numComponents, size) ;
+  self->means = vl_calloc (numComponents * dimension, size) ;
+  self->covariances = vl_calloc (numComponents * dimension, size) ;
+  self->sigmaLowBound = vl_calloc (dimension, sizeof(double)) ;
+
+  for (i = 0 ; i < (unsigned)self->dimension ; ++i)  { self->sigmaLowBound[i] = 1e-4 ; }
+  return self ;
+}
+
+/** @brief Reset state
+ ** @param self object.
+ **
+ ** The function reset the state of the GMM object. It deletes
+ ** any stored posterior and other internal state variables.
+ **/
+
+void
+vl_gmm_reset (VlGMM * self)
+{
+  if (self->posteriors) {
+    vl_free(self->posteriors) ;
+    self->posteriors = NULL ;
+    self->numData = 0 ;
+  }
+  if (self->kmeansInit && self->kmeansInitIsOwner) {
+    vl_kmeans_delete(self->kmeansInit) ;
+    self->kmeansInit = NULL ;
+    self->kmeansInitIsOwner = VL_FALSE ;
+  }
+}
+
+/** @brief Deletes a GMM object
+ ** @param self GMM object instance.
+ **
+ ** The function deletes the GMM object instance created
+ ** by ::vl_gmm_new.
+ **/
+
+void
+vl_gmm_delete (VlGMM * self)
+{
+  if(self->means) vl_free(self->means);
+  if(self->covariances) vl_free(self->covariances);
+  if(self->priors) vl_free(self->priors);
+  if(self->posteriors) vl_free(self->posteriors);
+  if(self->kmeansInit && self->kmeansInitIsOwner) {
+    vl_kmeans_delete(self->kmeansInit);
+  }
+  vl_free(self);
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Getters and setters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get data type
+ ** @param self object
+ ** @return data type.
+ **/
+
+vl_type
+vl_gmm_get_data_type (VlGMM const * self)
+{
+  return self->dataType ;
+}
+
+/** @brief Get the number of clusters
+ ** @param self object
+ ** @return number of clusters.
+ **/
+
+vl_size
+vl_gmm_get_num_clusters (VlGMM const * self)
+{
+  return self->numClusters ;
+}
+
+/** @brief Get the number of data points
+ ** @param self object
+ ** @return number of data points.
+ **/
+
+vl_size
+vl_gmm_get_num_data (VlGMM const * self)
+{
+  return self->numData ;
+}
+
+/** @brief Get the log likelihood of the current mixture
+ ** @param self object
+ ** @return loglikelihood.
+ **/
+
+double
+vl_gmm_get_loglikelihood (VlGMM const * self)
+{
+  return self->LL ;
+}
+
+/** @brief Get verbosity level
+ ** @param self object
+ ** @return verbosity level.
+ **/
+
+int
+vl_gmm_get_verbosity (VlGMM const * self)
+{
+  return self->verbosity ;
+}
+
+/** @brief Set verbosity level
+ ** @param self object
+ ** @param verbosity verbosity level.
+ **/
+
+void
+vl_gmm_set_verbosity (VlGMM * self, int verbosity)
+{
+  self->verbosity = verbosity ;
+}
+
+/** @brief Get means
+ ** @param self object
+ ** @return cluster means.
+ **/
+
+void const *
+vl_gmm_get_means (VlGMM const * self)
+{
+  return self->means ;
+}
+
+/** @brief Get covariances
+ ** @param self object
+ ** @return diagonals of cluster covariance matrices.
+ **/
+
+void const *
+vl_gmm_get_covariances (VlGMM const * self)
+{
+  return self->covariances ;
+}
+
+/** @brief Get priors
+ ** @param self object
+ ** @return priors of cluster gaussians.
+ **/
+
+void const *
+vl_gmm_get_priors (VlGMM const * self)
+{
+  return self->priors ;
+}
+
+/** @brief Get posteriors
+ ** @param self object
+ ** @return posterior probabilities of cluster memberships.
+ **/
+
+void const *
+vl_gmm_get_posteriors (VlGMM const * self)
+{
+  return self->posteriors ;
+}
+
+/** @brief Get maximum number of iterations
+ ** @param self object
+ ** @return maximum number of iterations.
+ **/
+
+vl_size
+vl_gmm_get_max_num_iterations (VlGMM const * self)
+{
+  return self->maxNumIterations ;
+}
+
+/** @brief Set maximum number of iterations
+ ** @param self VlGMM filter.
+ ** @param maxNumIterations maximum number of iterations.
+ **/
+
+void
+vl_gmm_set_max_num_iterations (VlGMM * self, vl_size maxNumIterations)
+{
+  self->maxNumIterations = maxNumIterations ;
+}
+
+/** @brief Get maximum number of repetitions.
+ ** @param self object
+ ** @return current number of repretitions for quantization.
+ **/
+
+vl_size
+vl_gmm_get_num_repetitions (VlGMM const * self)
+{
+  return self->numRepetitions ;
+}
+
+/** @brief Set maximum number of repetitions
+ ** @param self object
+ ** @param numRepetitions maximum number of repetitions.
+ ** The number of repetitions cannot be smaller than 1.
+ **/
+
+void
+vl_gmm_set_num_repetitions (VlGMM * self, vl_size numRepetitions)
+{
+  assert (numRepetitions >= 1) ;
+  self->numRepetitions = numRepetitions ;
+}
+
+/** @brief Get data dimension
+ ** @param self object
+ ** @return data dimension.
+ **/
+
+vl_size
+vl_gmm_get_dimension (VlGMM const * self)
+{
+  return self->dimension ;
+}
+
+/** @brief Get initialization algorithm
+ ** @param self object
+ ** @return initialization algorithm.
+ **/
+
+VlGMMInitialization
+vl_gmm_get_initialization (VlGMM const * self)
+{
+  return self->initialization ;
+}
+
+/** @brief Set initialization algorithm.
+ ** @param self object
+ ** @param init initialization algorithm.
+ **/
+void
+vl_gmm_set_initialization (VlGMM * self, VlGMMInitialization init)
+{
+  self->initialization = init;
+}
+
+/** @brief Get KMeans initialization object.
+ ** @param self object
+ ** @return kmeans initialization object.
+ **/
+VlKMeans * vl_gmm_get_kmeans_init_object (VlGMM const * self)
+{
+  return self->kmeansInit;
+}
+
+/** @brief Set KMeans initialization object.
+ ** @param self object
+ ** @param kmeans initialization KMeans object.
+ **/
+void vl_gmm_set_kmeans_init_object (VlGMM * self, VlKMeans * kmeans)
+{
+  if (self->kmeansInit && self->kmeansInitIsOwner) {
+    vl_kmeans_delete(self->kmeansInit) ;
+  }
+  self->kmeansInit = kmeans;
+  self->kmeansInitIsOwner = VL_FALSE;
+}
+
+/** @brief Get the lower bound on the diagonal covariance values.
+ ** @param self object
+ ** @return lower bound on covariances.
+ **/
+double const * vl_gmm_get_covariance_lower_bounds (VlGMM const * self)
+{
+  return self->sigmaLowBound;
+}
+
+/** @brief Set the lower bounds on diagonal covariance values.
+ ** @param self object.
+ ** @param bounds bounds.
+ **
+ ** There is one lower bound per dimension. Use ::vl_gmm_set_covariance_lower_bound
+ ** to set all of them to a given scalar.
+ **/
+void vl_gmm_set_covariance_lower_bounds (VlGMM * self, double const * bounds)
+{
+  memcpy(self->sigmaLowBound, bounds, sizeof(double) * self->dimension) ;
+}
+
+/** @brief Set the lower bounds on diagonal covariance values.
+ ** @param self object.
+ ** @param bound bound.
+ **
+ ** While there is one lower bound per dimension, this function sets
+ ** all of them to the specified scalar. Use ::vl_gmm_set_covariance_lower_bounds
+ ** to set them individually.
+ **/
+void vl_gmm_set_covariance_lower_bound (VlGMM * self, double bound)
+{
+  int i ;
+  for (i = 0 ; i < (signed)self->dimension ; ++i) {
+    self->sigmaLowBound[i] = bound ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/* Instantiate shuffle algorithm */
+
+#define VL_SHUFFLE_type vl_uindex
+#define VL_SHUFFLE_prefix _vl_gmm
+#include "shuffle-def.h"
+
+/* #ifdef VL_GMM_INSTANTITATING */
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifdef VL_GMM_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+/* ---------------------------------------------------------------- */
+/*                                            Posterior assignments */
+/* ---------------------------------------------------------------- */
+
+/** @fn vl_get_gmm_data_posterior_f(float*,vl_size,vl_size,float const*,float const*,vl_size,float const*,float const*)
+ ** @brief Get Gaussian modes posterior probabilities
+ ** @param posteriors posterior probabilities (output)/
+ ** @param numClusters number of modes in the GMM model.
+ ** @param numData number of data elements.
+ ** @param priors prior mode probabilities of the GMM model.
+ ** @param means means of the GMM model.
+ ** @param dimension data dimension.
+ ** @param covariances diagonal covariances of the GMM model.
+ ** @param data data.
+ ** @return data log-likelihood.
+ **
+ ** This is a helper function that does not require a ::VlGMM object
+ ** instance to operate.
+ **/
+
+double
+VL_XCAT(vl_get_gmm_data_posteriors_, SFX)
+(TYPE * posteriors,
+ vl_size numClusters,
+ vl_size numData,
+ TYPE const * priors,
+ TYPE const * means,
+ vl_size dimension,
+ TYPE const * covariances,
+ TYPE const * data)
+{
+  vl_index i_d, i_cl;
+  vl_size dim;
+  double LL = 0;
+
+  TYPE halfDimLog2Pi = (dimension / 2.0) * log(2.0*VL_PI);
+  TYPE * logCovariances ;
+  TYPE * logWeights ;
+  TYPE * invCovariances ;
+
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVector3ComparisonFunction distFn = vl_get_vector_3_comparison_function_f(VlDistanceMahalanobis) ;
+#else
+  VlDoubleVector3ComparisonFunction distFn = vl_get_vector_3_comparison_function_d(VlDistanceMahalanobis) ;
+#endif
+
+  logCovariances = vl_malloc(sizeof(TYPE) * numClusters) ;
+  invCovariances = vl_malloc(sizeof(TYPE) * numClusters * dimension) ;
+  logWeights = vl_malloc(sizeof(TYPE) * numClusters) ;
+
+#if defined(_OPENMP)
+#pragma omp parallel for private(i_cl,dim) num_threads(vl_get_max_threads())
+#endif
+  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
+    TYPE logSigma = 0 ;
+    if (priors[i_cl] < VL_GMM_MIN_PRIOR) {
+      logWeights[i_cl] = - (TYPE) VL_INFINITY_D ;
+    } else {
+      logWeights[i_cl] = log(priors[i_cl]);
+    }
+    for(dim = 0 ; dim < dimension ; ++ dim) {
+      logSigma += log(covariances[i_cl*dimension + dim]);
+      invCovariances [i_cl*dimension + dim] = (TYPE) 1.0 / covariances[i_cl*dimension + dim];
+    }
+    logCovariances[i_cl] = logSigma;
+  } /* end of parallel region */
+
+#if defined(_OPENMP)
+#pragma omp parallel for private(i_cl,i_d) reduction(+:LL) \
+num_threads(vl_get_max_threads())
+#endif
+  for (i_d = 0 ; i_d < (signed)numData ; ++ i_d) {
+    TYPE clusterPosteriorsSum = 0;
+    TYPE maxPosterior = (TYPE)(-VL_INFINITY_D) ;
+
+    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
+      TYPE p =
+      logWeights[i_cl]
+      - halfDimLog2Pi
+      - 0.5 * logCovariances[i_cl]
+      - 0.5 * distFn (dimension,
+                      data + i_d * dimension,
+                      means + i_cl * dimension,
+                      invCovariances + i_cl * dimension) ;
+      posteriors[i_cl + i_d * numClusters] = p ;
+      if (p > maxPosterior) { maxPosterior = p ; }
+    }
+
+    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+      TYPE p = posteriors[i_cl + i_d * numClusters] ;
+      p =  exp(p - maxPosterior) ;
+      posteriors[i_cl + i_d * numClusters] = p ;
+      clusterPosteriorsSum += p ;
+    }
+
+    LL +=  log(clusterPosteriorsSum) + (double) maxPosterior ;
+
+    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+      posteriors[i_cl + i_d * numClusters] /= clusterPosteriorsSum ;
+    }
+  } /* end of parallel region */
+
+  vl_free(logCovariances);
+  vl_free(logWeights);
+  vl_free(invCovariances);
+
+  return LL;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                 Restarts zero-weighted Gaussians */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_gmm_maximization_, SFX)
+(VlGMM * self,
+ TYPE * posteriors,
+ TYPE * priors,
+ TYPE * covariances,
+ TYPE * means,
+ TYPE const * data,
+ vl_size numData) ;
+
+static vl_size
+VL_XCAT(_vl_gmm_restart_empty_modes_, SFX) (VlGMM * self, TYPE const * data)
+{
+  vl_size dimension = self->dimension;
+  vl_size numClusters = self->numClusters;
+  vl_index i_cl, j_cl, i_d, d;
+  vl_size zeroWNum = 0;
+  TYPE * priors = (TYPE*)self->priors ;
+  TYPE * means = (TYPE*)self->means ;
+  TYPE * covariances = (TYPE*)self->covariances ;
+  TYPE * posteriors = (TYPE*)self->posteriors ;
+
+  //VlRand * rand = vl_get_rand() ;
+
+  TYPE * mass = vl_calloc(sizeof(TYPE), self->numClusters) ;
+
+  if (numClusters <= 1) { return 0 ; }
+
+  /* compute statistics */
+  {
+    vl_uindex i, k ;
+    vl_size numNullAssignments = 0 ;
+    for (i = 0 ; i < self->numData ; ++i) {
+      for (k = 0 ; k < self->numClusters ; ++k) {
+        TYPE p = ((TYPE*)self->posteriors)[k + i * self->numClusters] ;
+        mass[k] += p ;
+        if (p < VL_GMM_MIN_POSTERIOR) {
+          numNullAssignments ++ ;
+        }
+      }
+    }
+    if (self->verbosity) {
+      VL_PRINTF("gmm: sparsity of data posterior: %.1f%%\n", (double)numNullAssignments / (self->numData * self->numClusters) * 100) ;
+    }
+  }
+
+#if 0
+  /* search for cluster with negligible weight and reassign them to fat clusters */
+  for (i_cl = 0 ; i_cl < numClusters ; ++i_cl) {
+    if (priors[i_cl] < 0.00001/numClusters) {
+      double mass = priors[0]  ;
+      vl_index best = 0 ;
+
+      for (j_cl = 1 ; j_cl < numClusters ; ++j_cl) {
+        if (priors[j_cl] > mass) { mass = priors[j_cl] ; best = j_cl ; }
+      }
+
+      if (j_cl == i_cl) {
+        /* this should never happen */
+        continue ;
+      }
+
+      j_cl = best ;
+      zeroWNum ++ ;
+
+      VL_PRINTF("gmm: restarting mode %d by splitting mode %d (with prior %f)\n", i_cl,j_cl,mass) ;
+
+      priors[i_cl] = mass/2 ;
+      priors[j_cl] = mass/2 ;
+      for (d = 0 ; d < dimension ; ++d) {
+        TYPE sigma2 =  covariances[j_cl*dimension + d] ;
+        TYPE sigma = VL_XCAT(vl_sqrt_,SFX)(sigma2) ;
+        means[i_cl*dimension + d] = means[j_cl*dimension + d] + 0.001 * (vl_rand_real1(rand) - 0.5) * sigma ;
+        covariances[i_cl*dimension + d] = sigma2 ;
+      }
+    }
+  }
+#endif
+
+  /* search for cluster with negligible weight and reassign them to fat clusters */
+  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+    double size = - VL_INFINITY_D ;
+    vl_index best = -1 ;
+
+    if (mass[i_cl] >= VL_GMM_MIN_POSTERIOR *
+        VL_MAX(1.0, (double) self->numData / self->numClusters))
+    {
+      continue ;
+    }
+
+    if (self->verbosity) {
+      VL_PRINTF("gmm: mode %d is nearly empty (mass %f)\n", i_cl, mass[i_cl]) ;
+    }
+
+    /*
+     Search for the Gaussian components that (approximately)
+     maximally contribute to make the negative log-likelihood of the data
+     large. Then split the worst offender.
+     
+     To do so, we approximate the exptected log-likelihood of the GMM:
+     
+     E[-log(f(x))] = H(f) = - log \int f(x) log f(x)
+    
+     where the density f(x) = sum_k pk gk(x) is a GMM. This is intractable
+     but it is easy to approximate if we suppose that supp gk is disjoint with
+     supp gq for all components k ~= q. In this canse
+     
+     H(f) ~= sum_k [ - pk log(pk) + pk H(gk) ]
+     
+     where H(gk) is the entropy of component k taken alone. The entropy of
+     the latter is given by:
+     
+     H(gk) = D/2 (1 + log(2pi) + 1/2 sum_{i=0}^D log sigma_i^2
+
+     */
+
+    for (j_cl = 0 ; j_cl < (signed)numClusters ; ++j_cl) {
+      double size_ ;
+      if (priors[j_cl] < VL_GMM_MIN_PRIOR) { continue ; }
+      size_ = + 0.5 * dimension * (1.0 + log(2*VL_PI)) ;
+      for(d = 0 ; d < (signed)dimension ; d++) {
+        double sigma2 = covariances[j_cl * dimension + d] ;
+        size_ += 0.5 * log(sigma2) ;
+      }
+      size_ = priors[j_cl] * (size_ - log(priors[j_cl])) ;
+
+      if (self->verbosity > 1) {
+        VL_PRINTF("gmm: mode %d: prior %f, mass %f, entropy contribution %f\n",
+                  j_cl, priors[j_cl], mass[j_cl], size_) ;
+      }
+
+      if (size_ > size) {
+        size = size_ ;
+        best = j_cl ;
+      }
+    }
+
+    j_cl = best ;
+
+    if (j_cl == i_cl || j_cl < 0) {
+      if (self->verbosity) {
+        VL_PRINTF("gmm: mode %d is empty, "
+                  "but no other mode to split could be found\n", i_cl) ;
+      }
+      continue ;
+    }
+
+    if (self->verbosity) {
+      VL_PRINTF("gmm: reinitializing empty mode %d with mode %d (prior %f, mass %f, score %f)\n",
+                i_cl, j_cl, priors[j_cl], mass[j_cl], size) ;
+    }
+
+    /*
+     Search for the dimension with maximum variance.
+     */
+
+    size = - VL_INFINITY_D ;
+    best = - 1 ;
+
+    for(d = 0; d < (signed)dimension; d++) {
+      double sigma2 = covariances[j_cl * dimension + d] ;
+      if (sigma2 > size) {
+        size = sigma2 ;
+        best = d ;
+      }
+    }
+
+    /*
+     Reassign points j_cl (mode to split) to i_cl (empty mode).
+     */
+    {
+      TYPE mu = means[best + j_cl * self->dimension] ;
+      for(i_d = 0 ; i_d < (signed)self->numData ; ++ i_d) {
+        TYPE p = posteriors[j_cl + self->numClusters * i_d] ;
+        TYPE q = posteriors[i_cl + self->numClusters * i_d] ; /* ~= 0 */
+        if (data[best + i_d * self->dimension] < mu) {
+          /* assign this point to i_cl */
+          posteriors[i_cl + self->numClusters * i_d] = p + q ;
+          posteriors[j_cl + self->numClusters * i_d] = 0 ;
+        } else {
+          /* assign this point to j_cl */
+          posteriors[i_cl + self->numClusters * i_d] = 0 ;
+          posteriors[j_cl + self->numClusters * i_d] = p + q ;
+        }
+      }
+    }
+
+    /*
+     Re-estimate.
+     */
+    VL_XCAT(_vl_gmm_maximization_, SFX)
+    (self,posteriors,priors,covariances,means,data,self->numData) ;
+  }
+
+  return zeroWNum;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                          Helpers */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_gmm_apply_bounds_, SFX)(VlGMM * self)
+{
+  vl_uindex dim ;
+  vl_uindex k ;
+  vl_size numAdjusted = 0 ;
+  TYPE * cov = (TYPE*)self->covariances ;
+  double const * lbs = self->sigmaLowBound ;
+
+  for (k = 0 ; k < self->numClusters ; ++k) {
+    vl_bool adjusted = VL_FALSE ;
+    for (dim = 0 ; dim < self->dimension ; ++dim) {
+      if (cov[k * self->dimension + dim] < lbs[dim] ) {
+        cov[k * self->dimension + dim] = lbs[dim] ;
+        adjusted = VL_TRUE ;
+      }
+    }
+    if (adjusted) { numAdjusted ++ ; }
+  }
+
+  if (numAdjusted > 0 && self->verbosity > 0) {
+    VL_PRINT("gmm: detected %d of %d modes with at least one dimension "
+             "with covariance too small (set to lower bound)\n",
+             numAdjusted, self->numClusters) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                           EM - Maximization step */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_gmm_maximization_, SFX)
+(VlGMM * self,
+ TYPE * posteriors,
+ TYPE * priors,
+ TYPE * covariances,
+ TYPE * means,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_size numClusters = self->numClusters;
+  vl_index i_d, i_cl;
+  vl_size dim ;
+  TYPE * oldMeans ;
+  double time = 0 ;
+
+  if (self->verbosity > 1) {
+    VL_PRINTF("gmm: em: entering maximization step\n") ;
+    time = vl_get_cpu_time() ;
+  }
+
+  oldMeans = vl_malloc(sizeof(TYPE) * self->dimension * numClusters) ;
+  memcpy(oldMeans, means, sizeof(TYPE) * self->dimension * numClusters) ;
+
+  memset(priors, 0, sizeof(TYPE) * numClusters) ;
+  memset(means, 0, sizeof(TYPE) * self->dimension * numClusters) ;
+  memset(covariances, 0, sizeof(TYPE) * self->dimension * numClusters) ;
+
+#if defined(_OPENMP)
+#pragma omp parallel default(shared) private(i_d, i_cl, dim) \
+                     num_threads(vl_get_max_threads())
+#endif
+  {
+    TYPE * clusterPosteriorSum_, * means_, * covariances_ ;
+
+#if defined(_OPENMP)
+#pragma omp critical
+#endif
+    {
+      clusterPosteriorSum_ = vl_calloc(sizeof(TYPE), numClusters) ;
+      means_ = vl_calloc(sizeof(TYPE), self->dimension * numClusters) ;
+      covariances_ = vl_calloc(sizeof(TYPE), self->dimension * numClusters) ;
+    }
+
+    /*
+      Accumulate weighted sums and sum of square differences. Once normalized,
+      these become the means and covariances of each Gaussian mode.
+
+      The squared differences will be taken w.r.t. the old means however. In this manner,
+      one avoids doing two passes across the data. Eventually, these are corrected to account
+      for the new means properly. In principle, one could set the old means to zero, but
+      this may cause numerical instabilities (by accumulating large squares).
+    */
+
+#if defined(_OPENMP)
+#pragma omp for
+#endif
+    for (i_d = 0 ; i_d < (signed)numData ; ++i_d) {
+      for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+        TYPE p = posteriors[i_cl + i_d * self->numClusters] ;
+        vl_bool calculated = VL_FALSE ;
+
+        /* skip very small associations for speed */
+        if (p < VL_GMM_MIN_POSTERIOR / numClusters) { continue ; }
+
+        clusterPosteriorSum_ [i_cl] += p ;
+
+        #ifndef VL_DISABLE_AVX
+        if (vl_get_simd_enabled() && vl_cpu_has_avx()) {
+          VL_XCAT(_vl_weighted_mean_avx_, SFX)
+          (self->dimension,
+           means_+ i_cl * self->dimension,
+           data + i_d * self->dimension,
+           p) ;
+
+          VL_XCAT(_vl_weighted_sigma_avx_, SFX)
+          (self->dimension,
+           covariances_ + i_cl * self->dimension,
+           data + i_d * self->dimension,
+           oldMeans + i_cl * self->dimension,
+           p) ;
+
+          calculated = VL_TRUE;
+        }
+        #endif
+        #ifndef VL_DISABLE_SSE2
+        if (vl_get_simd_enabled() && vl_cpu_has_sse2() && !calculated) {
+          VL_XCAT(_vl_weighted_mean_sse2_, SFX)
+          (self->dimension,
+           means_+ i_cl * self->dimension,
+           data + i_d * self->dimension,
+           p) ;
+
+           VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
+          (self->dimension,
+           covariances_ + i_cl * self->dimension,
+           data + i_d * self->dimension,
+           oldMeans + i_cl * self->dimension,
+           p) ;
+
+          calculated = VL_TRUE;
+        }
+        #endif
+        if(!calculated) {
+          for (dim = 0 ; dim < self->dimension ; ++dim) {
+            TYPE x = data[i_d * self->dimension + dim] ;
+            TYPE mu = oldMeans[i_cl * self->dimension + dim] ;
+            TYPE diff = x - mu ;
+            means_ [i_cl * self->dimension + dim] += p * x ;
+            covariances_ [i_cl * self->dimension + dim] += p * (diff*diff) ;
+          }
+        }
+      }
+    }
+
+    /* accumulate */
+#if defined(_OPENMP)
+#pragma omp critical
+#endif
+    {
+      for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+        priors [i_cl] += clusterPosteriorSum_ [i_cl];
+        for (dim = 0 ; dim < self->dimension ; ++dim) {
+          means [i_cl * self->dimension + dim] += means_ [i_cl * self->dimension + dim] ;
+          covariances [i_cl * self->dimension + dim] += covariances_ [i_cl * self->dimension + dim] ;
+        }
+      }
+      vl_free(means_);
+      vl_free(covariances_);
+      vl_free(clusterPosteriorSum_);
+    }
+  } /* parallel section */
+
+  /* at this stage priors[] contains the total mass of each cluster */
+  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
+    TYPE mass = priors[i_cl] ;
+    /* do not update modes that do not recieve mass */
+    if (mass >= 1e-6 / numClusters) {
+      for (dim = 0 ; dim < self->dimension ; ++dim) {
+        means[i_cl * self->dimension + dim] /= mass ;
+        covariances[i_cl * self->dimension + dim] /= mass ;
+      }
+    }
+  }
+
+  /* apply old to new means correction */
+  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++ i_cl) {
+    TYPE mass = priors[i_cl] ;
+    if (mass >= 1e-6 / numClusters) {
+      for (dim = 0 ; dim < self->dimension ; ++dim) {
+        TYPE mu = means[i_cl * self->dimension + dim] ;
+        TYPE oldMu = oldMeans[i_cl * self->dimension + dim] ;
+        TYPE diff = mu - oldMu ;
+        covariances[i_cl * self->dimension + dim] -= diff * diff ;
+      }
+    }
+  }
+
+  VL_XCAT(_vl_gmm_apply_bounds_,SFX)(self) ;
+
+  {
+    TYPE sum = 0;
+    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+      sum += priors[i_cl] ;
+    }
+    sum = VL_MAX(sum, 1e-12) ;
+    for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
+      priors[i_cl] /= sum ;
+    }
+  }
+
+  if (self->verbosity > 1) {
+    VL_PRINTF("gmm: em: maximization step completed in %.2f s\n",
+              vl_get_cpu_time() - time) ;
+  }
+
+  vl_free(oldMeans);
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                    EM iterations */
+/* ---------------------------------------------------------------- */
+
+
+static double
+VL_XCAT(_vl_gmm_em_, SFX)
+(VlGMM * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_size iteration, restarted ;
+  double previousLL = (TYPE)(-VL_INFINITY_D) ;
+  double LL = (TYPE)(-VL_INFINITY_D) ;
+  double time = 0 ;
+
+  _vl_gmm_prepare_for_data (self, numData) ;
+
+  VL_XCAT(_vl_gmm_apply_bounds_,SFX)(self) ;
+
+  for (iteration = 0 ; 1 ; ++ iteration) {
+    double eps ;
+
+    /*
+     Expectation: assign data to Gaussian modes
+     and compute log-likelihood.
+     */
+
+    if (self->verbosity > 1) {
+      VL_PRINTF("gmm: em: entering expectation step\n") ;
+      time = vl_get_cpu_time() ;
+    }
+
+    LL = VL_XCAT(vl_get_gmm_data_posteriors_,SFX)
+    (self->posteriors,
+     self->numClusters,
+     numData,
+     self->priors,
+     self->means,
+     self->dimension,
+     self->covariances,
+     data) ;
+
+    if (self->verbosity > 1) {
+      VL_PRINTF("gmm: em: expectation step completed in %.2f s\n",
+                vl_get_cpu_time() - time) ;
+    }
+
+    /*
+     Check the termination conditions.
+     */
+    if (self->verbosity) {
+      VL_PRINTF("gmm: em: iteration %d: loglikelihood = %f (variation = %f)\n",
+                iteration, LL, LL - previousLL) ;
+    }
+    if (iteration >= self->maxNumIterations) {
+      if (self->verbosity) {
+        VL_PRINTF("gmm: em: terminating because "
+                  "the maximum number of iterations "
+                  "(%d) has been reached.\n", self->maxNumIterations) ;
+      }
+      break ;
+    }
+
+    eps = vl_abs_d ((LL - previousLL) / (LL));
+    if ((iteration > 0) && (eps < 0.00001)) {
+      if (self->verbosity) {
+        VL_PRINTF("gmm: em: terminating because the algorithm "
+                  "fully converged (log-likelihood variation = %f).\n", eps) ;
+      }
+      break ;
+    }
+    previousLL = LL ;
+
+    /*
+     Restart empty modes.
+     */
+    if (iteration > 1) {
+      restarted = VL_XCAT(_vl_gmm_restart_empty_modes_, SFX)
+        (self, data);
+      if ((restarted > 0) & (self->verbosity > 0)) {
+        VL_PRINTF("gmm: em: %d Gaussian modes restarted because "
+                  "they had become empty.\n", restarted);
+      }
+    }
+
+    /*
+      Maximization: reestimate the GMM parameters.
+    */
+    VL_XCAT(_vl_gmm_maximization_, SFX)
+      (self,self->posteriors,self->priors,self->covariances,self->means,data,numData) ;
+  }
+  return LL;
+}
+
+
+/* ---------------------------------------------------------------- */
+/*                                Kmeans initialization of mixtures */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_gmm_init_with_kmeans_, SFX)
+(VlGMM * self,
+ TYPE const * data,
+ vl_size numData,
+ VlKMeans * kmeansInit)
+{
+  vl_size i_d ;
+  vl_uint32 * assignments = vl_malloc(sizeof(vl_uint32) * numData);
+
+  _vl_gmm_prepare_for_data (self, numData) ;
+
+  memset(self->means,0,sizeof(TYPE) * self->numClusters * self->dimension) ;
+  memset(self->priors,0,sizeof(TYPE) * self->numClusters) ;
+  memset(self->covariances,0,sizeof(TYPE) * self->numClusters * self->dimension) ;
+  memset(self->posteriors,0,sizeof(TYPE) * self->numClusters * numData) ;
+
+  /* setup speified KMeans initialization object if any */
+  if (kmeansInit) { vl_gmm_set_kmeans_init_object (self, kmeansInit) ; }
+
+  /* if a KMeans initalization object is still unavailable, create one */
+  if(self->kmeansInit == NULL) {
+    vl_size ncomparisons = VL_MAX(numData / 4, 10) ;
+    vl_size niter = 5 ;
+    vl_size ntrees = 1 ;
+    vl_size nrepetitions = 1 ;
+    VlKMeansAlgorithm algorithm = VlKMeansANN ;
+    VlKMeansInitialization initialization = VlKMeansRandomSelection ;
+
+    VlKMeans * kmeansInitDefault = vl_kmeans_new(self->dataType,VlDistanceL2) ;
+    vl_kmeans_set_initialization(kmeansInitDefault, initialization);
+    vl_kmeans_set_max_num_iterations (kmeansInitDefault, niter) ;
+    vl_kmeans_set_max_num_comparisons (kmeansInitDefault, ncomparisons) ;
+    vl_kmeans_set_num_trees (kmeansInitDefault, ntrees);
+    vl_kmeans_set_algorithm (kmeansInitDefault, algorithm);
+    vl_kmeans_set_num_repetitions(kmeansInitDefault, nrepetitions);
+    vl_kmeans_set_verbosity (kmeansInitDefault, self->verbosity);
+
+    self->kmeansInit = kmeansInitDefault;
+    self->kmeansInitIsOwner = VL_TRUE ;
+  }
+
+  /* Use k-means to assign data to clusters */
+  vl_kmeans_cluster (self->kmeansInit, data, self->dimension, numData, self->numClusters);
+  vl_kmeans_quantize (self->kmeansInit, assignments, NULL, data, numData) ;
+
+  /* Transform the k-means assignments in posteriors and estimates the mode parameters */
+  for(i_d = 0; i_d < numData; i_d++) {
+    ((TYPE*)self->posteriors)[assignments[i_d] + i_d * self->numClusters] = (TYPE) 1.0 ;
+  }
+
+  /* Update cluster parameters */
+  VL_XCAT(_vl_gmm_maximization_, SFX)
+    (self,self->posteriors,self->priors,self->covariances,self->means,data,numData);
+  vl_free(assignments) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                Random initialization of mixtures */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_gmm_compute_init_sigma_, SFX)
+(VlGMM * self,
+ TYPE const * data,
+ TYPE * initSigma,
+ vl_size dimension,
+ vl_size numData)
+{
+  vl_size dim;
+  vl_uindex i;
+
+  TYPE * dataMean ;
+
+  memset(initSigma,0,sizeof(TYPE)*dimension) ;
+  if (numData <= 1) return ;
+
+  dataMean = vl_malloc(sizeof(TYPE)*dimension);
+  memset(dataMean,0,sizeof(TYPE)*dimension) ;
+
+  /* find mean of the whole dataset */
+  for(dim = 0 ; dim < dimension ; dim++) {
+    for(i = 0 ; i < numData ; i++) {
+      dataMean[dim] += data[i*dimension + dim];
+    }
+    dataMean[dim] /= numData;
+  }
+
+  /* compute variance of the whole dataset */
+  for(dim = 0; dim < dimension; dim++) {
+    for(i = 0; i < numData; i++) {
+      TYPE diff = (data[i*self->dimension + dim] - dataMean[dim]) ;
+      initSigma[dim] += diff*diff ;
+    }
+    initSigma[dim] /= numData - 1 ;
+  }
+
+  vl_free(dataMean) ;
+}
+
+static void
+VL_XCAT(_vl_gmm_init_with_rand_data_, SFX)
+(VlGMM * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_uindex i, k, dim ;
+  VlKMeans * kmeans ;
+
+  _vl_gmm_prepare_for_data(self, numData) ;
+
+  /* initilaize priors of gaussians so they are equal and sum to one */
+  for (i = 0 ; i < self->numClusters ; ++i) { ((TYPE*)self->priors)[i] = (TYPE) (1.0 / self->numClusters) ; }
+
+  /* initialize diagonals of covariance matrices to data covariance */
+  VL_XCAT(_vl_gmm_compute_init_sigma_, SFX) (self, data, self->covariances, self->dimension, numData);
+  for (k = 1 ; k < self->numClusters ; ++ k) {
+    for(dim = 0; dim < self->dimension; dim++) {
+      *((TYPE*)self->covariances + k * self->dimension + dim) =
+      *((TYPE*)self->covariances + dim) ;
+    }
+  }
+
+  /* use kmeans++ initialization to pick points at random */
+  kmeans = vl_kmeans_new(self->dataType,VlDistanceL2) ;
+  vl_kmeans_init_centers_plus_plus(kmeans, data, self->dimension, numData, self->numClusters) ;
+  memcpy(self->means, vl_kmeans_get_centers(kmeans), sizeof(TYPE) * self->dimension * self->numClusters) ;
+  vl_kmeans_delete(kmeans) ;
+}
+
+/* ---------------------------------------------------------------- */
+#else /* VL_GMM_INSTANTIATING */
+/* ---------------------------------------------------------------- */
+
+#ifndef __DOXYGEN__
+#define FLT VL_TYPE_FLOAT
+#define TYPE float
+#define SFX f
+#define VL_GMM_INSTANTIATING
+#include "gmm.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define TYPE double
+#define SFX d
+#define VL_GMM_INSTANTIATING
+#include "gmm.c"
+#endif
+
+/* VL_GMM_INSTANTIATING */
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_GMM_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+/** @brief Create a new GMM object by copy
+ ** @param self object.
+ ** @return new copy.
+ **
+ ** Most parameters, including the cluster priors, means, and
+ ** covariances are copied. Data posteriors (available after
+ ** initalization or EM) are not; nor is the KMeans object used for
+ ** initialization, if any.
+ **/
+
+VlGMM *
+vl_gmm_new_copy (VlGMM const * self)
+{
+  vl_size size = vl_get_type_size(self->dataType) ;
+  VlGMM * gmm = vl_gmm_new(self->dataType, self->dimension, self->numClusters);
+  gmm->initialization = self->initialization;
+  gmm->maxNumIterations = self->maxNumIterations;
+  gmm->numRepetitions = self->numRepetitions;
+  gmm->verbosity = self->verbosity;
+  gmm->LL = self->LL;
+
+  memcpy(gmm->means, self->means, size*self->numClusters*self->dimension);
+  memcpy(gmm->covariances, self->covariances, size*self->numClusters*self->dimension);
+  memcpy(gmm->priors, self->priors, size*self->numClusters);
+  return gmm ;
+}
+
+/** @brief Initialize mixture before EM takes place using random initialization
+ ** @param self GMM object instance.
+ ** @param data data points which should be clustered.
+ ** @param numData number of data points.
+ **/
+
+void
+vl_gmm_init_with_rand_data
+(VlGMM * self,
+ void const * data,
+ vl_size numData)
+{
+  vl_gmm_reset (self) ;
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT : _vl_gmm_init_with_rand_data_f (self, (float const *)data, numData) ; break ;
+    case VL_TYPE_DOUBLE : _vl_gmm_init_with_rand_data_d (self, (double const *)data, numData) ; break ;
+    default:
+      abort() ;
+  }
+}
+
+/** @brief Initializes the GMM using KMeans
+ ** @param self GMM object instance.
+ ** @param data data points which should be clustered.
+ ** @param numData number of data points.
+ ** @param kmeansInit KMeans object to use.
+ **/
+
+void
+vl_gmm_init_with_kmeans
+(VlGMM * self,
+ void const * data,
+ vl_size numData,
+ VlKMeans * kmeansInit)
+{
+  vl_gmm_reset (self) ;
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_gmm_init_with_kmeans_f
+      (self, (float const *)data, numData, kmeansInit) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_gmm_init_with_kmeans_d
+      (self, (double const *)data, numData, kmeansInit) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+#if 0
+#include<fenv.h>
+#endif
+
+/** @brief Run GMM clustering - includes initialization and EM
+ ** @param self GMM object instance.
+ ** @param data data points which should be clustered.
+ ** @param numData number of data points.
+ **/
+
+double vl_gmm_cluster (VlGMM * self,
+                       void const * data,
+                       vl_size numData)
+{
+  void * bestPriors = NULL ;
+  void * bestMeans = NULL;
+  void * bestCovariances = NULL;
+  void * bestPosteriors = NULL;
+  vl_size size = vl_get_type_size(self->dataType) ;
+  double bestLL = -VL_INFINITY_D;
+  vl_uindex repetition;
+
+  assert(self->numRepetitions >=1) ;
+
+  bestPriors = vl_malloc(size * self->numClusters) ;
+  bestMeans = vl_malloc(size * self->dimension * self->numClusters) ;
+  bestCovariances = vl_malloc(size * self->dimension * self->numClusters) ;
+  bestPosteriors = vl_malloc(size * self->numClusters * numData) ;
+
+#if 0
+  feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
+#endif
+
+  for (repetition = 0 ; repetition < self->numRepetitions ; ++ repetition) {
+    double LL ;
+    double timeRef ;
+
+    if (self->verbosity) {
+      VL_PRINTF("gmm: clustering: starting repetition %d of %d\n", repetition + 1, self->numRepetitions) ;
+    }
+
+    /* initialize a new mixture model */
+    timeRef = vl_get_cpu_time() ;
+    switch (self->initialization) {
+      case VlGMMKMeans : vl_gmm_init_with_kmeans (self, data, numData, NULL) ; break ;
+      case VlGMMRand : vl_gmm_init_with_rand_data (self, data, numData) ; break ;
+      case VlGMMCustom : break ;
+      default: abort() ;
+    }
+    if (self->verbosity) {
+      VL_PRINTF("gmm: model initialized in %.2f s\n",
+                vl_get_cpu_time() - timeRef) ;
+    }
+
+    /* fit the model to data by running EM */
+    timeRef = vl_get_cpu_time () ;
+    LL = vl_gmm_em (self, data, numData) ;
+    if (self->verbosity) {
+      VL_PRINTF("gmm: optimization terminated in %.2f s with loglikelihood %f\n",
+                vl_get_cpu_time() - timeRef, LL) ;
+    }
+
+    if (LL > bestLL || repetition == 0) {
+      void * temp ;
+
+      temp = bestPriors ;
+      bestPriors = self->priors ;
+      self->priors = temp ;
+
+      temp = bestMeans ;
+      bestMeans = self->means ;
+      self->means = temp ;
+
+      temp = bestCovariances ;
+      bestCovariances = self->covariances ;
+      self->covariances = temp ;
+
+      temp = bestPosteriors ;
+      bestPosteriors = self->posteriors ;
+      self->posteriors = temp ;
+
+      bestLL = LL;
+    }
+  }
+
+  vl_free (self->priors) ;
+  vl_free (self->means) ;
+  vl_free (self->covariances) ;
+  vl_free (self->posteriors) ;
+
+  self->priors = bestPriors ;
+  self->means = bestMeans ;
+  self->covariances = bestCovariances ;
+  self->posteriors = bestPosteriors ;
+  self->LL = bestLL;
+
+  if (self->verbosity) {
+    VL_PRINTF("gmm: all repetitions terminated with final loglikelihood %f\n", self->LL) ;
+  }
+
+  return bestLL ;
+}
+
+/** @brief Invoke the EM algorithm.
+ ** @param self GMM object instance.
+ ** @param data data points which should be clustered.
+ ** @param numData number of data points.
+ **/
+
+double vl_gmm_em (VlGMM * self, void const * data, vl_size numData)
+{
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT:
+      return _vl_gmm_em_f (self, (float const *)data, numData) ; break ;
+    case VL_TYPE_DOUBLE:
+      return _vl_gmm_em_d (self, (double const *)data, numData) ; break ;
+    default:
+      abort() ;
+  }
+  return 0 ;
+}
+
+/** @brief Explicitly set the initial means for EM.
+ ** @param self GMM object instance.
+ ** @param means initial values of means.
+ **/
+
+void
+vl_gmm_set_means (VlGMM * self, void const * means)
+{
+  memcpy(self->means,means,
+         self->dimension * self->numClusters * vl_get_type_size(self->dataType));
+}
+
+/** @brief Explicitly set the initial sigma diagonals for EM.
+ ** @param self GMM object instance.
+ ** @param covariances initial values of covariance matrix diagonals.
+ **/
+
+void vl_gmm_set_covariances (VlGMM * self, void const * covariances)
+{
+  memcpy(self->covariances,covariances,
+         self->dimension * self->numClusters * vl_get_type_size(self->dataType));
+}
+
+/** @brief Explicitly set the initial priors of the gaussians.
+ ** @param self GMM object instance.
+ ** @param priors initial values of the gaussian priors.
+ **/
+
+void vl_gmm_set_priors (VlGMM * self, void const * priors)
+{
+  memcpy(self->priors,priors,
+         self->numClusters * vl_get_type_size(self->dataType));
+}
+
+/* VL_GMM_INSTANTIATING */
+#endif
+
+#undef SFX
+#undef TYPE
+#undef FLT
+#undef VL_GMM_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/gmm.h b/opensfm/src/third_party/vlfeat/vl/gmm.h
new file mode 100644
index 000000000..3562d74c2
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/gmm.h
@@ -0,0 +1,149 @@
+/** @file gmm.h
+ ** @brief GMM (@ref gmm)
+ ** @author David Novotny
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_GMM_H
+#define VL_GMM_H
+
+#include "kmeans.h"
+
+/** @brief GMM initialization algorithms */
+typedef enum _VlGMMInitialization
+{
+  VlGMMKMeans, /**< Initialize GMM from KMeans clustering. */
+  VlGMMRand,   /**< Initialize GMM parameters by selecting points at random. */
+  VlGMMCustom  /**< User specifies the initial GMM parameters. */
+} VlGMMInitialization ;
+
+
+#ifndef __DOXYGEN__
+struct _VlGMM ;
+typedef struct _VlGMM VlGMM ;
+#else
+/** @brief GMM quantizer */
+typedef OPAQUE VlGMM ;
+#endif
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT VlGMM * vl_gmm_new (vl_type dataType, vl_size dimension, vl_size numComponents) ;
+VL_EXPORT VlGMM * vl_gmm_new_copy (VlGMM const * gmm) ;
+VL_EXPORT void vl_gmm_delete (VlGMM * self) ;
+VL_EXPORT void vl_gmm_reset (VlGMM * self);
+/** @} */
+
+/** @name Basic data processing
+ ** @{
+ **/
+VL_EXPORT double
+vl_gmm_cluster
+(VlGMM * self,
+ void const * data,
+ vl_size numData);
+/** @} */
+
+/** @name Fine grained data processing
+ ** @{ */
+
+VL_EXPORT void
+vl_gmm_init_with_rand_data
+(VlGMM * self,
+ void const * data,
+ vl_size numData) ;
+
+VL_EXPORT void
+vl_gmm_init_with_kmeans
+(VlGMM * self,
+ void const * data,
+ vl_size numData,
+ VlKMeans * kmeansInit);
+
+VL_EXPORT double
+vl_gmm_em
+(VlGMM * self,
+ void const * data,
+ vl_size numData);
+/** @} */
+
+VL_EXPORT void
+vl_gmm_set_means
+(VlGMM * self,
+ void const * means);
+
+VL_EXPORT void
+vl_gmm_set_covariances
+(VlGMM * self,
+ void const * covariances);
+
+VL_EXPORT void
+vl_gmm_set_priors
+(VlGMM * self,
+ void const * priors);
+
+VL_EXPORT double
+vl_get_gmm_data_posteriors_f(float * posteriors,
+                             vl_size numClusters,
+                             vl_size numData,
+                             float const * priors,
+                             float const * means,
+                             vl_size dimension,
+                             float const * covariances,
+                             float const * data) ;
+
+VL_EXPORT double
+vl_get_gmm_data_posteriors_d(double * posteriors,
+                             vl_size numClusters,
+                             vl_size numData,
+                             double const * priors,
+                             double const * means,
+                             vl_size dimension,
+                             double const * covariances,
+                             double const * data) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_EXPORT void vl_gmm_set_num_repetitions (VlGMM * self, vl_size numRepetitions) ;
+VL_EXPORT void vl_gmm_set_max_num_iterations (VlGMM * self, vl_size maxNumIterations) ;
+VL_EXPORT void vl_gmm_set_verbosity (VlGMM * self, int verbosity) ;
+VL_EXPORT void vl_gmm_set_initialization (VlGMM * self, VlGMMInitialization init);
+VL_EXPORT void vl_gmm_set_kmeans_init_object (VlGMM * self, VlKMeans * kmeans);
+VL_EXPORT void vl_gmm_set_covariance_lower_bounds (VlGMM * self, double const * bounds);
+VL_EXPORT void vl_gmm_set_covariance_lower_bound (VlGMM * self, double bound) ;
+/** @} */
+
+/** @name Get parameters
+ ** @{
+ **/
+VL_EXPORT void const * vl_gmm_get_means (VlGMM const * self);
+VL_EXPORT void const * vl_gmm_get_covariances (VlGMM const * self);
+VL_EXPORT void const * vl_gmm_get_priors (VlGMM const * self);
+VL_EXPORT void const * vl_gmm_get_posteriors (VlGMM const * self);
+VL_EXPORT vl_type vl_gmm_get_data_type (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_dimension (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_num_repetitions (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_num_data (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_num_clusters (VlGMM const * self);
+VL_EXPORT double vl_gmm_get_loglikelihood (VlGMM const * self);
+VL_EXPORT int vl_gmm_get_verbosity (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_max_num_iterations (VlGMM const * self);
+VL_EXPORT vl_size vl_gmm_get_num_repetitions (VlGMM const * self);
+VL_EXPORT VlGMMInitialization vl_gmm_get_initialization (VlGMM const * self);
+VL_EXPORT VlKMeans * vl_gmm_get_kmeans_init_object (VlGMM const * self);
+VL_EXPORT double const * vl_gmm_get_covariance_lower_bounds (VlGMM const * self);
+/** @} */
+
+/* VL_GMM_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/heap-def.h b/opensfm/src/third_party/vlfeat/vl/heap-def.h
new file mode 100644
index 000000000..bb56c6ceb
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/heap-def.h
@@ -0,0 +1,464 @@
+/** @file   heap-def.h
+ ** @brief  Heap preprocessor metaprogram
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file heap-def.h
+
+ A heap organizes an array of objects in a priority queue. This module
+ is a template metaprogram that defines heap operations on array of
+ generic objects, or even generic object containers.
+
+ - @ref heap-def-overview "Overview"
+   - @ref heap-def-overview-general "General usage"
+ - @ref heap-def-tech "Technical details"
+
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+ @section heap-def-overview Overview
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+ To use @ref heap-def.h one must specify at least a prefix and the data
+ type for the heap elements:
+
+ @code
+ #define VL_HEAP_prefix  my_heap
+ #define VL_HEAP_type    float
+ #include <vl/heap-def.h>
+ @endcode
+
+ This code fragment defines a number of functions prefixed by
+ ::VL_HEAP_prefix, such as @c my_heap_push (::VL_HEAP_push) and @c
+ my_heap_pop (::VL_HEAP_pop), that implement the heap operations.
+ These functions operate on an array that has type ::VL_HEAP_array.
+ By default, this is defined to be:
+
+ @code
+ #define VL_HEAP_array VL_HEAP_type*
+ #define VL_HEAP_array_const VL_HEAP_type const*
+ @endcode
+
+ The array itself is accessed uniquely by means of two functions:
+
+ - ::VL_HEAP_cmp, that compares two array elements. The default
+   implementation assumes that ::VL_HEAP_type is numeric.
+ - ::VL_HEAP_swap, that swaps two array elements. The default
+   implementation assumes that ::VL_HEAP_type can be copied by the @c
+   = operator.
+
+ The heap state is a integer @c numElements (of type ::vl_size) counting
+ the number of elements of the array that are currently part of the heap
+ and the content of the first @c numElements elements of the array. The
+ portion of the array that constitutes the heap satisfies a certain
+ invariant property (heap property, @ref heap-def-tech). From a user
+ viewpoint, the most important consequence is that the first element
+ of the array (the one of index 0) is also the smallest (according to
+ ::VL_HEAP_cmp).
+
+ Elements are added to the heap by ::VL_HEAP_push and removed from the
+ heap by ::VL_HEAP_pop.  A push operation adds to the heap the array
+ element immediately after the last element already in the heap
+ (i.e. the element of index @c numElements) and increases the number of
+ heap elements @c numElements. Elements in the heap are swapped as required in
+ order to maintain the heap consistency.  Similarly, a pop operation
+ removes the first (smaller) element from the heap and decreases the
+ number of heap elements @c numElements.
+
+ The values of nodes currently in the heap can be updated by
+ ::VL_HEAP_update. Notice however that using this function requires
+ knowing the index of the element that needs to be updated up to the
+ swapping operations that the heap performs to maintain
+ consistency. Typically, this requires redefining ::VL_HEAP_swap to
+ keep track of such changes (@ref heap-def-overview-general).
+
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+ @subsection heap-def-overview-general General usage
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+ The heap container may be mapped to any type by reimplementing
+ ::VL_HEAP_cmp and ::VL_HEAP_swap explicitly. For instance
+ the following code redefines ::VL_HEAP_cmp to deal with the case
+ in which the heap is an array of structures:
+
+ @code
+ typedef struct _S { int x ; } S ;
+ int s_cmp (S const * v, vl_uindex a, vl_uindex b) {
+   return v[a].x - v[b].x ;
+ }
+ #define VL_HEAP_prefix  s_heap
+ #define VL_HEAP_type    S
+ #define VL_HEAP_cmp     s_cmp
+ #include <vl/heap-def.h>
+ @endcode
+
+ In the following example, the heap itself is an arbitrary structure:
+
+ @code
+ typedef struct _H { int* array ; } H ;
+ int h_cmp (H const * h, vl_uindex a, vl_uindex b) {
+   return h->array[a] - h->array[b] ;
+ }
+ int h_swap (H * h, vl_uindex a, vl_uindex b) {
+   int t = h->array[a] ;
+   h->array[a] = h->array[b] ;
+   h->array[b] = t ;
+ }
+ #define VL_HEAP_prefix  h_heap
+ #define VL_HEAP_swap    h_swap
+ #define VL_HEAP_cmp     h_cmp
+ #include <vl/heap-def.h>
+ @endcode
+
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+ @section heap-def-tech Technical details
+ <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+ The heap is organised as a binary tree with the property (<em>heap
+ property</em>) that any node is not larger than any of its
+ children. In particular, the root is the smallest node.
+
+ @ref heap-def.h uses the standard binary tree representation as a linear
+ array. Tree nodes are mapped to array elements as follows:
+ <code>array[0]</code> corresponds to the root, <code>array[1]</code>
+ and <code>array[2]</code> to the root left and right children and so
+ on.  In this way, the tree structure is fully specified by the total
+ number of nodes <code>N</code>.
+
+ Assuming that the heap has <code>N</code> nodes (from
+ <code>array[0]</code> to <code>array[N-1]</code>), adding the node
+ <code>array[N]</code> to the heap is done by a <em>push down</em>
+ operation: if the node <code>array[N]</code> is smaller than its
+ parent (violating the heap property) it is pushed down by swapping it
+ with the parent, and so on recursively.
+
+ Removing the smallest element <code>array[0]</code> with an heap of
+ <code>N</code> nodes is done by swapping <code>array[0]</code> with
+ <code>array[N-1]</code>. If then <code>array[0]</code> is larger than
+ any of its children, it is swapped with the smallest of the two and
+ so on recursively (<em>push up</em> operation).
+
+ Restoring the heap property after an element <code>array[i]</code>
+ has been modified can be done by a push up or push down operation on
+ that node.
+
+ **/
+
+#include "host.h"
+#include <assert.h>
+
+#ifndef VL_HEAP_prefix
+#error "VL_HEAP_prefix must be defined"
+#endif
+
+#ifndef VL_HEAP_array
+#ifndef VL_HEAP_type
+#error "VL_HEAP_type must be defined if VL_HEAP_array is not"
+#endif
+#define VL_HEAP_array       VL_HEAP_type*
+#define VL_HEAP_array_const VL_HEAP_type const*
+#endif
+
+#ifndef VL_HEAP_array_const
+#define VL_HEAP_array_const VL_HEAP_array
+#endif
+
+#ifdef __DOXYGEN__
+#define VL_HEAP_prefix  HeapObject       /**< Prefix of the heap functions */
+#define VL_HEAP_type    HeapType         /**< Data type of the heap elements */
+#define VL_HEAP_array   HeapType*        /**< Data type of the heap container */
+#define VL_HEAP_array   HeapType const*  /**< Const data type of the heap container */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#ifndef VL_HEAP_DEF_H
+#define VL_HEAP_DEF_H
+
+/** @internal @brief Get index of parent node
+ ** @param index a node index.
+ ** @return index of the parent node.
+ **/
+
+VL_INLINE vl_uindex
+vl_heap_parent (vl_uindex index)
+{
+  if (index == 0) return 0 ;
+  return (index - 1) / 2 ;
+}
+
+/** @internal @brief Get index of left child
+ ** @param index a node index.
+ ** @return index of the left child.
+ **/
+
+VL_INLINE vl_uindex
+vl_heap_left_child (vl_uindex index)
+{
+  return 2 * index + 1 ;
+}
+
+/** @internal @brief Get index of right child
+ ** @param index a node index.
+ ** @return index of the right child.
+ **/
+
+VL_INLINE vl_uindex
+vl_heap_right_child (vl_uindex index)
+{
+  return vl_heap_left_child (index) + 1 ;
+}
+
+/* VL_HEAP_DEF_H */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_cmp) || defined(__DOXYGEN__)
+#define VL_HEAP_cmp VL_XCAT(VL_HEAP_prefix, _cmp)
+
+/** @brief Compare two heap elements
+ ** @param array heap array.
+ ** @param indexA index of the first element @c A to compare.
+ ** @param indexB index of the second element @c B to comapre.
+ ** @return a negative number if @c A<B, 0 if @c A==B, and
+ ** a positive number if if @c A>B.
+ **/
+
+VL_INLINE VL_HEAP_type
+VL_HEAP_cmp
+(VL_HEAP_array_const array,
+ vl_uindex indexA,
+ vl_uindex indexB)
+{
+  return array[indexA] - array[indexB] ;
+}
+
+/* VL_HEAP_cmp */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_swap) || defined(__DOXYGEN__)
+#define VL_HEAP_swap VL_XCAT(VL_HEAP_prefix, _swap)
+
+/** @brief Swap two heap elements
+ ** @param array array of nodes.
+ ** @param array heap array.
+ ** @param indexA index of the first node to swap.
+ ** @param indexB index of the second node to swap.
+ **
+ ** The function swaps the two heap elements @a a and @ b. The function
+ ** uses a temporary element and the copy operator, which must be
+ ** well defined for the heap elements.
+ **/
+
+VL_INLINE void
+VL_HEAP_swap
+(VL_HEAP_array array,
+ vl_uindex indexA,
+ vl_uindex indexB)
+{
+  VL_HEAP_type t = array [indexA] ;
+  array [indexA] = array [indexB] ;
+  array [indexB] = t ;
+}
+
+/* VL_HEAP_swap */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_up) || defined(__DOXYGEN__)
+#define VL_HEAP_up VL_XCAT(VL_HEAP_prefix, _up)
+
+/** @brief Heap up operation
+ ** @param array pointer to the heap array.
+ ** @param heapSize size of the heap.
+ ** @param index index of the node to push up.
+ **/
+
+VL_INLINE void
+VL_HEAP_up
+(VL_HEAP_array array, vl_size heapSize, vl_uindex index)
+{
+  vl_uindex leftIndex  = vl_heap_left_child (index) ;
+  vl_uindex rightIndex = vl_heap_right_child (index) ;
+
+  /* no childer: stop */
+  if (leftIndex >= heapSize) return ;
+
+  /* only left childer: easy */
+  if (rightIndex >= heapSize) {
+    if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
+      VL_HEAP_swap (array, index, leftIndex) ;
+    }
+    return ;
+  }
+
+  /* both childern */
+  {
+    if (VL_HEAP_cmp (array, leftIndex, rightIndex) < 0) {
+      /* swap with left */
+      if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
+        VL_HEAP_swap (array, index, leftIndex) ;
+        VL_HEAP_up (array, heapSize, leftIndex) ;
+      }
+    } else {
+      /* swap with right */
+      if (VL_HEAP_cmp (array, index, rightIndex) > 0) {
+        VL_HEAP_swap (array, index, rightIndex) ;
+        VL_HEAP_up (array, heapSize, rightIndex) ;
+      }
+    }
+  }
+}
+
+/* VL_HEAP_up */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_down) || defined(__DOXYGEN__)
+#define VL_HEAP_down VL_XCAT(VL_HEAP_prefix, _down)
+
+/** @brief Heap down operation
+ ** @param array pointer to the heap node array.
+ ** @param index index of the node to push up.
+ **/
+
+VL_INLINE void
+VL_HEAP_down
+(VL_HEAP_array array, vl_uindex index)
+{
+  vl_uindex parentIndex ;
+
+  if (index == 0) return  ;
+
+  parentIndex = vl_heap_parent (index) ;
+
+  if (VL_HEAP_cmp (array, index, parentIndex) < 0) {
+    VL_HEAP_swap (array, index, parentIndex) ;
+    VL_HEAP_down (array, parentIndex) ;
+  }
+}
+
+/* VL_HEAP_down */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_push) || defined(__DOXYGEN__)
+#define VL_HEAP_push VL_XCAT(VL_HEAP_prefix, _push)
+
+/** @brief Heap push operation
+ ** @param array pointer to the heap array.
+ ** @param heapSize (in/out) size of the heap.
+ **
+ ** The function adds to the heap the element of index @c heapSize
+ ** and increments @c heapSize.
+ **/
+
+VL_INLINE void
+VL_HEAP_push
+(VL_HEAP_array array, vl_size *heapSize)
+{
+  VL_HEAP_down (array, *heapSize) ;
+  *heapSize += 1 ;
+}
+
+/* VL_HEAP_push */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_pop) || defined(__DOXYGEN__)
+#define VL_HEAP_pop VL_XCAT(VL_HEAP_prefix, _pop)
+
+/** @brief Heap pop operation
+ ** @param array pointer to the heap array.
+ ** @param heapSize (in/out) size of the heap.
+ ** @return index of the popped element.
+ **
+ ** The function extracts from the heap the element of index 0
+ ** (the smallest element) and decreases @c heapSize.
+ **
+ ** The element extracted is moved as the first element after
+ ** the heap end (thus it has index @c heapSize). For convenience,
+ ** this index is returned by the function.
+ **
+ ** Popping from an empty heap is undefined.
+ **/
+
+VL_INLINE vl_uindex
+VL_HEAP_pop
+(VL_HEAP_array array, vl_size *heapSize)
+{
+  assert (*heapSize) ;
+
+  *heapSize -= 1 ;
+
+  VL_HEAP_swap (array, 0, *heapSize) ;
+
+  if (*heapSize > 1) {
+    VL_HEAP_up (array, *heapSize, 0) ;
+  }
+
+  return *heapSize ;
+}
+
+/* VL_HEAP_pop */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_HEAP_update) || defined(__DOXYGEN__)
+#define VL_HEAP_update VL_XCAT(VL_HEAP_prefix, _update)
+
+/** @brief Heap update operation
+ ** @param array pointer to the heap array.
+ ** @param heapSize size of the heap.
+ ** @param index index of the node to update.
+ **
+ ** The function updates the heap to account for a change to the
+ ** element of index @c index in the heap.
+ **
+ ** Notice that using this
+ ** function requires knowing the index of the heap index of
+ ** element that was changed. Since the heap swaps elements in the
+ ** array, this is in general different from the index that that
+ ** element had originally.
+ **/
+
+VL_INLINE void
+VL_HEAP_update
+(VL_HEAP_array array,
+ vl_size heapSize,
+ vl_uindex index)
+{
+  VL_HEAP_up (array, heapSize, index) ;
+  VL_HEAP_down (array, index) ;
+}
+
+/* VL_HEAP_update */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#undef VL_HEAP_cmp
+#undef VL_HEAP_swap
+#undef VL_HEAP_up
+#undef VL_HEAP_down
+#undef VL_HEAP_push
+#undef VL_HEAP_pop
+#undef VL_HEAP_update
+#undef VL_HEAP_prefix
+#undef VL_HEAP_type
+#undef VL_HEAP_array
+#undef VL_HEAP_array_const
diff --git a/opensfm/src/third_party/vlfeat/vl/hikmeans.c b/opensfm/src/third_party/vlfeat/vl/hikmeans.c
new file mode 100644
index 000000000..c72720831
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/hikmeans.c
@@ -0,0 +1,371 @@
+/** @file hikmeans.c
+ ** @brief Hierarchical Integer K-Means Clustering - Declaration
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file hikmeans.h
+ ** @brief Hierarchical integer K-Means clustering
+ **
+ ** Hierarchical integer K-Means clustering (HIKM) is a simple
+ ** hierarchical version of integer K-Means (@ref ikmeans.h
+ ** "IKM"). The algorithm recursively applies integer K-means to create
+ ** more refined partitions of the data.
+ **
+ ** Create a tree with ::vl_hikm_new() and delete it with
+ ** ::vl_hikm_delete(). Use ::vl_hikm_train() to build the tree
+ ** from training data and ::vl_hikm_push() to project new data down
+ ** a HIKM tree.
+ **
+ ** @section hikm-tree HIKM tree
+ **
+ ** The HIKM tree is represented by a ::VlHIKMTree structure, which
+ ** contains a tree composed of ::VlHIKMNode. Each node is an
+ ** integer K-means filter which partitions the data into @c K
+ ** clusters.
+ **/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "hikmeans.h"
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Copy a subset of the data to a buffer
+ ** @param data Data
+ ** @param ids Data labels
+ ** @param N Number of indices
+ ** @param M Data dimensionality
+ ** @param id Label of data to copy
+ ** @param N2 Number of data copied (out)
+ ** @return a new buffer with a copy of the selected data.
+ **/
+
+vl_uint8*
+vl_hikm_copy_subset (vl_uint8 const * data,
+                     vl_uint32 *ids,
+                     vl_size N, vl_size M,
+                     vl_uint32 id, vl_size *N2)
+{
+  vl_uindex i ;
+  vl_size count = 0;
+
+  /* count how many data points with this label there are */
+  for (i = 0 ; i < N ; i++) {
+    if (ids[i] == id) {
+      count ++ ;
+    }
+  }
+  *N2 = count ;
+
+  /* copy each datum to the buffer */
+  {
+    vl_uint8 *new_data = vl_malloc (sizeof(*new_data) * M * count);
+    count = 0;
+    for (i = 0 ; i < N ; i ++) {
+      if (ids[i] == id) {
+        memcpy(new_data + count * M,
+               data + i * M,
+               sizeof(*new_data) * M);
+        count ++ ;
+      }
+    }
+    *N2 = count ;
+    return new_data ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Compute HIKM clustering.
+ **
+ ** @param tree   HIKM tree to initialize.
+ ** @param data   Data to cluster.
+ ** @param N      Number of data points.
+ ** @param K      Number of clusters for this node.
+ ** @param height Tree height.
+ **
+ ** @remark height cannot be smaller than 1.
+ **
+ ** @return a new HIKM node representing a sub-clustering.
+ **/
+
+static VlHIKMNode *
+xmeans (VlHIKMTree *tree,
+        vl_uint8 const *data,
+        vl_size N, vl_size K, vl_size height)
+{
+  VlHIKMNode *node = vl_malloc (sizeof(*node)) ;
+  vl_uint32 *ids = vl_malloc (sizeof(*ids) * N) ;
+
+  node->filter = vl_ikm_new (tree -> method) ;
+  node->children = (height == 1) ? 0 : vl_malloc (sizeof(*node->children) * K) ;
+
+  vl_ikm_set_max_niters (node->filter, tree->max_niters) ;
+  vl_ikm_set_verbosity  (node->filter, tree->verb - 1  ) ;
+  vl_ikm_init_rand_data (node->filter, data, tree->M, N, K) ;
+  vl_ikm_train (node->filter, data, N) ;
+  vl_ikm_push (node->filter, ids, data, N) ;
+
+  /* recursively process each child */
+  if (height > 1) {
+    vl_uindex k ;
+    for (k = 0 ; k < K ; ++k) {
+      vl_size partition_N ;
+      vl_size partition_K ;
+      vl_uint8 *partition ;
+
+      partition = vl_hikm_copy_subset
+        (data, ids, N, tree->M, (vl_uint32)k, &partition_N) ;
+
+      partition_K = VL_MIN (K, partition_N) ;
+
+      node->children [k] = xmeans
+        (tree, partition, partition_N, partition_K, height - 1) ;
+
+      vl_free (partition) ;
+
+      if (tree->verb > (signed)tree->depth - (signed)height) {
+        VL_PRINTF("hikmeans: branch at depth %d: %6.1f %% completed\n",
+                  tree->depth - height,
+                  (double) (k+1) / K * 100) ;
+      }
+    }
+  }
+
+  vl_free (ids) ;
+  return node ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Delete node
+ **
+ ** @param node to delete.
+ **
+ ** The function deletes recursively @a node and all its descendent.
+ **/
+
+static void
+xdelete (VlHIKMNode *node)
+{
+  if(node) {
+    vl_uindex k ;
+    if (node->children) {
+      for(k = 0 ; k < vl_ikm_get_K (node->filter) ; ++k)
+        xdelete (node->children[k]) ;
+      vl_free (node->children) ;
+    }
+    if (node->filter) {
+      vl_ikm_delete (node->filter) ;
+    }
+    vl_free(node);
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief New HIKM tree
+ ** @param method clustering method.
+ ** @return new HIKM tree.
+ **/
+
+VlHIKMTree *
+vl_hikm_new (int method)
+{
+  VlHIKMTree *f = vl_calloc (sizeof(VlHIKMTree), 1) ;
+  f->max_niters = 200 ;
+  f->method = method ;
+  return f ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Delete HIKM tree
+ ** @param f HIKM tree.
+ **/
+
+void
+vl_hikm_delete (VlHIKMTree *f)
+{
+  if (f) {
+    xdelete (f->root) ;
+    vl_free (f) ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Initialize HIKM tree
+ ** @param f HIKM tree.
+ ** @param M Data dimensionality.
+ ** @param K Number of clusters per node.
+ ** @param depth Tree depth.
+ ** @return a new HIKM tree representing the clustering.
+ **
+ ** @remark @a depth cannot be smaller than 1.
+ **/
+
+void
+vl_hikm_init (VlHIKMTree *f, vl_size M, vl_size K, vl_size depth)
+{
+  assert(depth > 0) ;
+  assert(M > 0) ;
+  assert(K > 0) ;
+
+  xdelete (f -> root) ;
+  f->root = 0;
+  f->M = M ;
+  f->K = K ;
+  f->depth = depth ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Train HIKM tree
+ ** @param f       HIKM tree.
+ ** @param data    Data to cluster.
+ ** @param N       Number of data.
+ **/
+
+void
+vl_hikm_train (VlHIKMTree *f, vl_uint8 const *data, vl_size N)
+{
+  f->root= xmeans (f, data, N, VL_MIN(f->K, N), f->depth) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Project data down HIKM tree
+ ** @param f HIKM tree.
+ ** @param asgn Path down the tree (out).
+ ** @param data Data to project.
+ ** @param N Number of data.
+ **
+ ** The function writes to @a asgn the path of the data @a data
+ ** down the HIKM tree @a f. The parameter @a asgn must point to
+ ** an array of @c M by @c N elements, where @c M is the depth of
+ ** the HIKM tree and @c N is the number of data point to process.
+ **/
+
+void
+vl_hikm_push (VlHIKMTree *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N)
+{
+  vl_uindex i, d ;
+  vl_size M = vl_hikm_get_ndims (f) ;
+  vl_size depth = vl_hikm_get_depth (f) ;
+
+  /* for each datum */
+  for(i = 0 ; i < N ; i++) {
+    VlHIKMNode *node = f->root ;
+    d = 0 ;
+    while (node) {
+      vl_uint32 best ;
+      vl_ikm_push (node->filter,
+                   &best,
+                   data + i * M, 1) ;
+      asgn[i * depth + d] = best ;
+      ++ d ;
+      if (!node->children) break ;
+      node = node->children [best] ;
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Setters and getters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get data dimensionality
+ ** @param f HIKM tree.
+ ** @return data dimensionality.
+ **/
+
+vl_size
+vl_hikm_get_ndims (VlHIKMTree const* f)
+{
+  return f->M ;
+}
+
+/** @brief Get K
+ ** @param f HIKM tree.
+ ** @return K.
+ **/
+
+vl_size
+vl_hikm_get_K (VlHIKMTree const *f)
+{
+  return f->K ;
+}
+
+/** @brief Get depth
+ ** @param f HIKM tree.
+ ** @return depth.
+ **/
+
+vl_size
+vl_hikm_get_depth (VlHIKMTree const *f)
+{
+  return f->depth ;
+}
+
+
+/** @brief Get verbosity level
+ ** @param f HIKM tree.
+ ** @return verbosity level.
+ **/
+
+int
+vl_hikm_get_verbosity (VlHIKMTree const *f)
+{
+  return f->verb ;
+}
+
+/** @brief Get maximum number of iterations
+ ** @param f HIKM tree.
+ ** @return maximum number of iterations.
+ **/
+
+vl_size
+vl_hikm_get_max_niters (VlHIKMTree const *f)
+{
+  return f-> max_niters ;
+}
+
+/** @brief Get maximum number of iterations
+ ** @param f HIKM tree.
+ ** @return maximum number of iterations.
+ **/
+
+VlHIKMNode const *
+vl_hikm_get_root (VlHIKMTree const *f)
+{
+  return f->root ;
+}
+
+/** @brief Set verbosity level
+ ** @param f HIKM tree.
+ ** @param verb verbosity level.
+ **/
+
+void
+vl_hikm_set_verbosity (VlHIKMTree *f, int verb)
+{
+  f->verb = verb ;
+}
+
+/** @brief Set maximum number of iterations
+ ** @param f HIKM tree.
+ ** @param max_niters maximum number of iterations.
+ **/
+
+void
+vl_hikm_set_max_niters (VlHIKMTree *f, int max_niters)
+{
+  f->max_niters = max_niters ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/hikmeans.h b/opensfm/src/third_party/vlfeat/vl/hikmeans.h
new file mode 100644
index 000000000..5da4f5ec8
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/hikmeans.h
@@ -0,0 +1,80 @@
+/** @file hikmeans.h
+ ** @brief Hierarchical Integer K-Means Clustering
+ ** @author Brian Fulkerson
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_HIKMEANS_H
+#define VL_HIKMEANS_H
+
+#include "generic.h"
+#include "ikmeans.h"
+
+struct _VLHIKMTree ;
+struct _VLHIKMNode ;
+
+/** @brief HIKM tree node
+ **
+ ** The number of children @a K is not bigger than the @a K parameter
+ ** of the HIKM tree.
+ **/
+typedef struct _VlHIKMNode
+{
+  VlIKMFilt *filter ; /**< IKM filter for this node*/
+  struct _VlHIKMNode **children ; /**< Node children (if any) */
+} VlHIKMNode ;
+
+/** @brief HIKM tree */
+typedef struct _VlHIKMTree {
+  vl_size M ; /**< IKM: data dimensionality */
+  vl_size K ; /**< IKM: K */
+  vl_size depth ; /**< Depth of the tree */
+  vl_size max_niters ;  /**< IKM: maximum # of iterations */
+  int method ; /**< IKM: method */
+  int verb ; /**< Verbosity level */
+  VlHIKMNode * root; /**< Tree root node */
+} VlHIKMTree ;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT VlHIKMTree *vl_hikm_new (int method) ;
+VL_EXPORT void vl_hikm_delete (VlHIKMTree *f) ;
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{
+ **/
+VL_EXPORT vl_size vl_hikm_get_ndims (VlHIKMTree const *f) ;
+VL_EXPORT vl_size vl_hikm_get_K (VlHIKMTree const *f) ;
+VL_EXPORT vl_size vl_hikm_get_depth (VlHIKMTree const *f) ;
+VL_EXPORT int vl_hikm_get_verbosity (VlHIKMTree const *f) ;
+VL_EXPORT vl_size vl_hikm_get_max_niters (VlHIKMTree const *f) ;
+VL_EXPORT VlHIKMNode const * vl_hikm_get_root (VlHIKMTree const *f) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_EXPORT void vl_hikm_set_verbosity (VlHIKMTree *f, int verb) ;
+VL_EXPORT void vl_hikm_set_max_niters (VlHIKMTree *f, int max_niters) ;
+/** @} */
+
+/** @name Process data
+ ** @{
+ **/
+VL_EXPORT void vl_hikm_init (VlHIKMTree *f, vl_size M, vl_size K, vl_size depth) ;
+VL_EXPORT void vl_hikm_train (VlHIKMTree *f, vl_uint8 const *data, vl_size N) ;
+VL_EXPORT void vl_hikm_push (VlHIKMTree *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) ;
+/** @} */
+
+
+/* VL_HIKMEANS_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/hog.c b/opensfm/src/third_party/vlfeat/vl/hog.c
new file mode 100644
index 000000000..0a1487541
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/hog.c
@@ -0,0 +1,1072 @@
+/** @file hog.c
+ ** @brief Histogram of Oriented Gradients (HOG) - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+ Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+ All rights reserved.
+
+ This file is part of the VLFeat library and is made available under
+ the terms of the BSD license (see the COPYING file).
+*/
+
+#include "hog.h"
+#include "mathop.h"
+#include <string.h>
+
+/**
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page hog Histogram of Oriented Gradients (HOG) features
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref hog.h implements the Histogram of Oriented Gradients (HOG) features
+in the variants of Dalal Triggs @cite{dalal05histograms} and of UOCTTI
+@cite{felzenszwalb09object}. Applications include object detection
+and deformable object detection.
+
+- @ref hog-overview
+- @ref hog-tech
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section hog-overview Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+HOG is a standard image feature used, among others, in object detection
+and deformable object detection. It decomposes the image into square cells
+of a given size (typically eight pixels), compute a histogram of oriented
+gradient in each cell (similar to @ref sift), and then renormalizes
+the cells by looking into adjacent blocks.
+
+VLFeat implements two HOG variants: the original one of Dalal-Triggs
+@cite{dalal05histograms} and the one proposed in Felzenszwalb et al.
+@cite{felzenszwalb09object}.
+
+In order to use HOG, start by creating a new HOG object, set the desired
+parameters, pass a (color or grayscale) image, and read off the results.
+
+@code
+VlHog * hog = vl_hog_new(VlHogVariantDalalTriggs, numOrientations, VL_FALSE) ;
+vl_hog_put_image(hog, image, height, width, numChannels, cellSize) ;
+hogWidth = vl_hog_get_width(hog) ;
+hogHeight = vl_hog_get_height(hog) ;
+hogDimenison = vl_hog_get_dimension(hog) ;
+hogArray = vl_malloc(hogWidth*hogHeight*hogDimension*sizeof(float)) ;
+vl_hog_extract(hog, hogArray) ;
+vl_hog_delete(hog) ;
+@endcode
+
+HOG is a feature array of the dimension returned by ::vl_hog_get_width,
+::vl_hog_get_height, with each feature (histogram) having
+dimension ::vl_hog_get_dimension. The array is stored in row major order,
+with the slowest varying dimension beying the dimension indexing the histogram
+elements.
+
+The number of entreis in the histogram as well as their meaning depends
+on the HOG variant and is detailed later. However, it is usually
+unnecessary to know such details. @ref hog.h provides support for
+creating an inconic representation of a HOG feature array:
+
+@code
+glyphSize = vl_hog_get_glyph_size(hog) ;
+imageHeight = glyphSize * hogArrayHeight ;
+imageWidth = glyphSize * hogArrayWidth ;
+image = vl_malloc(sizeof(float)*imageWidth*imageHeight) ;
+vl_hog_render(hog, image, hogArray) ;
+@endcode
+
+It is often convenient to mirror HOG features from left to right. This
+can be obtained by mirroring an array of HOG cells, but the content
+of each cell must also be rearranged. This can be done by
+the permutation obtaiend by ::vl_hog_get_permutation.
+
+Furthermore, @ref hog.h suppots computing HOG features not from
+images but from vector fields.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section hog-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+HOG divdes the input image into square cells of size @c cellSize,
+fitting as many cells as possible, filling the image domain from
+the upper-left corner down to the right one. For each row and column,
+the last cell is at least half contained in the image.
+More precisely, the number of cells obtained in this manner is:
+
+@code
+hogWidth = (width + cellSize/2) / cellSize ;
+hogHeight = (height + cellSize/2) / cellSize ;
+@endcode
+
+Then the image gradient @f$ \nabla \ell(x,y) @f$
+is computed by using central difference (for colour image
+the channel with the largest gradient at that pixel is used).
+The gradient @f$ \nabla \ell(x,y) @f$ is assigned to one of @c 2*numOrientations orientation in the
+range @f$ [0,2\pi) @f$ (see @ref hog-conventions for details).
+Contributions are then accumulated by using bilinear interpolation
+to four neigbhour cells, as in @ref sift.
+This results in an histogram  @f$h_d@f$ of dimension
+2*numOrientations, called of @e directed orientations
+since it accounts for the direction as well as the orientation
+of the gradient. A second histogram @f$h_u@f$ of undirected orientations
+of half the size is obtained by folding @f$ h_d @f$ into two.
+
+Let a block of cell be a @f$ 2\times 2 @f$ sub-array of cells.
+Let the norm of a block be the @f$ l^2 @f$ norm of the stacking of the
+respective unoriented histogram. Given a HOG cell, four normalisation
+factors are then obtained as the inverse of the norm of the four
+blocks that contain the cell.
+
+For the Dalal-Triggs variant, each histogram @f$ h_d @f$ is copied
+four times, normalised using the four different normalisation factors,
+the four vectors are stacked, saturated at 0.2, and finally stored as the descriptor
+of the cell. This results in a @c numOrientations * 4 dimensional
+cell descriptor. Blocks are visited from left to right and top to bottom
+when forming the final descriptor.
+
+For the UOCCTI descriptor, the same is done for both the undirected
+as well as the directed orientation histograms. This would yield
+a dimension of @c 4*(2+1)*numOrientations elements, but the resulting
+vector is projected down to @c (2+1)*numOrientations elements
+by averaging corresponding histogram dimensions. This was shown to
+be an algebraic approximation of PCA for descriptors computed on natural
+images.
+
+In addition, for the UOCTTI variant the l1 norm of each of the
+four l2 normalised undirected histograms is computed and stored
+as additional four dimensions, for a total of
+@c 4+3*numOrientations dimensions.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection hog-conventions Conventions
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The orientation of a gradient is expressed as the angle it forms with the
+horizontal axis of the image. Angles are measured clock-wise (as the vertical
+image axis points downards), and the null angle corresponds to
+an horizontal vector pointing right. The quantized directed
+orientations are @f$ \mathrm{k} \pi / \mathrm{numOrientations} @f$, where
+@c k is an index that varies in the ingeger
+range @f$ \{0, \dots, 2\mathrm{numOrientations} - 1\} @f$.
+
+Note that the orientations capture the orientation of the gradeint;
+image edges would be oriented at 90 degrees from these.
+
+**/
+
+/* ---------------------------------------------------------------- */
+/** @brief Create a new HOG object
+ ** @param variant HOG descriptor variant.
+ ** @param numOrientations number of distinguished orientations.
+ ** @param transposed wether images are transposed (column major).
+ ** @return the new HOG object.
+ **
+ ** The function creates a new HOG object to extract descriptors of
+ ** the prescribed @c variant. The angular resolution is set by
+ ** @a numOrientations, which specifies the number of <em>undirected</em>
+ ** orientations. The object can work with column major images
+ ** by setting @a transposed to true.
+ **/
+
+VlHog *
+vl_hog_new (VlHogVariant variant, vl_size numOrientations, vl_bool transposed)
+{
+  vl_index o, k ;
+  VlHog * self = vl_calloc(1, sizeof(VlHog)) ;
+
+  assert(numOrientations >= 1) ;
+
+  self->variant = variant ;
+  self->numOrientations = numOrientations ;
+  self->glyphSize = 21 ;
+  self->transposed = transposed ;
+  self->useBilinearOrientationAssigment = VL_FALSE ;
+  self->orientationX = vl_malloc(sizeof(float) * self->numOrientations) ;
+  self->orientationY = vl_malloc(sizeof(float) * self->numOrientations) ;
+
+  /*
+   Create a vector along the center of each orientation bin. These
+   are used to map gradients to bins. If the image is transposed,
+   then this can be adjusted here by swapping X and Y in these
+   vectors.
+   */
+  for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
+    double angle = o * VL_PI / self->numOrientations ;
+    if (!self->transposed) {
+      self->orientationX[o] = (float) cos(angle) ;
+      self->orientationY[o] = (float) sin(angle) ;
+    } else {
+      self->orientationX[o] = (float) sin(angle) ;
+      self->orientationY[o] = (float) cos(angle) ;
+    }
+  }
+
+  /*
+   If the number of orientation is equal to 9, one gets:
+
+   Uoccti:: 18 directed orientations + 9 undirected orientations + 4 texture
+   DalalTriggs:: 9 undirected orientations x 4 blocks.
+   */
+  switch (self->variant) {
+    case VlHogVariantUoctti:
+      self->dimension = 3*self->numOrientations + 4 ;
+      break ;
+
+    case VlHogVariantDalalTriggs:
+      self->dimension = 4*self->numOrientations ;
+      break ;
+
+    default:
+      assert(0) ;
+  }
+
+  /*
+   A permutation specifies how to permute elements in a HOG
+   descriptor to flip it horizontally. Since the first orientation
+   of index 0 points to the right, this must be swapped with orientation
+   self->numOrientation that points to the left (for the directed case,
+   and to itself for the undirected one).
+   */
+
+  self->permutation = vl_malloc(self->dimension * sizeof(vl_index)) ;
+  switch (self->variant) {
+    case VlHogVariantUoctti:
+      for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
+        vl_index op = self->numOrientations - o ;
+        self->permutation[o] = op ;
+        self->permutation[o + self->numOrientations] = (op + self->numOrientations) % (2*self->numOrientations) ;
+        self->permutation[o + 2*self->numOrientations] = (op % self->numOrientations) + 2*self->numOrientations ;
+      }
+      for (k = 0 ; k < 4 ; ++k) {
+        /* The texture features correspond to four displaced block around
+         a cell. These permute with a lr flip as for DalalTriggs. */
+        vl_index blockx = k % 2 ;
+        vl_index blocky = k / 2 ;
+        vl_index q = (1 - blockx) + blocky * 2 ;
+        self->permutation[k + self->numOrientations * 3] = q + self->numOrientations * 3 ;
+      }
+      break ;
+
+    case VlHogVariantDalalTriggs:
+      for(k = 0 ; k < 4 ; ++k) {
+        /* Find the corresponding block. Blocks are listed in order 1,2,3,4,...
+           from left to right and top to bottom */
+        vl_index blockx = k % 2 ;
+        vl_index blocky = k / 2 ;
+        vl_index q = (1 - blockx) + blocky * 2 ;
+        for(o = 0 ; o < (signed)self->numOrientations ; ++o) {
+          vl_index op = self->numOrientations - o ;
+          self->permutation[o + k*self->numOrientations] = (op % self->numOrientations) + q*self->numOrientations ;
+        }
+      }
+      break ;
+
+    default:
+      assert(0) ;
+  }
+
+  /*
+   Create glyphs for representing the HOG features/ filters. The glyphs
+   are simple bars, oriented orthogonally to the gradients to represent
+   image edges. If the object is configured to work on transposed image,
+   the glyphs images are also stored in column-major.
+   */
+  self->glyphs = vl_calloc(self->glyphSize * self->glyphSize * self->numOrientations, sizeof(float)) ;
+#define atglyph(x,y,k) self->glyphs[(x) + self->glyphSize * (y) + self->glyphSize * self->glyphSize * (k)]
+  for (o = 0 ; o < (signed)self->numOrientations ; ++o) {
+    double angle = fmod(o * VL_PI / self->numOrientations + VL_PI/2, VL_PI) ;
+    double x2 = self->glyphSize * cos(angle) / 2 ;
+    double y2 = self->glyphSize * sin(angle) / 2 ;
+
+    if (angle <= VL_PI / 4 || angle >= VL_PI * 3 / 4) {
+      /* along horizontal direction */
+      double slope = y2 / x2 ;
+      double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
+      vl_index skip = (1 - fabs(cos(angle))) / 2 * self->glyphSize ;
+      vl_index i, j ;
+      for (i = skip ; i < (signed)self->glyphSize - skip ; ++i) {
+        j = vl_round_d(slope * i + offset) ;
+        if (! self->transposed) {
+          atglyph(i,j,o) = 1 ;
+        } else {
+          atglyph(j,i,o) = 1 ;
+        }
+      }
+    } else {
+      /* along vertical direction */
+      double slope = x2 / y2 ;
+      double offset = (1 - slope) * (self->glyphSize - 1) / 2 ;
+      vl_index skip = (1 - sin(angle)) / 2 * self->glyphSize ;
+      vl_index i, j ;
+      for (j = skip ; j < (signed)self->glyphSize - skip; ++j) {
+        i = vl_round_d(slope * j + offset) ;
+        if (! self->transposed) {
+          atglyph(i,j,o) = 1 ;
+        } else {
+          atglyph(j,i,o) = 1 ;
+        }
+      }
+    }
+  }
+  return self ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Delete a HOG object
+ ** @param self HOG object to delete.
+ **/
+
+void
+vl_hog_delete (VlHog * self)
+{
+  if (self->orientationX) {
+    vl_free(self->orientationX) ;
+    self->orientationX = NULL ;
+  }
+
+  if (self->orientationY) {
+    vl_free(self->orientationY) ;
+    self->orientationY = NULL ;
+  }
+
+  if (self->glyphs) {
+    vl_free(self->glyphs) ;
+    self->glyphs = NULL ;
+  }
+
+  if (self->permutation) {
+    vl_free(self->permutation) ;
+    self->permutation = NULL ;
+  }
+
+  if (self->hog) {
+    vl_free(self->hog) ;
+    self->hog = NULL ;
+  }
+
+  if (self->hogNorm) {
+    vl_free(self->hogNorm) ;
+    self->hogNorm = NULL ;
+  }
+
+  vl_free(self) ;
+}
+
+
+/* ---------------------------------------------------------------- */
+/** @brief Get HOG glyph size
+ ** @param self HOG object.
+ ** @return size (height and width) of a glyph.
+ **/
+
+vl_size
+vl_hog_get_glyph_size (VlHog const * self)
+{
+  return self->glyphSize ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get HOG left-right flip permutation
+ ** @param self HOG object.
+ ** @return left-right permutation.
+ **
+ ** The function returns a pointer to an array @c permutation of ::vl_hog_get_dimension
+ ** elements. Given a HOG descriptor (for a cell) @c hog, which is also
+ ** a vector of ::vl_hog_get_dimension elements, the
+ ** descriptor obtained for the same image flipped horizotnally is
+ ** given by <code>flippedHog[i] = hog[permutation[i]]</code>.
+ **/
+
+vl_index const *
+vl_hog_get_permutation (VlHog const * self)
+{
+  return self->permutation ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Turn bilinear interpolation of assignments on or off
+ ** @param self HOG object.
+ ** @param x @c true if orientations should be assigned with bilinear interpolation.
+ **/
+
+void
+vl_hog_set_use_bilinear_orientation_assignments (VlHog * self, vl_bool x) {
+  self->useBilinearOrientationAssigment = x ;
+}
+
+/** @brief Tell whether assignments use bilinear interpolation or not
+ ** @param self HOG object.
+ ** @return @c true if orientations are be assigned with bilinear interpolation.
+ **/
+
+vl_bool
+vl_hog_get_use_bilinear_orientation_assignments (VlHog const * self) {
+  return self->useBilinearOrientationAssigment ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Render a HOG descriptor to a glyph image
+ ** @param self HOG object.
+ ** @param image glyph image (output).
+ ** @param descriptor HOG descriptor.
+ ** @param width HOG descriptor width.
+ ** @param height HOG descriptor height.
+ **
+ ** The function renders the HOG descriptor or filter
+ ** @a descriptor as an image (for visualization) and stores the result in
+ ** the buffer @a image. This buffer
+ ** must be an array of dimensions @c width*glyphSize
+ ** by @c height*glyphSize elements, where @c glyphSize is
+ ** obtained from ::vl_hog_get_glyph_size and is the size in pixels
+ ** of the image element used to represent the descriptor of one
+ ** HOG cell.
+ **/
+
+void
+vl_hog_render (VlHog const * self,
+               float * image,
+               float const * descriptor,
+               vl_size width,
+               vl_size height)
+{
+  vl_index x, y, k, cx, cy ;
+  vl_size hogStride = width * height ;
+
+  assert(self) ;
+  assert(image) ;
+  assert(descriptor) ;
+  assert(width > 0) ;
+  assert(height > 0) ;
+
+  for (y = 0 ; y < (signed)height ; ++y) {
+    for (x = 0 ; x < (signed)width ; ++x) {
+      float minWeight = 0 ;
+      float maxWeight = 0 ;
+
+      for (k = 0 ; k < (signed)self->numOrientations ; ++k) {
+        float weight ;
+        float const * glyph = self->glyphs + k * (self->glyphSize*self->glyphSize) ;
+        float * glyphImage = image + self->glyphSize * x + y * width * (self->glyphSize*self->glyphSize) ;
+
+        switch (self->variant) {
+          case VlHogVariantUoctti:
+            weight =
+            descriptor[k * hogStride] +
+            descriptor[(k + self->numOrientations) * hogStride] +
+            descriptor[(k + 2 * self->numOrientations) * hogStride] ;
+            break ;
+          case VlHogVariantDalalTriggs:
+            weight =
+            descriptor[k * hogStride] +
+            descriptor[(k + self->numOrientations) * hogStride] +
+            descriptor[(k + 2 * self->numOrientations) * hogStride] +
+            descriptor[(k + 3 * self->numOrientations) * hogStride] ;
+            break ;
+          default:
+            abort() ;
+        }
+        maxWeight = VL_MAX(weight, maxWeight) ;
+        minWeight = VL_MIN(weight, minWeight);
+
+        for (cy = 0 ; cy < (signed)self->glyphSize ; ++cy) {
+          for (cx = 0 ; cx < (signed)self->glyphSize ; ++cx) {
+            *glyphImage++ += weight * (*glyph++) ;
+          }
+          glyphImage += (width - 1) * self->glyphSize  ;
+        }
+      } /* next orientation */
+
+      {
+        float * glyphImage = image + self->glyphSize * x + y * width * (self->glyphSize*self->glyphSize) ;
+        for (cy = 0 ; cy < (signed)self->glyphSize ; ++cy) {
+          for (cx = 0 ; cx < (signed)self->glyphSize ; ++cx) {
+            float value = *glyphImage ;
+            *glyphImage++ = VL_MAX(minWeight, VL_MIN(maxWeight, value)) ;
+          }
+          glyphImage += (width - 1) * self->glyphSize  ;
+        }
+      }
+
+      ++ descriptor ;
+    } /* next column of cells (x) */
+  } /* next row of cells (y) */
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the dimension of the HOG features
+ ** @param self HOG object.
+ ** @return imension of a HOG cell descriptors.
+ **/
+
+vl_size
+vl_hog_get_dimension (VlHog const * self)
+{
+  return self->dimension ;
+}
+
+/** @brief Get the width of the HOG cell array
+ ** @param self HOG object.
+ ** @return number of HOG cells in the horizontal direction.
+ **/
+
+vl_size
+vl_hog_get_width (VlHog * self)
+{
+  return self->hogWidth ;
+}
+
+/** @brief Get the height of the HOG cell array
+ ** @param self HOG object.
+ ** @return number of HOG cells in the vertical direction.
+ **/
+
+vl_size
+vl_hog_get_height (VlHog * self)
+{
+  return self->hogHeight ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @internal @brief Prepare internal buffers
+ ** @param self HOG object.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param cellSize size of a HOG cell.
+ **/
+
+static void
+vl_hog_prepare_buffers (VlHog * self, vl_size width, vl_size height, vl_size cellSize)
+{
+  vl_size hogWidth = (width + cellSize/2) / cellSize ;
+  vl_size hogHeight = (height + cellSize/2) / cellSize ;
+
+  assert(width > 3) ;
+  assert(height > 3) ;
+  assert(hogWidth > 0) ;
+  assert(hogHeight > 0) ;
+
+  if (self->hog &&
+      self->hogWidth == hogWidth &&
+      self->hogHeight == hogHeight) {
+    /* a suitable buffer is already allocated */
+    memset(self->hog, 0, sizeof(float) * hogWidth * hogHeight * self->numOrientations * 2) ;
+    memset(self->hogNorm, 0, sizeof(float) * hogWidth * hogHeight) ;
+    return ;
+  }
+
+  if (self->hog) {
+    vl_free(self->hog) ;
+    self->hog = NULL ;
+  }
+
+  if (self->hogNorm) {
+    vl_free(self->hogNorm) ;
+    self->hogNorm = NULL ;
+  }
+
+  self->hog = vl_calloc(hogWidth * hogHeight * self->numOrientations * 2, sizeof(float)) ;
+  self->hogNorm = vl_calloc(hogWidth * hogHeight, sizeof(float)) ;
+  self->hogWidth = hogWidth ;
+  self->hogHeight = hogHeight ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Process features starting from an image
+ ** @param self HOG object.
+ ** @param image image to process.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param numChannels number of image channles.
+ ** @param cellSize size of a HOG cell.
+ **
+ ** The buffer @c hog must be a three-dimensional array.
+ ** The first two dimensions are @c (width + cellSize/2)/cellSize and
+ ** @c (height + cellSize/2)/cellSize, where divisions are integer.
+ ** This is approximately @c width/cellSize and @c height/cellSize,
+ ** adjusted so that the last cell is at least half contained in the
+ ** image.
+ **
+ ** The image @c width and @c height must be not smaller than three
+ ** pixels and not smaller than @c cellSize.
+ **/
+
+void
+vl_hog_put_image (VlHog * self,
+                  float const * image,
+                  vl_size width, vl_size height, vl_size numChannels,
+                  vl_size cellSize)
+{
+  vl_size hogStride ;
+  vl_size channelStride = width * height ;
+  vl_index x, y ;
+  vl_uindex k ;
+
+  assert(self) ;
+  assert(image) ;
+
+  /* clear features */
+  vl_hog_prepare_buffers(self, width, height, cellSize) ;
+  hogStride = self->hogWidth * self->hogHeight ;
+
+#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
+
+  /* compute gradients and map the to HOG cells by bilinear interpolation */
+  for (y = 1 ; y < (signed)height - 1 ; ++y) {
+    for (x = 1 ; x < (signed)width - 1 ; ++x) {
+      float gradx = 0 ;
+      float grady = 0 ;
+      float gradNorm ;
+      float orientationWeights [2] = {-1, -1} ;
+      vl_index orientationBins [2] = {-1, -1} ;
+      vl_index orientation = 0 ;
+      float hx, hy, wx1, wx2, wy1, wy2 ;
+      vl_index binx, biny, o ;
+
+      /*
+       Compute the gradient at (x,y). The image channel with
+       the maximum gradient at each location is selected.
+       */
+      {
+        float const * iter = image + y * width + x ;
+        float gradNorm2 = 0 ;
+        for (k = 0 ; k < numChannels ; ++k) {
+          float gradx_ = *(iter + 1) - *(iter - 1) ;
+          float grady_ = *(iter + width)  - *(iter - width) ;
+          float gradNorm2_ = gradx_ * gradx_ + grady_ * grady_ ;
+          if (gradNorm2_ > gradNorm2) {
+            gradx = gradx_ ;
+            grady = grady_ ;
+            gradNorm2 = gradNorm2_ ;
+          }
+          iter += channelStride ;
+        }
+        gradNorm = sqrtf(gradNorm2) ;
+      }
+
+      /*
+       Map the gradient to the closest and second closets orientation bins.
+       There are numOrientations orientation in the interval [0,pi).
+       The next numOriantations are the symmetric ones, for a total
+       of 2*numOrientation directed orientations.
+       */
+      for (k = 0 ; k < self->numOrientations ; ++k) {
+        float orientationScore_ = gradx * self->orientationX[k] +  grady * self->orientationY[k] ;
+        vl_index orientationBin_ = k ;
+        if (orientationScore_ < 0) {
+          orientationScore_ = - orientationScore_ ;
+          orientationBin_ += self->numOrientations ;
+        }
+        if (orientationScore_ > orientationWeights[0]) {
+          orientationBins[1] = orientationBins[0] ;
+          orientationWeights[1] = orientationWeights[0] ;
+          orientationBins[0] = orientationBin_ ; ;
+          orientationWeights[0] = orientationScore_ ;
+        } else if (orientationScore_ > orientationWeights[1]) {
+          orientationBins[1] = orientationBin_ ;
+          orientationWeights[1] = orientationScore_ ;
+        }
+      }
+
+      if (self->useBilinearOrientationAssigment) {
+        /* min(1.0,...) guards against small overflows causing NaNs */
+        float angle0 = acosf(VL_MIN(orientationWeights[0] / VL_MAX(gradNorm, 1e-10),1.0)) ;
+        orientationWeights[1] = angle0 / (VL_PI / self->numOrientations) ;
+        orientationWeights[0] = 1 - orientationWeights[1] ;
+      } else {
+        orientationWeights[0] = 1 ;
+        orientationBins[1] = -1 ;
+      }
+
+      for (o = 0 ; o < 2 ; ++o) {
+        float ow ;
+        /*
+         Accumulate the gradient. hx is the distance of the
+         pixel x to the cell center at its left, in units of cellSize.
+         With this parametrixation, a pixel on the cell center
+         has hx = 0, which gradually increases to 1 moving to the next
+         center.
+         */
+
+        orientation = orientationBins[o] ;
+        if (orientation < 0) continue ;
+
+        /*  (x - (w-1)/2) / w = (x + 0.5)/w - 0.5 */
+        hx = (x + 0.5) / cellSize - 0.5 ;
+        hy = (y + 0.5) / cellSize - 0.5 ;
+        binx = vl_floor_f(hx) ;
+        biny = vl_floor_f(hy) ;
+        wx2 = hx - binx ;
+        wy2 = hy - biny ;
+        wx1 = 1.0 - wx2 ;
+        wy1 = 1.0 - wy2 ;
+
+        ow = orientationWeights[o] ;
+
+        /*VL_PRINTF("%d %d - %d %d %f %f - %f %f %f %f - %d \n ",x,y,binx,biny,hx,hy,wx1,wx2,wy1,wy2,o);*/
+
+        if (binx >= 0 && biny >=0) {
+          at(binx,biny,orientation) += gradNorm * ow * wx1 * wy1 ;
+        }
+        if (binx < (signed)self->hogWidth - 1 && biny >=0) {
+          at(binx+1,biny,orientation) += gradNorm * ow * wx2 * wy1 ;
+        }
+        if (binx < (signed)self->hogWidth - 1 && biny < (signed)self->hogHeight - 1) {
+          at(binx+1,biny+1,orientation) += gradNorm * ow * wx2 * wy2 ;
+        }
+        if (binx >= 0 && biny < (signed)self->hogHeight - 1) {
+          at(binx,biny+1,orientation) += gradNorm * ow * wx1 * wy2 ;
+        }
+      } /* next o */
+    } /* next x */
+  } /* next y */
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Process features starting from a field in polar notation
+ ** @param self HOG object.
+ ** @param modulus image gradient modulus.
+ ** @param angle image gradient angle.
+ ** @param directed wrap the gradient angles at 2pi (directed) or pi (undirected).
+ ** @param width image width.
+ ** @param height image height.
+ ** @param cellSize size of a HOG cell.
+ **
+ ** The function behaves like ::vl_hog_put_image, but foregoes the internal
+ ** computation of the gradient field, allowing the user to specify
+ ** their own. Angles are measure clockwise, the y axis pointing downwards,
+ ** starting from the x axis (pointing to the right).
+ **/
+
+void vl_hog_put_polar_field (VlHog * self,
+                             float const * modulus,
+                             float const * angle,
+                             vl_bool directed,
+                             vl_size width, vl_size height,
+                             vl_size cellSize)
+{
+  vl_size hogStride ;
+  vl_index x, y, o ;
+  vl_index period = self->numOrientations * (directed ? 2 : 1) ;
+  double angleStep = VL_PI / self->numOrientations ;
+
+  assert(self) ;
+  assert(modulus) ;
+  assert(angle) ;
+
+  /* clear features */
+  vl_hog_prepare_buffers(self, width, height, cellSize) ;
+  hogStride = self->hogWidth * self->hogHeight ;
+
+#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
+#define atNorm(x,y) (self->hogNorm[(x) + (y) * self->hogWidth])
+
+  /* fill HOG cells from gradient field */
+  for (y = 0 ; y < (signed)height ; ++y) {
+    for (x = 0 ; x < (signed)width ; ++x) {
+      float ho, hx, hy, wo1, wo2, wx1, wx2, wy1, wy2 ;
+      vl_index bino, binx, biny ;
+      float orientationWeights [2] = {0,0} ;
+      vl_index orientationBins [2] = {-1,-1} ;
+      vl_index orientation = 0 ;
+      float thisAngle = *angle++ ;
+      float thisModulus = *modulus++ ;
+
+      if (thisModulus <= 0.0f) continue ;
+
+      /*  (x - (w-1)/2) / w = (x + 0.5)/w - 0.5 */
+
+      ho = (float)thisAngle / angleStep ;
+      bino = vl_floor_f(ho) ;
+      wo2 = ho - bino ;
+      wo1 = 1.0f - wo2 ;
+
+      while (bino < 0) { bino += self->numOrientations * 2 ; }
+
+      if (self->useBilinearOrientationAssigment) {
+        orientationBins[0] = bino % period ;
+        orientationBins[1] = (bino + 1) % period ;
+        orientationWeights[0] = wo1 ;
+        orientationWeights[1] = wo2 ;
+      } else {
+        orientationBins[0] = (bino + ((wo1 > wo2) ? 0 : 1)) % period ;
+        orientationWeights[0] = 1 ;
+        orientationBins[1] = -1 ;
+      }
+
+      for (o = 0 ; o < 2 ; ++o) {
+        /*
+         Accumulate the gradient. hx is the distance of the
+         pixel x to the cell center at its left, in units of cellSize.
+         With this parametrixation, a pixel on the cell center
+         has hx = 0, which gradually increases to 1 moving to the next
+         center.
+         */
+
+        orientation = orientationBins[o] ;
+        if (orientation < 0) continue ;
+
+        hx = (x + 0.5) / cellSize - 0.5 ;
+        hy = (y + 0.5) / cellSize - 0.5 ;
+        binx = vl_floor_f(hx) ;
+        biny = vl_floor_f(hy) ;
+        wx2 = hx - binx ;
+        wy2 = hy - biny ;
+        wx1 = 1.0 - wx2 ;
+        wy1 = 1.0 - wy2 ;
+
+        wx1 *= orientationWeights[o] ;
+        wx2 *= orientationWeights[o] ;
+        wy1 *= orientationWeights[o] ;
+        wy2 *= orientationWeights[o] ;
+
+        /*VL_PRINTF("%d %d - %d %d %f %f - %f %f %f %f - %d \n ",x,y,binx,biny,hx,hy,wx1,wx2,wy1,wy2,o);*/
+
+        if (binx >= 0 && biny >=0) {
+          at(binx,biny,orientation) += thisModulus * wx1 * wy1 ;
+        }
+        if (binx < (signed)self->hogWidth - 1 && biny >=0) {
+          at(binx+1,biny,orientation) += thisModulus * wx2 * wy1 ;
+        }
+        if (binx < (signed)self->hogWidth - 1 && biny < (signed)self->hogHeight - 1) {
+          at(binx+1,biny+1,orientation) += thisModulus * wx2 * wy2 ;
+        }
+        if (binx >= 0 && biny < (signed)self->hogHeight - 1) {
+          at(binx,biny+1,orientation) += thisModulus * wx1 * wy2 ;
+        }
+      } /* next o */
+    } /* next x */
+  } /* next y */
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Extract HOG features
+ ** @param self HOG object.
+ ** @param features HOG features (output).
+ **
+ ** This method is called after ::vl_hog_put_image or ::vl_hog_put_polar_field
+ ** in order to retrieve the computed HOG features. The buffer @c features must have the dimensions returned by
+ ** ::vl_hog_get_width, ::vl_hog_get_height, and ::vl_hog_get_dimension.
+ **/
+
+void
+vl_hog_extract (VlHog * self, float * features)
+{
+  vl_index x, y ;
+  vl_uindex k ;
+  vl_size hogStride = self->hogWidth * self->hogHeight ;
+
+  assert(features) ;
+
+#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
+#define atNorm(x,y) (self->hogNorm[(x) + (y) * self->hogWidth])
+
+  /*
+   Compute the squared L2 norm of the unoriented version of each HOG
+   cell histogram. The unoriented version is obtained by folding
+   the 2*numOrientations compotnent into numOrientations only.
+   */
+  {
+    float const * iter = self->hog ;
+    for (k = 0 ; k < self->numOrientations ; ++k) {
+      float * niter = self->hogNorm ;
+      float * niterEnd = self->hogNorm + self->hogWidth * self->hogHeight ;
+      vl_size stride = self->hogWidth*self->hogHeight*self->numOrientations ;
+      while (niter != niterEnd) {
+        float h1 = *iter ;
+        float h2 = *(iter + stride) ;
+        float h = h1 + h2 ;
+        *niter += h * h ;
+        niter++ ;
+        iter++ ;
+      }
+    }
+  }
+
+  /*
+   HOG block-normalisation.
+
+   The Dalal-Triggs implementation computes a normalized descriptor for
+   each block of 2x2 cells, by stacking the histograms of each cell
+   into a vector and L2-normalizing and truncating the result.
+   
+   Each block-level descriptor is then decomposed back into cells
+   and corresponding parts are stacked into cell-level descritpors.
+   Each HOG cell is contained in exactly
+   four 2x2 cell blocks. For example, the cell number 5 in the following
+   figure is contained in blocks 1245, 2356, 4578, 5689:
+
+   +---+---+---+
+   | 1 | 2 | 3 |
+   +---+---+---+
+   | 4 | 5 | 6 |
+   +---+---+---+
+   | 7 | 8 | 9 |
+   +---+---+---+
+
+   Hence, when block-level descriptors are decomposed back
+   into cells, each cell receives contributions from four blocks. So,
+   if each cell started with a D-dimensional histogram, it
+   ends up with a 4D dimesional descriptor vector.
+
+   Note however that this is just a convenient way of rewriting the 
+   blocks as per-cell contributions, but the block information
+   is unchanged. In particular, barring boundary effects,
+   in an array of H x W cells there are approximately HW blocks;
+   hence the L2 norm of all the blocks stacked is approximately HW
+   (because individual blocks are L2-normalized). Since this does
+   not change in the final HOG descriptor,
+   the L2 norm of the HOG descriptor of an image should be approximately
+   the same as the area of the image divided by the
+   area of a HOG cell. This can be used as a sanity check.
+
+   The UoCTTI variant differs in some non-negligible ways. First, 
+   it includes both oriented and unoriented histograms, as well
+   as four components capturing texture. Second, and most importantly, 
+   it merges the four chunks of block-level descirptors landing in
+   each cell into one by taking their average. This makes sense
+   because, ultimately, these four sub-descriptors are identical
+   to the original cell histogram, just with four different normalisations
+   applied.
+   */
+  {
+    float const * iter = self->hog ;
+    for (y = 0 ; y < (signed)self->hogHeight ; ++y) {
+      for (x = 0 ; x < (signed)self->hogWidth ; ++x) {
+
+        /* norm of upper-left, upper-right, ... cells */
+        vl_index xm = VL_MAX(x - 1, 0) ;
+        vl_index xp = VL_MIN(x + 1, (signed)self->hogWidth - 1) ;
+        vl_index ym = VL_MAX(y - 1, 0) ;
+        vl_index yp = VL_MIN(y + 1, (signed)self->hogHeight - 1) ;
+
+        double norm1 = atNorm(xm,ym) ;
+        double norm2 = atNorm(x,ym) ;
+        double norm3 = atNorm(xp,ym) ;
+        double norm4 = atNorm(xm,y) ;
+        double norm5 = atNorm(x,y) ;
+        double norm6 = atNorm(xp,y) ;
+        double norm7 = atNorm(xm,yp) ;
+        double norm8 = atNorm(x,yp) ;
+        double norm9 = atNorm(xp,yp) ;
+
+        double factor1, factor2, factor3, factor4 ;
+
+        double t1 = 0 ;
+        double t2 = 0 ;
+        double t3 = 0 ;
+        double t4 = 0 ;
+
+        float * oiter = features + x + self->hogWidth * y ;
+
+        /* each factor is the inverse of the l2 norm of one of the 2x2 blocks surrounding
+           cell x,y */
+#if 0
+        if (self->transposed) {
+          /* if the image is transposed, y and x are swapped */
+          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
+          factor3 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
+          factor2 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
+          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
+        } else {
+          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
+          factor2 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
+          factor3 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
+          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
+        }
+#else
+        /* as implemented in UOCTTI code */
+        if (self->transposed) {
+          /* if the image is transposed, y and x are swapped */
+          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
+          factor3 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
+          factor2 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
+          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
+        } else {
+          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
+          factor2 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
+          factor3 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
+          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
+        }
+#endif
+
+        for (k = 0 ; k < self->numOrientations ; ++k) {
+          double ha = iter[hogStride * k] ;
+          double hb = iter[hogStride * (k + self->numOrientations)] ;
+          double hc ;
+
+          double ha1 = factor1 * ha ;
+          double ha2 = factor2 * ha ;
+          double ha3 = factor3 * ha ;
+          double ha4 = factor4 * ha ;
+
+          double hb1 = factor1 * hb ;
+          double hb2 = factor2 * hb ;
+          double hb3 = factor3 * hb ;
+          double hb4 = factor4 * hb ;
+
+          double hc1 = ha1 + hb1 ;
+          double hc2 = ha2 + hb2 ;
+          double hc3 = ha3 + hb3 ;
+          double hc4 = ha4 + hb4 ;
+
+          ha1 = VL_MIN(0.2, ha1) ;
+          ha2 = VL_MIN(0.2, ha2) ;
+          ha3 = VL_MIN(0.2, ha3) ;
+          ha4 = VL_MIN(0.2, ha4) ;
+
+          hb1 = VL_MIN(0.2, hb1) ;
+          hb2 = VL_MIN(0.2, hb2) ;
+          hb3 = VL_MIN(0.2, hb3) ;
+          hb4 = VL_MIN(0.2, hb4) ;
+
+          hc1 = VL_MIN(0.2, hc1) ;
+          hc2 = VL_MIN(0.2, hc2) ;
+          hc3 = VL_MIN(0.2, hc3) ;
+          hc4 = VL_MIN(0.2, hc4) ;
+
+          t1 += hc1 ;
+          t2 += hc2 ;
+          t3 += hc3 ;
+          t4 += hc4 ;
+
+          switch (self->variant) {
+            case VlHogVariantUoctti :
+              ha = 0.5 * (ha1 + ha2 + ha3 + ha4) ;
+              hb = 0.5 * (hb1 + hb2 + hb3 + hb4) ;
+              hc = 0.5 * (hc1 + hc2 + hc3 + hc4) ;
+              *oiter = ha ;
+              *(oiter + hogStride * self->numOrientations) = hb ;
+              *(oiter + 2 * hogStride * self->numOrientations) = hc ;
+              break ;
+
+            case VlHogVariantDalalTriggs :
+              *oiter = hc1 ;
+              *(oiter + hogStride * self->numOrientations) = hc2 ;
+              *(oiter + 2 * hogStride * self->numOrientations) = hc3 ;
+              *(oiter + 3 * hogStride * self->numOrientations) = hc4 ;
+              break ;
+          }
+          oiter += hogStride ;
+
+        } /* next orientation */
+
+        switch (self->variant) {
+          case VlHogVariantUoctti :
+            oiter += 2 * hogStride * self->numOrientations ;
+            *oiter = (1.0f/sqrtf(18.0f)) * t1 ; oiter += hogStride ;
+            *oiter = (1.0f/sqrtf(18.0f)) * t2 ; oiter += hogStride ;
+            *oiter = (1.0f/sqrtf(18.0f)) * t3 ; oiter += hogStride ;
+            *oiter = (1.0f/sqrtf(18.0f)) * t4 ; oiter += hogStride ;
+            break ;
+
+          case VlHogVariantDalalTriggs :
+            break ;
+        }
+        ++iter ;
+      } /* next x */
+    } /* next y */
+  } /* block normalization */
+}
+
diff --git a/opensfm/src/third_party/vlfeat/vl/hog.h b/opensfm/src/third_party/vlfeat/vl/hog.h
new file mode 100644
index 000000000..0a513d41e
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/hog.h
@@ -0,0 +1,89 @@
+/** @file hog.h
+ ** @brief Histogram of Oriented Gradients (@ref hog)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+ Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+ All rights reserved.
+
+ This file is part of the VLFeat library and is made available under
+ the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_HOG_H
+#define VL_HOG_H
+
+#include "generic.h"
+
+enum VlHogVariant_ { VlHogVariantDalalTriggs, VlHogVariantUoctti } ;
+
+typedef enum VlHogVariant_ VlHogVariant ;
+
+struct VlHog_
+{
+  VlHogVariant variant ;
+  vl_size dimension ;
+  vl_size numOrientations ;
+  vl_bool transposed ;
+  vl_bool useBilinearOrientationAssigment ;
+
+  /* left-right flip permutation */
+  vl_index * permutation ;
+
+  /* glyphs */
+  float * glyphs ;
+  vl_size glyphSize ;
+
+  /* helper vectors */
+  float * orientationX ;
+  float * orientationY ;
+
+  /* buffers */
+  float * hog ;
+  float * hogNorm ;
+  vl_size hogWidth ;
+  vl_size hogHeight ;
+} ;
+
+typedef struct VlHog_ VlHog ;
+
+VL_EXPORT VlHog * vl_hog_new (VlHogVariant variant, vl_size numOrientations, vl_bool transposed) ;
+VL_EXPORT void vl_hog_delete (VlHog * self) ;
+VL_EXPORT void vl_hog_process (VlHog * self,
+                               float * features,
+                               float const * image,
+                               vl_size width, vl_size height, vl_size numChannels,
+                               vl_size cellSize) ;
+
+VL_EXPORT void vl_hog_put_image (VlHog * self,
+                                 float const * image,
+                                 vl_size width, vl_size height, vl_size numChannels,
+                                 vl_size cellSize) ;
+
+VL_EXPORT void vl_hog_put_polar_field (VlHog * self,
+                                       float const * modulus,
+                                       float const * angle,
+                                       vl_bool directed,
+                                       vl_size width, vl_size height, vl_size cellSize) ;
+
+VL_EXPORT void vl_hog_extract (VlHog * self, float * features) ;
+VL_EXPORT vl_size vl_hog_get_height (VlHog * self) ;
+VL_EXPORT vl_size vl_hog_get_width (VlHog * self) ;
+
+
+VL_EXPORT void vl_hog_render (VlHog const * self,
+                              float * image,
+                              float const * features,
+                              vl_size width,
+                              vl_size height) ;
+
+VL_EXPORT vl_size vl_hog_get_dimension (VlHog const * self) ;
+VL_EXPORT vl_index const * vl_hog_get_permutation (VlHog const * self) ;
+VL_EXPORT vl_size vl_hog_get_glyph_size (VlHog const * self) ;
+
+VL_EXPORT vl_bool vl_hog_get_use_bilinear_orientation_assignments (VlHog const * self) ;
+VL_EXPORT void vl_hog_set_use_bilinear_orientation_assignments (VlHog * self, vl_bool x) ;
+
+/* VL_HOG_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/homkermap.c b/opensfm/src/third_party/vlfeat/vl/homkermap.c
new file mode 100644
index 000000000..9113990fb
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/homkermap.c
@@ -0,0 +1,580 @@
+/** @file homkermap.c
+ ** @brief Homogeneous kernel map - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file homkermap.h
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@page homkermap Homogeneous kernel map
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+@ref homkermap.h implements the homogeneous kernel maps introduced in
+@cite{vedaldi10efficient},@cite{vedaldi12efficient}.  Such maps are
+efficient linear representations of popular kernels such as the
+intersection, $\chi^2$, and Jensen-Shannon ones.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section homkermap-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The homogeneous kernel map is implemented as an object of type
+::VlHomogeneousKernelMap. To use thois object, first create an
+instance by using ::vl_homogeneouskernelmap_new, then use
+::vl_homogeneouskernelmap_evaluate_d or
+::vl_homogeneouskernelmap_evaluate_f (depdening on whether the data is
+@c double or @c float) to compute the feature map $ \Psi(x)
+$. When done, dispose of the object by calling
+::vl_homogeneouskernelmap_delete.
+
+@code
+double gamma = 1.0 ;
+int order = 1 ;
+double period = -1 ; // use default
+double psi [3] ;
+vl_size psiStride = 1 ;
+double x = 0.5 ;
+VlHomogeneousKernelMap * hom = vl_homogeneouskernelmap_new(
+  VlHomogeneousKernelChi2, gamma, order, period,
+  VlHomogeneousKernelMapWindowRectangular) ;
+vl_homogeneouskernelmap_evaluate_d(hom, psi, psiStride, x) ;
+vl_homogeneouskernelmap_delete(x) ;
+@endcode
+
+The constructor ::vl_homogeneouskernelmap_new takes the kernel type @c
+kernel (see ::VlHomogeneousKernelType), the homogeneity order @c gamma
+(use one for the standard $1$-homogeneous kernels), the approximation
+order @c order (usually order one is enough), the period @a period
+(use a negative value to use the default period), and a window type @c
+window (use ::VlHomogeneousKernelMapWindowRectangular if unsure). The
+approximation order trades off the quality and dimensionality of the
+approximation. The resulting feature map $ \Psi(x) $, computed by
+::vl_homogeneouskernelmap_evaluate_d or
+::vl_homogeneouskernelmap_evaluate_f , is <code>2*order+1</code>
+dimensional.
+
+The code pre-computes the map $ \Psi(x) $ for efficient
+evaluation. The table spans values of $ x $ in the range
+$[2^{-20}, 2^{8}) $. In particular, values smaller than $
+2^{-20} $ are treated as zeroes (which results in a null feature).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section homkermap-fundamentals Fundamentals
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+The <em>homogeneous kernel map</em> is a finite dimensional linear
+approximation of homogeneous kernels, including the intersection,
+$\chi^2$, and Jensen-Shannon kernels. These kernels are frequently
+used in computer vision applications because they are particular
+suited to data in the format of histograms, which includes many common
+visual descriptors.
+
+Let $x,y \in \mathbb{R}_+$ be non-negative scalars and let $k(x,y) \in
+\mathbb{R}$ be an homogeneous kernel such as the $\chi^2$ and or the
+intersection ones:
+
+@f[
+  k_{\mathrm{inters}}(x,y) = \min\{x, y\},
+  \quad
+  k_{\chi^2}(x,y) = 2 \frac{(x - y)^2}{x+y}.
+@f]
+
+For vectorial data $ \mathbf{x},\mathbf{y} \in \mathbb{R}_+^d $, the
+homogeneous kernels is defined as an <em>additive combination</em> of
+scalar kernels $K(\mathbf{x},\mathbf{y}) = \sum_{i=1}^d k(x_i,y_i)$.
+
+The <em>homogeneous kernel map</em> of order $n$ is a vector function
+$\Psi(x) \in \mathbb{R}^{2n+1}$ such that, for any choice of $x, y \in
+\mathbb{R}_+$, the following approximation holds:
+
+@f[
+  k(x,y) \approx \langle \Psi(x), \Psi(y) \rangle.
+@f]
+
+Given the feature map for the scalar case, the corresponding feature
+map $\Psi(\mathbf{x})$ for the vectorial case is obtained by stacking
+$[\Psi(x_1), \dots, \Psi(x_n)]$.  Note that the stacked feature
+$\Psi(\mathbf{x})$ has dimension $d(2n+1)$.
+
+Using linear analysis tools (e.g. a linear support vector machine)
+on top of dataset that has been encoded by the homogeneous kernel map
+is therefore approximately equivalent to using a method based
+on the corresponding non-linear kernel.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection homkermap-overview-negative Extension to the negative reals
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+Any positive (semi-)definite kernel $k(x,y)$ defined on the
+non-negative reals $x,y \in \mathbb{R}_+$ can be extended to the
+entire real line by using the definition:
+
+@f[
+k_\pm(x,y) = \operatorname{sign}(x) \operatorname{sign}(y) k(|x|,|y|).
+@f]
+
+The homogeneous kernel map implements this extension by defining
+$\Psi_\pm(x) = \operatorname{sign}(x) \Psi(|x|)$. Note that other
+extensions are possible, such as
+
+@f[
+k_\pm(x,y) = H(xy) \operatorname{sign}(y) k(|x|,|y|)
+@f]
+
+where $H$ is the Heaviside function, but may result in higher
+dimensional feature maps.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection homkermap-overview-homogeneity Homogeneity degree
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+Any (1-)homogeneous kernel $k_1(x,y)$ can be extended to a so called
+$\gamma$-homgeneous kernel $k_\gamma(x,y)$ by the definition
+
+@f[
+  k_\gamma(x,y) = (xy)^{\frac{\gamma}{2}} \frac{k_1(x,y)}{\sqrt{xy}}
+@f]
+
+Smaller values of $\gamma$ enhance the kernel non-linearity and are
+sometimes beneficial in applications (see
+@cite{vedaldi10efficient},@cite{vedaldi12efficient} for details).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@subsection homkermap-overview-window Windowing and period
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+This section discusses aspects of the homogeneous kernel map which are
+more technical and may be skipped. The homogeneous kernel map
+approximation is based on periodizing the kernel; given the kernel
+signature
+
+@f[
+    \mathcal{K}(\lambda) = k(e^{\frac{\lambda}{2}}, e^{-\frac{\lambda}{2}})
+@f]
+
+the homogeneous kernel map is a feature map for the windowed and
+periodized kernel whose signature is given by
+
+@f[
+   \hat{\mathcal{K}}(\lambda)
+   =
+   \sum_{i=-\infty}^{+\infty} \mathcal{K}(\lambda + k \Lambda) W(\lambda + k \Lambda)
+@f]
+
+where $W(\lambda)$ is a windowing function and $\Lambda$ is the
+period. This implementation of the homogeneous kernel map supports the
+use of a <em>uniform window</em> ($ W(\lambda) = 1 $) or of a
+<em>rectangular window</em> ($ W(\lambda) =
+\operatorname{rect}(\lambda/\Lambda) $). Note that $ \lambda =
+\log(y/x) $ is equal to the logarithmic ratio of the arguments of the
+kernel. Empirically, the rectangular window seems to have a slight
+edge in applications.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section homkermap-details Implementation details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+This implementation uses the expressions given in
+@cite{vedaldi10efficient},@cite{vedaldi11efficient} to compute in
+closed form the maps $\Psi(x)$ for the supported kernel types. For
+efficiency reasons, it precomputes $\Psi(x)$ for a large range of
+values of the argument when the homogeneous kernel map object is
+created.
+
+The internal table stores $\Psi(x) \in \mathbb{R}^{2n+1}$ by sampling
+$x\geq 0$. This uses the internal decomposition of IEEE floating point
+representations (@c float and @c double) in mantissa and exponent:
+<pre>
+  x = mantissa * (2**exponent),
+  minExponent <= exponent <= maxExponent,
+  1 <= matnissa < 2.
+</pre>
+Each octave is further sampled in @c numSubdivisions sublevels.
+
+When the map $\Psi(x)$ is evaluated, @c x is decomposed again into
+exponent and mantissa to index the table. The output is obtained by
+bilinear interpolation from the appropriate table entries.
+
+**/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_HOMKERMAP_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+#include "homkermap.h"
+#include "mathop.h"
+#include <math.h>
+
+struct _VlHomogeneousKernelMap
+{
+  VlHomogeneousKernelType kernelType ;
+  double gamma ;
+  VlHomogeneousKernelMapWindowType windowType ;
+  vl_size order ;
+  double period ;
+  vl_size numSubdivisions ;
+  double subdivision  ;
+  vl_index minExponent ;
+  vl_index maxExponent ;
+  double * table ;
+} ;
+
+/** @internal @brief Sample the kernel specturm
+ ** @param self homogeneous kernel map.
+ ** @param omega sampling frequency.
+ ** @return the spectrum sampled at @a omega.
+ **/
+
+VL_INLINE double
+vl_homogeneouskernelmap_get_spectrum (VlHomogeneousKernelMap const * self, double omega)
+{
+  assert (self) ;
+  switch (self->kernelType) {
+    case VlHomogeneousKernelIntersection:
+      return (2.0 / VL_PI) / (1 + 4 * omega*omega) ;
+    case VlHomogeneousKernelChi2:
+      return 2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) ;
+    case VlHomogeneousKernelJS:
+      return (2.0 / log(4.0)) *
+      2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) /
+      (1 + 4 * omega*omega) ;
+    default:
+      abort() ;
+  }
+}
+
+/* helper */
+VL_INLINE double sinc(double x)
+{
+  if (x == 0.0) return 1.0 ;
+  return sin(x) / x ;
+}
+
+/** @internal @brief Sample the smoothed kernel spectrum
+ ** @param self homogeneous kernel map.
+ ** @param omega sampling frequency.
+ ** @return the spectrum sampled at @a omega after smoothing.
+ **/
+
+VL_INLINE double
+vl_homogeneouskernelmap_get_smooth_spectrum (VlHomogeneousKernelMap const * self, double omega)
+{
+  double kappa_hat = 0 ;
+  double omegap ;
+  double epsilon = 1e-2 ;
+  double const omegaRange = 2.0 / (self->period * epsilon) ;
+  double const domega = 2 * omegaRange / (2 * 1024.0 + 1) ;
+  assert (self) ;
+  switch (self->windowType) {
+    case VlHomogeneousKernelMapWindowUniform:
+      kappa_hat = vl_homogeneouskernelmap_get_spectrum(self, omega) ;
+      break ;
+    case VlHomogeneousKernelMapWindowRectangular:
+      for (omegap = - omegaRange ; omegap <= omegaRange ; omegap += domega) {
+        double win = sinc((self->period/2.0) * omegap) ;
+        win *= (self->period/(2.0*VL_PI)) ;
+        kappa_hat += win * vl_homogeneouskernelmap_get_spectrum(self, omegap + omega) ;
+      }
+      kappa_hat *= domega ;
+      /* project on the postivie orthant (see PAMI) */
+      kappa_hat = VL_MAX(kappa_hat, 0.0) ;
+      break ;
+    default:
+      abort() ;
+  }
+  return kappa_hat ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                     Constructors and destructors */
+/* ---------------------------------------------------------------- */
+
+/** @brief Create a new homgeneous kernel map
+ ** @param kernelType type of homogeneous kernel.
+ ** @param gamma kernel homogeneity degree.
+ ** @param order approximation order.
+ ** @param period kernel period.
+ ** @param windowType type of window used to truncate the kernel.
+ ** @return the new homogeneous kernel map.
+ **
+ ** The function intializes a new homogeneous kernel map for the
+ ** specified kernel type, homogeneity degree, approximation order,
+ ** period, and truncation window. See @ref homkermap-fundamentals for
+ ** details.
+ **
+ ** The homogeneity degree @c gamma must be positive (the standard
+ ** kernels are obtained by setting @c gamma to 1). When unsure, set
+ ** @c windowType to ::VlHomogeneousKernelMapWindowRectangular. The @c
+ ** period should be non-negative; specifying a negative or null value
+ ** causes the function to switch to a default value.
+ **
+ ** The function returns @c NULL if there is not enough free memory.
+ **/
+
+VlHomogeneousKernelMap *
+vl_homogeneouskernelmap_new (VlHomogeneousKernelType kernelType,
+                             double gamma,
+                             vl_size order,
+                             double period,
+                             VlHomogeneousKernelMapWindowType windowType)
+{
+  int tableWidth, tableHeight ;
+  VlHomogeneousKernelMap * self = vl_malloc(sizeof(VlHomogeneousKernelMap)) ;
+  if (! self) return NULL ;
+
+  assert(gamma > 0) ;
+
+  assert(kernelType == VlHomogeneousKernelIntersection ||
+         kernelType == VlHomogeneousKernelChi2 ||
+         kernelType == VlHomogeneousKernelJS) ;
+
+  assert(windowType == VlHomogeneousKernelMapWindowUniform ||
+         windowType == VlHomogeneousKernelMapWindowRectangular) ;
+
+  if (period < 0) {
+    switch (windowType) {
+    case VlHomogeneousKernelMapWindowUniform:
+      switch (kernelType) {
+      case VlHomogeneousKernelChi2:         period = 5.86 * sqrt(order + 0)  + 3.65 ; break ;
+      case VlHomogeneousKernelJS:           period = 6.64 * sqrt(order + 0)  + 7.24 ; break ;
+      case VlHomogeneousKernelIntersection: period = 2.38 * log(order + 0.8) + 5.6 ; break ;
+      }
+      break ;
+    case VlHomogeneousKernelMapWindowRectangular:
+      switch (kernelType) {
+      case VlHomogeneousKernelChi2:         period = 8.80 * sqrt(order + 4.44) - 12.6 ; break ;
+      case VlHomogeneousKernelJS:           period = 9.63 * sqrt(order + 1.00) - 2.93;  break ;
+      case VlHomogeneousKernelIntersection: period = 2.00 * log(order + 0.99)  + 3.52 ; break ;
+      }
+      break ;
+    }
+    period = VL_MAX(period, 1.0) ;
+  }
+
+  self->kernelType = kernelType ;
+  self->windowType = windowType ;
+  self->gamma = gamma ;
+  self->order = order ;
+  self->period = period ;
+  self->numSubdivisions = 8 + 8*order ;
+  self->subdivision = 1.0 / self->numSubdivisions ;
+  self->minExponent = -20 ;
+  self->maxExponent = 8 ;
+
+  tableHeight = (int) (2*self->order + 1) ;
+  tableWidth = (int) (self->numSubdivisions * (self->maxExponent - self->minExponent + 1)) ;
+  self->table = vl_malloc (sizeof(double) *
+                           (tableHeight * tableWidth + 2*(1+self->order))) ;
+  if (! self->table) {
+    vl_free(self) ;
+    return NULL ;
+  }
+
+  {
+    vl_index exponent ;
+    vl_uindex i, j ;
+    double * tablep = self->table ;
+    double * kappa = self->table + tableHeight * tableWidth ;
+    double * freq = kappa + (1+self->order) ;
+    double L = 2.0 * VL_PI / self->period ;
+
+    /* precompute the sampled periodicized spectrum */
+    j = 0 ;
+    i = 0 ;
+    while (i <= self->order) {
+      freq[i] = j ;
+      kappa[i] = vl_homogeneouskernelmap_get_smooth_spectrum(self, j * L) ;
+      ++ j ;
+      if (kappa[i] > 0 || j >= 3*i) ++ i ;
+    }
+
+    /* fill table */
+    for (exponent  = self->minExponent ;
+         exponent <= self->maxExponent ; ++ exponent) {
+
+      double x, Lxgamma, Llogx, xgamma ;
+      double sqrt2kappaLxgamma ;
+      double mantissa = 1.0 ;
+
+      for (i = 0 ; i < self->numSubdivisions ;
+           ++i, mantissa += self->subdivision) {
+        x = ldexp(mantissa, (int)exponent) ;
+        xgamma = pow(x, self->gamma) ;
+        Lxgamma = L * xgamma ;
+        Llogx = L * log(x) ;
+
+        *tablep++ = sqrt(Lxgamma * kappa[0]) ;
+        for (j = 1 ; j <= self->order ; ++j) {
+          sqrt2kappaLxgamma = sqrt(2.0 * Lxgamma * kappa[j]) ;
+          *tablep++ = sqrt2kappaLxgamma * cos(freq[j] * Llogx) ;
+          *tablep++ = sqrt2kappaLxgamma * sin(freq[j] * Llogx) ;
+        }
+      } /* next mantissa */
+    } /* next exponent */
+  }
+  return self ;
+}
+
+/** @brief Delete an object instance.
+ ** @param self object.
+ ** The function deletes the specified map object.
+ **/
+
+void
+vl_homogeneouskernelmap_delete (VlHomogeneousKernelMap * self)
+{
+  vl_free(self->table) ;
+  self->table = NULL ;
+  vl_free(self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                     Retrieve data and parameters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get the map order.
+ ** @param self object.
+ ** @return the map order.
+ **/
+
+vl_size
+vl_homogeneouskernelmap_get_order (VlHomogeneousKernelMap const * self)
+{
+  assert(self) ;
+  return self->order ;
+}
+
+/** @brief Get the map dimension.
+ ** @param self object.
+ ** @return the map dimension (2 @c order  +1).
+ **/
+
+vl_size
+vl_homogeneouskernelmap_get_dimension (VlHomogeneousKernelMap const * self)
+{
+  assert(self) ;
+  return 2 * self->order + 1 ;
+}
+
+/** @brief Get the kernel type.
+ ** @param self object.
+ ** @return kernel type.
+ **/
+
+VlHomogeneousKernelType
+vl_homogeneouskernelmap_get_kernel_type (VlHomogeneousKernelMap const * self)
+{
+  assert(self) ;
+  return self->kernelType ;
+}
+
+/** @brief Get the window type.
+ ** @param self object.
+ ** @return window type.
+ **/
+
+VlHomogeneousKernelMapWindowType
+vl_homogeneouskernelmap_get_window_type (VlHomogeneousKernelMap const * self)
+{
+  assert(self) ;
+  return self->windowType ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                     Process data */
+/* ---------------------------------------------------------------- */
+
+/** @fn ::vl_homogeneouskernelmap_evaluate_d(VlHomogeneousKernelMap const*,double*,vl_size,double)
+ ** @brief Evaluate map
+ ** @param self map object.
+ ** @param destination output buffer.
+ ** @param stride stride of the output buffer.
+ ** @param x value to expand.
+ **
+ ** The function evaluates the feature map on @a x and stores the
+ ** resulting <code>2*order+1</code> dimensional vector to
+ ** @a destination[0], @a destination[stride], @a destination[2*stride], ....
+ **/
+
+/** @fn ::vl_homogeneouskernelmap_evaluate_f(VlHomogeneousKernelMap const*,float*,vl_size,double)
+ ** @copydetails ::vl_homogeneouskernelmap_evaluate_d(VlHomogeneousKernelMap const*,double*,vl_size,double)
+ **/
+
+#define FLT VL_TYPE_FLOAT
+#define VL_HOMKERMAP_INSTANTIATING
+#include "homkermap.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define VL_HOMKERMAP_INSTANTIATING
+#include "homkermap.c"
+
+/* VL_HOMKERMAP_INSTANTIATING */
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifdef VL_HOMKERMAP_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+#include "float.h"
+
+void
+VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)
+(VlHomogeneousKernelMap const * self,
+ T * destination,
+ vl_size stride,
+ double x)
+{
+  /* break value into exponent and mantissa */
+  int exponent ;
+  int unsigned j ;
+  double mantissa = frexp(x, &exponent) ;
+  double sign = (mantissa >= 0.0) ? +1.0 : -1.0 ;
+  mantissa *= 2*sign ;
+  exponent -- ;
+
+  if (mantissa == 0 ||
+      exponent <= self->minExponent ||
+      exponent >= self->maxExponent) {
+    for (j = 0 ; j < 2*self->order+1 ; ++j) {
+      *destination = (T) 0.0 ;
+      destination += stride ;
+    }
+    return  ;
+  }
+  {
+    vl_size featureDimension = 2*self->order + 1 ;
+    double const * v1 = self->table +
+    (exponent - self->minExponent) * self->numSubdivisions * featureDimension ;
+    double const * v2 ;
+    double f1, f2 ;
+
+    mantissa -= 1.0 ;
+    while (mantissa >= self->subdivision) {
+      mantissa -= self->subdivision ;
+      v1 += featureDimension ;
+    }
+    v2 = v1 + featureDimension ;
+    for (j = 0 ; j < featureDimension ; ++j) {
+      f1 = *v1++ ;
+      f2 = *v2++ ;
+      *destination = (T) sign * ((f2 - f1) * (self->numSubdivisions * mantissa) + f1) ;
+      destination += stride ;
+    }
+  }
+}
+
+#undef FLT
+#undef VL_HOMKERMAP_INSTANTIATING
+/* VL_HOMKERMAP_INSTANTIATING */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/homkermap.h b/opensfm/src/third_party/vlfeat/vl/homkermap.h
new file mode 100644
index 000000000..e16a7167e
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/homkermap.h
@@ -0,0 +1,86 @@
+/** @file homkermap.h
+ ** @brief Homogeneous kernel map (@ref homkermap)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_HOMKERMAP_H
+#define VL_HOMKERMAP_H
+
+#include "generic.h"
+
+#include <math.h>
+
+/** @brief Type of kernel */
+typedef enum {
+  VlHomogeneousKernelIntersection = 0, /**< intersection kernel */
+  VlHomogeneousKernelChi2, /**< Chi2 kernel */
+  VlHomogeneousKernelJS /**< Jensen-Shannon kernel */
+} VlHomogeneousKernelType ;
+
+/** @brief Type of spectral windowing function  */
+typedef enum {
+  VlHomogeneousKernelMapWindowUniform = 0, /**< uniform window */
+  VlHomogeneousKernelMapWindowRectangular = 1, /**< rectangular window */
+} VlHomogeneousKernelMapWindowType ;
+
+#ifndef __DOXYGEN__
+struct _VlHomogeneousKernelMap ;
+typedef struct _VlHomogeneousKernelMap VlHomogeneousKernelMap ;
+#else
+/** @brief Homogeneous kernel map object */
+typedef OPAQUE VlHomogeneousKernelMap ;
+#endif
+
+/** @name Create and destroy
+ ** @{ */
+VL_EXPORT VlHomogeneousKernelMap *
+vl_homogeneouskernelmap_new (VlHomogeneousKernelType kernelType,
+                             double gamma,
+                             vl_size order,
+                             double period,
+                             VlHomogeneousKernelMapWindowType windowType) ;
+VL_EXPORT void
+vl_homogeneouskernelmap_delete (VlHomogeneousKernelMap * self) ;
+/** @} */
+
+/** @name Process data
+ ** @{ */
+VL_EXPORT void
+vl_homogeneouskernelmap_evaluate_d (VlHomogeneousKernelMap const * self,
+                                    double * destination,
+                                    vl_size stride,
+                                    double x) ;
+
+VL_EXPORT void
+vl_homogeneouskernelmap_evaluate_f (VlHomogeneousKernelMap const * self,
+                                    float * destination,
+                                    vl_size stride,
+                                    double x) ;
+/** @} */
+
+
+/** @name Retrieve data and parameters
+ ** @{ */
+VL_EXPORT vl_size
+vl_homogeneouskernelmap_get_order (VlHomogeneousKernelMap const * self) ;
+
+VL_EXPORT vl_size
+vl_homogeneouskernelmap_get_dimension (VlHomogeneousKernelMap const * self) ;
+
+VL_EXPORT VlHomogeneousKernelType
+vl_homogeneouskernelmap_get_kernel_type (VlHomogeneousKernelMap const * self) ;
+
+VL_EXPORT VlHomogeneousKernelMapWindowType
+vl_homogeneouskernelmap_get_window_type (VlHomogeneousKernelMap const * self) ;
+/** @} */
+
+/* VL_HOMKERMAP_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/host.c b/opensfm/src/third_party/vlfeat/vl/host.c
new file mode 100644
index 000000000..50a0f0f40
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/host.c
@@ -0,0 +1,586 @@
+/** @file host.c
+ ** @brief Host - Definition
+ ** @author Andrea Vedaldi
+ ** @see @ref portability
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page portability Portability features
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Platform dependent details are isolated in the @ref host.h.  This
+module provides functionalities to identify the host operating system,
+C compiler, and CPU architecture. It also provides a few features to
+abstract from such details.
+
+@see http://predef.sourceforge.net/index.php
+@see http://en.wikipedia.org/wiki/64-bit_computing
+
+@section host-os Host operating system
+
+The module defines a symbol to identify the host operating system:
+::VL_OS_WIN for Windows, ::VL_OS_LINUX for Linux, ::VL_OS_MACOSX for
+Mac OS X, and so on.
+
+@section host-compiler Host compiler
+
+The module defines a symbol to identify the host compiler:
+::VL_COMPILER_MSC for Microsoft Visual C++, ::VL_COMPILER_GNUC for
+GNU C, and so on. The (integer) value of such symbols corresponds the
+version of the compiler.
+
+The module defines a symbol to identify the data model of the
+compiler: ::VL_COMPILER_ILP32, ::VL_COMPILER_LP64, or
+::VL_COMPILER_LLP64 (see Sect. @ref host-compiler-data-model).  For
+convenience, it also defines a number of atomic types of prescribed
+width (::vl_int8, ::vl_int16, ::vl_int32, etc.).
+
+@remark While some of such functionalities are provided by the
+standard header @c stdint.h, the latter is not supported by all
+platforms.
+
+@subsection host-compiler-data-model Data models
+
+The C language defines a number of atomic data types (such as @c char,
+@c short, @c int and so on). The number of bits (width) used to
+represent each data type depends on the compiler data model. The
+different models are *ILP32* (@c int, @c long, and pointer 32 bit),
+*LP64* (@c int 32 bit, @c long and pointer 64 bit), *ILP64* (@c int,
+@c long, and pointer 64 bit), and *LLP64* (@c int, @c long 32 bit and
+pointer 64 -- and `long long` -- 64 bit). Note in particular that
+`long long` is 64 bit in all models of interest. The following table
+summarizes them:
+
+<table><caption><b>Compiler data models.</b> </caption>
+<tr style="font-weight:bold;">
+<td>Data model</td>
+<td><code>short</code></td>
+<td><code>int</code></td>
+<td><code>long</code></td>
+<td><code>long long</code></td>
+<td><code>void*</code></td>
+<td>Compiler</td>
+</tr>
+<tr>
+<td>ILP32</td>
+<td style="background-color:#ffa;">16</td>
+<td style="background-color:#afa;">32</td>
+<td style="background-color:#afa;">32</td>
+<td>64</td>
+<td style="background-color:#afa;">32</td>
+<td>Most 32 bit architectures.</td>
+</tr>
+<tr>
+<td>LP64</td>
+<td style="background-color:#ffa;">16</td>
+<td style="background-color:#afa;">32</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td>UNIX-64 (Linux, Mac OS X)</td>
+</tr>
+<tr>
+<td>ILP64</td>
+<td style="background-color:#ffa;">16</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td>Alpha, Cray</td>
+</tr>
+<tr>
+<td>SLIP64</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td>64</td>
+<td></td>
+</tr>
+<tr>
+<td>LLP64</td>
+<td style="background-color:#ffa;">16</td>
+<td style="background-color:#afa;">32</td>
+<td style="background-color:#afa;">32</td>
+<td>64</td>
+<td>64</td>
+<td>Windows-64</td>
+</tr>
+</table>
+
+Macros such as ::VL_UINT32_C can be used to generate integer literal
+with the correct suffix for a type of a given width.
+
+@subsection host-compiler-other Other compiler-specific features
+
+The module provides the macro ::VL_EXPORT to declare symbols exported
+from the library and the macro ::VL_INLINE to declare inline
+functions.  Such features are not part of the C89 standard, and
+change depending on the compiler.
+
+@par "Example:"
+The following header file declares a function @c f that
+should be visible from outside the library.
+@code
+#include <vl/generic.h>
+VL_EXPORT void f () ;
+VL_EXPORT int i ;
+@endcode
+Notice that the macro ::VL_EXPORT needs not to be included again
+when the function is defined.
+
+@par "Example:"
+The following header file declares an inline function @c f:
+@code
+#include <vl/generic.h>
+VL_INLINE int f() ;
+
+VL_INLINE int f() { return 1 ; }
+@endcode
+
+Here the first instruction defines the function @c f, where the
+second declares it. Notice that since this is an inline function, its
+definition must be found in the header file rather than in an
+implementation file.  Notice also that definition and declaration can
+be merged.
+
+These macros translate according to the following tables:
+
+<table class="doxtable" style="font-size:70%;">
+<caption>Macros for exporting library symbols</caption>
+<tr>
+<td>Platform</td>
+<td>Macro name</td>
+<td>Value when building the library</td>
+<td>Value when importing the library</td>
+</tr>
+<tr>
+<td>Unix/GCC</td>
+<td>::VL_EXPORT</td>
+<td>empty (assumes <c>-visibility=hidden</c> GCC option)</td>
+<td><c>__attribute__((visibility ("default")))</c></td>
+</tr>
+<tr>
+<td>Win/Visual C++</td>
+<td>::VL_EXPORT</td>
+<td>@c __declspec(dllexport)</td>
+<td>@c __declspec(dllimport)</td>
+</tr>
+</table>
+
+<table class="doxtable" style="font-size:70%;">
+<caption>Macros for declaring inline functions</caption>
+<tr>
+<td>Platform</td>
+<td>Macro name</td>
+<td>Value</td>
+</tr>
+<tr>
+<td>Unix/GCC</td>
+<td>::VL_INLINE</td>
+<td>static inline</td>
+</tr>
+<tr>
+<td>Win/Visual C++</td>
+<td>::VL_INLINE</td>
+<td>static __inline</td>
+</tr>
+</table>
+
+@section host-arch Host CPU architecture
+
+The module defines a symbol to identify the host CPU architecture:
+::VL_ARCH_IX86 for Intel x86, ::VL_ARCH_IA64 for Intel 64, and so on.
+
+@subsection host-arch-endianness Endianness
+
+The module defines a symbol to identify the host CPU endianness:
+::VL_ARCH_BIG_ENDIAN for big endian and ::VL_ARCH_LITTLE_ENDIAN for
+little endian. The functions ::vl_swap_host_big_endianness_8(),
+::vl_swap_host_big_endianness_4(), ::vl_swap_host_big_endianness_2()
+to change the endianness of data (from/to host and network order).
+
+Recall that <em>endianness</em> concerns the way multi-byte data
+types (such as 16, 32 and 64 bits integers) are stored into the
+addressable memory.  All CPUs uses a contiguous address range to
+store atomic data types (e.g. a 16-bit integer could be assigned to
+the addresses <c>0x10001</c> and <c>0x10002</c>), but the order may
+differ.
+
+- The convention is <em>big endian</em>, or in <em>network
+  order</em>, if the most significant byte of the multi-byte data
+  types is assigned to the smaller memory address. This is the
+  convention used for instance by the PPC architecture.
+
+- The convention is <em>little endian</em> if the least significant
+  byte is assigned to the smaller memory address. This is the
+  convention used for instance by the x86 architecture.
+
+@remark The names &ldquo;big endian&rdquo; and &ldquo;little
+endian&rdquo; are a little confusing. &ldquo;Big endian&rdquo; means
+&ldquo;big endian first&rdquo;, i.e.  the address of the most
+significant byte comes first. Similarly, &ldquo;little endian&rdquo;
+means &ldquo;little endian first&rdquo;, in the sense that the
+address of the least significant byte comes first.
+
+Endianness is a concern when data is either exchanged with processors
+that use different conventions, transmitted over a network, or stored
+to a file. For the latter two cases, one usually saves data in big
+endian (network) order regardless of the host CPU.
+
+@section host-threads Multi-threading
+
+The file defines #VL_THREADS_WIN if multi-threading support is
+enabled and the host supports Windows threads and #VL_THREADS_POSIX if
+it supports POSIX threads.
+**/
+
+/** @def VL_OS_LINUX
+ ** @brief Defined if the host operating system is Linux.
+ **/
+
+/** @def VL_OS_MACOSX
+ ** @brief Defined if the host operating system is Mac OS X.
+ **/
+
+/** @def VL_OS_WIN
+ ** @brief Defined if the host operating system is Windows (32 or 64)
+ **/
+
+/** @def VL_OS_WIN64
+ ** @brief Defined if the host operating system is Windows-64.
+ **/
+
+/** @def VL_COMPILER_GNUC
+ ** @brief Defined if the host compiler is GNU C.
+ **
+ ** This macro is defined if the compiler is GNUC.
+ ** Its value is calculated as
+ ** @code
+ ** 10000 * MAJOR + 100 * MINOR + PATCHLEVEL
+ ** @endcode
+ ** @see @ref host-compiler
+ **/
+
+/** @def VL_COMPILER_MSC
+ ** @brief Defined if the host compiler is Microsoft Visual C++.
+ ** @see @ref host-compiler
+ **/
+
+/** @def VL_COMPILER_LCC
+ ** @brief Defined if the host compiler is LCC.
+ ** @deprecated The LCC is not supported anymore.
+ ** @see @ref host-compiler
+ **/
+
+/** @def VL_COMPILER_LLP64
+ ** @brief Defined if the host compiler data model is LLP64.
+ ** @see @ref host-compiler-data-model
+ **/
+
+/** @def VL_COMPILER_LP64
+ ** @brief Defined if the host compiler data model is LP64.
+ ** @see @ref host-compiler-data-model
+ **/
+
+/** @def VL_COMPILER_ILP32
+ ** @brief Defined if the host compiler data model is ILP32.
+ ** @see @ref host-compiler-data-model
+ **/
+
+/** @def VL_INT8_C(x)
+ ** @brief Create an integer constant of the specified width and sign
+ ** @param x integer constant.
+ ** @return @a x with the correct suffix for the given sign and size.
+ ** The suffix used depends on the @ref host-compiler-data-model.
+ ** @par "Example:"
+ ** The macro <code>VL_INT64_C(1234)</code> is expanded as @c 123L in
+ ** a LP64 system and as @c 123LL in a LLP64 system.
+ **/
+
+/** @def VL_INT16_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_INT32_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_INT64_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_UINT8_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_UINT16_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_UINT32_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_UINT64_C(x)
+ ** @copydoc VL_INT8_C */
+
+/** @def VL_ARCH_IX86
+ ** @brief Defined if the host CPU is of the Intel x86 family.
+ ** @see @ref host-arch
+ **/
+
+/** @def VL_ARCH_IA64
+ ** @brief Defined if the host CPU is of the Intel Architecture-64 family.
+ ** @see @ref host-arch
+ **/
+
+/** @def VL_ARCH_LITTLE_ENDIAN
+ ** @brief Defined if the host CPU is little endian
+ ** @see @ref host-arch-endianness
+ **/
+
+/** @def VL_ARCH_BIG_ENDIAN
+ ** @brief Defined if the host CPU is big endian
+ ** @see @ref host-arch-endianness
+ **/
+
+/** @def VL_INLINE
+ ** @brief Adds appropriate inline function qualifier
+ ** @see @ref host-compiler-other
+ **/
+
+/** @def VL_EXPORT
+ ** @brief Declares a DLL exported symbol
+ ** @see @ref host-compiler-other
+ **/
+
+/** @def VL_DISABLE_SSE2
+ ** @brief Defined if SSE2 support if disabled
+ **
+ ** Define this symbol during compliation of the library and linking
+ ** to another project to disable VLFeat SSE2 support.
+ **/
+
+/** @def VL_DISABLE_THREADS
+ ** @brief Defined if multi-threading support is disabled
+ **
+ ** Define this symbol during compilation of the library and linking
+ ** to another project to disable VLFeat multi-threading support.
+ **/
+
+/** @def VL_DISABLE_OPENMP
+ ** @brief Defined if OpenMP support is disabled
+ **
+ ** Define this symbol during compilation of the library and linking
+ ** to another project to disable VLFeat OpenMP support.
+ **/
+
+/** @def VL_THREADS_WIN
+ ** @brief Defined if the host uses Windows threads.
+ ** @see @ref host-threads
+ **/
+
+/** @def VL_THREADS_POSIX
+ ** @brief Defiend if the host uses POISX threads.
+ ** @see @ref host-threads
+ **/
+
+/** --------------------------------------------------------------- */
+
+#include "host.h"
+#include "generic.h"
+#include <stdio.h>
+
+#if defined(VL_ARCH_IX86) || defined(VL_ARCH_IA64) || defined(VL_ARCH_X64)
+#define HAS_CPUID
+#else
+#undef HAS_CPUID
+#endif
+
+#if defined(HAS_CPUID) & defined(VL_COMPILER_MSC)
+#include <intrin.h>
+VL_INLINE void
+_vl_cpuid (vl_int32* info, int function)
+{
+  __cpuid(info, function) ;
+}
+#endif
+
+#if defined(HAS_CPUID) & defined(VL_COMPILER_GNUC)
+VL_INLINE void
+_vl_cpuid (vl_int32* info, int function)
+{
+#if defined(VL_ARCH_IX86) && (defined(__PIC__) || defined(__pic__))
+  /* This version is compatible with -fPIC on x386 targets. This special
+   * case is required becaus
+   * on such platform -fPIC alocates ebx as global offset table pointer.
+   * Note that =r below will be mapped to a register different from ebx,
+   * so the code is sound. */
+  __asm__ __volatile__
+  ("pushl %%ebx      \n" /* save %ebx */
+   "cpuid            \n"
+   "movl %%ebx, %1   \n" /* save what cpuid just put in %ebx */
+   "popl %%ebx       \n" /* restore the old %ebx */
+   : "=a"(info[0]), "=r"(info[1]), "=c"(info[2]), "=d"(info[3])
+   : "a"(function)
+   : "cc") ; /* clobbered (cc=condition codes) */
+#else /* no -fPIC or -fPIC with a 64-bit target */
+  __asm__ __volatile__
+  ("cpuid"
+   : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3])
+   : "a"(function)
+   : "cc") ;
+#endif
+}
+
+#endif
+
+#if defined(HAS_CPUID)
+
+void
+_vl_x86cpu_info_init (VlX86CpuInfo *self)
+{
+  vl_int32 info [4] ;
+  int max_func = 0 ;
+  _vl_cpuid(info, 0) ;
+  max_func = info[0] ;
+  self->vendor.words[0] = info[1] ;
+  self->vendor.words[1] = info[3] ;
+  self->vendor.words[2] = info[2] ;
+
+  if (max_func >= 1) {
+    _vl_cpuid(info, 1) ;
+    self->hasMMX   = info[3] & (1 << 23) ;
+    self->hasSSE   = info[3] & (1 << 25) ;
+    self->hasSSE2  = info[3] & (1 << 26) ;
+    self->hasSSE3  = info[2] & (1 <<  0) ;
+    self->hasSSE41 = info[2] & (1 << 19) ;
+    self->hasSSE42 = info[2] & (1 << 20) ;
+    self->hasAVX   = info[2] & (1 << 28) ;
+  }
+}
+
+#endif
+
+char *
+_vl_x86cpu_info_to_string_copy (VlX86CpuInfo const *self)
+{
+  char * string = 0 ;
+  int length = 0 ;
+  while (string == 0) {
+    if (length > 0) {
+      string = vl_malloc(sizeof(char) * length) ;
+      if (string == NULL) break ;
+    }
+    length = snprintf(string, length, "%s%s%s%s%s%s%s%s",
+                      self->vendor.string,
+                      self->hasMMX   ? " MMX" : "",
+                      self->hasSSE   ? " SSE" : "",
+                      self->hasSSE2  ? " SSE2" : "",
+                      self->hasSSE3  ? " SSE3" : "",
+                      self->hasSSE41 ? " SSE41" : "",
+                      self->hasSSE42 ? " SSE42" : "",
+                      self->hasAVX   ? " AVX" : "") ;
+    length += 1 ;
+  }
+  return string ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Human readable static library configuration
+ ** @return a new string with the static configuration.
+ **
+ ** The string includes information about the compiler, the host, and
+ ** other static configuration parameters. The string must be released
+ ** by ::vl_free.
+ **/
+
+VL_EXPORT char *
+vl_static_configuration_to_string_copy ()
+{
+  char const * hostString =
+#ifdef VL_ARCH_X64
+  "X64"
+#endif
+#ifdef VL_ARCH_IA64
+  "IA64"
+#endif
+#ifdef VL_ARCH_IX86
+  "IX86"
+#endif
+#ifdef VL_ARCH_PPC
+  "PPC"
+#endif
+  ", "
+#ifdef VL_ARCH_BIG_ENDIAN
+  "big_endian"
+#endif
+#ifdef VL_ARCH_LITTLE_ENDIAN
+  "little_endian"
+#endif
+  ;
+
+  char compilerString [1024] ;
+
+  char const * libraryString =
+#ifndef VL_DISABLE_THREADS
+#ifdef VL_THREADS_WIN
+  "Windows_threads"
+#elif VL_THREADS_POSIX
+  "POSIX_threads"
+#endif
+#else
+  "No_threads"
+#endif
+#ifndef VL_DISABLE_SSE2
+  ", SSE2"
+#endif
+#if defined(_OPENMP)
+  ", OpenMP"
+#endif
+  ;
+
+snprintf(compilerString, 1024,
+#ifdef VL_COMPILER_MSC
+  "Microsoft Visual C++ %d"
+#define v VL_COMPILER_MSC
+#endif
+#ifdef VL_COMPILER_GNUC
+  "GNU C %d"
+#define v VL_COMPILER_GNUC
+#endif
+  " "
+#ifdef VL_COMPILER_LP64
+  "LP64"
+#endif
+#ifdef VL_COMPILER_LLP64
+  "LP64"
+#endif
+#ifdef VL_COMPILER_ILP32
+  "ILP32"
+#endif
+           , v) ;
+
+  {
+    char * string = 0 ;
+    int length = 0 ;
+    while (string == 0) {
+      if (length > 0) {
+        string = vl_malloc(sizeof(char) * length) ;
+        if (string == NULL) break ;
+      }
+      length = snprintf(string, length, "%s, %s, %s",
+                        hostString,
+                        compilerString,
+                        libraryString) ;
+      length += 1 ;
+    }
+    return string ;
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/host.h b/opensfm/src/third_party/vlfeat/vl/host.h
new file mode 100644
index 000000000..fb2700c77
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/host.h
@@ -0,0 +1,662 @@
+/** @file host.h
+ ** @brief Host
+ ** @author Andrea Vedaldi
+ ** @sa @ref portability
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_HOST_H
+#define VL_HOST_H
+
+/** ------------------------------------------------------------------
+ ** @name Configuration options
+ ** @{ */
+
+#if defined(__DOXYGEN__)
+#define VL_DISABLE_THREADS
+#define VL_DISABLE_SSE2
+#define VL_DISABLE_OPENMP
+#endif
+
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Defining functions
+ ** @{ */
+
+#if defined(__DOXYGEN__)
+#define VL_EXPORT
+#define VL_INLINE
+#endif
+
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name C preprocessor helper macros
+ ** @{ */
+
+/** @brief Convert the argument to a string
+ ** @param x value to be stringified.
+ **
+ ** This macro stringifies the argument @a x by means of the
+ ** <code>#</code> prerpocessor operator.
+ **
+ ** The standard C preprocessor does not prescan arguments which are
+ ** stringified, so
+ **
+ ** @code
+ ** #define A B
+ ** char const * str = VL_STRINGIFY(A) ;
+ ** @endcode
+ **
+ ** initializes <code>str</code> with a pointer to the string
+ ** <code>"A"</code>, which mihgt be unexpected. To fix this issue,
+ ** you can use ::VL_XSTRINGIFY.
+ **
+ ** @sa ::VL_XSTRINGIFY
+ **/
+
+#define VL_STRINGIFY(x) # x
+
+/** @brief Expand and then convert the argument to a string
+ ** @param x value to be macro-expanded and converted.
+ **
+ ** This macro macro-expands the argument @a x and stringifies the
+ ** result of the expansion. For instance
+ **
+ ** @code
+ ** #define A B
+ ** char const * str = VL_STRINGIFY(A) ;
+ ** @endcode
+ **
+ ** initializes <code>str</code> with a pointer to the string
+ ** <code>"B"</code>.
+ **
+ ** @sa ::VL_STRINGIFY
+ **/
+
+#define VL_XSTRINGIFY(x) VL_STRINGIFY(x)
+
+/** @brief Concatenate two arguments into a lexical unit
+ ** @param x first argument to be concatenated.
+ ** @param y second argument to be concatenated.
+ **
+ ** This macro concatenates its arguments into a single lexical unit
+ ** by means of the <code>##</code> preprocessor operator. Notice that
+ ** arguments concatenated by <code>##</code> are not pre-expanded by
+ ** the C preprocessor. To macro-expand the arguments and then
+ ** concatenate them,use ::VL_XCAT.
+ **
+ ** @see ::VL_XCAT
+ **/
+
+#define VL_CAT(x,y) x ## y
+
+/** @brief Expand and then concatenate two arguments into a lexical unit
+ ** @param x first argument to be concatenated.
+ ** @param y second argument to be concatenated.
+ **
+ ** This macro is the same as ::VL_CAT, except that the arguments are
+ ** macro expanded before being concatenated.
+ **
+ ** @see ::VL_CAT
+ **/
+
+#define VL_XCAT(x,y) VL_CAT(x,y)
+
+/** @brief Expand and then concatenate three arguments into a lexical unit
+ ** @param x first argument to be concatenated.
+ ** @param y second argument to be concatenated.
+ ** @param z third argument to be concatenated.
+ **
+ ** This macro is the same as ::VL_XCAT, except that it has three arguments.
+ **
+ ** @see ::VL_XCAT
+ **/
+
+#define VL_XCAT3(x,y,z) VL_XCAT(VL_XCAT(x,y),z)
+
+/** @brief Expand and then concatenate four arguments into a lexical unit
+ ** @param x first argument to be concatenated.
+ ** @param y second argument to be concatenated.
+ ** @param z third argument to be concatenated.
+ ** @param u fourth argument to be concatenated.
+ **
+ ** This macro is the same as ::VL_XCAT, except that it has four arguments.
+ **
+ ** @see ::VL_XCAT
+ **/
+
+#define VL_XCAT4(x,y,z,u) VL_XCAT(VL_XCAT3(x,y,z),u)
+
+/** @brief Expand and then concatenate five arguments into a lexical unit
+ ** @param x first argument to be concatenated.
+ ** @param y second argument to be concatenated.
+ ** @param z third argument to be concatenated.
+ ** @param u fourth argument to be concatenated.
+ ** @param v fifth argument to be concatenated.
+ **
+ ** This macro is the same as ::VL_XCAT, except that it has five arguments.
+ **
+ ** @see ::VL_XCAT
+ **/
+
+#define VL_XCAT5(x,y,z,u,v) VL_XCAT(VL_XCAT4(x,y,z,u),v)
+
+/** @brief Convert a boolean to "yes" or "no" strings
+ ** @param x boolean to convert.
+ **
+ ** A pointer to either the string "yes" (if @a x is true)
+ ** or the string "no".
+ **
+ ** @par Example
+ ** @code
+ ** VL_PRINTF("Is x true? %s.", VL_YESNO(x))
+ ** @endcode
+ **/
+
+#define VL_YESNO(x) ((x)?"yes":"no")
+
+/** @} */
+
+/*
+ The following macros identify the host OS, architecture and compiler.
+ They are derived from http://predef.sourceforge.net/
+ */
+
+/** @name Identifying the host operating system
+ ** @{ */
+#if defined(linux)     || \
+    defined(__linux)   || \
+    defined(__linux__) || \
+    defined(__DOXYGEN__)
+#define VL_OS_LINUX 1
+#endif
+
+#if (defined(__APPLE__) & defined(__MACH__)) || \
+     defined(__DOXYGEN__)
+#define VL_OS_MACOSX 1
+#endif
+
+#if defined(__WIN32__) || \
+    defined(_WIN32)    || \
+    defined(__DOXYGEN__)
+#define VL_OS_WIN 1
+#endif
+
+#if defined(_WIN64) || \
+    defined(__DOXYGEN__)
+#define VL_OS_WIN64 1
+#endif
+/** @} */
+
+/** @name Identifying the host threading library
+ ** @{ */
+#if !defined(VL_OS_WIN) && !defined(VL_OS_WIN64) || \
+defined(__DOXYGEN__)
+#define VL_THREADS_POSIX 1
+#endif
+
+#if defined(VL_OS_WIN) || defined(VL_OS_WIN64) || \
+defined(__DOXYGEN__)
+#define VL_THREADS_WIN 1
+#endif
+/** @} */
+
+/** @name Identifying the host compiler
+ ** @{ */
+#if defined(__GNUC__) || defined(__DOXYGEN__)
+# if defined(__GNUC_PATCHLEVEL__)
+#  define VL_COMPILER_GNUC (__GNUC__ * 10000 \
++ __GNUC_MINOR__ * 100 \
++ __GNUC_PATCHLEVEL__)
+# else
+#  define VL_COMPILER_GNUC (__GNUC__ * 10000 \
++ __GNUC_MINOR__ * 100)
+# endif
+#endif
+
+#if defined(_MSC_VER) || defined(__DOXYGEN__)
+#define VL_COMPILER_MSC _MSC_VER
+#endif
+
+#if defined(__LCC__) || defined(__DOXYGEN__)
+#warning "LCC support is experimental!"
+#define VL_COMPILER_LCC 1
+#endif
+
+/** @} */
+
+/** @name Identifying the host CPU architecture
+ ** @{ */
+#if defined(i386)     || \
+    defined(__i386__) || \
+    defined(__DOXYGEN__)
+#define VL_ARCH_IX86 300
+#elif defined(__i486__)
+#define VL_ARCH_IX86 400
+#elif defined(__i586__)
+#define VL_ARCH_IX86 500
+#elif defined(__i686__)
+#define VL_ARCH_IX86 600
+#elif defined(_M_IX86)
+#define VL_ARCH_IX86 _M_IX86
+#endif
+
+#if defined(_M_X64)    || \
+    defined(__amd64__) || \
+    defined(__amd64)   || \
+    defined(__x86_64)  || \
+    defined(__x86_64)
+#define VL_ARCH_X64
+#endif
+
+#if defined(__ia64__)   || \
+    defined(_IA64)      || \
+    defined(__IA64)     || \
+    defined(__ia64)     || \
+    defined(_M_IA64)    || \
+    defined(__DOXYGEN__)
+#define VL_ARCH_IA64
+#endif
+/** @} */
+
+/** @name Identifying the host data model
+ ** @{ */
+#if defined(__LLP64__) || \
+    defined(__LLP64)   || \
+    defined(__LLP64)   || \
+    (defined(VL_COMPILER_MSC) & defined(VL_OS_WIN64)) || \
+    (defined(VL_COMPILER_LCC) & defined(VL_OS_WIN64)) || \
+    defined(__DOXYGEN__)
+#define VL_COMPILER_LLP64
+#endif
+
+#if defined(__LP64__) || \
+    defined(__LP64)   || \
+    defined(__LP64)   || \
+    (defined(VL_OS_MACOSX) & defined(VL_ARCH_IA64)) || \
+    defined(__DOXYGEN__)
+#define VL_COMPILER_LP64
+#endif
+
+#if (!defined(VL_COMPILER_LLP64) & !defined(VL_COMPILER_LP64)) || \
+    defined(__DOXYGEN__)
+#define VL_COMPILER_ILP32
+#endif
+/** @} */
+
+/** @name Identifying the host endianness
+ ** @{ */
+#if defined(__LITTLE_ENDIAN__) || \
+    defined(VL_ARCH_IX86)      || \
+    defined(VL_ARCH_IA64)      || \
+    defined(VL_ARCH_X64)       || \
+    defined(__DOXYGEN__)
+#define VL_ARCH_LITTLE_ENDIAN
+#endif
+
+#if  defined(__DOXYGEN__) || \
+    !defined(VL_ARCH_LITTLE_ENDIAN)
+#define VL_ARCH_BIG_ENDIAN
+#endif
+/** @} */
+
+#if defined(VL_COMPILER_MSC) & ! defined(__DOXYGEN__)
+#  define VL_UNUSED
+#  define VL_INLINE static __inline
+#if defined _MSC_VER && _MSC_VER < 1900
+#  define snprintf _snprintf
+#endif
+#  define isnan _isnan
+#  ifdef VL_BUILD_DLL
+#    ifdef __cplusplus
+#      define VL_EXPORT extern "C" __declspec(dllexport)
+#    else
+#      define VL_EXPORT extern __declspec(dllexport)
+#    endif
+#  else
+#    ifdef __cplusplus
+#      define VL_EXPORT extern "C"
+#    else
+#      define VL_EXPORT extern
+#    endif
+#  endif
+#endif
+
+#if defined(VL_COMPILER_LCC) & ! defined(__DOXYGEN__)
+#  define VL_UNUSED
+#  define VL_INLINE static __inline
+#  define snprintf _snprintf
+#  define isnan _isnan
+VL_INLINE float fabsf(float x) { return (float) fabs((double) x) ; }
+#  ifdef VL_BUILD_DLL
+#    define VL_EXPORT extern __declspec(dllexport)
+#  else
+#    define VL_EXPORT extern
+#  endif
+#endif
+
+#if defined(VL_COMPILER_GNUC) & ! defined(__DOXYGEN__)
+#  define VL_UNUSED __attribute__((unused))
+#  define VL_INLINE static __inline__
+#  ifdef VL_BUILD_DLL
+#    ifdef __cplusplus
+#      define VL_EXPORT __attribute__((visibility ("default"))) extern "C"
+#    else
+#      define VL_EXPORT __attribute__((visibility ("default"))) extern
+#    endif
+#  else
+#    ifdef __cplusplus
+#      define VL_EXPORT extern "C"
+#    else
+#      define VL_EXPORT extern
+#    endif
+#  endif
+#endif
+
+VL_EXPORT char * vl_static_configuration_to_string_copy () ;
+
+/** ------------------------------------------------------------------
+ ** @name Atomic data types
+ ** @{
+ **/
+
+#define VL_TRUE 1   /**< @brief @c true (1) constant */
+#define VL_FALSE 0  /**< @brief @c false (0) constant */
+
+#if defined(VL_COMPILER_LP64) || defined(VL_COMPILER_LLP64)
+typedef long long           vl_int64 ;   /**< @brief Signed 64-bit integer. */
+typedef int                 vl_int32 ;   /**< @brief Signed 32-bit integer. */
+typedef short               vl_int16 ;   /**< @brief Signed 16-bit integer. */
+typedef char                vl_int8  ;   /**< @brief Signed  8-bit integer. */
+
+typedef long long unsigned  vl_uint64 ;  /**< @brief Unsigned 64-bit integer. */
+typedef int       unsigned  vl_uint32 ;  /**< @brief Unsigned 32-bit integer. */
+typedef short     unsigned  vl_uint16 ;  /**< @brief Unsigned 16-bit integer. */
+typedef char      unsigned  vl_uint8 ;   /**< @brief Unsigned  8-bit integer. */
+
+typedef int                 vl_int ;     /**< @brief Same as @c int. */
+typedef unsigned int        vl_uint ;    /**< @brief Same as <code>unsigned int</code>. */
+
+typedef int                 vl_bool ;    /**< @brief Boolean. */
+typedef vl_int64            vl_intptr ;  /**< @brief Integer holding a pointer. */
+typedef vl_uint64           vl_uintptr ; /**< @brief Unsigned integer holding a pointer. */
+typedef vl_int64            vl_size ;    /**< @brief Signed integer holding the size of a memory block. */
+typedef vl_int64            vl_index ;   /**< @brief Signed version of ::vl_size and ::vl_uindex */
+typedef vl_uint64           vl_uindex ;  /**< @brief Same as ::vl_size */
+#endif
+
+#if defined(VL_COMPILER_ILP32)
+
+#ifdef VL_COMPILER_MSC
+typedef __int64             vl_int64 ;
+#else
+typedef long long           vl_int64 ;
+#endif
+
+typedef int                 vl_int32 ;
+typedef short               vl_int16 ;
+typedef char                vl_int8  ;
+
+#ifdef VL_COMPILER_MSC
+typedef __int64   unsigned  vl_uint64 ;
+#else
+typedef long long unsigned  vl_uint64 ;
+#endif
+typedef int       unsigned  vl_uint32 ;
+typedef short     unsigned  vl_uint16 ;
+typedef char      unsigned  vl_uint8 ;
+
+typedef int                 vl_int ;
+typedef unsigned int        vl_uint ;
+
+typedef int                 vl_bool ;
+typedef vl_int32            vl_intptr ;
+typedef vl_uint32           vl_uintptr ;
+typedef vl_uint32           vl_size ;
+typedef vl_int32            vl_index ;
+typedef vl_uint32           vl_uindex ;
+#endif
+/** @} */
+
+/** @name Creating integer constants
+ ** @{ */
+#if defined(VL_COMPILER_LP64) || defined(__DOXYGEN__)
+#define VL_INT8_C(x) x
+#define VL_INT16_C(x) x
+#define VL_INT32_C(x) x
+#define VL_INT64_C(x) x ## L
+
+#define VL_UINT8_C(x) x
+#define VL_UINT16_C(x) x
+#define VL_UINT32_C(x) x ## U
+#define VL_UINT64_C(x) x ## UL
+#endif
+
+#if (defined(VL_COMPILER_LLP64) || defined(VL_COMPILER_ILP32)) \
+    & !defined(__DOXYGEN__)
+#define VL_INT8_C(x) x
+#define VL_INT16_C(x) x
+#define VL_INT32_C(x) x
+#define VL_INT64_C(x) x ## LL
+
+#define VL_UINT8_C(x) x
+#define VL_UINT16_C(x) x
+#define VL_UINT32_C(x) x ## U
+#define VL_UINT64_C(x) x ## ULL
+#endif
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Printing the atomic data types
+ ** @{ */
+
+/* Lengths only: */
+
+/** @def VL_FL_INT64
+ ** @brief @c printf length flag for ::vl_int64 and ::vl_uint64.
+ **/
+
+/** @def VL_FL_INT32
+ ** @brief @c printf length flag for ::vl_int32 and ::vl_uint32.
+ **/
+
+/** @def VL_FL_INT16
+ ** @brief @c printf length flag for ::vl_int16 and ::vl_uint16.
+ **/
+
+/** @def VL_FL_INT8
+ ** @brief @c printf length flag for ::vl_int8 and ::vl_uint8.
+ **/
+
+/** @def VL_FL_INDEX
+ ** @brief @c printf length flag for ::vl_index and ::vl_uindex
+ **/
+
+#ifdef VL_COMPILER_MSC
+#define VL_FL_INT64  "I64"
+#else
+#define VL_FL_INT64  "ll"
+#endif
+#define VL_FL_INT32  ""
+#define VL_FL_INT16  "h"
+#define VL_FL_INT8   "hh"
+
+#if defined(VL_COMPILER_LP64) || defined(VL_COMPILER_LLP64)
+#define VL_FL_INDEX VL_FL_INT64
+#endif
+
+#if defined(VL_COMPILER_ILP32)
+#define VL_FL_INDEX VL_FL_INT32
+#endif
+
+/* Formats (but not conversions!): */
+
+/** @def VL_FMT_SIZE
+ ** @brief @c printf flag for ::vl_size
+ **/
+
+/** @def VL_FMT_INDEX
+ ** @brief @c printf flag for ::vl_index
+ **/
+
+/** @def VL_FMT_UINDEX
+ ** @brief @c printf flag for ::vl_uindex
+ **/
+
+/** @def VL_FMT_INTPTR
+ ** @brief @c printf flag for ::vl_intptr
+ **/
+
+/** @def VL_FMT_UINTPTR
+ ** @brief @c printf flag for ::vl_uintptr
+ **/
+
+#define VL_FMT_INDEX   VL_FL_INDEX "d"
+#define VL_FMT_INTPTR  VL_FMT_INDEX
+#define VL_FMT_UINDEX  VL_FL_INDEX "u"
+#define VL_FMT_SIZE    VL_FMT_UINDEX
+#define VL_FMT_UINTPTR VL_FMT_UINDEX
+
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Atomic data types limits
+ ** @{ */
+
+/** @brief Largest integer (math constant) */
+#define VL_BIG_INT  0x7FFFFFFFL
+
+/** @brief Smallest integer (math constant) */
+#define VL_SMALL_INT  (- VL_BIG_INT - 1)
+
+/** @brief Largest unsigned integer (math constant) */
+#define VL_BIG_UINT 0xFFFFFFFFUL
+
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Endianness detection and conversion
+ ** @{
+ **/
+VL_INLINE void vl_swap_host_big_endianness_8 (void *dst, void* src) ;
+VL_INLINE void vl_swap_host_big_endianness_4 (void *dst, void* src) ;
+VL_INLINE void vl_swap_host_big_endianness_2 (void *dst, void* src) ;
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @name Obtaining host info at run time
+ ** @{ */
+
+typedef struct _VlX86CpuInfo
+{
+  union {
+    char string [0x20] ;
+    vl_uint32 words [0x20 / 4] ;
+  } vendor ;
+  vl_bool hasAVX ;
+  vl_bool hasSSE42 ;
+  vl_bool hasSSE41 ;
+  vl_bool hasSSE3 ;
+  vl_bool hasSSE2 ;
+  vl_bool hasSSE ;
+  vl_bool hasMMX ;
+} VlX86CpuInfo ;
+
+void _vl_x86cpu_info_init (VlX86CpuInfo *self) ;
+char * _vl_x86cpu_info_to_string_copy (VlX86CpuInfo const *self) ;
+
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @brief Host <-> big endian transformation for 8-bytes value
+ **
+ ** @param dst destination 8-byte buffer.
+ ** @param src source 8-byte bufffer.
+ ** @see @ref host-arch-endianness.
+ **/
+
+VL_INLINE void
+vl_swap_host_big_endianness_8 (void *dst, void* src)
+{
+  char *dst_ = (char*) dst ;
+  char *src_ = (char*) src ;
+#if defined(VL_ARCH_BIG_ENDIAN)
+    dst_ [0] = src_ [0] ;
+    dst_ [1] = src_ [1] ;
+    dst_ [2] = src_ [2] ;
+    dst_ [3] = src_ [3] ;
+    dst_ [4] = src_ [4] ;
+    dst_ [5] = src_ [5] ;
+    dst_ [6] = src_ [6] ;
+    dst_ [7] = src_ [7] ;
+#else
+    dst_ [0] = src_ [7] ;
+    dst_ [1] = src_ [6] ;
+    dst_ [2] = src_ [5] ;
+    dst_ [3] = src_ [4] ;
+    dst_ [4] = src_ [3] ;
+    dst_ [5] = src_ [2] ;
+    dst_ [6] = src_ [1] ;
+    dst_ [7] = src_ [0] ;
+#endif
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Host <-> big endian transformation for 4-bytes value
+ **
+ ** @param dst destination 4-byte buffer.
+ ** @param src source 4-byte bufffer.
+ ** @sa @ref host-arch-endianness.
+ **/
+
+VL_INLINE void
+vl_swap_host_big_endianness_4 (void *dst, void* src)
+{
+  char *dst_ = (char*) dst ;
+  char *src_ = (char*) src ;
+#if defined(VL_ARCH_BIG_ENDIAN)
+    dst_ [0] = src_ [0] ;
+    dst_ [1] = src_ [1] ;
+    dst_ [2] = src_ [2] ;
+    dst_ [3] = src_ [3] ;
+#else
+    dst_ [0] = src_ [3] ;
+    dst_ [1] = src_ [2] ;
+    dst_ [2] = src_ [1] ;
+    dst_ [3] = src_ [0] ;
+#endif
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Host <-> big endian transformation for 2-bytes value
+ **
+ ** @param dst destination 2-byte buffer.
+ ** @param src source 2-byte bufffer.
+ ** @see @ref host-arch-endianness.
+ **/
+
+VL_INLINE void
+vl_swap_host_big_endianness_2 (void *dst, void* src)
+{
+  char *dst_ = (char*) dst ;
+  char *src_ = (char*) src ;
+#if defined(VL_ARCH_BIG_ENDIAN)
+    dst_ [0] = src_ [0] ;
+    dst_ [1] = src_ [1] ;
+#else
+    dst_ [0] = src_ [1] ;
+    dst_ [1] = src_ [0] ;
+#endif
+}
+
+/* VL_HOST_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/ikmeans.c b/opensfm/src/third_party/vlfeat/vl/ikmeans.c
new file mode 100644
index 000000000..4eb7c4687
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/ikmeans.c
@@ -0,0 +1,297 @@
+/** @file ikmeans.c
+ ** @brief Integer K-Means clustering - Definition
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file ikmeans.h
+ **
+ ** Integer K-means (IKM) is an implementation of K-means clustering
+ ** (or Vector Quantization, VQ) for integer data. This is
+ ** particularly useful for clustering large collections of visual
+ ** descriptors.
+ **
+ ** Use the function ::vl_ikm_new() to create a IKM
+ ** quantizer. Initialize the IKM quantizer with @c K clusters by
+ ** ::vl_ikm_init() or similar function. Use ::vl_ikm_train() to train
+ ** the quantizer. Use ::vl_ikm_push() or ::vl_ikm_push_one() to
+ ** quantize new data.
+ **
+ ** Given data @f$x_1,\dots,x_N\in R^d@f$ and a number of clusters
+ ** @f$K@f$, the goal is to find assignments @f$a_i\in\{1,\dots,K\},@f$
+ ** and centers @f$c_1,\dots,c_K\in R^d@f$ so that the <em>expected
+ ** distortion</em>
+ **
+ ** @f[
+ **   E(\{a_{i}, c_j\}) = \frac{1}{N} \sum_{i=1}^N d(x_i, c_{a_i})
+ ** @f]
+ **
+ ** is minimized. Here @f$d(x_i, c_{a_i})@f$ is the
+ ** <em>distortion</em>, i.e. the cost we pay for representing @f$ x_i
+ ** @f$ by @f$ c_{a_i} @f$. IKM uses the squared distortion
+ ** @f$d(x,y)=\|x-y\|^2_2@f$.
+ **
+ ** @section ikmeans-algo Algorithms
+ **
+ ** @subsection ikmeans-alg-init Initialization
+ **
+ ** Most K-means algorithms are iterative and needs an initialization
+ ** in the form of an initial choice of the centers
+ ** @f$c_1,\dots,c_K@f$. We include the following options:
+ **
+ ** - User specified centers (::vl_ikm_init);
+ ** - Random centers (::vl_ikm_init_rand);
+ ** - Centers from @c K randomly selected data points (::vl_ikm_init_rand_data).
+ **
+ ** @subsection ikmeans-alg-lloyd Lloyd
+ **
+ ** The Lloyd (also known as Lloyd-Max and LBG) algorithm iteratively:
+ **
+ ** - Fixes the centers, optimizing the assignments (minimizing by
+ **   exhaustive search the association of each data point to the
+ **   centers);
+ ** - Fixes the assignments and optimizes the centers (by descending
+ **   the distortion error function). For the squared distortion, this
+ **   step is in closed form.
+ **
+ ** This algorithm is not particularly efficient because all data
+ ** points need to be compared to all centers, for a complexity
+ ** @f$O(dNKT)@f$, where <em>T</em> is the total number of iterations.
+ **
+ ** @subsection ikmeans-alg-elkan Elkan
+ **
+ ** The Elkan algorithm is an optimized variant of Lloyd. By making
+ ** use of the triangle inequality, many comparisons of data points
+ ** and centers are avoided, especially at later iterations.
+ ** Usually 4-5 times less comparisons than Lloyd are preformed,
+ ** providing a dramatic speedup in the execution time.
+ **
+ **/
+
+#include "ikmeans.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h> /* memset */
+#include "assert.h"
+
+static void vl_ikm_init_lloyd (VlIKMFilt*) ;
+static void vl_ikm_init_elkan (VlIKMFilt*) ;
+static int vl_ikm_train_lloyd (VlIKMFilt*, vl_uint8 const*, vl_size) ;
+static int vl_ikm_train_elkan (VlIKMFilt*, vl_uint8 const*, vl_size) ;
+static void vl_ikm_push_lloyd (VlIKMFilt*, vl_uint32*, vl_uint8 const*, vl_size) ;
+static void  vl_ikm_push_elkan  (VlIKMFilt*, vl_uint32*, vl_uint8 const*, vl_size) ;
+
+/** @brief Create a new IKM quantizer
+ ** @param method Clustering algorithm.
+ ** @return new IKM quantizer.
+ **
+ ** The function allocates initializes a new IKM quantizer to
+ ** operate based algorithm @a method.
+ **
+ ** @a method has values in the enumerations ::VlIKMAlgorithms.
+ **/
+
+VlIKMFilt *
+vl_ikm_new (int method)
+{
+  VlIKMFilt *f = vl_calloc (sizeof(VlIKMFilt), 1) ;
+  f -> method = method ;
+  f -> max_niters = 200 ;
+  return f ;
+}
+
+/** @brief Delete IKM quantizer
+ ** @param f IKM quantizer.
+ **/
+
+void
+vl_ikm_delete (VlIKMFilt* f)
+{
+  if (f) {
+    if (f->centers) vl_free(f->centers) ;
+    if (f->inter_dist) vl_free(f->inter_dist) ;
+    vl_free(f) ;
+  }
+}
+
+/** @brief Train clusters
+ ** @param f IKM quantizer.
+ ** @param data data.
+ ** @param N number of data (@a N @c >= 1).
+ ** @return -1 if an overflow may have occurred.
+ **/
+
+int
+vl_ikm_train (VlIKMFilt *f, vl_uint8 const *data, vl_size N)
+{
+  int err ;
+
+  if (f-> verb) {
+    VL_PRINTF ("ikm: training with %d data\n",  N) ;
+    VL_PRINTF ("ikm: %d clusters\n",  f -> K) ;
+  }
+
+  switch (f -> method) {
+  case VL_IKM_LLOYD : err = vl_ikm_train_lloyd (f, data, N) ; break ;
+  case VL_IKM_ELKAN : err = vl_ikm_train_elkan (f, data, N) ; break ;
+  default :
+    abort() ;
+  }
+  return err ;
+}
+
+/** @brief Project data to clusters
+ ** @param f     IKM quantizer.
+ ** @param asgn  Assignments (out).
+ ** @param data  data.
+ ** @param N     number of data (@a N @c >= 1).
+ **
+ ** The function projects the data @a data on the integer K-means
+ ** clusters specified by the IKM quantizer @a f. Notice that the
+ ** quantizer must be initialized.
+ **/
+
+void
+vl_ikm_push (VlIKMFilt *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) {
+  switch (f -> method) {
+  case VL_IKM_LLOYD : vl_ikm_push_lloyd (f, asgn, data, N) ; break ;
+  case VL_IKM_ELKAN : vl_ikm_push_elkan (f, asgn, data, N) ; break ;
+  default :
+    abort() ;
+  }
+}
+
+/** @brief Project one datum to clusters
+ ** @param centers centers.
+ ** @param data datum to project.
+ ** @param K number of centers.
+ ** @param M dimensionality of the datum.
+ ** @return the cluster index.
+ **
+ ** The function projects the specified datum @a data on the clusters
+ ** specified by the centers @a centers.
+ **/
+
+vl_uint32
+vl_ikm_push_one (vl_ikmacc_t const *centers,
+		 vl_uint8 const *data,
+		 vl_size M, vl_size K)
+{
+  vl_uindex i,k ;
+
+  /* assign data to centers */
+  vl_uindex best = (vl_uindex) -1 ;
+  vl_ikmacc_t best_dist = 0 ;
+
+  for(k = 0 ; k < K ; ++k) {
+    vl_ikmacc_t dist = 0 ;
+
+    /* compute distance with this center */
+    for(i = 0 ; i < M ; ++i) {
+      vl_ikmacc_t delta = (vl_ikmacc_t)data[i] - centers[k*M + i] ;
+      dist += delta * delta ;
+    }
+
+    /* compare with current best */
+    if (best == (vl_uindex) -1 || dist < best_dist) {
+      best = k  ;
+      best_dist = dist ;
+    }
+  }
+  return (vl_uint32)best;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Getters and setters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get data dimensionality
+ ** @param f IKM filter.
+ ** @return data dimensionality.
+ **/
+
+vl_size
+vl_ikm_get_ndims (VlIKMFilt const* f)
+{
+  return f->M ;
+}
+
+
+/** @brief Get the number of centers K
+ ** @param f IKM filter.
+ ** @return number of centers K.
+ **/
+
+vl_size
+vl_ikm_get_K (VlIKMFilt const* f)
+{
+  return f->K ;
+}
+
+/** @brief Get verbosity level
+ ** @param f IKM filter.
+ ** @return verbosity level.
+ **/
+
+int
+vl_ikm_get_verbosity (VlIKMFilt const* f)
+{
+  return f->verb ;
+}
+
+/** @brief Get maximum number of iterations
+ ** @param f IKM filter.
+ ** @return maximum number of iterations.
+ **/
+
+vl_size
+vl_ikm_get_max_niters (VlIKMFilt const* f)
+{
+  return f->max_niters ;
+}
+
+/** @brief Get maximum number of iterations
+ ** @param f IKM filter.
+ ** @return maximum number of iterations.
+ **/
+
+vl_ikmacc_t const *
+vl_ikm_get_centers (VlIKMFilt const* f)
+{
+  return f-> centers ;
+}
+
+/** @brief Set verbosity level
+ ** @param f IKM filter.
+ ** @param verb verbosity level.
+ **/
+
+void
+vl_ikm_set_verbosity (VlIKMFilt *f, int verb)
+{
+  f-> verb = VL_MAX(0,verb) ;
+}
+
+/** @brief Set maximum number of iterations
+ ** @param f IKM filter.
+ ** @param max_niters maximum number of iterations.
+ **/
+
+void
+vl_ikm_set_max_niters (VlIKMFilt *f, vl_size max_niters)
+{
+  f-> max_niters = max_niters ;
+}
+
+#include "ikmeans_init.tc"
+#include "ikmeans_lloyd.tc"
+#include "ikmeans_elkan.tc"
diff --git a/opensfm/src/third_party/vlfeat/vl/ikmeans.h b/opensfm/src/third_party/vlfeat/vl/ikmeans.h
new file mode 100644
index 000000000..e79908056
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/ikmeans.h
@@ -0,0 +1,87 @@
+/** @file ikmeans.h
+ ** @brief Integer K-Means clustering
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2014 Andrea Vedaldi.
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_IKMEANS_H
+#define VL_IKMEANS_H
+
+#include "generic.h"
+#include "random.h"
+
+#if 0
+typedef vl_int64 vl_ikmacc_t ; /**< IKM accumulator data type */
+#define VL_IKMACC_MAX 0x7fffffffffffffffULL
+#else
+typedef vl_int32 vl_ikmacc_t ; /**< IKM accumulator data type */
+#define VL_IKMACC_MAX 0x7fffffffUL
+#endif
+
+
+/** ------------------------------------------------------------------
+ ** @brief IKM algorithms
+ **/
+
+enum VlIKMAlgorithms {
+  VL_IKM_LLOYD, /**< Lloyd algorithm */
+  VL_IKM_ELKAN, /**< Elkan algorithm */
+} ;
+
+/** ------------------------------------------------------------------
+ ** @brief IKM quantizer
+ **/
+
+typedef struct _VlIKMFilt
+{
+  vl_size M ; /**< data dimensionality */
+  vl_size K ; /**< number of centers   */
+  vl_size max_niters ; /**< Lloyd: maximum number of iterations */
+  int method ; /**< Learning method */
+  int verb ; /**< verbosity level */
+  vl_ikmacc_t *centers ; /**< centers */
+  vl_ikmacc_t *inter_dist ; /**< centers inter-distances */
+} VlIKMFilt ;
+
+/** @name Create and destroy
+ ** @{ */
+VL_EXPORT VlIKMFilt *vl_ikm_new (int method) ;
+VL_EXPORT void vl_ikm_delete (VlIKMFilt *f) ;
+/** @} */
+
+/** @name Process data
+ ** @{ */
+VL_EXPORT void vl_ikm_init (VlIKMFilt *f, vl_ikmacc_t const *centers, vl_size M, vl_size K) ;
+VL_EXPORT void vl_ikm_init_rand (VlIKMFilt *f, vl_size M, vl_size K) ;
+VL_EXPORT void vl_ikm_init_rand_data (VlIKMFilt *f, vl_uint8 const *data, vl_size M, vl_size N, vl_size K) ;
+VL_EXPORT int  vl_ikm_train (VlIKMFilt *f, vl_uint8 const *data, vl_size N) ;
+VL_EXPORT void vl_ikm_push (VlIKMFilt *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) ;
+VL_EXPORT vl_uint vl_ikm_push_one (vl_ikmacc_t const *centers, vl_uint8 const *data, vl_size M, vl_size K) ;
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{ */
+VL_EXPORT vl_size vl_ikm_get_ndims (VlIKMFilt const *f) ;
+VL_EXPORT vl_size vl_ikm_get_K (VlIKMFilt const *f) ;
+VL_EXPORT int vl_ikm_get_verbosity (VlIKMFilt const *f) ;
+VL_EXPORT vl_size vl_ikm_get_max_niters (VlIKMFilt const *f) ;
+VL_EXPORT vl_ikmacc_t const *vl_ikm_get_centers (VlIKMFilt const *f) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{ */
+VL_EXPORT void vl_ikm_set_verbosity (VlIKMFilt *f, int verb) ;
+VL_EXPORT void vl_ikm_set_max_niters (VlIKMFilt *f, vl_size max_niters) ;
+/** @} */
+
+/* VL_IKMEANS_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv.c b/opensfm/src/third_party/vlfeat/vl/imopv.c
new file mode 100644
index 000000000..984b5061a
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/imopv.c
@@ -0,0 +1,1074 @@
+/** @file imopv.c
+ ** @brief Vectorized image operations - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file imopv.h
+ **
+ ** This module provides the following image operations:
+ **
+ ** - <b>Separable convolution.</b> The function ::vl_imconvcol_vf()
+ **   can be used to compute separable convolutions.
+ **
+ ** - <b>Convolution by a triangular kernel.</b> The function
+ **   vl_imconvcoltri_vf() is an optimized convolution routine for
+ **   triangular kernels.
+ **
+ ** - <b>Distance transform.</b> ::vl_image_distance_transform_f() is
+ **   a linear algorithm to compute the distance transform of an
+ **   image.
+ **
+ ** @remark  Some operations are optimized to exploit possible SIMD
+ ** instructions. This requires image data to be properly aligned (typically
+ ** to 16 bytes). Similalry, the image stride (the number of bytes to skip to move
+ ** to the next image row), must be aligned.
+  **/
+
+#ifndef VL_IMOPV_INSTANTIATING
+
+#include "imopv.h"
+#include "imopv_sse2.h"
+#include "mathop.h"
+
+#define FLT VL_TYPE_FLOAT
+#define VL_IMOPV_INSTANTIATING
+#include "imopv.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define VL_IMOPV_INSTANTIATING
+#include "imopv.c"
+
+#define FLT VL_TYPE_UINT32
+#define VL_IMOPV_INSTANTIATING
+#include "imopv.c"
+
+#define FLT VL_TYPE_INT32
+#define VL_IMOPV_INSTANTIATING
+#include "imopv.c"
+
+/* VL_IMOPV_INSTANTIATING */
+#endif
+
+#if defined(VL_IMOPV_INSTANTIATING) || defined(__DOXYGEN__)
+
+#include "float.h"
+
+/* ---------------------------------------------------------------- */
+/*                                                Image Convolution */
+/* ---------------------------------------------------------------- */
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+/** @fn vl_imconvcol_vd(double*,vl_size,double const*,vl_size,vl_size,vl_size,double const*,vl_index,vl_index,int,unsigned int)
+ ** @brief Convolve image along columns
+ **
+ ** @param dst destination image.
+ ** @param dst_stride width of the destination image including padding.
+ ** @param src source image.
+ ** @param src_width width of the source image.
+ ** @param src_height height of the source image.
+ ** @param src_stride width of the source image including padding.
+ ** @param filt filter kernel.
+ ** @param filt_begin coordinate of the first filter element.
+ ** @param filt_end coordinate of the last filter element.
+ ** @param step sub-sampling step.
+ ** @param flags operation modes.
+ **
+ ** The function convolves the column of the image @a src by the
+ ** filter @a filt and saves the result to the image @a dst. The size
+ ** of @a dst must be equal to the size of @a src.  Formally, this
+ ** results in the calculation
+ **
+ ** @f[
+ ** \mathrm{dst} [x,y] = \sum_{p=y-\mathrm{filt\_end}}^{y-\mathrm{filt\_begin}}
+ ** \mathrm{src}[x,y] \mathrm{filt}[y - p - \mathrm{filt\_begin}]
+ ** @f]
+ **
+ ** The function subsamples the image along the columns according to
+ ** the parameter @a step. Setting @a step to 1 (one) computes the
+ ** elements @f$\mathrm{dst}[x,y]@f$ for all pairs (x,0), (x,1), (x,2)
+ ** and so on. Setting @a step two 2 (two) computes only (x,0), (x,2)
+ ** and so on (in this case the height of the destination image is
+ ** <code>floor(src_height/step)+1)</code>.
+ **
+ ** Calling twice the function can be used to compute 2-D separable
+ ** convolutions.  Use the flag ::VL_TRANSPOSE to transpose the result
+ ** (in this case @a dst has transposed dimension as well).
+ **
+ ** The function allows the support of the filter to be any range.
+ ** Usually the support is <code>@a filt_end = -@a filt_begin</code>.
+ **
+ ** The convolution operation may pick up values outside the image
+ ** boundary. To cope with this edge cases, the function either pads
+ ** the image by zero (::VL_PAD_BY_ZERO) or with the values at the
+ ** boundary (::VL_PAD_BY_CONTINUITY).
+ **/
+
+/** @fn vl_imconvcol_vf(float*,vl_size,float const*,vl_size,vl_size,vl_size,float const*,vl_index,vl_index,int,unsigned int)
+ ** @see ::vl_imconvcol_vd
+ **/
+
+VL_EXPORT void
+VL_XCAT(vl_imconvcol_v, SFX)
+(T* dst, vl_size dst_stride,
+ T const* src,
+ vl_size src_width, vl_size src_height, vl_size src_stride,
+ T const* filt, vl_index filt_begin, vl_index filt_end,
+ int step, unsigned int flags)
+{
+  vl_index x = 0 ;
+  vl_index y ;
+  vl_index dheight = (src_height - 1) / step + 1 ;
+  vl_bool transp = flags & VL_TRANSPOSE ;
+  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
+
+  /* dispatch to accelerated version */
+#ifndef VL_DISABLE_SSE2
+  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
+    VL_XCAT3(_vl_imconvcol_v,SFX,_sse2)
+    (dst,dst_stride,
+     src,src_width,src_height,src_stride,
+     filt,filt_begin,filt_end,
+     step,flags) ;
+    return ;
+  }
+#endif
+
+  /* let filt point to the last sample of the filter */
+  filt += filt_end - filt_begin ;
+
+  while (x < (signed)src_width) {
+    /* Calculate dest[x,y] = sum_p image[x,p] filt[y - p]
+     * where supp(filt) = [filt_begin, filt_end] = [fb,fe].
+     *
+     * CHUNK_A: y - fe <= p < 0
+     *          completes VL_MAX(fe - y, 0) samples
+     * CHUNK_B: VL_MAX(y - fe, 0) <= p < VL_MIN(y - fb, height - 1)
+     *          completes fe - VL_MAX(fb, height - y) + 1 samples
+     * CHUNK_C: completes all samples
+     */
+    T const *filti ;
+    vl_index stop ;
+
+    for (y = 0 ; y < (signed)src_height ; y += step) {
+      T acc = 0 ;
+      T v = 0, c ;
+      T const* srci ;
+
+      filti = filt ;
+      stop = filt_end - y ;
+      srci = src + x - stop * src_stride ;
+
+      if (stop > 0) {
+        if (zeropad) {
+          v = 0 ;
+        } else {
+          v = *(src + x) ;
+        }
+        while (filti > filt - stop) {
+          c = *filti-- ;
+          acc += v * c ;
+          srci += src_stride ;
+        }
+      }
+
+      stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
+      while (filti > filt - stop) {
+        v = *srci ;
+        c = *filti-- ;
+        acc += v * c ;
+        srci += src_stride ;
+      }
+
+      if (zeropad) v = 0 ;
+
+      stop = filt_end - filt_begin + 1 ;
+      while (filti > filt - stop) {
+        c = *filti-- ;
+        acc += v * c ;
+      }
+
+      if (transp) {
+        *dst = acc ; dst += 1 ;
+      } else {
+        *dst = acc ; dst += dst_stride ;
+      }
+    } /* next y */
+    if (transp) {
+      dst += 1 * dst_stride - dheight * 1 ;
+    } else {
+      dst += 1 * 1 - dheight * dst_stride ;
+    }
+    x += 1 ;
+  } /* next x */
+}
+
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                         Image distance transform */
+/* ---------------------------------------------------------------- */
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+/** @fn ::vl_image_distance_transform_d(double const*,vl_size,vl_size,vl_size,vl_size,double*,vl_uindex*,double,double)
+ ** @brief Compute the distance transform of an image
+ ** @param image image.
+ ** @param numColumns number of columns of the image.
+ ** @param numRows number of rows of the image.
+ ** @param columnStride offset from one column to the next.
+ ** @param rowStride offset from one row to the next.
+ ** @param distanceTransform distance transform (out).
+ ** @param indexes nearest neighbor indexes (in/out).
+ ** @param coeff quadratic cost coefficient (non-negative).
+ ** @param offset quadratic cost offset.
+ **
+ ** The function computes the distance transform along the first
+ ** dimension of the image @a image. Let @f$ I(u,v) @f$ be @a image.
+ ** Its distance transfrom @f$ D(u,v) @f$ is given by:
+ **
+ ** @f[
+ **   u^*(u,v) = \min_{u'} I(u',v) + \mathtt{coeff} (u' - u - \mathtt{offset})^2,
+ **   \quad D(u,v) = I(u^*(u,v),v).
+ ** @f]
+ **
+ ** Notice that @a coeff must be non negative.
+ **
+ ** The function fills in the buffer @a distanceTransform with @f$ D
+ ** @f$.  This buffer must have the same size as @a image.
+ **
+ ** If @a indexes is not @c NULL, it must be a matrix of the same size
+ ** o the image. The function interprets the value of this matrix as
+ ** indexes of the pixels, i.e @f$ \mathtt{indexes}(u,v) @f$ is the
+ ** index of pixel @f$ (u,v) @f$. On output, the matrix @a indexes
+ ** contains @f$ \mathtt{indexes}(u^*(u,v),v) @f$. This information
+ ** can be used to determine for each pixel @f$ (u,v) @f$ its
+ ** &ldquo;nearest neighbor&rdquo.
+ **
+ ** Notice that by swapping @a numRows and @a numColumns and @a
+ ** columnStride and @a rowStride, the function can be made to operate
+ ** along the other image dimension. Specifically, to compute the
+ ** distance transform along columns and rows, call the functinon
+ ** twice:
+ ***
+ ** @code
+ **   for (i = 0 ; i < numColumns * numRows ; ++i) indexes[i] = i ;
+ **   vl_image_distance_transform_d(image,numColumns,numRows,1,numColumns,
+ **                                 distanceTransform,indexes,u_coeff,u_offset) ;
+ **   vl_image_distance_transform_d(distanceTransform,numRows,numColumns,numColumns,1,
+ **                                 distanceTransform,indexes,u_coeff,u_offset) ;
+ ** @endcode
+ **
+ ** @par Algorithm
+ **
+ ** The function implements the algorithm described in:
+ ** P. F. Felzenszwalb and D. P. Huttenlocher, <em>Distance Transforms
+ ** of Sampled Functions,</em> Technical Report, Cornell University,
+ ** 2004.
+ **
+ ** Since the algorithm operates along one dimension per time,
+ ** consider the 1D version of the problem for simplicity:
+ **
+ ** @f[
+ **  d(y) = \min_{x} g(y;x), \quad g(y;x) = f(x) + \alpha (y - x - \beta)^2,
+ **  \quad x,y \in \{0,1,\dots,N-1\}.
+ ** @f]
+ **
+ ** Hence the distance transform @f$ d(y) @f$ is the lower envelope of
+ ** the family of parabolas @f$ g(y;x) @f$ indexed by @f$ x
+ ** @f$. Notice that all parabolas have the same curvature and that
+ ** their centers are located at @f$ x + \beta, @f$ @f$ x=0,\dots,N-1
+ ** @f$. The algorithm considers one parabola per time, from left to
+ ** right, and finds the interval for which the parabola belongs to
+ ** the lower envelope (if any).
+ **
+ ** Initially, only the leftmost parabola @f$ g(y;0) @f$ has been
+ ** considered, and its validity interval is @f$(-\infty, \infty) @f$.
+ ** Then the second parabola @f$ g(y;1) @f$ is considered. As long as
+ ** @f$ \alpha > 0 @f$, the two parabolas @f$ g(y;0),\ g(y;1) @f$
+ ** intersect at a unique point @f$ \bar y @f$. Then the first
+ ** parabola belongs to the envelope in the interval @f$ (-\infty,
+ ** \bar y] @f$ and the second one in the interval @f$ (\bar y,
+ ** +\infty] @f$. When the third parabola @f$ g(y;2) @f$ is
+ ** considered, the intersection point @f$ \hat y @f$ with the
+ ** previously added parabola @f$ g(y;1) @f$ is found. Now two cases
+ ** may arise:
+ **
+ ** - @f$ \hat y > \bar y @f$, in which case all three parabolas
+ **   belong to the envelope in the intervals @f$ (-\infty,\bar y],
+ **   (\bar y, \hat y], (\hat y, +\infty] @f$.
+ **
+ ** - @f$ \hat y \leq \bar y @f$, in which case the second parabola
+ **   @f$ g(y;1) @f$ has no point beloning to the envelope, and it is
+ **   removed.  One then remains with the two parabolas @f$ g(y;0),\
+ **   g(y;2) @f$ and the algorithm is re-iterated.
+ **
+ ** The algorithm proceeds in this fashion. Every time a new parabola
+ ** is considered, its intersection point with the previously added
+ ** parabola on the left is computed, and that parabola is potentially
+ ** removed.  The cost of an iteration is 1 plus the number of deleted
+ ** parabolas. Since there are @f$ N @f$ iterations and at most @f$ N
+ ** @f$ parabolas to delete overall, the complexity is linear,
+ ** i.e. @f$ O(N) @f$.
+ **/
+
+/** @fn ::vl_image_distance_transform_f(float const*,vl_size,vl_size,vl_size,vl_size,float*,vl_uindex*,float,float)
+ ** @see ::vl_image_distance_transform_d
+ **/
+
+VL_EXPORT void
+VL_XCAT(vl_image_distance_transform_,SFX)
+(T const * image,
+ vl_size numColumns,
+ vl_size numRows,
+ vl_size columnStride,
+ vl_size rowStride,
+ T * distanceTransform,
+ vl_uindex * indexes,
+ T coeff,
+ T offset)
+{
+  /* Each image pixel corresponds to a parabola. The algorithm scans
+   such parabolas from left to right, keeping track of which
+   parabolas belong to the lower envelope and in which interval. There are
+   NUM active parabolas, FROM stores the beginning of the interval
+   for which a certain parabola is part of the envoelope, and WHICH store
+   the index of the parabola (that is, the pixel x from which the parabola
+   originated).
+   */
+  vl_uindex x, y ;
+  T * from = vl_malloc (sizeof(T) * (numColumns + 1)) ;
+  T * base = vl_malloc (sizeof(T) * numColumns) ;
+  vl_uindex * baseIndexes = vl_malloc (sizeof(vl_uindex) * numColumns) ;
+  vl_uindex * which = vl_malloc (sizeof(vl_uindex) * numColumns) ;
+  vl_uindex num = 0 ;
+
+  for (y = 0 ; y < numRows ; ++y) {
+    num = 0 ;
+    for (x = 0 ; x < numColumns ; ++x) {
+      T r = image[x  * columnStride + y * rowStride] ;
+      T x2 = x * x ;
+#if (FLT == VL_TYPE_FLOAT)
+      T from_ = - VL_INFINITY_F ;
+#else
+      T from_ = - VL_INFINITY_D ;
+#endif
+
+      /*
+       Add next parabola (there are NUM so far). The algorithm finds
+       intersection INTERS with the previously added parabola. If
+       the intersection is on the right of the "starting point" of
+       this parabola, then the previous parabola is kept, and the
+       new one is added to its right. Otherwise the new parabola
+       "eats" the old one, which gets deleted and the check is
+       repeated with the parabola added before the deleted one.
+       */
+
+      while (num >= 1) {
+        vl_uindex x_ = which[num - 1] ;
+        T x2_ = x_ * x_ ;
+        T r_ = image[x_ * columnStride + y * rowStride] ;
+        T inters ;
+        if (r == r_) {
+          /* handles the case r = r_ = \pm inf */
+          inters = (x + x_) / 2.0 + offset ;
+        }
+#if (FLT == VL_TYPE_FLOAT)
+        else if (coeff > VL_EPSILON_F)
+#else
+        else if (coeff > VL_EPSILON_D)
+#endif
+        {
+          inters = ((r - r_) + coeff * (x2 - x2_)) / (x - x_) / (2*coeff) + offset ;
+        } else {
+          /* If coeff is very small, the parabolas are flat (= lines).
+           In this case the previous parabola should be deleted if the current
+           pixel has lower score */
+#if (FLT == VL_TYPE_FLOAT)
+          inters = (r < r_) ? - VL_INFINITY_F : VL_INFINITY_F ;
+#else
+          inters = (r < r_) ? - VL_INFINITY_D : VL_INFINITY_D ;
+#endif
+        }
+        if (inters <= from [num - 1]) {
+          /* delete a previous parabola */
+          -- num ;
+        } else {
+          /* accept intersection */
+          from_ = inters ;
+          break ;
+        }
+      }
+
+      /* add a new parabola */
+      which[num] = x ;
+      from[num] = from_ ;
+      base[num] = r ;
+      if (indexes) baseIndexes[num] = indexes[x  * columnStride + y * rowStride] ;
+      num ++ ;
+    } /* next column */
+
+#if (FLT == VL_TYPE_FLOAT)
+    from[num] = VL_INFINITY_F ;
+#else
+    from[num] = VL_INFINITY_D ;
+#endif
+
+    /* fill in */
+    num = 0 ;
+    for (x = 0 ; x < numColumns ; ++x) {
+      double delta ;
+      while (x >= from[num + 1]) ++ num ;
+      delta = (double) x - (double) which[num] - offset ;
+      distanceTransform[x  * columnStride + y * rowStride]
+      = base[num] + coeff * delta * delta ;
+      if (indexes) {
+        indexes[x  * columnStride + y * rowStride]
+        = baseIndexes[num] ;
+      }
+    }
+  } /* next row */
+
+  vl_free (from) ;
+  vl_free (which) ;
+  vl_free (base) ;
+  vl_free (baseIndexes) ;
+}
+
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                         Image convolution by a triangular kernel */
+/* ---------------------------------------------------------------- */
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+/** @fn vl_imconvcoltri_d(double*,vl_size,double const*,vl_size,vl_size,vl_size,vl_size,vl_size,int unsigned)
+ ** @brief Convolve an image along the columns with a triangular kernel
+ ** @param dest destination image.
+ ** @param destStride destination image stride.
+ ** @param image image to convolve.
+ ** @param imageWidth width of the image.
+ ** @param imageHeight height of the image.
+ ** @param imageStride width of the image including padding.
+ ** @param filterSize size of the triangular filter.
+ ** @param step sub-sampling step.
+ ** @param flags operation modes.
+ **
+ ** The function convolves the columns of the image @a image with the
+ ** triangular kernel
+ **
+ ** @f[
+ **   k(t) = \frac{1}{\Delta^2} \max\{ \Delta -  |t|, 0 \},
+ **   \quad t \in \mathbb{Z}
+ ** @f]
+ **
+ ** The paramter @f$ \Delta @f$, equal to the function argument @a
+ ** filterSize, controls the width of the kernel. Notice that the
+ ** support of @f$ k(x) @f$ as a continuous function of @f$ x @f$ is
+ ** the open interval @f$ (-\Delta,\Delta) @f$, which has length @f$
+ ** 2\Delta @f$.  However, @f$ k(x) @f$ restricted to the ingeter
+ ** domain @f$ x \in \mathcal{Z} @f$ has support @f$ \{ -\Delta + 1,
+ ** \Delta +2, \dots, \Delta-1 \} @f$, which counts @f$ 2 \Delta - 1
+ ** @f$ elements only. In particular, the discrete kernel is symmetric
+ ** about the origin for all values of @f$ \Delta @f$.
+ **
+ ** The normalization factor @f$ 1 / \Delta^2 @f$ guaratnees that the
+ ** filter is normalized to one, i.e.:
+ **
+ ** @f[
+ **   \sum_{t=-\infty}^{+\infty} k(t) = 1
+ ** @f]
+ **
+ ** @par Algorithm
+ **
+ ** The function exploits the fact that convolution by a triangular
+ ** kernel can be expressed as the repeated convolution by a
+ ** rectangular kernel, and that the latter can be performed in time
+ ** indepenedent on the fiter width by using an integral-image type
+ ** trick. Overall, the algorithm complexity is independent on the
+ ** parameter @a filterSize and linear in the nubmer of image pixels.
+ **
+ ** @see ::vl_imconvcol_vd for details on the meaning of the other parameters.
+ **/
+
+/** @fn vl_imconvcoltri_f(float*,vl_size,float const*,vl_size,vl_size,vl_size,vl_size,vl_size,int unsigned)
+ ** @brief Convolve an image along the columns with a triangular kernel
+ ** @see ::vl_imconvcoltri_d()
+ **/
+
+VL_EXPORT void
+VL_XCAT(vl_imconvcoltri_, SFX)
+(T * dest, vl_size destStride,
+ T const * image,
+ vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
+ vl_size filterSize,
+ vl_size step, unsigned int flags)
+{
+  vl_index x, y, dheight ;
+  vl_bool transp = flags & VL_TRANSPOSE ;
+  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
+  T scale = (T) (1.0 / ((double)filterSize * (double)filterSize)) ;
+  T * buffer = vl_malloc (sizeof(T) * (imageHeight + filterSize)) ;
+  buffer += filterSize ;
+
+  if (imageHeight == 0) {
+    return  ;
+  }
+
+  x = 0 ;
+  dheight = (imageHeight - 1) / step + 1 ;
+
+  while (x < (signed)imageWidth) {
+    T const * imagei ;
+    imagei = image + x + imageStride * (imageHeight - 1) ;
+
+    /* We decompose the convolution by a triangluar signal as the convolution
+     * by two rectangular signals. The rectangular convolutions are computed
+     * quickly by computing the integral signals. Each rectangular convolution
+     * introduces a delay, which is compensated by convolving each in opposite
+     * directions.
+     */
+
+    /* integrate backward the column */
+    buffer[imageHeight - 1] = *imagei ;
+    for (y = (signed)imageHeight - 2 ; y >=  0 ; --y) {
+      imagei -= imageStride ;
+      buffer[y] = buffer[y + 1] + *imagei ;
+    }
+    if (zeropad) {
+      for ( ; y >= - (signed)filterSize ; --y) {
+        buffer[y] = buffer[y + 1] ;
+      }
+    } else {
+      for ( ; y >= - (signed)filterSize ; --y) {
+        buffer[y] = buffer[y + 1] + *imagei ;
+      }
+    }
+
+    /* compute the filter forward */
+    for (y = - (signed)filterSize ;
+         y < (signed)imageHeight - (signed)filterSize ; ++y) {
+      buffer[y] = buffer[y] - buffer[y + filterSize] ;
+    }
+    if (! zeropad) {
+      for (y = (signed)imageHeight - (signed)filterSize ;
+           y < (signed)imageHeight ;
+           ++y) {
+        buffer[y] = buffer[y] - buffer[imageHeight - 1]  *
+        ((signed)imageHeight - (signed)filterSize - y) ;
+      }
+    }
+
+    /* integrate forward the column */
+    for (y = - (signed)filterSize + 1 ;
+         y < (signed)imageHeight ; ++y) {
+      buffer[y] += buffer[y - 1] ;
+    }
+
+    /* compute the filter backward */
+    {
+      vl_size stride = transp ? 1 : destStride ;
+      dest += dheight * stride ;
+      for (y = step * (dheight - 1) ; y >= 0 ; y -= step) {
+        dest -= stride ;
+        *dest = scale * (buffer[y] - buffer[y - (signed)filterSize]) ;
+      }
+      dest += transp ? destStride : 1 ;
+    }
+    x += 1 ;
+  } /* next x */
+  vl_free (buffer - filterSize) ;
+}
+
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                               Gaussian Smoothing */
+/* ---------------------------------------------------------------- */
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+/** @fn vl_imsmooth_d(double*,vl_size,double const*,vl_size,vl_size,vl_size,double,double)
+ ** @brief Smooth an image with a Gaussian filter
+ ** @param smoothed
+ ** @param smoothedStride
+ ** @param image
+ ** @param width
+ ** @param height
+ ** @param stride
+ ** @param sigmax
+ ** @param sigmay
+ **/
+
+/** @fn vl_imsmooth_f(float*,vl_size,float const*,vl_size,vl_size,vl_size,double,double)
+ ** @brief Smooth an image with a Gaussian filter
+ ** @see ::vl_imsmooth_d
+ **/
+
+static T*
+VL_XCAT(_vl_new_gaussian_fitler_,SFX)(vl_size *size, double sigma)
+{
+  T* filter ;
+  T mass = (T)1.0 ;
+  vl_index i ;
+  vl_size width = vl_ceil_d(sigma * 3.0) ;
+  *size = 2 * width + 1 ;
+
+  assert(size) ;
+
+  filter = vl_malloc((*size) * sizeof(T)) ;
+  filter[width] = 1.0 ;
+  for (i = 1 ; i <= (signed)width ; ++i) {
+    double x = (double)i / sigma ;
+    double g = exp(-0.5 * x * x) ;
+    mass += g + g ;
+    filter[width-i] = g ;
+    filter[width+i] = g ;
+  }
+  for (i = 0 ; i < (signed)(*size) ; ++i) {filter[i] /= mass ;}
+  return filter ;
+}
+
+VL_EXPORT void
+VL_XCAT(vl_imsmooth_, SFX)
+(T * smoothed, vl_size smoothedStride,
+ T const *image, vl_size width, vl_size height, vl_size stride,
+ double sigmax, double sigmay)
+{
+  T *filterx, *filtery, *buffer ;
+  vl_size sizex, sizey ;
+
+  filterx = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizex,sigmax) ;
+  if (sigmax == sigmay) {
+    filtery = filterx ;
+    sizey = sizex ;
+  } else {
+    filtery = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizey,sigmay) ;
+  }
+  buffer = vl_malloc(width*height*sizeof(T)) ;
+
+  VL_XCAT(vl_imconvcol_v,SFX) (buffer, height,
+                               image, width, height, stride,
+                               filtery,
+                               -((signed)sizey-1)/2, ((signed)sizey-1)/2,
+                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
+
+  VL_XCAT(vl_imconvcol_v,SFX) (smoothed, smoothedStride,
+                               buffer, height, width, height,
+                               filterx,
+                               -((signed)sizex-1)/2, ((signed)sizex-1)/2,
+                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
+
+  vl_free(buffer) ;
+  vl_free(filterx) ;
+  if (sigmax != sigmay) {
+    vl_free(filtery) ;
+  }
+}
+
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                                   Image Gradient */
+/* ---------------------------------------------------------------- */
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+/** @fn vl_imgradient_d(double*,double*,vl_size,vl_size,double*,vl_size,vl_size,vl_size)
+ ** @brief Compute image gradient
+ ** @param xGradient Pointer to amplitude gradient plane
+ ** @param yGradient Pointer to angle gradient plane
+ ** @param gradWidthStride Width of the gradient plane including padding
+ ** @param gradHeightStride Height of the gradient plane including padding
+ ** @param image Pointer to the source image
+ ** @param imageWidth Source image width
+ ** @param imageHeight Source image height
+ ** @param imageStride Width of the image including padding.
+ **
+ ** This functions computes the amplitudes and angles of input image gradient.
+ **
+ ** Gradient is computed simple by gradient kernel \f$ (-1 ~ 1) \f$,
+ ** \f$ (-1 ~ 1)^T \f$ for border pixels and with sobel filter kernel
+ ** \f$ (-0.5 ~ 0 ~ 0.5) \f$, \f$ (-0.5 ~ 0 ~ 0.5)^T \f$ otherwise on the input
+ ** image @a image yielding x-gradient \f$ dx \f$, stored in @a xGradient and
+ ** y-gradient \f$ dy \f$, stored in @a yGradient, respectively.
+ **
+ ** This function also allows to process only part of the input image
+ ** defining the @a imageStride as original image width and @a width as
+ ** width of the sub-image.
+ **
+ ** Also it allows to easily align the output data by definition
+ ** of the @a gradWidthStride and @a gradHeightStride .
+ **/
+
+/** @fn vl_imgradient_f(float*,float*,vl_size,vl_size,float*,vl_size,vl_size,vl_size)
+ ** @brief Compute image gradient
+ ** @see ::vl_imgradient_d
+ **/
+
+VL_EXPORT void
+VL_XCAT(vl_imgradient_, SFX)
+(T * xGradient, T * yGradient,
+ vl_size gradWidthStride, vl_size gradHeightStride,
+ T const * image,
+ vl_size imageWidth, vl_size imageHeight,
+ vl_size imageStride)
+{
+  /* Shortcuts */
+  vl_index const xo = 1 ;
+  vl_index const yo = imageStride ;
+  vl_size const w = imageWidth;
+  vl_size const h = imageHeight;
+
+  T const *src, *end ;
+  T *pgrad_x, *pgrad_y;
+  vl_size y;
+
+  src  = image ;
+  pgrad_x = xGradient ;
+  pgrad_y = yGradient ;
+
+  /* first pixel of the first row */
+  *pgrad_x = src[+xo] - src[0] ;
+  pgrad_x += gradWidthStride;
+  *pgrad_y = src[+yo] - src[0] ;
+  pgrad_y += gradWidthStride;
+  src++;
+
+  /* middle pixels of the  first row */
+  end = (src - 1) + w - 1 ;
+  while (src < end) {
+    *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
+    pgrad_x += gradWidthStride;
+    *pgrad_y =        src[+yo] - src[0] ;
+    pgrad_y += gradWidthStride;
+    src++;
+  }
+
+  /* last pixel of the first row */
+  *pgrad_x = src[0]   - src[-xo] ;
+  pgrad_x += gradWidthStride;
+  *pgrad_y = src[+yo] - src[0] ;
+  pgrad_y += gradWidthStride;
+  src++;
+
+  xGradient += gradHeightStride;
+  pgrad_x = xGradient;
+  yGradient += gradHeightStride;
+  pgrad_y = yGradient;
+  image += yo;
+  src = image;
+
+  for (y = 1 ; y < h -1 ; ++y) {
+
+    /* first pixel of the middle rows */
+    *pgrad_x =        src[+xo] - src[0] ;
+    pgrad_x += gradWidthStride;
+    *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
+    pgrad_y += gradWidthStride;
+    src++;
+
+    /* middle pixels of the middle rows */
+    end = (src - 1) + w - 1 ;
+    while (src < end) {
+      *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
+      pgrad_x += gradWidthStride;
+      *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
+      pgrad_y += gradWidthStride;
+      src++;
+    }
+
+    /* last pixel of the middle row */
+    *pgrad_x =        src[0]   - src[-xo] ;
+    pgrad_x += gradWidthStride;
+    *pgrad_y = 0.5 * (src[+yo] - src[-yo]) ;
+    pgrad_y += gradWidthStride;
+    src++;
+
+    xGradient += gradHeightStride;
+    pgrad_x = xGradient;
+    yGradient += gradHeightStride;
+    pgrad_y = yGradient;
+    image += yo;
+    src = image;
+  }
+
+  /* first pixel of the last row */
+  *pgrad_x = src[+xo] - src[0] ;
+  pgrad_x += gradWidthStride;
+  *pgrad_y = src[  0] - src[-yo] ;
+  pgrad_y += gradWidthStride;
+  src++;
+
+  /* middle pixels of the last row */
+  end = (src - 1) + w - 1 ;
+  while (src < end) {
+    *pgrad_x = 0.5 * (src[+xo] - src[-xo]) ;
+    pgrad_x += gradWidthStride;
+    *pgrad_y =        src[0]   - src[-yo] ;
+    pgrad_y += gradWidthStride;
+    src++;
+  }
+
+  /* last pixel of the last row */
+  *pgrad_x = src[0]   - src[-xo] ;
+  *pgrad_y = src[0]   - src[-yo] ;
+}
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+
+/** @fn vl_imgradient_polar_d(double*,double*,vl_size,vl_size,double const*,vl_size,vl_size,vl_size)
+ ** @brief Compute gradient mangitudes and directions of an image.
+ ** @param amplitudeGradient Pointer to amplitude gradient plane
+ ** @param angleGradient Pointer to angle gradient plane
+ ** @param gradWidthStride Width of the gradient plane including padding
+ ** @param gradHeightStride Height of the gradient plane including padding
+ ** @param image Pointer to the source image
+ ** @param imageWidth Source image width
+ ** @param imageHeight Source image height
+ ** @param imageStride Width of the source image including padding.
+ **
+ ** This functions computes the amplitudes and angles of input image gradient.
+ **
+ ** Gradient is computed simple by gradient kernel \f$ (-1 ~ 1) \f$,
+ ** \f$ (-1 ~ 1)^T \f$ for border pixels and with sobel filter kernel
+ ** \f$ (-0.5 ~ 0 ~ 0.5) \f$, \f$ (-0.5 ~ 0 ~ 0.5)^T \f$ otherwise on
+ ** the input image @a image yielding x-gradient \f$ dx \f$, stored in
+ ** @a xGradient and y-gradient \f$ dy \f$, stored in @a yGradient,
+ ** respectively.
+ **
+ ** The amplitude of the gradient, stored in plane @a
+ ** amplitudeGradient, is then calculated as \f$ \sqrt(dx^2+dy^2) \f$
+ ** and the angle of the gradient, stored in @a angleGradient is \f$
+ ** atan(\frac{dy}{dx}) \f$ normalised into interval 0 and @f$ 2\pi
+ ** @f$.
+ **
+ ** This function also allows to process only part of the input image
+ ** defining the @a imageStride as original image width and @a width
+ ** as width of the sub-image.
+ **
+ ** Also it allows to easily align the output data by definition
+ ** of the @a gradWidthStride and @a gradHeightStride .
+ **/
+
+/** @fn vl_imgradient_polar_f(float*,float*,vl_size,vl_size,float const*,vl_size,vl_size,vl_size)
+ ** @see ::vl_imgradient_polar_d
+ **/
+
+#if (FLT == VL_TYPE_FLOAT || FLT == VL_TYPE_DOUBLE)
+
+VL_EXPORT void
+VL_XCAT(vl_imgradient_polar_, SFX)
+(T * gradientModulus, T * gradientAngle,
+ vl_size gradientHorizontalStride, vl_size gradHeightStride,
+ T const* image,
+ vl_size imageWidth, vl_size imageHeight, vl_size imageStride)
+{
+  /* Shortcuts */
+  vl_index const xo = 1 ;
+  vl_index const yo = imageStride ;
+  vl_size const w = imageWidth;
+  vl_size const h = imageHeight;
+
+  T const *src, *end;
+  T *pgrad_angl, *pgrad_ampl;
+  T gx, gy ;
+  vl_size y;
+
+#define SAVE_BACK                                                    \
+*pgrad_ampl = vl_fast_sqrt_f (gx*gx + gy*gy) ;                       \
+pgrad_ampl += gradientHorizontalStride ;                             \
+*pgrad_angl = vl_mod_2pi_f   (vl_fast_atan2_f (gy, gx) + 2*VL_PI) ;  \
+pgrad_angl += gradientHorizontalStride ;                             \
+++src ;                                                              \
+
+  src  = image ;
+  pgrad_angl = gradientAngle ;
+  pgrad_ampl = gradientModulus ;
+
+  /* first pixel of the first row */
+  gx = src[+xo] - src[0] ;
+  gy = src[+yo] - src[0] ;
+  SAVE_BACK ;
+
+  /* middle pixels of the  first row */
+  end = (src - 1) + w - 1 ;
+  while (src < end) {
+    gx = 0.5 * (src[+xo] - src[-xo]) ;
+    gy =        src[+yo] - src[0] ;
+    SAVE_BACK ;
+  }
+
+  /* last pixel of the first row */
+  gx = src[0]   - src[-xo] ;
+  gy = src[+yo] - src[0] ;
+  SAVE_BACK ;
+
+  gradientModulus += gradHeightStride;
+  pgrad_ampl = gradientModulus;
+  gradientAngle += gradHeightStride;
+  pgrad_angl = gradientAngle;
+  image += imageStride;
+  src = image;
+
+  for (y = 1 ; y < h -1 ; ++y) {
+
+    /* first pixel of the middle rows */
+    gx =        src[+xo] - src[0] ;
+    gy = 0.5 * (src[+yo] - src[-yo]) ;
+    SAVE_BACK ;
+
+    /* middle pixels of the middle rows */
+    end = (src - 1) + w - 1 ;
+    while (src < end) {
+      gx = 0.5 * (src[+xo] - src[-xo]) ;
+      gy = 0.5 * (src[+yo] - src[-yo]) ;
+      SAVE_BACK ;
+    }
+
+    /* last pixel of the middle row */
+    gx =        src[0]   - src[-xo] ;
+    gy = 0.5 * (src[+yo] - src[-yo]) ;
+    SAVE_BACK ;
+
+    gradientModulus += gradHeightStride;
+    pgrad_ampl = gradientModulus;
+    gradientAngle += gradHeightStride;
+    pgrad_angl = gradientAngle;
+    image += imageStride;
+    src = image;
+  }
+
+  /* first pixel of the last row */
+  gx = src[+xo] - src[0] ;
+  gy = src[  0] - src[-yo] ;
+  SAVE_BACK ;
+
+  /* middle pixels of the last row */
+  end = (src - 1) + w - 1 ;
+  while (src < end) {
+    gx = 0.5 * (src[+xo] - src[-xo]) ;
+    gy =        src[0]   - src[-yo] ;
+    SAVE_BACK ;
+  }
+
+  /* last pixel of the last row */
+  gx = src[0]   - src[-xo] ;
+  gy = src[0]   - src[-yo] ;
+  SAVE_BACK ;
+
+}
+/* VL_TYPE_FLOAT, VL_TYPE_DOUBLE */
+#endif
+
+/* ---------------------------------------------------------------- */
+/*                                                   Integral Image */
+/* ---------------------------------------------------------------- */
+
+/** @fn vl_imintegral_d(double*,vl_size,double const*,vl_size,vl_size,vl_size)
+ ** @brief Compute integral image
+ **
+ ** @param integral integral image.
+ ** @param integralStride integral image stride.
+ ** @param image source image.
+ ** @param imageWidth source image width.
+ ** @param imageHeight source image height.
+ ** @param imageStride source image stride.
+ **
+ ** Let @f$ I(x,y), (x,y) \in [0, W-1] \times [0, H-1] @f$. The
+ ** function computes the integral image @f$ J(x,y) @f$ of @f$ I(x,g)
+ ** @f$:
+ **
+ ** @f[
+ **   J(x,y) = \sum_{x'=0}^{x} \sum_{y'=0}^{y} I(x',y')
+ ** @f]
+ **
+ ** The integral image @f$ J(x,y) @f$ can be used to compute quickly
+ ** the integral of of @f$ I(x,y) @f$ in a rectangular region @f$ R =
+ ** [x',x'']\times[y',y''] @f$:
+ **
+ ** @f[
+ **  \sum_{(x,y)\in[x',x'']\times[y',y'']} I(x,y) =
+ **  (J(x'',y'') - J(x'-1, y'')) - (J(x'',y'-1) - J(x'-1,y'-1)).
+ ** @f]
+ **
+ ** Note that the order of operations is important when the integral image
+ ** has an unsigned data type (e.g. ::vl_uint32). The formula
+ ** is easily derived as follows:
+ **
+ ** @f{eqnarray*}
+ **   \sum_{(x,y)\in R} I(x,y)
+ **   &=& \sum_{x=x'}^{x''} \sum_{y=y'}^{y''} I(x,y)\\
+ **   &=& \sum_{x=0}^{x''}  \sum_{y=y'}^{y''} I(x,y)
+ **     - \sum_{x=0}^{x'-1} \sum_{y=y'}^{y''} I(x,y)\\
+ **   &=& \sum_{x=0}^{x''}  \sum_{y=0}^{y''}  I(x,y)
+ **     - \sum_{x=0}^{x''}  \sum_{y=0}^{y'-1} I(x,y)
+ **     - \sum_{x=0}^{x'-1} \sum_{y=0}^{y''}  I(x,y)
+ **     + \sum_{x=0}^{x'-1} \sum_{y=0}^{y'-1} I(x,y)\\
+ **   &=& J(x'',y'') - J(x'-1,y'') - J(x'',y'-1) + J(x'-1,y'-1).
+ ** @f}
+ **/
+
+/** @fn vl_imintegral_f(float*,vl_size,float const*,vl_size,vl_size,vl_size)
+ ** @brief Compute integral image
+ ** @see ::vl_imintegral_d.
+ **/
+
+/** @fn vl_imintegral_ui32(vl_uint32*,vl_size,vl_uint32 const*,vl_size,vl_size,vl_size)
+ ** @brief Compute integral image
+ ** @see ::vl_imintegral_d.
+ **/
+
+/** @fn vl_imintegral_i32(vl_int32*,vl_size,vl_int32 const*,vl_size,vl_size,vl_size)
+ ** @brief Compute integral image
+ ** @see ::vl_imintegral_d.
+ **/
+
+VL_EXPORT void
+VL_XCAT(vl_imintegral_, SFX)
+(T * integral, vl_size integralStride,
+ T const * image,
+ vl_size imageWidth, vl_size imageHeight, vl_size imageStride)
+{
+  vl_uindex x, y ;
+  T temp  = 0 ;
+
+  if (imageHeight > 0) {
+    for (x = 0 ; x < imageWidth ; ++ x) {
+      temp += *image++ ;
+      *integral++ = temp ;
+    }
+  }
+
+  for (y = 1 ; y < imageHeight ; ++ y) {
+    T * integralPrev ;
+    integral += integralStride - imageWidth ;
+    image += imageStride - imageWidth ;
+    integralPrev = integral - integralStride ;
+
+    temp = 0 ;
+    for (x = 0 ; x < imageWidth ; ++ x) {
+      temp += *image++ ;
+      *integral++ = *integralPrev++ + temp ;
+    }
+  }
+}
+
+/* endif VL_IMOPV_INSTANTIATING */
+#undef FLT
+#undef VL_IMOPV_INSTANTIATING
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv.h b/opensfm/src/third_party/vlfeat/vl/imopv.h
new file mode 100644
index 000000000..ca127ca3c
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/imopv.h
@@ -0,0 +1,164 @@
+/** @file imopv.h
+ ** @brief Vectorized image operations
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_IMOPV_H
+#define VL_IMOPV_H
+
+#include "generic.h"
+
+/** @name Image convolution flags
+ ** @{ */
+#define VL_PAD_BY_ZERO       (0x0 << 0) /**< @brief Pad with zeroes. */
+#define VL_PAD_BY_CONTINUITY (0x1 << 0) /**< @brief Pad by continuity. */
+#define VL_PAD_MASK          (0x3)      /**< @brief Padding field selector. */
+#define VL_TRANSPOSE         (0x1 << 2) /**< @brief Transpose result. */
+/** @} */
+
+/** @name Image convolution
+ ** @{ */
+VL_EXPORT
+void vl_imconvcol_vf (float* dst, vl_size dst_stride,
+                      float const* src,
+                      vl_size src_width, vl_size src_height, vl_size src_stride,
+                      float const* filt, vl_index filt_begin, vl_index filt_end,
+                      int step, unsigned int flags) ;
+
+VL_EXPORT
+void vl_imconvcol_vd (double* dst, vl_size dst_stride,
+                      double const* src,
+                      vl_size src_width, vl_size src_height, vl_size src_stride,
+                      double const* filt, vl_index filt_begin, vl_index filt_end,
+                      int step, unsigned int flags) ;
+
+VL_EXPORT
+void vl_imconvcoltri_f (float * dest, vl_size destStride,
+                        float const * image,
+                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
+                        vl_size filterSize,
+                        vl_size step, int unsigned flags) ;
+
+VL_EXPORT
+void vl_imconvcoltri_d (double * dest, vl_size destStride,
+                        double const * image,
+                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride,
+                        vl_size filterSize,
+                        vl_size step, int unsigned flags) ;
+/** @} */
+
+/** @name Integral image
+ ** @{ */
+VL_EXPORT
+void vl_imintegral_f (float * integral,  vl_size integralStride,
+                      float const * image,
+                      vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
+
+VL_EXPORT
+void vl_imintegral_d (double * integral,  vl_size integralStride,
+                      double const * image,
+                      vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
+
+VL_EXPORT
+void vl_imintegral_i32 (vl_int32 * integral,  vl_size integralStride,
+                        vl_int32 const * image,
+                        vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
+
+VL_EXPORT
+void vl_imintegral_ui32 (vl_uint32 * integral,  vl_size integralStride,
+                         vl_uint32 const * image,
+                         vl_size imageWidth, vl_size imageHeight, vl_size imageStride) ;
+/** @} */
+
+/** @name Distance transform */
+/** @{ */
+
+VL_EXPORT void
+vl_image_distance_transform_d (double const * image,
+                               vl_size numColumns,
+                               vl_size numRows,
+                               vl_size columnStride,
+                               vl_size rowStride,
+                               double * distanceTransform,
+                               vl_uindex * indexes,
+                               double coeff,
+                               double offset) ;
+
+VL_EXPORT void
+vl_image_distance_transform_f (float const * image,
+                               vl_size numColumns,
+                               vl_size numRows,
+                               vl_size columnStride,
+                               vl_size rowStride,
+                               float * distanceTransform,
+                               vl_uindex * indexes,
+                               float coeff,
+                               float offset) ;
+
+/** @} */
+
+/* ---------------------------------------------------------------- */
+/** @name Image smoothing */
+/** @{ */
+
+VL_EXPORT void
+vl_imsmooth_f (float *smoothed, vl_size smoothedStride,
+               float const *image, vl_size width, vl_size height, vl_size stride,
+               double sigmax, double sigmay) ;
+
+VL_EXPORT void
+vl_imsmooth_d (double *smoothed, vl_size smoothedStride,
+               double const *image, vl_size width, vl_size height, vl_size stride,
+               double sigmax, double sigmay) ;
+
+/** @} */
+
+/* ---------------------------------------------------------------- */
+/** @name Image gradients */
+/** @{ */
+VL_EXPORT void
+vl_imgradient_polar_f (float* amplitudeGradient, float* angleGradient,
+                       vl_size gradWidthStride, vl_size gradHeightStride,
+                       float const* image,
+                       vl_size imageWidth, vl_size imageHeight,
+                       vl_size imageStride);
+
+VL_EXPORT void
+vl_imgradient_polar_d (double* amplitudeGradient, double* angleGradient,
+                       vl_size gradWidthStride, vl_size gradHeightStride,
+                       double const* image,
+                       vl_size imageWidth, vl_size imageHeight,
+                       vl_size imageStride);
+
+VL_EXPORT void
+vl_imgradient_f (float* xGradient, float* yGradient,
+                 vl_size gradWidthStride, vl_size gradHeightStride,
+                 float const *image,
+                 vl_size imageWidth, vl_size imageHeight, vl_size imageStride);
+
+VL_EXPORT void
+vl_imgradient_d(double* xGradient, double* yGradient,
+                vl_size gradWidthStride, vl_size gradHeightStride,
+                double const *image,
+                vl_size imageWidth, vl_size imageHeight, vl_size imageStride);
+
+VL_EXPORT void
+vl_imgradient_polar_f_callback(float const *sourceImage,
+                               int sourceImageWidth, int sourceImageHeight,
+                               float *dstImage,
+                               int dstWidth, int dstHeight,
+                               int octave, int level,
+                               void *params);
+
+/** @} */
+
+/* VL_IMOPV_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
new file mode 100644
index 000000000..11df6d858
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.c
@@ -0,0 +1,289 @@
+/** @file imopv_sse2.c
+ ** @brief Vectorized image operations - SSE2 - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#if ! defined(VL_DISABLE_SSE2) & ! defined(__SSE2__)
+#error "Compiling with SSE2 enabled, but no __SSE2__ defined"
+#endif
+
+#if ! defined(VL_DISABLE_SSE2)
+
+#ifndef VL_IMOPV_SSE2_INSTANTIATING
+
+#include <emmintrin.h>
+
+#include "imopv.h"
+#include "imopv_sse2.h"
+
+#define FLT VL_TYPE_FLOAT
+#define VL_IMOPV_SSE2_INSTANTIATING
+#include "imopv_sse2.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define VL_IMOPV_SSE2_INSTANTIATING
+#include "imopv_sse2.c"
+
+/* ---------------------------------------------------------------- */
+/* VL_IMOPV_SSE2_INSTANTIATING */
+#else
+
+#include "float.h"
+
+/* ---------------------------------------------------------------- */
+void
+VL_XCAT3(_vl_imconvcol_v, SFX, _sse2)
+(T* dst, vl_size dst_stride,
+ T const* src,
+ vl_size src_width, vl_size src_height, vl_size src_stride,
+ T const* filt, vl_index filt_begin, vl_index filt_end,
+ int step, unsigned int flags)
+{
+  vl_index x = 0 ;
+  vl_index y ;
+  vl_index dheight = (src_height - 1) / step + 1 ;
+  vl_bool use_simd  = VALIGNED(src_stride) ;
+  vl_bool transp    = flags & VL_TRANSPOSE ;
+  vl_bool zeropad   = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
+  double totcol = 0 ;
+  double simdcol = 0 ;
+
+  /* let filt point to the last sample of the filter */
+  filt += filt_end - filt_begin ;
+
+  while (x < (signed)src_width) {
+    /* Calculate dest[x,y] = sum_p image[x,p] filt[y - p]
+     * where supp(filt) = [filt_begin, filt_end] = [fb,fe].
+     *
+     * CHUNK_A: y - fe <= p < 0
+     *          completes VL_MAX(fe - y, 0) samples
+     * CHUNK_B: VL_MAX(y - fe, 0) <= p < VL_MIN(y - fb, height - 1)
+     *          completes fe - VL_MAX(fb, height - y) + 1 samples
+     * CHUNK_C: completes all samples
+     */
+
+    T const *filti ;
+    vl_index stop ;
+
+    if ((x + VSIZE < (signed)src_width) &
+        VALIGNED(src + x) & use_simd)
+    {
+      /* ----------------------------------------------  Vectorized */
+      for (y = 0 ; y < (signed)src_height ; y += step)  {
+        union {VTYPE v ; T x [VSIZE] ; } acc ;
+        VTYPE v, c ;
+        T const *srci ;
+        acc.v = VSTZ () ;
+        v = VSTZ() ;
+
+        filti = filt ;
+        stop = filt_end - y ;
+        srci = src + x - stop * src_stride ;
+
+        if (stop > 0) {
+          if (zeropad) {
+            v = VSTZ () ;
+          } else {
+            v = * (VTYPE*) (src + x) ;
+          }
+          while (filti > filt - stop) {
+            c = VLD1 (filti--) ;
+            acc.v = VADD (acc.v,  VMUL (v, c)) ;
+            srci += src_stride ;
+          }
+        }
+
+        stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
+        while (filti > filt - stop) {
+          v = * (VTYPE*) srci ;
+          c = VLD1 (filti--) ;
+          acc.v = VADD (acc.v, VMUL (v, c)) ;
+          srci += src_stride ;
+        }
+
+        if (zeropad) v = VSTZ () ;
+
+        stop = filt_end - filt_begin + 1;
+        while (filti > filt - stop) {
+          c = VLD1 (filti--) ;
+          acc.v = VADD (acc.v, VMUL (v, c)) ;
+        }
+
+        if (transp) {
+          *dst = acc.x[0] ; dst += dst_stride ;
+          *dst = acc.x[1] ; dst += dst_stride ;
+#if(VSIZE == 4)
+          *dst = acc.x[2] ; dst += dst_stride ;
+          *dst = acc.x[3] ; dst += dst_stride ;
+#endif
+          dst += 1 * 1 - VSIZE * dst_stride ;
+        } else {
+          *dst = acc.x[0] ; dst += 1 ;
+          *dst = acc.x[1] ; dst += 1 ;
+#if(VSIZE == 4)
+          *dst = acc.x[2] ; dst += 1 ;
+          *dst = acc.x[3] ; dst += 1 ;
+#endif
+          dst += 1 * dst_stride - VSIZE * 1 ;
+        }
+      } /* next y */
+      if (transp) {
+        dst += VSIZE * dst_stride - dheight * 1 ;
+      } else {
+        dst += VSIZE * 1 - dheight * dst_stride ;
+      }
+      x       += VSIZE ;
+      simdcol += VSIZE ;
+      totcol  += VSIZE ;
+    } else {
+      /* -------------------------------------------------  Vanilla */
+      for (y = 0 ; y < (signed)src_height ; y += step) {
+        T acc = 0 ;
+        T v = 0, c ;
+        T const* srci ;
+
+        filti = filt ;
+        stop = filt_end - y ;
+        srci = src + x - stop * src_stride ;
+
+        if (stop > 0) {
+          if (zeropad) {
+            v = 0 ;
+          } else {
+            v = *(src + x) ;
+          }
+          while (filti > filt - stop) {
+            c = *filti-- ;
+            acc += v * c ;
+            srci += src_stride ;
+          }
+        }
+
+        stop = filt_end - VL_MAX(filt_begin, y - (signed)src_height + 1) + 1 ;
+        while (filti > filt - (signed)stop) {
+          v = *srci ;
+          c = *filti-- ;
+          acc += v * c ;
+          srci += src_stride ;
+        }
+
+        if (zeropad) v = 0 ;
+
+        stop = filt_end - filt_begin + 1 ;
+        while (filti > filt - stop) {
+          c = *filti-- ;
+          acc += v * c ;
+        }
+
+        if (transp) {
+          *dst = acc ; dst += 1 ;
+        } else {
+          *dst = acc ; dst += dst_stride ;
+        }
+      } /* next y */
+      if (transp) {
+        dst += 1 * dst_stride - dheight * 1 ;
+      } else {
+        dst += 1 * 1 - dheight * dst_stride ;
+      }
+      x      += 1 ;
+      totcol += 1 ;
+    } /* next x */
+  }
+}
+
+/* ---------------------------------------------------------------- */
+#if 0
+void
+VL_XCAT(_vl_imconvcoltri_v, SFX, sse2)
+(T* dst, int dst_stride,
+ T const* src,
+ int src_width, int src_height, int src_stride,
+ int filt_size,
+ int step, unsigned int flags)
+{
+  int x = 0 ;
+  int y ;
+  int dheight = (src_height - 1) / step + 1 ;
+  vl_bool use_simd  = ((src_stride & ALIGNSTRIDE) == 0) &&
+  (! (flags & VL_NO_SIMD)) ;
+  vl_bool transp = flags & VL_TRANSPOSE ;
+  vl_bool zeropad = (flags & VL_PAD_MASK) == VL_PAD_BY_ZERO ;
+
+  T * buff = vl_malloc(sizeof(T) * (src_height + filt_size)) ;
+#define fa (1.0 / (double) (filt_size + 1))
+  T scale = fa*fa*fa*fa ;
+  buff += filt_size ;
+
+  while (x < src_width) {
+    T const *srci ;
+
+    use_simd = 0 ;
+    if ((x + VSIZE < src_width) &
+        (((vl_ptrint)(src + x) & ALIGNPTR) == 0) &
+        use_simd)
+    {
+
+    } else {
+      int stridex = transp ? dst_stride : 1 ;
+      int stridey = transp ? 1 : dst_stride ;
+      srci = src + x + src_stride * (src_height - 1) ;
+
+      /* integrate backward the column */
+      buff [src_height - 1] = *srci ;
+      for (y = src_height-2 ; y >=  0 ; --y) {
+        srci -= src_stride ;
+        buff [y] = buff [y+1] + *srci ;
+      }
+      if (zeropad) {
+        for ( ; y >= - filt_size ; --y) {
+          buff [y] = buff [y+1] ;
+        }
+      } else {
+        for ( ; y >= - filt_size ; --y) {
+          buff [y] = buff[y+1] + *srci ;
+        }
+      }
+
+      /* compute the filter forward */
+      for (y = - filt_size ; y < src_height - filt_size ; ++y) {
+        buff [y] = buff [y] - buff [y + filt_size] ;
+      }
+      if (! zeropad) {
+        for (y = src_height - filt_size ; y < src_height ; ++y) {
+          buff [y] = buff [y] - buff [src_height-1]  *
+          (src_height - filt_size - y) ;
+        }
+      }
+
+      /* integrate forward the column */
+      for (y = - filt_size + 1 ; y < src_height ; ++y) {
+        buff [y] += buff [y - 1] ;
+      }
+
+      /* compute the filter backward */
+      for (y = src_height - 1 ; y >= 0 ; --y) {
+        dst [x*stridex + y*stridey]
+        = scale * (buff [y] - buff [y - filt_size]) ;
+      }
+    } /* next y */
+    x += 1 ;
+  }
+  vl_free (buff - filt_size) ;
+}
+#endif
+
+#undef FLT
+#undef VL_IMOPV_SSE2_INSTANTIATING
+#endif
+
+/* ! VL_DISABLE_SSE2 */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
new file mode 100644
index 000000000..0f8da374e
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/imopv_sse2.h
@@ -0,0 +1,54 @@
+/** @file imopv_sse2.h
+ ** @brief Vectorized image operations - SSE2
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_IMOPV_SSE2_H
+#define VL_IMOPV_SSE2_H
+
+#include "generic.h"
+
+#ifndef VL_DISABLE_SSE2
+
+VL_EXPORT
+void _vl_imconvcol_vf_sse2 (float* dst, vl_size dst_stride,
+                            float const* src,
+                            vl_size src_width, vl_size src_height, vl_size src_stride,
+                            float const* filt, vl_index filt_begin, vl_index filt_end,
+                            int step, unsigned int flags) ;
+
+VL_EXPORT
+void _vl_imconvcol_vd_sse2 (double* dst, vl_size dst_stride,
+                            double const* src,
+                            vl_size src_width, vl_size src_height, vl_size src_stride,
+                            double const* filt, vl_index filt_begin, vl_index filt_end,
+                            int step, unsigned int flags) ;
+
+/*
+VL_EXPORT
+void _vl_imconvcoltri_vf_sse2 (float* dst, int dst_stride,
+                               float const* src,
+                               int src_width, int src_height, int src_stride,
+                               int filt_size,
+                               int step, unsigned int flags) ;
+
+VL_EXPORT
+void _vl_imconvcoltri_vd_sse2 (double* dst, int dst_stride,
+                               double const* src,
+                               int src_width, int src_height, int src_stride,
+                               int filt_size,
+                               int step, unsigned int flags) ;
+*/
+
+#endif
+
+/* VL_IMOPV_SSE2_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/kdtree.c b/opensfm/src/third_party/vlfeat/vl/kdtree.c
new file mode 100644
index 000000000..889cc7dc3
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/kdtree.c
@@ -0,0 +1,1082 @@
+/** @file kdtree.c
+ ** @brief KD-tree - Definition
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page kdtree KD-trees and forests
+@author Andrea Vedaldi
+@author David Novotny
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref kdtree.h implements a KD-tree object, a data structure that can
+efficiently index moderately dimensional vector spaces. Both
+best-bin-first @cite{beis97shape} and randomized KD-tree forests are
+implemented
+@cite{silpa-anan08optimised},@cite{muja09fast}. Applications include
+fast matching of feature descriptors.
+
+- @ref kdtree-overview
+- @ref kdtree-tech
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kdtree-overview Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+To create a ::VlKDForest object use ::vl_kdforest_new specifying the
+dimensionality of the data and the number of trees in the forest.
+With one tree only, the algorithm is analogous to @cite{beis97shape}
+(best-bin KDTree). Multiple trees correspond to the randomized KDTree
+forest as in @cite{silpa-anan08optimised},@cite{muja09fast}.
+
+To let the KD-tree index some data use ::vl_kdforest_build. Note that
+for efficiency KD-tree does not copy the data but retains a pointer to
+it. Therefore the data must exist (and not change) until the KD-tree
+is deleted. To delete the KD-tree object, use ::vl_kdforest_delete.
+
+To find the N nearest neighbors to a query point first instantiate
+a ::VlKDForestSearcher and then start search using a ::vl_kdforest_query
+with the searcher object as an argument. To set a maximum number of
+comparisons per query and calculate approximate nearest neighbors use
+::vl_kdforest_set_max_num_comparisons.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kdtree-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+::VlKDForest implements the best-bin-first kd-tree of @cite{beis97shape}.
+
+<b>Construction.</b> Given a set of points @f$ x_1,\dots,x_n \in
+\mathbb{R}^d @f$, the algorithm recursively partitions the @e d
+dimensional Euclidean space @f$ \mathbb{R}^d @f$ into (hyper-)
+rectangles.
+
+Partitions are organized into a binary tree with the root
+corresponding to the whole space @f$ \mathbb{R}^d @f$. The algorithm
+refines each partition by dividing it into two halves by thresholding
+along a given dimension. Both the splitting dimension and the
+threshold are determined as a statistic of the data points contained
+in the partition. The splitting dimension is the one which has largest
+sample variance and the splitting threshold is either the sample mean
+or the median. Leaves are atomic partitions and they contain a list of
+zero or more data points (typically one).
+
+<b>Querying.</b> Querying amounts to finding the N data points closer
+to a given query point @f$ x_q \in \mathbb{R}^d @f$. This is done by
+branch-and-bound. A search state is an active partition (initially the
+root) and it is weighed by the lower bound on the distance of any
+point in the partition and the query point. Such a lower bound is
+trivial to compute because partitions are hyper-rectangles.
+
+<b>Querying usage.</b> As said before a user has to create an instance
+::VlKDForestSearcher using ::vl_kdforest_new_searcher in order to be able
+to make queries. When a user wants to delete a KD-Tree all the searchers
+bound to the given KD-Forest are erased automatically. If a user wants to
+delete some of the searchers before the KD-Tree erase, he could do it
+using the vl_kdforest_delete_searcher method.
+**/
+
+#include "kdtree.h"
+#include "generic.h"
+#include "random.h"
+#include "mathop.h"
+#include <stdlib.h>
+
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+
+#define VL_HEAP_prefix     vl_kdforest_search_heap
+#define VL_HEAP_type       VlKDForestSearchState
+#define VL_HEAP_cmp(v,x,y) (v[x].distanceLowerBound - v[y].distanceLowerBound)
+#include "heap-def.h"
+
+#define VL_HEAP_prefix     vl_kdtree_split_heap
+#define VL_HEAP_type       VlKDTreeSplitDimension
+#define VL_HEAP_cmp(v,x,y) (v[x].variance - v[y].variance)
+#include "heap-def.h"
+
+#define VL_HEAP_prefix     vl_kdforest_neighbor_heap
+#define VL_HEAP_type       VlKDForestNeighbor
+#define VL_HEAP_cmp(v,x,y) (v[y].distance - v[x].distance)
+#include "heap-def.h"
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Allocate a new node from the tree pool
+ **/
+
+static vl_uindex
+vl_kdtree_node_new (VlKDTree * tree, vl_uindex parentIndex)
+{
+  VlKDTreeNode * node = NULL ;
+  vl_uindex nodeIndex = tree->numUsedNodes ;
+  tree -> numUsedNodes += 1 ;
+
+  assert (tree->numUsedNodes <= tree->numAllocatedNodes) ;
+
+  node = tree->nodes + nodeIndex ;
+  node -> parent = parentIndex ;
+  node -> lowerChild = 0 ;
+  node -> upperChild = 0 ;
+  node -> splitDimension = 0 ;
+  node -> splitThreshold = 0 ;
+  return nodeIndex ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Compare KDTree index entries for sorting
+ **/
+
+VL_INLINE int
+vl_kdtree_compare_index_entries (void const * a,
+                                 void const * b)
+{
+  double delta =
+    ((VlKDTreeDataIndexEntry const*)a) -> value -
+    ((VlKDTreeDataIndexEntry const*)b) -> value ;
+  if (delta < 0) return -1 ;
+  if (delta > 0) return +1 ;
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Build KDTree recursively
+ ** @param forest forest to which the tree belongs.
+ ** @param tree tree being built.
+ ** @param nodeIndex node to process.
+ ** @param dataBegin begin of data for this node.
+ ** @param dataEnd end of data for this node.
+ ** @param depth depth of this node.
+ **/
+
+static void
+vl_kdtree_build_recursively
+(VlKDForest * forest,
+ VlKDTree * tree, vl_uindex nodeIndex,
+ vl_uindex dataBegin, vl_uindex dataEnd,
+ unsigned int depth)
+{
+  vl_uindex d, i, medianIndex, splitIndex ;
+  VlKDTreeNode * node = tree->nodes + nodeIndex ;
+  VlKDTreeSplitDimension * splitDimension ;
+
+  /* base case: there is only one data point */
+  if (dataEnd - dataBegin <= 1) {
+    if (tree->depth < depth) tree->depth = depth ;
+    node->lowerChild = - dataBegin - 1;
+    node->upperChild = - dataEnd - 1 ;
+    return ;
+  }
+
+  /* compute the dimension with largest variance > 0 */
+  forest->splitHeapNumNodes = 0 ;
+  for (d = 0 ; d < forest->dimension ; ++ d) {
+    double mean = 0 ; /* unnormalized */
+    double secondMoment = 0 ;
+    double variance = 0 ;
+    vl_size numSamples = VL_KDTREE_VARIANCE_EST_NUM_SAMPLES;
+    vl_bool useAllData = VL_FALSE;
+
+    if(dataEnd - dataBegin <= VL_KDTREE_VARIANCE_EST_NUM_SAMPLES) {
+      useAllData = VL_TRUE;
+      numSamples = dataEnd - dataBegin;
+    }
+
+    for (i = 0; i < numSamples ; ++ i) {
+      vl_uint32 sampleIndex;
+      vl_index di;
+      double datum ;
+
+      if(useAllData == VL_TRUE) {
+        sampleIndex = (vl_uint32)i;
+      } else {
+        sampleIndex = (vl_rand_uint32(forest->rand) % VL_KDTREE_VARIANCE_EST_NUM_SAMPLES);
+      }
+      sampleIndex += dataBegin;
+
+      di = tree->dataIndex[sampleIndex].index ;
+
+      switch(forest->dataType) {
+        case VL_TYPE_FLOAT: datum = ((float const*)forest->data)
+          [di * forest->dimension + d] ;
+          break ;
+        case VL_TYPE_DOUBLE: datum = ((double const*)forest->data)
+          [di * forest->dimension + d] ;
+          break ;
+        default:
+          abort() ;
+      }
+      mean += datum ;
+      secondMoment += datum * datum ;
+    }
+
+    mean /= numSamples ;
+    secondMoment /= numSamples ;
+    variance = secondMoment - mean * mean ;
+
+    if (variance <= 0) continue ;
+
+    /* keep splitHeapSize most varying dimensions */
+    if (forest->splitHeapNumNodes < forest->splitHeapSize) {
+      VlKDTreeSplitDimension * splitDimension
+        = forest->splitHeapArray + forest->splitHeapNumNodes ;
+      splitDimension->dimension = (unsigned int)d ;
+      splitDimension->mean = mean ;
+      splitDimension->variance = variance ;
+      vl_kdtree_split_heap_push (forest->splitHeapArray, &forest->splitHeapNumNodes) ;
+    } else {
+      VlKDTreeSplitDimension * splitDimension = forest->splitHeapArray + 0 ;
+      if (splitDimension->variance < variance) {
+        splitDimension->dimension = (unsigned int)d ;
+        splitDimension->mean = mean ;
+        splitDimension->variance = variance ;
+        vl_kdtree_split_heap_update (forest->splitHeapArray, forest->splitHeapNumNodes, 0) ;
+      }
+    }
+  }
+
+  /* additional base case: the maximum variance is equal to 0 (overlapping points) */
+  if (forest->splitHeapNumNodes == 0) {
+    node->lowerChild = - dataBegin - 1 ;
+    node->upperChild = - dataEnd - 1 ;
+    return ;
+  }
+
+  /* toss a dice to decide the splitting dimension (variance > 0) */
+  splitDimension = forest->splitHeapArray
+  + (vl_rand_uint32(forest->rand) % VL_MIN(forest->splitHeapSize, forest->splitHeapNumNodes)) ;
+
+  node->splitDimension = splitDimension->dimension ;
+
+  /* sort data along largest variance dimension */
+  for (i = dataBegin ; i < dataEnd ; ++ i) {
+    vl_index di = tree->dataIndex[i].index ;
+    double datum ;
+    switch (forest->dataType) {
+      case VL_TYPE_FLOAT: datum = ((float const*)forest->data)
+        [di * forest->dimension + splitDimension->dimension] ;
+        break ;
+      case VL_TYPE_DOUBLE: datum = ((double const*)forest->data)
+        [di * forest->dimension + splitDimension->dimension] ;
+        break ;
+      default:
+        abort() ;
+    }
+    tree->dataIndex [i] .value = datum ;
+  }
+  qsort (tree->dataIndex + dataBegin,
+         dataEnd - dataBegin,
+         sizeof (VlKDTreeDataIndexEntry),
+         vl_kdtree_compare_index_entries) ;
+
+  /* determine split threshold */
+  switch (forest->thresholdingMethod) {
+    case VL_KDTREE_MEAN :
+      node->splitThreshold = splitDimension->mean ;
+      for (splitIndex = dataBegin ;
+           splitIndex < dataEnd && tree->dataIndex[splitIndex].value <= node->splitThreshold ;
+           ++ splitIndex) ;
+      splitIndex -= 1 ;
+      /* If the mean does not provide a proper partition, fall back to
+       * median. This usually happens if all points have the same
+       * value and the zero variance test fails for numerical accuracy
+       * reasons. In this case, also due to numerical accuracy, the
+       * mean value can be smaller, equal, or larger than all
+       * points. */
+      if (dataBegin <= splitIndex && splitIndex + 1 < dataEnd) break ;
+
+    case VL_KDTREE_MEDIAN :
+      medianIndex = (dataBegin + dataEnd - 1) / 2 ;
+      splitIndex = medianIndex ;
+      node -> splitThreshold = tree->dataIndex[medianIndex].value ;
+      break ;
+
+    default:
+      abort() ;
+  }
+
+  /* divide subparts */
+  node->lowerChild = vl_kdtree_node_new (tree, nodeIndex) ;
+  vl_kdtree_build_recursively (forest, tree, node->lowerChild, dataBegin, splitIndex + 1, depth + 1) ;
+
+  node->upperChild = vl_kdtree_node_new (tree, nodeIndex) ;
+  vl_kdtree_build_recursively (forest, tree, node->upperChild, splitIndex + 1, dataEnd, depth + 1) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create new KDForest object
+ ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
+ ** @param dimension data dimensionality.
+ ** @param numTrees number of trees in the forest.
+ ** @param distance type of distance norm (::VlDistanceL1 or ::VlDistanceL2).
+ ** @return new KDForest.
+ **
+ ** The data dimension @a dimension and the number of trees @a
+ ** numTrees must not be smaller than one.
+ **/
+
+VlKDForest *
+vl_kdforest_new (vl_type dataType,
+                 vl_size dimension, vl_size numTrees, VlVectorComparisonType distance)
+{
+  VlKDForest * self = vl_calloc (sizeof(VlKDForest), 1) ;
+
+  assert(dataType == VL_TYPE_FLOAT || dataType == VL_TYPE_DOUBLE) ;
+  assert(dimension >= 1) ;
+  assert(numTrees >= 1) ;
+
+  self -> rand = vl_get_rand () ;
+  self -> dataType = dataType ;
+  self -> numData = 0 ;
+  self -> data = 0 ;
+  self -> dimension = dimension ;
+  self -> numTrees = numTrees ;
+  self -> trees = 0 ;
+  self -> thresholdingMethod = VL_KDTREE_MEDIAN ;
+  self -> splitHeapSize = VL_MIN(numTrees, VL_KDTREE_SPLIT_HEAP_SIZE) ;
+  self -> splitHeapNumNodes = 0 ;
+  self -> distance = distance;
+  self -> maxNumNodes = 0 ;
+  self -> numSearchers = 0 ;
+  self -> headSearcher = 0 ;
+
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT:
+      self -> distanceFunction = (void(*)(void))
+      vl_get_vector_comparison_function_f (distance) ;
+      break;
+    case VL_TYPE_DOUBLE :
+      self -> distanceFunction = (void(*)(void))
+      vl_get_vector_comparison_function_d (distance) ;
+      break ;
+    default :
+      abort() ;
+  }
+
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a KDForest searcher object, used for processing queries
+ ** @param kdforest a forest to which the queries should be pointing.
+ ** @return KDForest searcher object.
+ **
+ ** A searcher is an object attached to the forest which must be created
+ ** before running the queries. Each query has to be invoked with the
+ ** searcher as its argument.
+ **
+ ** When using a multi-threaded approach a user should at first instantiate
+ ** a correct number of searchers - each used in one thread.
+ ** Then in each thread a query to the given searcher could be run.
+ **
+ **/
+
+VlKDForestSearcher *
+vl_kdforest_new_searcher (VlKDForest * kdforest)
+{
+  VlKDForestSearcher * self = vl_calloc(sizeof(VlKDForestSearcher), 1);
+  if(kdforest->numSearchers == 0) {
+    kdforest->headSearcher = self;
+    self->previous = NULL;
+    self->next = NULL;
+  } else {
+    VlKDForestSearcher * lastSearcher = kdforest->headSearcher;
+    while (1) {
+      if(lastSearcher->next) {
+        lastSearcher = lastSearcher->next;
+      } else {
+        lastSearcher->next = self;
+        self->previous = lastSearcher;
+        self->next = NULL;
+        break;
+      }
+    }
+  }
+
+  kdforest->numSearchers++;
+
+  self->forest = kdforest;
+  self->searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * kdforest->maxNumNodes) ;
+  self->searchIdBook = vl_calloc (sizeof(vl_uindex), kdforest->numData) ;
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Delete object
+ ** @param self object.
+ **/
+
+void
+vl_kdforestsearcher_delete (VlKDForestSearcher * self)
+{
+  if (self->previous && self->next) {
+    self->previous->next = self->next;
+    self->next->previous = self->previous;
+  } else if (self->previous && !self->next) {
+    self->previous->next = NULL;
+  } else if (!self->previous && self->next) {
+    self->next->previous = NULL;
+    self->forest->headSearcher = self->next;
+  } else {
+    self->forest->headSearcher = NULL;
+  }
+  self->forest->numSearchers -- ;
+  vl_free(self->searchHeapArray) ;
+  vl_free(self->searchIdBook) ;
+  vl_free(self) ;
+}
+
+VlKDForestSearcher *
+vl_kdforest_get_searcher (VlKDForest const * self, vl_uindex pos)
+{
+  VlKDForestSearcher * lastSearcher = self->headSearcher ;
+  vl_uindex i ;
+
+  for(i = 0; (i < pos) & (lastSearcher != NULL) ; ++i) {
+    lastSearcher = lastSearcher->next ;
+  }
+  return lastSearcher ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Delete KDForest object
+ ** @param self KDForest object to delete
+ ** @sa ::vl_kdforest_new
+ **/
+
+void
+vl_kdforest_delete (VlKDForest * self)
+{
+  vl_uindex ti ;
+  VlKDForestSearcher * searcher ;
+
+  while ((searcher = vl_kdforest_get_searcher(self, 0))) {
+    vl_kdforestsearcher_delete(searcher) ;
+  }
+
+  if (self->trees) {
+    for (ti = 0 ; ti < self->numTrees ; ++ ti) {
+      if (self->trees[ti]) {
+        if (self->trees[ti]->nodes) vl_free (self->trees[ti]->nodes) ;
+        if (self->trees[ti]->dataIndex) vl_free (self->trees[ti]->dataIndex) ;
+        vl_free (self->trees[ti]) ;
+      }
+    }
+    vl_free (self->trees) ;
+  }
+  vl_free (self) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Compute tree bounds recursively
+ ** @param tree KDTree object instance.
+ ** @param nodeIndex node index to start from.
+ ** @param searchBounds 2 x numDimension array of bounds.
+ **/
+
+static void
+vl_kdtree_calc_bounds_recursively (VlKDTree * tree,
+                                   vl_uindex nodeIndex, double * searchBounds)
+{
+  VlKDTreeNode * node = tree->nodes + nodeIndex ;
+  vl_uindex i = node->splitDimension ;
+  double t = node->splitThreshold ;
+
+  node->lowerBound = searchBounds [2 * i + 0] ;
+  node->upperBound = searchBounds [2 * i + 1] ;
+
+  //VL_PRINT("%f %f\n",node->lowerBound,node->upperBound);
+
+  if (node->lowerChild > 0) {
+    searchBounds [2 * i + 1] = t ;
+    vl_kdtree_calc_bounds_recursively (tree, node->lowerChild, searchBounds) ;
+    searchBounds [2 * i + 1] = node->upperBound ;
+  }
+  if (node->upperChild > 0) {
+    searchBounds [2 * i + 0] = t ;
+    vl_kdtree_calc_bounds_recursively (tree, node->upperChild, searchBounds) ;
+    searchBounds [2 * i + 0] = node->lowerBound ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Build KDTree from data
+ ** @param self KDTree object
+ ** @param numData number of data points.
+ ** @param data pointer to the data.
+ **
+ ** The function builds the KDTree by processing the data @a data. For
+ ** efficiency, KDTree does not make a copy the data, but retains a
+ ** pointer to it. Therefore the data buffer must be valid and
+ ** unchanged for the lifespan of the object.
+ **
+ ** The number of data points @c numData must not be smaller than one.
+ **/
+
+void
+vl_kdforest_build (VlKDForest * self, vl_size numData, void const * data)
+{
+  vl_uindex di, ti ;
+  vl_size maxNumNodes ;
+  double * searchBounds;
+
+  assert(data) ;
+  assert(numData >= 1) ;
+
+  /* need to check: if alredy built, clean first */
+  self->data = data ;
+  self->numData = numData ;
+  self->trees = vl_malloc (sizeof(VlKDTree*) * self->numTrees) ;
+  maxNumNodes = 0 ;
+
+  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
+    self->trees[ti] = vl_malloc (sizeof(VlKDTree)) ;
+    self->trees[ti]->dataIndex = vl_malloc (sizeof(VlKDTreeDataIndexEntry) * self->numData) ;
+    for (di = 0 ; di < self->numData ; ++ di) {
+      self->trees[ti]->dataIndex[di].index = di ;
+    }
+    self->trees[ti]->numUsedNodes = 0 ;
+    /* num. nodes of a complete binary tree with numData leaves */
+    self->trees[ti]->numAllocatedNodes = 2 * self->numData - 1 ;
+    self->trees[ti]->nodes = vl_malloc (sizeof(VlKDTreeNode) * self->trees[ti]->numAllocatedNodes) ;
+    self->trees[ti]->depth = 0 ;
+    vl_kdtree_build_recursively (self, self->trees[ti],
+                                 vl_kdtree_node_new(self->trees[ti], 0), 0,
+                                 self->numData, 0) ;
+    maxNumNodes += self->trees[ti]->numUsedNodes ;
+  }
+
+  searchBounds = vl_malloc(sizeof(double) * 2 * self->dimension);
+
+  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
+    double * iter = searchBounds  ;
+    double * end = iter + 2 * self->dimension ;
+    while (iter < end) {
+      *iter++ = - VL_INFINITY_F ;
+      *iter++ = + VL_INFINITY_F ;
+    }
+
+    vl_kdtree_calc_bounds_recursively (self->trees[ti], 0, searchBounds) ;
+  }
+
+  vl_free(searchBounds);
+  self -> maxNumNodes = maxNumNodes;
+}
+
+
+/** ------------------------------------------------------------------
+ ** @internal @brief
+ **/
+
+vl_uindex
+vl_kdforest_query_recursively (VlKDForestSearcher * searcher,
+                               VlKDTree * tree,
+                               vl_uindex nodeIndex,
+                               VlKDForestNeighbor * neighbors,
+                               vl_size numNeighbors,
+                               vl_size * numAddedNeighbors,
+                               double dist,
+                               void const * query)
+{
+
+  VlKDTreeNode const * node = tree->nodes + nodeIndex ;
+  vl_uindex i = node->splitDimension ;
+  vl_index nextChild, saveChild ;
+  double delta, saveDist ;
+  double x ;
+  double x1 = node->lowerBound ;
+  double x2 = node->splitThreshold ;
+  double x3 = node->upperBound ;
+  VlKDForestSearchState * searchState ;
+
+  searcher->searchNumRecursions ++ ;
+
+  switch (searcher->forest->dataType) {
+    case VL_TYPE_FLOAT :
+      x = ((float const*) query)[i] ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      x = ((double const*) query)[i] ;
+      break ;
+    default :
+      abort() ;
+  }
+
+  /* base case: this is a leaf node */
+  if (node->lowerChild < 0) {
+
+    vl_index begin = - node->lowerChild - 1 ;
+    vl_index end   = - node->upperChild - 1 ;
+    vl_index iter ;
+
+    for (iter = begin ;
+         iter < end &&
+         (searcher->forest->searchMaxNumComparisons == 0 ||
+          searcher->searchNumComparisons < searcher->forest->searchMaxNumComparisons) ;
+         ++ iter) {
+
+      vl_index di = tree->dataIndex [iter].index ;
+
+      /* multiple KDTrees share the database points and we must avoid
+       * adding the same point twice */
+      if (searcher->searchIdBook[di] == searcher->searchId) continue ;
+      searcher->searchIdBook[di] = searcher->searchId ;
+
+      /* compare the query to this point */
+      switch (searcher->forest->dataType) {
+        case VL_TYPE_FLOAT:
+          dist = ((VlFloatVectorComparisonFunction)searcher->forest->distanceFunction)
+                 (searcher->forest->dimension,
+                  ((float const *)query),
+                  ((float const*)searcher->forest->data) + di * searcher->forest->dimension) ;
+          break ;
+        case VL_TYPE_DOUBLE:
+          dist = ((VlDoubleVectorComparisonFunction)searcher->forest->distanceFunction)
+                 (searcher->forest->dimension,
+                  ((double const *)query),
+                  ((double const*)searcher->forest->data) + di * searcher->forest->dimension) ;
+          break ;
+        default:
+          abort() ;
+      }
+      searcher->searchNumComparisons += 1 ;
+
+      /* see if it should be added to the result set */
+      if (*numAddedNeighbors < numNeighbors) {
+        VlKDForestNeighbor * newNeighbor = neighbors + *numAddedNeighbors ;
+        newNeighbor->index = di ;
+        newNeighbor->distance = dist ;
+        vl_kdforest_neighbor_heap_push (neighbors, numAddedNeighbors) ;
+      } else {
+        VlKDForestNeighbor * largestNeighbor = neighbors + 0 ;
+        if (largestNeighbor->distance > dist) {
+          largestNeighbor->index = di ;
+          largestNeighbor->distance = dist ;
+          vl_kdforest_neighbor_heap_update (neighbors, *numAddedNeighbors, 0) ;
+        }
+      }
+    } /* next data point */
+
+
+    return nodeIndex ;
+  }
+
+#if 0
+  assert (x1 <= x2 && x2 <= x3) ;
+  assert (node->lowerChild >= 0) ;
+  assert (node->upperChild >= 0) ;
+#endif
+
+  /*
+   *   x1  x2 x3
+   * x (---|---]
+   *   (--x|---]
+   *   (---|x--]
+   *   (---|---] x
+   */
+
+  delta = x - x2 ;
+  saveDist = dist + delta*delta ;
+
+  if (x <= x2) {
+    nextChild = node->lowerChild ;
+    saveChild = node->upperChild ;
+    if (x <= x1) {
+      delta = x - x1 ;
+      saveDist -= delta*delta ;
+    }
+  } else {
+    nextChild = node->upperChild ;
+    saveChild = node->lowerChild ;
+    if (x > x3) {
+      delta = x - x3 ;
+      saveDist -= delta*delta ;
+    }
+  }
+
+  if (*numAddedNeighbors < numNeighbors || neighbors[0].distance > saveDist) {
+    searchState = searcher->searchHeapArray + searcher->searchHeapNumNodes ;
+    searchState->tree = tree ;
+    searchState->nodeIndex = saveChild ;
+    searchState->distanceLowerBound = saveDist ;
+    vl_kdforest_search_heap_push (searcher->searchHeapArray ,
+                                  &searcher->searchHeapNumNodes) ;
+  }
+
+  return vl_kdforest_query_recursively (searcher,
+                                        tree,
+                                        nextChild,
+                                        neighbors,
+                                        numNeighbors,
+                                        numAddedNeighbors,
+                                        dist,
+                                        query) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Query the forest
+ ** @param self object.
+ ** @param neighbors list of nearest neighbors found (output).
+ ** @param numNeighbors number of nearest neighbors to find.
+ ** @param query query point.
+ ** @return number of tree leaves visited.
+ **
+ ** A neighbor is represented by an instance of the structure
+ ** ::VlKDForestNeighbor. Each entry contains the index of the
+ ** neighbor (this is an index into the KDTree data) and its distance
+ ** to the query point. Neighbors are sorted by increasing distance.
+ **/
+
+vl_size
+vl_kdforest_query (VlKDForest * self,
+                   VlKDForestNeighbor * neighbors,
+                   vl_size numNeighbors,
+                   void const * query)
+{
+  VlKDForestSearcher * searcher = vl_kdforest_get_searcher(self, 0) ;
+  if (searcher == NULL) {
+    searcher = vl_kdforest_new_searcher(self) ;
+  }
+  return vl_kdforestsearcher_query(searcher,
+                                   neighbors,
+                                   numNeighbors,
+                                   query) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Query the forest
+ ** @param self object.
+ ** @param neighbors list of nearest neighbors found (output).
+ ** @param numNeighbors number of nearest neighbors to find.
+ ** @param query query point.
+ ** @return number of tree leaves visited.
+ **
+ ** A neighbor is represented by an instance of the structure
+ ** ::VlKDForestNeighbor. Each entry contains the index of the
+ ** neighbor (this is an index into the KDTree data) and its distance
+ ** to the query point. Neighbors are sorted by increasing distance.
+ **/
+
+vl_size
+vl_kdforestsearcher_query (VlKDForestSearcher * self,
+                           VlKDForestNeighbor * neighbors,
+                           vl_size numNeighbors,
+                           void const * query)
+{
+
+  vl_uindex i, ti ;
+  vl_bool exactSearch = self->forest->searchMaxNumComparisons == 0 ;
+
+  VlKDForestSearchState * searchState  ;
+  vl_size numAddedNeighbors = 0 ;
+
+  assert (neighbors) ;
+  assert (numNeighbors > 0) ;
+  assert (query) ;
+
+  /* this number is used to differentiate a query from the next */
+  self -> searchId += 1 ;
+  self -> searchNumRecursions = 0 ;
+
+  self->searchNumComparisons = 0 ;
+  self->searchNumSimplifications = 0 ;
+
+  /* put the root node into the search heap */
+  self->searchHeapNumNodes = 0 ;
+  for (ti = 0 ; ti < self->forest->numTrees ; ++ ti) {
+    searchState = self->searchHeapArray + self->searchHeapNumNodes ;
+    searchState -> tree = self->forest->trees[ti] ;
+    searchState -> nodeIndex = 0 ;
+    searchState -> distanceLowerBound = 0 ;
+
+    vl_kdforest_search_heap_push (self->searchHeapArray, &self->searchHeapNumNodes) ;
+  }
+
+  /* branch and bound */
+  while (exactSearch || self->searchNumComparisons < self->forest->searchMaxNumComparisons)
+  {
+    /* pop the next optimal search node */
+    VlKDForestSearchState * searchState ;
+
+    /* break if search space completed */
+    if (self->searchHeapNumNodes == 0) {
+      break ;
+    }
+    searchState = self->searchHeapArray +
+                  vl_kdforest_search_heap_pop (self->searchHeapArray, &self->searchHeapNumNodes) ;
+    /* break if no better solution may exist */
+    if (numAddedNeighbors == numNeighbors &&
+        neighbors[0].distance < searchState->distanceLowerBound) {
+      self->searchNumSimplifications ++ ;
+      break ;
+    }
+    vl_kdforest_query_recursively (self,
+                                   searchState->tree,
+                                   searchState->nodeIndex,
+                                   neighbors,
+                                   numNeighbors,
+                                   &numAddedNeighbors,
+                                   searchState->distanceLowerBound,
+                                   query) ;
+  }
+
+  /* sort neighbors by increasing distance */
+  for (i = numAddedNeighbors ; i < numNeighbors ; ++ i) {
+    neighbors[i].index = -1 ;
+    neighbors[i].distance = VL_NAN_F ;
+  }
+
+  while (numAddedNeighbors) {
+    vl_kdforest_neighbor_heap_pop (neighbors, &numAddedNeighbors) ;
+  }
+
+  return self->searchNumComparisons ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Run multiple queries
+ ** @param self object.
+ ** @param indexes assignments of points.
+ ** @param numNeighbors number of nearest neighbors to be found for each data point
+ ** @param numQueries number of query points.
+ ** @param distances distances of query points.
+ ** @param queries lisf of vectors to use as queries.
+ **
+ ** @a indexes and @a distances are @a numNeighbors by @a numQueries
+ ** matrices containing the indexes and distances of the nearest neighbours
+ ** for each of the @a numQueries queries @a queries.
+ **
+ ** This function is similar to ::vl_kdforest_query. The main
+ ** difference is that the function can use multiple cores to query
+ ** large amounts of data.
+ **
+ ** @sa ::vl_kdforest_query.
+ **/
+
+vl_size
+vl_kdforest_query_with_array (VlKDForest * self,
+                              vl_uint32 * indexes,
+                              vl_size numNeighbors,
+                              vl_size numQueries,
+                              void * distances,
+                              void const * queries)
+{
+  vl_size numComparisons = 0;
+  vl_type dataType = vl_kdforest_get_data_type(self) ;
+  vl_size dimension = vl_kdforest_get_data_dimension(self) ;
+
+#ifdef _OPENMP
+#pragma omp parallel default(shared) num_threads(vl_get_max_threads())
+#endif
+  {
+    vl_index qi ;
+    vl_size thisNumComparisons = 0 ;
+    VlKDForestSearcher * searcher ;
+    VlKDForestNeighbor * neighbors ;
+
+#ifdef _OPENMP
+#pragma omp critical
+#endif
+    {
+      searcher = vl_kdforest_new_searcher(self) ;
+      neighbors = vl_calloc (sizeof(VlKDForestNeighbor), numNeighbors) ;
+    }
+
+#ifdef _OPENMP
+#pragma omp for
+#endif
+    for(qi = 0 ; qi < (signed)numQueries; ++ qi) {
+      switch (dataType) {
+        case VL_TYPE_FLOAT: {
+          vl_size ni;
+          thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
+                                                           (float const *) (queries) + qi * dimension) ;
+          for (ni = 0 ; ni < numNeighbors ; ++ni) {
+            indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
+            if (distances){
+              *((float*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
+            }
+          }
+          break ;
+        }
+        case VL_TYPE_DOUBLE: {
+          vl_size ni;
+          thisNumComparisons += vl_kdforestsearcher_query (searcher, neighbors, numNeighbors,
+                                                           (double const *) (queries) + qi * dimension) ;
+          for (ni = 0 ; ni < numNeighbors ; ++ni) {
+            indexes [qi*numNeighbors + ni] = (vl_uint32) neighbors[ni].index ;
+            if (distances){
+              *((double*)distances + qi*numNeighbors + ni) = neighbors[ni].distance ;
+            }
+          }
+          break ;
+        }
+        default:
+          abort() ;
+      }
+    }
+
+#ifdef _OPENMP
+#pragma omp critical
+#endif
+    {
+      numComparisons += thisNumComparisons ;
+      vl_kdforestsearcher_delete (searcher) ;
+      vl_free (neighbors) ;
+    }
+  }
+  return numComparisons ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the number of nodes of a given tree
+ ** @param self KDForest object.
+ ** @param treeIndex index of the tree.
+ ** @return number of trees.
+ **/
+
+vl_size
+vl_kdforest_get_num_nodes_of_tree (VlKDForest const * self, vl_uindex treeIndex)
+{
+  assert (treeIndex < self->numTrees) ;
+  return self->trees[treeIndex]->numUsedNodes ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the detph of a given tree
+ ** @param self KDForest object.
+ ** @param treeIndex index of the tree.
+ ** @return number of trees.
+ **/
+
+vl_size
+vl_kdforest_get_depth_of_tree (VlKDForest const * self, vl_uindex treeIndex)
+{
+  assert (treeIndex < self->numTrees) ;
+  return self->trees[treeIndex]->depth ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the number of trees in the forest
+ **
+ ** @param self KDForest object.
+ ** @return number of trees.
+ **/
+
+vl_size
+vl_kdforest_get_num_trees (VlKDForest const * self)
+{
+  return self->numTrees ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set the maximum number of comparisons for a search
+ **
+ ** @param self KDForest object.
+ ** @param n maximum number of leaves.
+ **
+ ** This function sets the maximum number of comparisons for a
+ ** nearest neighbor search. Setting it to 0 means unbounded comparisons.
+ **
+ ** @sa ::vl_kdforest_query, ::vl_kdforest_get_max_num_comparisons.
+ **/
+
+void
+vl_kdforest_set_max_num_comparisons (VlKDForest * self, vl_size n)
+{
+  self->searchMaxNumComparisons = n ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the maximum number of comparisons for a search
+ **
+ ** @param self KDForest object.
+ ** @return maximum number of leaves.
+ **
+ ** @sa ::vl_kdforest_set_max_num_comparisons.
+ **/
+
+vl_size
+vl_kdforest_get_max_num_comparisons (VlKDForest * self)
+{
+  return self->searchMaxNumComparisons ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set the thresholding method
+ ** @param self KDForest object.
+ ** @param method one of ::VlKDTreeThresholdingMethod.
+ **
+ ** @sa ::vl_kdforest_get_thresholding_method
+ **/
+
+ void
+vl_kdforest_set_thresholding_method (VlKDForest * self, VlKDTreeThresholdingMethod method)
+{
+  assert(method == VL_KDTREE_MEDIAN || method == VL_KDTREE_MEAN) ;
+  self->thresholdingMethod = method ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the thresholding method
+ **
+ ** @param self KDForest object.
+ ** @return thresholding method.
+ **
+ ** @sa ::vl_kdforest_set_thresholding_method
+ **/
+
+ VlKDTreeThresholdingMethod
+vl_kdforest_get_thresholding_method (VlKDForest const * self)
+{
+  return self->thresholdingMethod ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the dimension of the data
+ ** @param self KDForest object.
+ ** @return dimension of the data.
+ **/
+
+ vl_size
+vl_kdforest_get_data_dimension (VlKDForest const * self)
+{
+  return self->dimension ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the data type
+ ** @param self KDForest object.
+ ** @return data type (one of ::VL_TYPE_FLOAT, ::VL_TYPE_DOUBLE).
+ **/
+
+vl_type
+vl_kdforest_get_data_type (VlKDForest const * self)
+{
+  return self->dataType ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the forest linked to the searcher
+ ** @param self object.
+ ** @return correspoinding KD-Forest.
+ **/
+
+VlKDForest *
+vl_kdforestsearcher_get_forest (VlKDForestSearcher const * self)
+{
+  return self->forest;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/kdtree.h b/opensfm/src/third_party/vlfeat/vl/kdtree.h
new file mode 100644
index 000000000..8c8f212be
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/kdtree.h
@@ -0,0 +1,185 @@
+/** @file kdtree.h
+ ** @brief KD-tree (@ref kdtree)
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_KDTREE_H
+#define VL_KDTREE_H
+
+#include "generic.h"
+#include "mathop.h"
+
+#define VL_KDTREE_SPLIT_HEAP_SIZE 5
+#define VL_KDTREE_VARIANCE_EST_NUM_SAMPLES 1024
+
+typedef struct _VlKDTreeNode VlKDTreeNode ;
+typedef struct _VlKDTreeSplitDimension VlKDTreeSplitDimension ;
+typedef struct _VlKDTreeDataIndexEntry VlKDTreeDataIndexEntry ;
+typedef struct _VlKDForestSearchState VlKDForestSearchState ;
+
+struct _VlKDTreeNode
+{
+  vl_uindex parent ;
+  vl_index lowerChild ;
+  vl_index upperChild ;
+  unsigned int splitDimension ;
+  double splitThreshold ;
+  double lowerBound ;
+  double upperBound ;
+} ;
+
+struct _VlKDTreeSplitDimension
+{
+  unsigned int dimension ;
+  double mean ;
+  double variance ;
+} ;
+
+struct _VlKDTreeDataIndexEntry
+{
+  vl_index index ;
+  double value ;
+} ;
+
+/** @brief Thresholding method */
+typedef enum _VlKDTreeThresholdingMethod
+{
+  VL_KDTREE_MEDIAN,
+  VL_KDTREE_MEAN
+} VlKDTreeThresholdingMethod ;
+
+/** @brief Neighbor of a query point */
+typedef struct _VlKDForestNeighbor {
+  double distance ;   /**< distance to the query point */
+  vl_uindex index ;   /**< index of the neighbor in the KDTree data */
+} VlKDForestNeighbor ;
+
+typedef struct _VlKDTree
+{
+  VlKDTreeNode * nodes ;
+  vl_size numUsedNodes ;
+  vl_size numAllocatedNodes ;
+  VlKDTreeDataIndexEntry * dataIndex ;
+  unsigned int depth ;
+} VlKDTree ;
+
+struct _VlKDForestSearchState
+{
+  VlKDTree * tree ;
+  vl_uindex nodeIndex ;
+  double distanceLowerBound ;
+} ;
+
+struct _VlKDForestSearcher;
+
+/** @brief KDForest object */
+typedef struct _VlKDForest
+{
+  vl_size dimension ;
+
+  /* random number generator */
+  VlRand * rand ;
+
+  /* indexed data */
+  vl_type dataType ;
+  void const * data ;
+  vl_size numData ;
+  VlVectorComparisonType distance;
+  void (*distanceFunction)(void) ;
+
+  /* tree structure */
+  VlKDTree ** trees ;
+  vl_size numTrees ;
+
+  /* build */
+  VlKDTreeThresholdingMethod thresholdingMethod ;
+  VlKDTreeSplitDimension splitHeapArray [VL_KDTREE_SPLIT_HEAP_SIZE] ;
+  vl_size splitHeapNumNodes ;
+  vl_size splitHeapSize ;
+  vl_size maxNumNodes;
+
+  /* query */
+  vl_size searchMaxNumComparisons ;
+  vl_size numSearchers;
+  struct _VlKDForestSearcher * headSearcher ;  /* head of the double linked list with searchers */
+
+} VlKDForest ;
+
+/** @brief ::VlKDForest searcher object */
+typedef struct _VlKDForestSearcher
+{
+  /* maintain a linked list of searchers for later disposal*/
+  struct _VlKDForestSearcher * next;
+  struct _VlKDForestSearcher * previous;
+
+  vl_uindex * searchIdBook ;
+  VlKDForestSearchState * searchHeapArray ;
+  VlKDForest * forest;
+
+  vl_size searchNumComparisons;
+  vl_size searchNumRecursions ;
+  vl_size searchNumSimplifications ;
+
+  vl_size searchHeapNumNodes ;
+  vl_uindex searchId ;
+} VlKDForestSearcher ;
+
+/** @name Creating, copying and disposing
+ ** @{ */
+VL_EXPORT VlKDForest * vl_kdforest_new (vl_type dataType,
+                                        vl_size dimension, vl_size numTrees, VlVectorComparisonType normType) ;
+VL_EXPORT VlKDForestSearcher * vl_kdforest_new_searcher (VlKDForest * kdforest);
+VL_EXPORT void vl_kdforest_delete (VlKDForest * self) ;
+VL_EXPORT void vl_kdforestsearcher_delete (VlKDForestSearcher * searcher) ;
+/** @} */
+
+/** @name Building and querying
+ ** @{ */
+VL_EXPORT void vl_kdforest_build (VlKDForest * self,
+                                  vl_size numData,
+                                  void const * data) ;
+
+VL_EXPORT vl_size vl_kdforest_query (VlKDForest * self,
+                                     VlKDForestNeighbor * neighbors,
+                                     vl_size numNeighbors,
+                                     void const * query) ;
+
+VL_EXPORT vl_size vl_kdforest_query_with_array (VlKDForest * self,
+                                                vl_uint32 * index,
+                                                vl_size numNeighbors,
+                                                vl_size numQueries,
+                                                void * distance,
+                                                void const * queries) ;
+
+VL_EXPORT vl_size vl_kdforestsearcher_query (VlKDForestSearcher * self,
+                                             VlKDForestNeighbor * neighbors,
+                                             vl_size numNeighbors,
+                                             void const * query) ;
+/** @} */
+
+/** @name Retrieving and setting parameters
+ ** @{ */
+VL_EXPORT vl_size vl_kdforest_get_depth_of_tree (VlKDForest const * self, vl_uindex treeIndex) ;
+VL_EXPORT vl_size vl_kdforest_get_num_nodes_of_tree (VlKDForest const * self, vl_uindex treeIndex) ;
+VL_EXPORT vl_size vl_kdforest_get_num_trees (VlKDForest const * self) ;
+VL_EXPORT vl_size vl_kdforest_get_data_dimension (VlKDForest const * self) ;
+VL_EXPORT vl_type vl_kdforest_get_data_type (VlKDForest const * self) ;
+VL_EXPORT void vl_kdforest_set_max_num_comparisons (VlKDForest * self, vl_size n) ;
+VL_EXPORT vl_size vl_kdforest_get_max_num_comparisons (VlKDForest * self) ;
+VL_EXPORT void vl_kdforest_set_thresholding_method (VlKDForest * self, VlKDTreeThresholdingMethod method) ;
+VL_EXPORT VlKDTreeThresholdingMethod vl_kdforest_get_thresholding_method (VlKDForest const * self) ;
+VL_EXPORT VlKDForest * vl_kdforest_searcher_get_forest (VlKDForestSearcher const * self) ;
+VL_EXPORT VlKDForestSearcher * vl_kdforest_get_searcher (VlKDForest const * self, vl_uindex pos) ;
+/** @} */
+
+
+/* VL_KDTREE_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/kmeans.c b/opensfm/src/third_party/vlfeat/vl/kmeans.c
new file mode 100644
index 000000000..b7c93088b
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/kmeans.c
@@ -0,0 +1,2101 @@
+/** @file kmeans.c
+ ** @brief K-means - Declaration
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi and David Novotny.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page kmeans K-means clustering
+@author Andrea Vedaldi
+@author David Novotny
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref kmeans.h implements a number of algorithm for **K-means
+quantization**: Lloyd @cite{lloyd82least}, an accelerated version by
+Elkan @cite{elkan03using}, and a large scale algorithm based on
+Approximate Nearest Neighbors (ANN). All algorithms support @c float
+or @c double data and can use the $l^1$ or the $l^2$ distance for
+clustering. Furthermore, all algorithms can take advantage of multiple
+CPU cores.
+
+Please see @subpage kmeans-fundamentals for a technical description of
+K-means and of the algorithms implemented here.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kmeans-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The goal of K-means is to partition a dataset into $K$
+&ldquo;compact&rdquo; clusters. The following example demonstrates
+using @ref kmeans.h in the C programming language to partition @c
+numData @c float vectors into compute @c numCenters clusters using
+Lloyd's algorithm:
+
+@code
+#include <vl/kmeans.h>
+double energy ;
+double * centers ;
+
+// Use float data and the L2 distance for clustering
+KMeans * kmeans = vl_kmeans_new (VLDistanceL2, VL_TYPE_FLOAT) ;
+
+// Use Lloyd algorithm
+vl_kmeans_set_algorithm (kmeans, VlKMeansLloyd) ;
+
+// Initialize the cluster centers by randomly sampling the data
+vl_kmeans_init_centers_with_rand_data (kmeans, data, dimension, numData, numCenters) ;
+
+// Run at most 100 iterations of cluster refinement using Lloyd algorithm
+vl_kmeans_set_max_num_iterations (kmeans, 100) ;
+vl_kmeans_refine_centers (kmeans, data, numData) ;
+
+// Obtain the energy of the solution
+energy = vl_kmeans_get_energy(kmeans) ;
+
+// Obtain the cluster centers
+centers = vl_kmeans_get_centers(kmeans) ;
+@endcode
+
+Once the centers have been obtained, new data points can be assigned
+to clusters by using the ::vl_kmeans_quantize function:
+
+@code
+vl_uint32 * assignments = vl_malloc(sizeof(vl_uint32) * numData) ;
+float * distances = vl_malloc(sizeof(float) * numData) ;
+vl_kmeans_quantize(kmeans, assignments, distances, data, numData) ;
+@endcode
+
+Alternatively, one can directly assign new pointers to the closest
+centers, without bothering with a ::VlKMeans object.
+
+There are several considerations that may impact the performance of
+KMeans. First, since K-means is usually based local optimization
+algorithm, the **initialization method** is important. The following
+initialization methods are supported:
+
+Method         | Function                                | Description
+---------------|-----------------------------------------|-----------------------------------------------
+Random samples | ::vl_kmeans_init_centers_with_rand_data | Random data points
+K-means++      | ::vl_kmeans_init_centers_plus_plus      | Random selection biased towards diversity
+Custom         | ::vl_kmeans_set_centers                 | Choose centers (useful to run quantization only)
+
+See @ref kmeans-init for further details. The initialization methods
+use a randomized selection of the data points; the random number
+generator init is controlled by ::vl_rand_init.
+
+The second important choice is the **optimization algorithm**. The
+following optimization algorithms are supported:
+
+Algorithm   | Symbol           | See               | Description
+------------|------------------|-------------------|-----------------------------------------------
+Lloyd       | ::VlKMeansLloyd  | @ref kmeans-lloyd | Alternate EM-style optimization
+Elkan       | ::VlKMeansElkan  | @ref kmeans-elkan | A speedup using triangular inequalities
+ANN         | ::VlKMeansANN    | @ref kmeans-ann   | A speedup using approximated nearest neighbors
+
+See the relative sections for further details. These algorithm are
+iterative, and stop when either a **maximum number of iterations**
+(::vl_kmeans_set_max_num_iterations) is reached, or when the energy
+changes sufficiently slowly in one iteration (::vl_kmeans_set_min_energy_variation).
+
+
+All the three algorithms support multithreaded computations. The number
+of threads used is usually controlled globally by ::vl_set_num_threads.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page kmeans-fundamentals K-means fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Given $n$ points $\bx_1,\dots,\bx_n \in \real^d$, the goal of K-means
+is find $K$ `centers` $\bc_1,\dots,\bc_m \in \real^d$ and
+`assignments` $q_1,\dots,q_n \in \{1,\dots,K\}$ of the points to the
+centers such that the sum of distances
+
+\[
+ E(\bc_1,\dots,\bc_k,q_1,\dots,q_n)
+ = \sum_{i=1}^n \|\bx_i - \bc_{q_i} \|_p^p
+\]
+
+is minimized. $K$-means is obtained for the case $p=2$ ($l^2$ norm),
+because in this case the optimal centers are the means of the input
+vectors assigned to them. Here the generalization $p=1$ ($l^1$ norm)
+will also be considered.
+
+Up to normalization, the K-means objective $E$ is also the average
+reconstruction error if the original points are approximated with the
+cluster centers. Thus K-means is used not only to group the input
+points into cluster, but also to `quantize` their values.
+
+K-means is widely used in computer vision, for example in the
+construction of vocabularies of visual features (visual words). In
+these applications the number $n$ of points to cluster and/or the
+number $K$ of clusters is often large. Unfortunately, minimizing the
+objective $E$ is in general a difficult combinatorial problem, so
+locally optimal or approximated solutions are sought instead.
+
+The basic K-means algorithm alternate between re-estimating the
+centers and the assignments (@ref kmeans-lloyd). Combined with a good
+initialization strategy (@ref kmeans-init) and, potentially, by
+re-running the optimization from a number of randomized starting
+states, this algorithm may attain satisfactory solutions in practice.
+
+However, despite its simplicity, Lloyd's algorithm is often too slow.
+A good replacement is Elkan's algorithm (@ref kmeans-elkan), which
+uses the triangular inequality to cut down significantly the cost of
+Lloyd's algorithm. Since this algorithm is otherwise equivalent, it
+should often be preferred.
+
+For very large problems (millions of point to clusters and hundreds,
+thousands, or more clusters to find), even Elkan's algorithm is not
+sufficiently fast. In these cases, one can resort to a variant of
+Lloyd's algorithm that uses an approximated nearest neighbors routine
+(@ref kmeans-ann).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kmeans-init Initialization methods
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+All the $K$-means algorithms considered here find locally optimal
+solutions; as such the way they are initialized is important. @ref
+kmeans.h supports the following initialization algorithms:
+
+@par Random data samples
+
+The simplest initialization method is to sample $K$ points at random
+from the input data and use them as initial values for the cluster
+centers.
+
+@par K-means++
+
+@cite{arthur07k-means} proposes a randomized initialization of the
+centers which improves upon random selection. The first center $\bc_1$
+is selected at random from the data points $\bx_1, \dots, \bx_n $ and
+the distance from this center to all points $\|\bx_i - \bc_1\|_p^p$ is
+computed. Then the second center $\bc_2$ is selected at random from
+the data points with probability proportional to the distance. The
+procedure is repeated to obtain the other centers by using the minimum
+distance to the centers collected so far.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kmeans-lloyd Lloyd's algorithm
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The most common K-means method is Lloyd's algorithm
+@cite{lloyd82least}. This algorithm is based on the observation that,
+while jointly optimizing clusters and assignment is difficult,
+optimizing one given the other is easy. Lloyd's algorithm alternates
+the steps:
+
+1. **Quantization.** Each point $\bx_i$ is reassigned to the center
+   $\bc_{q_j}$ closer to it. This requires finding for each point the
+   closest among $K$ other points, which is potentially slow.
+2. **Center estimation.** Each center $\bc_q$ is updated to minimize
+   its average distances to the points assigned to it. It is easy to
+   show that the best center is the mean or median of the points,
+   respectively if the $l^2$ or $l^1$ norm is considered.
+
+A naive implementation of the assignment step requires $O(dnK)$
+operations, where $d$ is the dimensionality of the data, $n$ the
+number of data points, and $K$ the number of centers. Updating the
+centers is much cheaper: $O(dn)$ operations suffice to compute the $K$
+means and a slightly higher cost is required for the medians. Clearly,
+the bottleneck is the assignment computation, and this is what the
+other K-means algorithm try to improve.
+
+During the iterations, it can happen that a cluster becomes empty. In
+this case, K-means automatically **&ldquo;restarts&rdquo; the
+cluster** center by selecting a training point at random.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kmeans-elkan Elkan's algorithm
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Elkan's algorithm @cite{elkan03using} is a variation of Lloyd
+alternate optimization algorithm (@ref kmeans-lloyd) that uses the
+triangular inequality to avoid many distance calculations when
+assigning points to clusters. While much faster than Lloyd, Elkan's
+method uses storage proportional to the umber of clusters by data
+points, which makes it unpractical for a very large number of
+clusters.
+
+The idea of this algorithm is that, if a center update does not move
+them much, then most of the point-to-center computations can be
+avoided when the point-to-center assignments are recomputed. To detect
+which distances need evaluation, the triangular inequality is used to
+lower and upper bound distances after a center update.
+
+Elkan algorithms uses two key observations. First, one has
+
+\[
+\|\bx_i - \bc_{q_i}\|_p \leq \|\bc - \bc_{q_i}\|_p / 2
+\quad\Rightarrow\quad
+\|\bx_i - \bc_{q_i}\|_p \leq \|\bx_i - \bc\|_p.
+\]
+
+Thus if the distance between $\bx_i$ and its current center
+$\bc_{q_i}$ is less than half the distance of the center $\bc_{q_i}$
+to another center $\bc$, then $\bc$ can be skipped when the new
+assignment for $\bx_i$ is searched. Checking this requires keeping
+track of all the inter-center distances, but centers are typically a
+small fraction of the training data, so overall this can be a
+significant saving. In particular, if this condition is satisfied for
+all the centers $\bc \not= \bc_{q_i}$, the point $\bx_i$ can be
+skipped completely. Furthermore, the condition can be tested also
+based on an upper bound $UB_i$ of $\|\bx_i - \bc_{q_i}\|_p$.
+
+Second, if a center $\bc$ is updated to $\hat{\bc}$, then the new
+distance from $\bx$ to $\hat{\bc}$ is bounded from below and above by
+
+\[
+\|\bx - \bc\|_p - \|bc - \hat\bc\|_p
+\leq
+\|\bx - \hat{\bc}\|_p
+\leq
+\|\bx - \hat{\bc}\|_p + \|\bc + \hat{\bc}\|_p.
+\]
+
+This allows to maintain an upper bound on the distance of $\bx_i$ to
+its current center $\bc_{q_i}$ and a lower bound to any other center
+$\bc$:
+
+@f{align*}
+  UB_i      & \leftarrow UB_i + \|\bc_{q_i} - \hat{\bc}_{q_i} \|_p \\
+  LB_i(\bc) & \leftarrow LB_i(\bc) - \|\bc -\hat \bc\|_p.
+@f}
+
+Thus the K-means algorithm becomes:
+
+1.  **Initialization.** Compute $LB_i(\bc) = \|\bx_i -\hat \bc\|_p$ for
+    all points and centers.  Find the current assignments $q_i$ and
+    bounds $UB_i$ by finding the closest centers to each point: $UB_i =
+    \min_{\bc} LB_i(\bc)$.
+2.  **Center estimation.**
+    1. Recompute all the centers based on the new means; call the updated
+       version $\hat{\bc}$.
+    2. Update all the bounds based on the distance $\|\bc - \hat\bc\|_p$
+       as explained above.
+    3. Set $\bc \leftarrow \hat\bc$ for all the centers and go to the next
+       iteration.
+3.  **Quantization.**
+    1. Skip any point $\bx_i$ such that $UB_i \leq \frac{1}{2} \|\bc_{q_i} - \bc\|_p$
+       for all centers $\bc \not= \bc_{q_i}$.
+    2. For each remaining point $\bx_i$ and center $\bc \not= \bc_{q_i}$:
+       1. Skip $\bc$ if
+          \[
+           UB_i \leq \frac{1}{2} \| \bc_{q_i} - \bc \|
+           \quad\text{or}\quad
+           UB_i \leq LB_i(\bc).
+           \]
+          The first condition reflects the first observation above; the
+          second uses the bounds to decide if $\bc$ can be closer than the
+          current center $\bc_{q_i}$ to the point $\bx_i$. If the center
+          cannot be skipped, continue as follows.
+       3. Skip $\bc$ if the condition above is satisfied after making the
+          upper bound tight:
+          \[
+          UB_i = LB_i(\bc_{q_i}) = \| \bx_i - \bc_{q_i} \|_p.
+          \]
+          Note that the latter calculation can be done only once for $\bx_i$.
+          If the center cannot be skipped still, continue as follows.
+       4. Tighten the lower bound too:
+          \[
+          LB_i(\bc) = \| \bx_i - \bc \|_p.
+          \]
+          At this point both $UB_i$ and $LB_i(\bc)$ are tight. If $LB_i <
+          UB_i$, then the point $\bx_i$ should be reassigned to
+          $\bc$. Update $q_i$ to the index of center $\bc$ and reset $UB_i
+          = LB_i(\bc)$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section kmeans-ann ANN algorithm
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The *Approximate Nearest Neighbor* (ANN) K-means algorithm
+@cite{beis97shape} @cite{silpa-anan08optimised} @cite{muja09fast} is a
+variant of Lloyd's algorithm (@ref kmeans-lloyd) uses a best-bin-first
+randomized KD-tree algorithm to approximately (and quickly) find the
+closest cluster center to each point. The KD-tree implementation is
+based on @ref kdtree.
+
+The algorithm can be summarized as follows:
+
+1. **Quantization.** Each point $\bx_i$ is reassigned to the center
+   $\bc_{q_j}$ closer to it. This starts by indexing the $K$ centers
+   by a KD-tree and then using the latter to quickly find the closest
+   center for every training point. The search is approximated to
+   further improve speed. This opens up the possibility that a data
+   point may receive an assignment that is *worse* than the current
+   one. This is avoided by checking that the new assignment estimated
+   by using ANN is an improvement; otherwise the old assignment is
+   kept.
+2. **Center estimation.** Each center $\bc_q$ is updated to minimize
+   its average distances to the points assigned to it. It is easy to
+   show that the best center is the mean or median of the points,
+   respectively if the $l^2$ or $l^1$ norm is considered.
+
+The key is to trade-off carefully the speedup obtained by using the
+ANN algorithm and the loss in accuracy when retrieving neighbors.  Due
+to the curse of dimensionality, KD-trees become less effective for
+higher dimensional data, so that the search cost, which in the best
+case is logarithmic with this data structure, may become effectively
+linear. This is somehow mitigated by the fact that new a new KD-tree
+is computed at each iteration, reducing the likelihood that points may
+get stuck with sub-optimal assignments.
+
+Experiments with the quantization of 128-dimensional SIFT features
+show that the ANN algorithm may use one quarter of the comparisons of
+Elkan's while retaining a similar solution accuracy.
+
+*/
+
+#include "kmeans.h"
+#include "generic.h"
+#include "mathop.h"
+#include <string.h>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+/* ================================================================ */
+#ifndef VL_KMEANS_INSTANTIATING
+
+
+/** ------------------------------------------------------------------
+ ** @brief Reset state
+ **
+ ** The function reset the state of the KMeans object. It deletes
+ ** any stored centers, releasing the corresponding memory. This
+ ** cancels the effect of seeding or setting the centers, but
+ ** does not change the other configuration parameters.
+ **/
+
+VL_EXPORT void
+vl_kmeans_reset (VlKMeans * self)
+{
+  self->numCenters = 0 ;
+  self->dimension = 0 ;
+
+  if (self->centers) vl_free(self->centers) ;
+  if (self->centerDistances) vl_free(self->centerDistances) ;
+
+  self->centers = NULL ;
+  self->centerDistances = NULL ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new KMeans object
+ ** @param dataType type of data (::VL_TYPE_FLOAT or ::VL_TYPE_DOUBLE)
+ ** @param distance distance.
+ ** @return new KMeans object instance.
+**/
+
+VL_EXPORT VlKMeans *
+vl_kmeans_new (vl_type dataType,
+               VlVectorComparisonType distance)
+{
+  VlKMeans * self = vl_calloc(1, sizeof(VlKMeans)) ;
+
+  self->algorithm = VlKMeansLloyd ;
+  self->distance = distance ;
+  self->dataType = dataType ;
+  self->verbosity = 0 ;
+  self->maxNumIterations = 100 ;
+  self->minEnergyVariation = 1e-4 ;
+  self->numRepetitions = 1 ;
+  self->centers = NULL ;
+  self->centerDistances = NULL ;
+  self->numTrees = 3;
+  self->maxNumComparisons = 100;
+
+  vl_kmeans_reset (self) ;
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new KMeans object by copy
+ ** @param kmeans KMeans object to copy.
+ ** @return new copy.
+ **/
+
+VL_EXPORT VlKMeans *
+vl_kmeans_new_copy (VlKMeans const * kmeans)
+{
+  VlKMeans * self = vl_malloc(sizeof(VlKMeans)) ;
+
+  self->algorithm = kmeans->algorithm ;
+  self->distance = kmeans->distance ;
+  self->dataType = kmeans->dataType ;
+
+  self->verbosity = kmeans->verbosity ;
+  self->maxNumIterations = kmeans->maxNumIterations ;
+  self->numRepetitions = kmeans->numRepetitions ;
+
+  self->dimension = kmeans->dimension ;
+  self->numCenters = kmeans->numCenters ;
+  self->centers = NULL ;
+  self->centerDistances = NULL ;
+
+  self->numTrees = kmeans->numTrees;
+  self->maxNumComparisons = kmeans->maxNumComparisons;
+
+  if (kmeans->centers) {
+    vl_size dataSize = vl_get_type_size(self->dataType) * self->dimension * self->numCenters ;
+    self->centers = vl_malloc(dataSize) ;
+    memcpy (self->centers, kmeans->centers, dataSize) ;
+  }
+
+  if (kmeans->centerDistances) {
+    vl_size dataSize = vl_get_type_size(self->dataType) * self->numCenters * self->numCenters ;
+    self->centerDistances = vl_malloc(dataSize) ;
+    memcpy (self->centerDistances, kmeans->centerDistances, dataSize) ;
+  }
+
+  return self ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Deletes a KMeans object
+ ** @param self KMeans object instance.
+ **
+ ** The function deletes the KMeans object instance created
+ ** by ::vl_kmeans_new.
+ **/
+
+VL_EXPORT void
+vl_kmeans_delete (VlKMeans * self)
+{
+  vl_kmeans_reset (self) ;
+  vl_free (self) ;
+}
+
+/* an helper structure */
+typedef struct _VlKMeansSortWrapper {
+  vl_uint32 * permutation ;
+  void const * data ;
+  vl_size stride ;
+} VlKMeansSortWrapper ;
+
+
+/* ---------------------------------------------------------------- */
+/* Instantiate shuffle algorithm */
+
+#define VL_SHUFFLE_type vl_uindex
+#define VL_SHUFFLE_prefix _vl_kmeans
+#include "shuffle-def.h"
+
+/* #ifdef VL_KMEANS_INSTANTITATING */
+#endif
+
+/* ================================================================ */
+#ifdef VL_KMEANS_INSTANTIATING
+
+/* ---------------------------------------------------------------- */
+/*                                                      Set centers */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_kmeans_set_centers_, SFX)
+(VlKMeans * self,
+ TYPE const * centers,
+ vl_size dimension,
+ vl_size numCenters)
+{
+  self->dimension = dimension ;
+  self->numCenters = numCenters ;
+  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
+  memcpy ((TYPE*)self->centers, centers,
+          sizeof(TYPE) * dimension * numCenters) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                   Random seeding */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_kmeans_init_centers_with_rand_data_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size dimension,
+ vl_size numData,
+ vl_size numCenters)
+{
+  vl_uindex i, j, k ;
+  VlRand * rand = vl_get_rand () ;
+
+  self->dimension = dimension ;
+  self->numCenters = numCenters ;
+  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
+
+  {
+    vl_uindex * perm = vl_malloc (sizeof(vl_uindex) * numData) ;
+#if (FLT == VL_TYPE_FLOAT)
+    VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+    VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+    TYPE * distances = vl_malloc (sizeof(TYPE) * numCenters) ;
+
+    /* get a random permutation of the data point */
+    for (i = 0 ; i < numData ; ++i) perm[i] = i ;
+    _vl_kmeans_shuffle (perm, numData, rand) ;
+
+    for (k = 0, i = 0 ; k < numCenters ; ++ i) {
+
+      /* compare the next data point to all centers collected so far
+       to detect duplicates (if there are enough left)
+       */
+      if (numCenters - k < numData - i) {
+        vl_bool duplicateDetected = VL_FALSE ;
+        VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(distances,
+            dimension,
+            data + dimension * perm[i], 1,
+            (TYPE*)self->centers, k,
+            distFn) ;
+        for (j = 0 ; j < k ; ++j) {
+          duplicateDetected |= (distances[j] == 0) ;
+        }
+        if (duplicateDetected) continue ;
+      }
+
+      /* ok, it is not a duplicate so we can accept it! */
+      memcpy ((TYPE*)self->centers + dimension * k,
+              data + dimension * perm[i],
+              sizeof(TYPE) * dimension) ;
+      k ++ ;
+    }
+    vl_free(distances) ;
+    vl_free(perm) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 kmeans++ seeding */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_kmeans_init_centers_plus_plus_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size dimension,
+ vl_size numData,
+ vl_size numCenters)
+{
+  vl_uindex x, c ;
+  VlRand * rand = vl_get_rand () ;
+  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
+  TYPE * minDistances = vl_malloc (sizeof(TYPE) * numData) ;
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+
+  self->dimension = dimension ;
+  self->numCenters = numCenters ;
+  self->centers = vl_malloc (sizeof(TYPE) * dimension * numCenters) ;
+
+  for (x = 0 ; x < numData ; ++x) {
+    minDistances[x] = (TYPE) VL_INFINITY_D ;
+  }
+
+  /* select the first point at random */
+  x = vl_rand_uindex (rand, numData) ;
+  c = 0 ;
+  while (1) {
+    TYPE energy = 0 ;
+    TYPE acc = 0 ;
+    TYPE thresh = (TYPE) vl_rand_real1 (rand) ;
+
+    memcpy ((TYPE*)self->centers + c * dimension,
+            data + x * dimension,
+            sizeof(TYPE) * dimension) ;
+
+    c ++ ;
+    if (c == numCenters) break ;
+
+    VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)
+    (distances,
+     dimension,
+     (TYPE*)self->centers + (c - 1) * dimension, 1,
+     data, numData,
+     distFn) ;
+
+    for (x = 0 ; x < numData ; ++x) {
+      minDistances[x] = VL_MIN(minDistances[x], distances[x]) ;
+      energy += minDistances[x] ;
+    }
+
+    for (x = 0 ; x < numData - 1 ; ++x) {
+      acc += minDistances[x] ;
+      if (acc >= thresh * energy) break ;
+    }
+  }
+
+  vl_free(distances) ;
+  vl_free(minDistances) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                     Quantization */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_kmeans_quantize_, SFX)
+(VlKMeans * self,
+ vl_uint32 * assignments,
+ TYPE * distances,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_index i ;
+
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+
+#ifdef _OPENMP
+#pragma omp parallel \
+            shared(self, distances, assignments, numData, distFn, data) \
+            num_threads(vl_get_max_threads())
+#endif
+  {
+    /* vl_malloc cannot be used here if mapped to MATLAB malloc */
+    TYPE * distanceToCenters = malloc(sizeof(TYPE) * self->numCenters) ;
+
+#ifdef _OPENMP
+#pragma omp for
+#endif
+    for (i = 0 ; i < (signed)numData ; ++i) {
+      vl_uindex k ;
+      TYPE bestDistance = (TYPE) VL_INFINITY_D ;
+      VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(distanceToCenters,
+                                                            self->dimension,
+                                                            data + self->dimension * i, 1,
+                                                            (TYPE*)self->centers, self->numCenters,
+                                                            distFn) ;
+      for (k = 0 ; k < self->numCenters ; ++k) {
+        if (distanceToCenters[k] < bestDistance) {
+          bestDistance = distanceToCenters[k] ;
+          assignments[i] = (vl_uint32)k ;
+        }
+      }
+      if (distances) distances[i] = bestDistance ;
+    }
+
+    free(distanceToCenters) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 ANN quantization */
+/* ---------------------------------------------------------------- */
+
+static void
+VL_XCAT(_vl_kmeans_quantize_ann_, SFX)
+(VlKMeans * self,
+ vl_uint32 * assignments,
+ TYPE * distances,
+ TYPE const * data,
+ vl_size numData,
+ vl_bool update)
+{
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+
+  VlKDForest * forest = vl_kdforest_new(self->dataType,self->dimension,self->numTrees, self->distance) ;
+  vl_kdforest_set_max_num_comparisons(forest,self->maxNumComparisons);
+  vl_kdforest_set_thresholding_method(forest,VL_KDTREE_MEDIAN);
+  vl_kdforest_build(forest,self->numCenters,self->centers);
+
+#ifdef _OPENMP
+#pragma omp parallel default(none) \
+  num_threads(vl_get_max_threads()) \
+  shared(self, forest, update, assignments, distances, data, numData, distFn)
+#endif
+  {
+    VlKDForestNeighbor neighbor ;
+    VlKDForestSearcher * searcher ;
+    vl_index x;
+
+#ifdef _OPENMP
+#pragma omp critical
+#endif
+    searcher = vl_kdforest_new_searcher (forest) ;
+
+#ifdef _OPENMP
+#pragma omp for
+#endif
+    for(x = 0 ; x < (signed)numData ; ++x) {
+      vl_kdforestsearcher_query (searcher, &neighbor, 1, (TYPE const *) (data + x*self->dimension));
+
+      if (distances) {
+        if(!update) {
+          distances[x] = (TYPE) neighbor.distance;
+          assignments[x] = (vl_uint32) neighbor.index ;
+        } else {
+          TYPE prevDist = (TYPE) distFn(self->dimension,
+                                        data + self->dimension * x,
+                                        (TYPE*)self->centers + self->dimension *assignments[x]);
+          if (prevDist > (TYPE) neighbor.distance) {
+            distances[x] = (TYPE) neighbor.distance ;
+            assignments[x] = (vl_uint32) neighbor.index ;
+          } else {
+            distances[x] = prevDist ;
+          }
+        }
+      } else {
+        assignments[x] = (vl_uint32) neighbor.index ;
+      }
+    } /* end for */
+  } /* end of parallel region */
+
+  vl_kdforest_delete(forest);
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 Helper functions */
+/* ---------------------------------------------------------------- */
+
+/* The sorting routine is used to find increasing permutation of each
+ * data dimension. This is used to quickly find the median for l1
+ * distance clustering. */
+
+VL_INLINE TYPE
+VL_XCAT3(_vl_kmeans_, SFX, _qsort_cmp)
+(VlKMeansSortWrapper * array, vl_uindex indexA, vl_uindex indexB)
+{
+  return
+    ((TYPE*)array->data) [array->permutation[indexA] * array->stride]
+    -
+    ((TYPE*)array->data) [array->permutation[indexB] * array->stride] ;
+}
+
+VL_INLINE void
+VL_XCAT3(_vl_kmeans_, SFX, _qsort_swap)
+(VlKMeansSortWrapper * array, vl_uindex indexA, vl_uindex indexB)
+{
+  vl_uint32 tmp = array->permutation[indexA] ;
+  array->permutation[indexA] = array->permutation[indexB] ;
+  array->permutation[indexB] = tmp ;
+}
+
+#define VL_QSORT_prefix  VL_XCAT3(_vl_kmeans_, SFX, _qsort)
+#define VL_QSORT_array   VlKMeansSortWrapper*
+#define VL_QSORT_cmp     VL_XCAT3(_vl_kmeans_, SFX, _qsort_cmp)
+#define VL_QSORT_swap    VL_XCAT3(_vl_kmeans_, SFX, _qsort_swap)
+#include "qsort-def.h"
+
+static void
+VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)
+(VlKMeans * self, vl_uint32 * permutations, TYPE const * data, vl_size numData)
+{
+  vl_uindex d, x ;
+
+  for (d = 0 ; d < self->dimension ; ++d) {
+    VlKMeansSortWrapper array ;
+    array.permutation = permutations + d * numData ;
+    array.data = data + d ;
+    array.stride = self->dimension ;
+    for (x = 0 ; x < numData ; ++x) {
+      array.permutation[x] = (vl_uint32)x ;
+    }
+    VL_XCAT3(_vl_kmeans_, SFX, _qsort_sort)(&array, numData) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 Lloyd refinement */
+/* ---------------------------------------------------------------- */
+
+static double
+VL_XCAT(_vl_kmeans_refine_centers_lloyd_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_size c, d, x, iteration ;
+  double previousEnergy = VL_INFINITY_D ;
+  double initialEnergy = VL_INFINITY_D ;
+  double energy ;
+  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
+
+  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
+  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
+  vl_uint32 * permutations = NULL ;
+  vl_size * numSeenSoFar = NULL ;
+  VlRand * rand = vl_get_rand () ;
+  vl_size totNumRestartedCenters = 0 ;
+  vl_size numRestartedCenters = 0 ;
+
+  if (self->distance == VlDistanceL1) {
+    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
+    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
+    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
+  }
+
+  for (energy = VL_INFINITY_D,
+       iteration = 0;
+       1 ;
+       ++ iteration) {
+
+    /* assign data to cluters */
+    VL_XCAT(_vl_kmeans_quantize_, SFX)(self, assignments, distances, data, numData) ;
+
+    /* compute energy */
+    energy = 0 ;
+    for (x = 0 ; x < numData ; ++x) energy += distances[x] ;
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: Lloyd iter %d: energy = %g\n", iteration,
+                energy) ;
+    }
+
+    /* check termination conditions */
+    if (iteration >= self->maxNumIterations) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: Lloyd terminating because maximum number of iterations reached\n") ;
+      }
+      break ;
+    }
+    if (energy == previousEnergy) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: Lloyd terminating because the algorithm fully converged\n") ;
+      }
+      break ;
+    }
+    
+    if (iteration == 0) {
+      initialEnergy = energy ;
+    } else {
+      double eps = (previousEnergy - energy) / (initialEnergy - energy) ;
+      if (eps < self->minEnergyVariation) {
+        if (self->verbosity) {
+          VL_PRINTF("kmeans: ANN terminating because the energy relative variation was less than %f\n", self->minEnergyVariation) ;
+        }
+        break ;
+      }
+    }
+    
+    /* begin next iteration */
+    previousEnergy = energy ;
+
+    /* update clusters */
+    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
+    for (x = 0 ; x < numData ; ++x) {
+      clusterMasses[assignments[x]] ++ ;
+    }
+
+    numRestartedCenters = 0 ;
+    switch (self->distance) {
+      case VlDistanceL2:
+        memset(self->centers, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
+        for (x = 0 ; x < numData ; ++x) {
+          TYPE * cpt = (TYPE*)self->centers + assignments[x] * self->dimension ;
+          TYPE const * xpt = data + x * self->dimension ;
+          for (d = 0 ; d < self->dimension ; ++d) {
+            cpt[d] += xpt[d] ;
+          }
+        }
+        for (c = 0 ; c < self->numCenters ; ++c) {
+          TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
+          if (clusterMasses[c] > 0) {
+            TYPE mass = clusterMasses[c] ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] /= mass ;
+            }
+          } else {
+            vl_uindex x = vl_rand_uindex(rand, numData) ;
+            numRestartedCenters ++ ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] = data[x * self->dimension + d] ;
+            }
+          }
+        }
+        break ;
+      case VlDistanceL1:
+        for (d = 0 ; d < self->dimension ; ++d) {
+          vl_uint32 * perm = permutations + d * numData ;
+          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
+          for (x = 0; x < numData ; ++x) {
+            c = assignments[perm[x]] ;
+            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
+              ((TYPE*)self->centers) [d + c * self->dimension] =
+                data [d + perm[x] * self->dimension] ;
+            }
+            numSeenSoFar[c] ++ ;
+          }
+          /* restart the centers as required  */
+          for (c = 0 ; c < self->numCenters ; ++c) {
+            if (clusterMasses[c] == 0) {
+              TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
+              vl_uindex x = vl_rand_uindex(rand, numData) ;
+              numRestartedCenters ++ ;
+              for (d = 0 ; d < self->dimension ; ++d) {
+                cpt[d] = data[x * self->dimension + d] ;
+              }
+            }
+          }
+        }
+        break ;
+      default:
+        abort();
+    } /* done compute centers */
+
+    totNumRestartedCenters += numRestartedCenters ;
+    if (self->verbosity && numRestartedCenters) {
+      VL_PRINTF("kmeans: Lloyd iter %d: restarted %d centers\n", iteration,
+                numRestartedCenters) ;
+    }
+  } /* next Lloyd iteration */
+
+  if (permutations) {
+    vl_free(permutations) ;
+  }
+  if (numSeenSoFar) {
+    vl_free(numSeenSoFar) ;
+  }
+  vl_free(distances) ;
+  vl_free(assignments) ;
+  vl_free(clusterMasses) ;
+  return energy ;
+}
+
+static double
+VL_XCAT(_vl_kmeans_update_center_distances_, SFX)
+(VlKMeans * self)
+{
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+
+  if (! self->centerDistances) {
+    self->centerDistances = vl_malloc (sizeof(TYPE) *
+                                       self->numCenters *
+                                       self->numCenters) ;
+  }
+  VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(self->centerDistances,
+      self->dimension,
+      self->centers, self->numCenters,
+      NULL, 0,
+      distFn) ;
+  return self->numCenters * (self->numCenters - 1) / 2 ;
+}
+
+static double
+VL_XCAT(_vl_kmeans_refine_centers_ann_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_size c, d, x, iteration ;
+  double initialEnergy = VL_INFINITY_D ;
+  double previousEnergy = VL_INFINITY_D ;
+  double energy ;
+
+  vl_uint32 * permutations = NULL ;
+  vl_size * numSeenSoFar = NULL ;
+  VlRand * rand = vl_get_rand () ;
+  vl_size totNumRestartedCenters = 0 ;
+  vl_size numRestartedCenters = 0 ;
+
+  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
+  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
+  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
+
+  if (self->distance == VlDistanceL1) {
+    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
+    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
+    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
+  }
+
+  for (energy = VL_INFINITY_D,
+       iteration = 0;
+       1 ;
+       ++ iteration) {
+
+    /* assign data to cluters */
+    VL_XCAT(_vl_kmeans_quantize_ann_, SFX)(self, assignments, distances, data, numData, iteration > 0) ;
+
+    /* compute energy */
+    energy = 0 ;
+    for (x = 0 ; x < numData ; ++x) energy += distances[x] ;
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: ANN iter %d: energy = %g\n", iteration,
+                energy) ;
+    }
+
+    /* check termination conditions */
+    if (iteration >= self->maxNumIterations) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: ANN terminating because the maximum number of iterations has been reached\n") ;
+      }
+      break ;
+    }
+    if (energy == previousEnergy) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: ANN terminating because the algorithm fully converged\n") ;
+      }
+      break ;
+    }
+    
+    if (iteration == 0) {
+      initialEnergy = energy ;
+    } else {
+      double eps = (previousEnergy - energy) / (initialEnergy - energy) ;
+      if (eps < self->minEnergyVariation) {
+        if (self->verbosity) {
+          VL_PRINTF("kmeans: ANN terminating because the energy relative variation was less than %f\n", self->minEnergyVariation) ;
+        }
+        break ;
+      }
+    }
+
+    /* begin next iteration */
+    previousEnergy = energy ;
+
+    /* update clusters */
+    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
+    for (x = 0 ; x < numData ; ++x) {
+      clusterMasses[assignments[x]] ++ ;
+    }
+
+    numRestartedCenters = 0 ;
+    switch (self->distance) {
+      case VlDistanceL2:
+        memset(self->centers, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
+        for (x = 0 ; x < numData ; ++x) {
+          TYPE * cpt = (TYPE*)self->centers + assignments[x] * self->dimension ;
+          TYPE const * xpt = data + x * self->dimension ;
+          for (d = 0 ; d < self->dimension ; ++d) {
+            cpt[d] += xpt[d] ;
+          }
+        }
+        for (c = 0 ; c < self->numCenters ; ++c) {
+          TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
+          if (clusterMasses[c] > 0) {
+            TYPE mass = clusterMasses[c] ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] /= mass ;
+            }
+          } else {
+            vl_uindex x = vl_rand_uindex(rand, numData) ;
+            numRestartedCenters ++ ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] = data[x * self->dimension + d] ;
+            }
+          }
+        }
+        break ;
+      case VlDistanceL1:
+        for (d = 0 ; d < self->dimension ; ++d) {
+          vl_uint32 * perm = permutations + d * numData ;
+          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
+          for (x = 0; x < numData ; ++x) {
+            c = assignments[perm[x]] ;
+            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
+              ((TYPE*)self->centers) [d + c * self->dimension] =
+                data [d + perm[x] * self->dimension] ;
+            }
+            numSeenSoFar[c] ++ ;
+          }
+          /* restart the centers as required  */
+          for (c = 0 ; c < self->numCenters ; ++c) {
+            if (clusterMasses[c] == 0) {
+              TYPE * cpt = (TYPE*)self->centers + c * self->dimension ;
+              vl_uindex x = vl_rand_uindex(rand, numData) ;
+              numRestartedCenters ++ ;
+              for (d = 0 ; d < self->dimension ; ++d) {
+                cpt[d] = data[x * self->dimension + d] ;
+              }
+            }
+          }
+        }
+        break ;
+      default:
+        VL_PRINT("bad distance set: %d\n",self->distance);
+        abort();
+    } /* done compute centers */
+
+    totNumRestartedCenters += numRestartedCenters ;
+    if (self->verbosity && numRestartedCenters) {
+      VL_PRINTF("kmeans: ANN iter %d: restarted %d centers\n", iteration,
+                numRestartedCenters) ;
+    }
+  }
+
+  if (permutations) {
+    vl_free(permutations) ;
+  }
+  if (numSeenSoFar) {
+    vl_free(numSeenSoFar) ;
+  }
+
+  vl_free(distances) ;
+  vl_free(assignments) ;
+  vl_free(clusterMasses) ;
+  return energy ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                 Elkan refinement */
+/* ---------------------------------------------------------------- */
+
+static double
+VL_XCAT(_vl_kmeans_refine_centers_elkan_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  vl_size d, iteration ;
+  vl_index x ;
+  vl_uint32 c, j ;
+  vl_bool allDone ;
+  TYPE * distances = vl_malloc (sizeof(TYPE) * numData) ;
+  vl_uint32 * assignments = vl_malloc (sizeof(vl_uint32) * numData) ;
+  vl_size * clusterMasses = vl_malloc (sizeof(vl_size) * numData) ;
+  VlRand * rand = vl_get_rand () ;
+
+#if (FLT == VL_TYPE_FLOAT)
+  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
+#else
+  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
+#endif
+
+  TYPE * nextCenterDistances = vl_malloc (sizeof(TYPE) * self->numCenters) ;
+  TYPE * pointToClosestCenterUB = vl_malloc (sizeof(TYPE) * numData) ;
+  vl_bool * pointToClosestCenterUBIsStrict = vl_malloc (sizeof(vl_bool) * numData) ;
+  TYPE * pointToCenterLB = vl_malloc (sizeof(TYPE) * numData * self->numCenters) ;
+  TYPE * newCenters = vl_malloc(sizeof(TYPE) * self->dimension * self->numCenters) ;
+  TYPE * centerToNewCenterDistances = vl_malloc (sizeof(TYPE) * self->numCenters) ;
+
+  vl_uint32 * permutations = NULL ;
+  vl_size * numSeenSoFar = NULL ;
+
+  double energy ;
+
+  vl_size totDistanceComputationsToInit = 0 ;
+  vl_size totDistanceComputationsToRefreshUB = 0 ;
+  vl_size totDistanceComputationsToRefreshLB = 0 ;
+  vl_size totDistanceComputationsToRefreshCenterDistances = 0 ;
+  vl_size totDistanceComputationsToNewCenters = 0 ;
+  vl_size totDistanceComputationsToFinalize = 0 ;
+  vl_size totNumRestartedCenters = 0 ;
+
+  if (self->distance == VlDistanceL1) {
+    permutations = vl_malloc(sizeof(vl_uint32) * numData * self->dimension) ;
+    numSeenSoFar = vl_malloc(sizeof(vl_size) * self->numCenters) ;
+    VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)(self, permutations, data, numData) ;
+  }
+
+  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+  /*                          Initialization                        */
+  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+  /* An iteration is: get_new_centers + reassign + get_energy.
+   This counts as iteration 0, where get_new_centers is assumed
+   to be performed before calling the train function by
+   the initialization function */
+
+  /* update distances between centers */
+  totDistanceComputationsToInit +=
+  VL_XCAT(_vl_kmeans_update_center_distances_, SFX)(self) ;
+
+  /* assigmen points to the initial centers and initialize bounds */
+  memset(pointToCenterLB, 0, sizeof(TYPE) * self->numCenters *  numData) ;
+  for (x = 0 ; x < (signed)numData ; ++x) {
+    TYPE distance ;
+
+    /* do the first center */
+    assignments[x] = 0 ;
+    distance = distFn(self->dimension,
+                      data + x * self->dimension,
+                      (TYPE*)self->centers + 0) ;
+    pointToClosestCenterUB[x] = distance ;
+    pointToClosestCenterUBIsStrict[x] = VL_TRUE ;
+    pointToCenterLB[0 + x * self->numCenters] = distance ;
+    totDistanceComputationsToInit += 1 ;
+
+    /* do other centers */
+    for (c = 1 ; c < self->numCenters ; ++c) {
+
+      /* Can skip if the center assigned so far is twice as close
+       as its distance to the center under consideration */
+
+      if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
+          pointToClosestCenterUB[x] <=
+          ((TYPE*)self->centerDistances)
+          [c + assignments[x] * self->numCenters]) {
+        continue ;
+      }
+
+      distance = distFn(self->dimension,
+                        data + x * self->dimension,
+                        (TYPE*)self->centers + c * self->dimension) ;
+      pointToCenterLB[c + x * self->numCenters] = distance ;
+      totDistanceComputationsToInit += 1 ;
+      if (distance < pointToClosestCenterUB[x]) {
+        pointToClosestCenterUB[x] = distance ;
+        assignments[x] = c ;
+      }
+    }
+  }
+
+  /* compute UB on energy */
+  energy = 0 ;
+  for (x = 0 ; x < (signed)numData ; ++x) {
+    energy += pointToClosestCenterUB[x] ;
+  }
+
+  if (self->verbosity) {
+    VL_PRINTF("kmeans: Elkan iter 0: energy = %g, dist. calc. = %d\n",
+              energy, totDistanceComputationsToInit) ;
+  }
+
+  /* #define SANITY*/
+#ifdef SANITY
+  {
+    int xx ;
+    int cc ;
+    TYPE tol = 1e-5 ;
+    VL_PRINTF("inconsistencies after initial assignments:\n");
+    for (xx = 0 ; xx < numData ; ++xx) {
+      for (cc = 0 ; cc < self->numCenters ; ++cc) {
+        TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
+        TYPE b = distFn(self->dimension,
+                        data + self->dimension * xx,
+                        (TYPE*)self->centers + self->dimension * cc) ;
+        if (cc == assignments[xx]) {
+          TYPE z = pointToClosestCenterUB[xx] ;
+          if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
+                                 cc, xx, z, b) ;
+        }
+        if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f\n",
+                               cc, xx, a, b) ;
+      }
+    }
+  }
+#endif
+
+  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+  /*                          Iterations                            */
+  /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+  for (iteration = 1 ; 1; ++iteration) {
+
+    vl_size numDistanceComputationsToRefreshUB = 0 ;
+    vl_size numDistanceComputationsToRefreshLB = 0 ;
+    vl_size numDistanceComputationsToRefreshCenterDistances = 0 ;
+    vl_size numDistanceComputationsToNewCenters = 0 ;
+    vl_size numRestartedCenters = 0 ;
+
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /*                         Compute new centers                  */
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+    memset(clusterMasses, 0, sizeof(vl_size) * numData) ;
+    for (x = 0 ; x < (signed)numData ; ++x) {
+      clusterMasses[assignments[x]] ++ ;
+    }
+
+    switch (self->distance) {
+      case VlDistanceL2:
+        memset(newCenters, 0, sizeof(TYPE) * self->dimension * self->numCenters) ;
+        for (x = 0 ; x < (signed)numData ; ++x) {
+          TYPE * cpt = newCenters + assignments[x] * self->dimension ;
+          TYPE const * xpt = data + x * self->dimension ;
+          for (d = 0 ; d < self->dimension ; ++d) {
+            cpt[d] += xpt[d] ;
+          }
+        }
+        for (c = 0 ; c < self->numCenters ; ++c) {
+          TYPE * cpt = newCenters + c * self->dimension ;
+          if (clusterMasses[c] > 0) {
+            TYPE mass = clusterMasses[c] ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] /= mass ;
+            }
+          } else {
+            /* restart the center */
+            vl_uindex x = vl_rand_uindex(rand, numData) ;
+            numRestartedCenters ++ ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] = data[x * self->dimension + d] ;
+            }
+          }
+        }
+        break ;
+      case VlDistanceL1:
+        for (d = 0 ; d < self->dimension ; ++d) {
+          vl_uint32 * perm = permutations + d * numData ;
+          memset(numSeenSoFar, 0, sizeof(vl_size) * self->numCenters) ;
+          for (x = 0; x < (signed)numData ; ++x) {
+            c = assignments[perm[x]] ;
+            if (2 * numSeenSoFar[c] < clusterMasses[c]) {
+              newCenters [d + c * self->dimension] =
+              data [d + perm[x] * self->dimension] ;
+            }
+            numSeenSoFar[c] ++ ;
+          }
+        }
+        /* restart the centers as required  */
+        for (c = 0 ; c < self->numCenters ; ++c) {
+          if (clusterMasses[c] == 0) {
+            TYPE * cpt = newCenters + c * self->dimension ;
+            vl_uindex x = vl_rand_uindex(rand, numData) ;
+            numRestartedCenters ++ ;
+            for (d = 0 ; d < self->dimension ; ++d) {
+              cpt[d] = data[x * self->dimension + d] ;
+            }
+          }
+        }
+        break ;
+      default:
+        abort();
+    } /* done compute centers */
+
+    /* compute the distance from the old centers to the new centers */
+    for (c = 0 ; c < self->numCenters ; ++c) {
+      TYPE distance = distFn(self->dimension,
+                             newCenters + c * self->dimension,
+                             (TYPE*)self->centers + c * self->dimension) ;
+      centerToNewCenterDistances[c] = distance ;
+      numDistanceComputationsToNewCenters += 1 ;
+    }
+
+    /* make the new centers current */
+    {
+      TYPE * tmp = self->centers ;
+      self->centers = newCenters ;
+      newCenters = tmp ;
+    }
+
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+    /*                Reassign points to a centers                  */
+    /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+    /*
+     Update distances between centers.
+     */
+    numDistanceComputationsToRefreshCenterDistances
+    += VL_XCAT(_vl_kmeans_update_center_distances_, SFX)(self) ;
+
+    for (c = 0 ; c < self->numCenters ; ++c) {
+      nextCenterDistances[c] = (TYPE) VL_INFINITY_D ;
+      for (j = 0 ; j < self->numCenters ; ++j) {
+        if (j == c) continue ;
+        nextCenterDistances[c] = VL_MIN(nextCenterDistances[c],
+                                        ((TYPE*)self->centerDistances)
+                                        [j + c * self->numCenters]) ;
+      }
+    }
+
+    /*
+     Update upper bounds on point-to-closest-center distances
+     based on the center variation.
+     */
+    for (x = 0 ; x < (signed)numData ; ++x) {
+      TYPE a = pointToClosestCenterUB[x] ;
+      TYPE b = centerToNewCenterDistances[assignments[x]] ;
+      if (self->distance == VlDistanceL1) {
+        pointToClosestCenterUB[x] = a + b ;
+      } else {
+#if (FLT == VL_TYPE_FLOAT)
+        TYPE sqrtab =  sqrtf (a * b) ;
+#else
+        TYPE sqrtab =  sqrt (a * b) ;
+#endif
+        pointToClosestCenterUB[x] = a + b + 2.0 * sqrtab ;
+      }
+      pointToClosestCenterUBIsStrict[x] = VL_FALSE ;
+    }
+
+    /*
+     Update lower bounds on point-to-center distances
+     based on the center variation.
+     */
+
+#if defined(_OPENMP)
+#pragma omp parallel for default(shared) private(x,c) num_threads(vl_get_max_threads())
+#endif
+    for (x = 0 ; x < (signed)numData ; ++x) {
+      for (c = 0 ; c < self->numCenters ; ++c) {
+        TYPE a = pointToCenterLB[c + x * self->numCenters] ;
+        TYPE b = centerToNewCenterDistances[c] ;
+        if (a < b) {
+          pointToCenterLB[c + x * self->numCenters] = 0 ;
+        } else {
+          if (self->distance == VlDistanceL1) {
+            pointToCenterLB[c + x * self->numCenters]  = a - b ;
+          } else {
+#if (FLT == VL_TYPE_FLOAT)
+            TYPE sqrtab =  sqrtf (a * b) ;
+#else
+            TYPE sqrtab =  sqrt (a * b) ;
+#endif
+            pointToCenterLB[c + x * self->numCenters]  = a + b - 2.0 * sqrtab ;
+          }
+        }
+      }
+    }
+
+#ifdef SANITY
+    {
+      int xx ;
+      int cc ;
+      TYPE tol = 1e-5 ;
+      VL_PRINTF("inconsistencies before assignments:\n");
+      for (xx = 0 ; xx < numData ; ++xx) {
+        for (cc = 0 ; cc < self->numCenters ; ++cc) {
+          TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
+          TYPE b = distFn(self->dimension,
+                          data + self->dimension * xx,
+                          (TYPE*)self->centers + self->dimension * cc) ;
+          if (cc == assignments[xx]) {
+            TYPE z = pointToClosestCenterUB[xx] ;
+            if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
+                                   cc, xx, z, b) ;
+          }
+          if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f (assign = %d)\n",
+                                 cc, xx, a, b, assignments[xx]) ;
+        }
+      }
+    }
+#endif
+
+    /*
+     Scan the data and do the reassignments. Use the bounds to
+     skip as many point-to-center distance calculations as possible.
+     */
+    allDone = VL_TRUE ;
+
+#if defined(_OPENMP)
+#pragma omp parallel for \
+            default(none) \
+            shared(self,numData, \
+              pointToClosestCenterUB,pointToCenterLB, \
+              nextCenterDistances,pointToClosestCenterUBIsStrict, \
+              assignments,data,distFn,allDone) \
+            private(c,x) \
+            reduction(+:numDistanceComputationsToRefreshUB,numDistanceComputationsToRefreshLB) \
+            num_threads(vl_get_max_threads())
+#endif
+    for (x = 0 ; x < (signed)numData ; ++ x) {
+      /*
+       A point x sticks with its current center assignmets[x]
+       the UB to d(x, c[assigmnets[x]]) is not larger than half
+       the distance of c[assigments[x]] to any other center c.
+       */
+      if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
+          pointToClosestCenterUB[x] <= nextCenterDistances[assignments[x]]) {
+        continue ;
+      }
+
+      for (c = 0 ; c < self->numCenters ; ++c) {
+        vl_uint32 cx = assignments[x] ;
+        TYPE distance ;
+
+        /* The point is not reassigned to a given center c
+         if either:
+
+         0 - c is already the assigned center
+         1 - The UB of d(x, c[assignments[x]]) is smaller than half
+         the distance of c[assigments[x]] to c, OR
+         2 - The UB of d(x, c[assignmets[x]]) is smaller than the
+         LB of the distance of x to c.
+         */
+        if (cx == c) {
+          continue ;
+        }
+        if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
+            pointToClosestCenterUB[x] <= ((TYPE*)self->centerDistances)
+            [c + cx * self->numCenters]) {
+          continue ;
+        }
+        if (pointToClosestCenterUB[x] <= pointToCenterLB
+            [c + x * self->numCenters]) {
+          continue ;
+        }
+
+        /* If the UB is loose, try recomputing it and test again */
+        if (! pointToClosestCenterUBIsStrict[x]) {
+          distance = distFn(self->dimension,
+                            data + self->dimension * x,
+                            (TYPE*)self->centers + self->dimension * cx) ;
+          pointToClosestCenterUB[x] = distance ;
+          pointToClosestCenterUBIsStrict[x] = VL_TRUE ;
+          pointToCenterLB[cx + x * self->numCenters] = distance ;
+          numDistanceComputationsToRefreshUB += 1 ;
+
+          if (((self->distance == VlDistanceL1) ? 2.0 : 4.0) *
+              pointToClosestCenterUB[x] <= ((TYPE*)self->centerDistances)
+              [c + cx * self->numCenters]) {
+            continue ;
+          }
+          if (pointToClosestCenterUB[x] <= pointToCenterLB
+              [c + x * self->numCenters]) {
+            continue ;
+          }
+        }
+
+        /*
+         Now the UB is strict (equal to d(x, assignments[x])), but
+         we still could not exclude that x should be reassigned to
+         c. We therefore compute the distance, update the LB,
+         and check if a reassigmnet must be made
+         */
+        distance = distFn(self->dimension,
+                          data + x * self->dimension,
+                          (TYPE*)self->centers + c *  self->dimension) ;
+        numDistanceComputationsToRefreshLB += 1 ;
+        pointToCenterLB[c + x * self->numCenters] = distance ;
+
+        if (distance < pointToClosestCenterUB[x]) {
+          assignments[x] = c ;
+          pointToClosestCenterUB[x] = distance ;
+          allDone = VL_FALSE ;
+          /* the UB strict flag is already set here */
+        }
+
+      } /* assign center */
+    } /* next data point */
+
+
+    totDistanceComputationsToRefreshUB
+    += numDistanceComputationsToRefreshUB ;
+
+    totDistanceComputationsToRefreshLB
+    += numDistanceComputationsToRefreshLB ;
+
+    totDistanceComputationsToRefreshCenterDistances
+    += numDistanceComputationsToRefreshCenterDistances ;
+
+    totDistanceComputationsToNewCenters
+    += numDistanceComputationsToNewCenters ;
+
+    totNumRestartedCenters
+    += numRestartedCenters ;
+
+#ifdef SANITY
+    {
+      int xx ;
+      int cc ;
+      TYPE tol = 1e-5 ;
+      VL_PRINTF("inconsistencies after assignments:\n");
+      for (xx = 0 ; xx < numData ; ++xx) {
+        for (cc = 0 ; cc < self->numCenters ; ++cc) {
+          TYPE a = pointToCenterLB[cc + xx * self->numCenters] ;
+          TYPE b = distFn(self->dimension,
+                          data + self->dimension * xx,
+                          (TYPE*)self->centers + self->dimension * cc) ;
+          if (cc == assignments[xx]) {
+            TYPE z = pointToClosestCenterUB[xx] ;
+            if (z+tol<b) VL_PRINTF("UB %d %d = %f < %f\n",
+                                   cc, xx, z, b) ;
+          }
+          if (a>b+tol) VL_PRINTF("LB %d %d = %f  > %f (assign = %d)\n",
+                                 cc, xx, a, b, assignments[xx]) ;
+        }
+      }
+    }
+#endif
+
+    /* compute UB on energy */
+    energy = 0 ;
+    for (x = 0 ; x < (signed)numData ; ++x) {
+      energy += pointToClosestCenterUB[x] ;
+    }
+
+    if (self->verbosity) {
+      vl_size numDistanceComputations =
+      numDistanceComputationsToRefreshUB +
+      numDistanceComputationsToRefreshLB +
+      numDistanceComputationsToRefreshCenterDistances +
+      numDistanceComputationsToNewCenters ;
+      VL_PRINTF("kmeans: Elkan iter %d: energy <= %g, dist. calc. = %d\n",
+                iteration,
+                energy,
+                numDistanceComputations) ;
+      if (numRestartedCenters) {
+        VL_PRINTF("kmeans: Elkan iter %d: restarted %d centers\n",
+                  iteration,
+                  energy,
+                  numRestartedCenters) ;
+      }
+      if (self->verbosity > 1) {
+        VL_PRINTF("kmeans: Elkan iter %d: total dist. calc. per type: "
+                  "UB: %.1f%% (%d), LB: %.1f%% (%d), "
+                  "intra_center: %.1f%% (%d), "
+                  "new_center: %.1f%% (%d)\n",
+                  iteration,
+                  100.0 * numDistanceComputationsToRefreshUB / numDistanceComputations,
+                  numDistanceComputationsToRefreshUB,
+                  100.0 *numDistanceComputationsToRefreshLB / numDistanceComputations,
+                  numDistanceComputationsToRefreshLB,
+                  100.0 * numDistanceComputationsToRefreshCenterDistances / numDistanceComputations,
+                  numDistanceComputationsToRefreshCenterDistances,
+                  100.0 * numDistanceComputationsToNewCenters / numDistanceComputations,
+                  numDistanceComputationsToNewCenters) ;
+      }
+    }
+
+    /* check termination conditions */
+    if (iteration >= self->maxNumIterations) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: Elkan terminating because maximum number of iterations reached\n") ;
+      }
+      break ;
+    }
+    if (allDone) {
+      if (self->verbosity) {
+        VL_PRINTF("kmeans: Elkan terminating because the algorithm fully converged\n") ;
+      }
+      break ;
+    }
+
+  } /* next Elkan iteration */
+
+  /* compute true energy */
+  energy = 0 ;
+  for (x = 0 ; x < (signed)numData ; ++ x) {
+    vl_uindex cx = assignments [x] ;
+    energy += distFn(self->dimension,
+                     data + self->dimension * x,
+                     (TYPE*)self->centers + self->dimension * cx) ;
+    totDistanceComputationsToFinalize += 1 ;
+  }
+
+  {
+    vl_size totDistanceComputations =
+    totDistanceComputationsToInit +
+    totDistanceComputationsToRefreshUB +
+    totDistanceComputationsToRefreshLB +
+    totDistanceComputationsToRefreshCenterDistances +
+    totDistanceComputationsToNewCenters +
+    totDistanceComputationsToFinalize ;
+
+    double saving = (double)totDistanceComputations
+    / (iteration * self->numCenters * numData) ;
+
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: Elkan: total dist. calc.: %d (%.2f %% of Lloyd)\n",
+                totDistanceComputations, saving * 100.0) ;
+      if (totNumRestartedCenters) {
+        VL_PRINTF("kmeans: Elkan: there have been %d restarts\n",
+                  totNumRestartedCenters) ;
+      }
+    }
+
+    if (self->verbosity > 1) {
+      VL_PRINTF("kmeans: Elkan: total dist. calc. per type: "
+                "init: %.1f%% (%d), UB: %.1f%% (%d), LB: %.1f%% (%d), "
+                "intra_center: %.1f%% (%d), "
+                "new_center: %.1f%% (%d), "
+                "finalize: %.1f%% (%d)\n",
+                100.0 * totDistanceComputationsToInit / totDistanceComputations,
+                totDistanceComputationsToInit,
+                100.0 * totDistanceComputationsToRefreshUB / totDistanceComputations,
+                totDistanceComputationsToRefreshUB,
+                100.0 *totDistanceComputationsToRefreshLB / totDistanceComputations,
+                totDistanceComputationsToRefreshLB,
+                100.0 * totDistanceComputationsToRefreshCenterDistances / totDistanceComputations,
+                totDistanceComputationsToRefreshCenterDistances,
+                100.0 * totDistanceComputationsToNewCenters / totDistanceComputations,
+                totDistanceComputationsToNewCenters,
+                100.0 * totDistanceComputationsToFinalize / totDistanceComputations,
+                totDistanceComputationsToFinalize) ;
+    }
+  }
+
+  if (permutations) {
+    vl_free(permutations) ;
+  }
+  if (numSeenSoFar) {
+    vl_free(numSeenSoFar) ;
+  }
+
+  vl_free(distances) ;
+  vl_free(assignments) ;
+  vl_free(clusterMasses) ;
+
+  vl_free(nextCenterDistances) ;
+  vl_free(pointToClosestCenterUB) ;
+  vl_free(pointToClosestCenterUBIsStrict) ;
+  vl_free(pointToCenterLB) ;
+  vl_free(newCenters) ;
+  vl_free(centerToNewCenterDistances) ;
+
+  return energy ;
+}
+
+/* ---------------------------------------------------------------- */
+static double
+VL_XCAT(_vl_kmeans_refine_centers_, SFX)
+(VlKMeans * self,
+ TYPE const * data,
+ vl_size numData)
+{
+  switch (self->algorithm) {
+    case VlKMeansLloyd:
+      return
+        VL_XCAT(_vl_kmeans_refine_centers_lloyd_, SFX)(self, data, numData) ;
+      break ;
+    case VlKMeansElkan:
+      return
+        VL_XCAT(_vl_kmeans_refine_centers_elkan_, SFX)(self, data, numData) ;
+      break ;
+    case VlKMeansANN:
+      return
+        VL_XCAT(_vl_kmeans_refine_centers_ann_, SFX)(self, data, numData) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/* VL_KMEANS_INSTANTIATING */
+#else
+
+#ifndef __DOXYGEN__
+#define FLT VL_TYPE_FLOAT
+#define TYPE float
+#define SFX f
+#define VL_KMEANS_INSTANTIATING
+#include "kmeans.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define TYPE double
+#define SFX d
+#define VL_KMEANS_INSTANTIATING
+#include "kmeans.c"
+#endif
+
+/* VL_KMEANS_INSTANTIATING */
+#endif
+
+/* ================================================================ */
+#ifndef VL_KMEANS_INSTANTIATING
+
+/** ------------------------------------------------------------------
+ ** @brief Set centers
+ ** @param self KMeans object.
+ ** @param centers centers to copy.
+ ** @param dimension data dimension.
+ ** @param numCenters number of centers.
+ **/
+
+VL_EXPORT void
+vl_kmeans_set_centers
+(VlKMeans * self,
+ void const * centers,
+ vl_size dimension,
+ vl_size numCenters)
+{
+  vl_kmeans_reset (self) ;
+
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_kmeans_set_centers_f
+      (self, (float const *)centers, dimension, numCenters) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_kmeans_set_centers_d
+      (self, (double const *)centers, dimension, numCenters) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief init centers by randomly sampling data
+ ** @param self KMeans object.
+ ** @param data data to sample from.
+ ** @param dimension data dimension.
+ ** @param numData nmber of data points.
+ ** @param numCenters number of centers.
+ **
+ ** The function inits the KMeans centers by randomly sampling
+ ** the data @a data.
+ **/
+
+VL_EXPORT void
+vl_kmeans_init_centers_with_rand_data
+(VlKMeans * self,
+ void const * data,
+ vl_size dimension,
+ vl_size numData,
+ vl_size numCenters)
+{
+  vl_kmeans_reset (self) ;
+
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_kmeans_init_centers_with_rand_data_f
+      (self, (float const *)data, dimension, numData, numCenters) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_kmeans_init_centers_with_rand_data_d
+      (self, (double const *)data, dimension, numData, numCenters) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Seed centers by the KMeans++ algorithm
+ ** @param self KMeans object.
+ ** @param data data to sample from.
+ ** @param dimension data dimension.
+ ** @param numData nmber of data points.
+ ** @param numCenters number of centers.
+ **/
+
+VL_EXPORT void
+vl_kmeans_init_centers_plus_plus
+(VlKMeans * self,
+ void const * data,
+ vl_size dimension,
+ vl_size numData,
+ vl_size numCenters)
+{
+  vl_kmeans_reset (self) ;
+
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_kmeans_init_centers_plus_plus_f
+      (self, (float const *)data, dimension, numData, numCenters) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_kmeans_init_centers_plus_plus_d
+      (self, (double const *)data, dimension, numData, numCenters) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Quantize data
+ ** @param self KMeans object.
+ ** @param assignments data to closest center assignments (output).
+ ** @param distances data to closest center distance (output).
+ ** @param data data to quantize.
+ ** @param numData number of data points to quantize.
+ **/
+
+VL_EXPORT void
+vl_kmeans_quantize
+(VlKMeans * self,
+ vl_uint32 * assignments,
+ void * distances,
+ void const * data,
+ vl_size numData)
+{
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_kmeans_quantize_f
+      (self, assignments, distances, (float const *)data, numData) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_kmeans_quantize_d
+      (self, assignments, distances, (double const *)data, numData) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Quantize data using approximate nearest neighbours (ANN).
+ ** @param self KMeans object.
+ ** @param assignments data to centers assignments (output).
+ ** @param distances data to closes center distance (output)
+ ** @param data data to quantize.
+ ** @param numData number of data points.
+ ** @param update choose wether to update current assignments.
+ **
+ ** The function uses an ANN procedure to compute the approximate
+ ** nearest neighbours of the input data point.
+ **
+ ** Setting @a update to ::VL_TRUE will cause the algorithm
+ ** to *update existing assignments*. This means that each
+ ** element of @a assignments and @a distances is updated ony if the
+ ** ANN procedure can find a better assignment of the existing one.
+ **/
+
+VL_EXPORT void
+vl_kmeans_quantize_ann
+(VlKMeans * self,
+ vl_uint32 * assignments,
+ void * distances,
+ void const * data,
+ vl_size numData,
+ vl_bool update)
+{
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      _vl_kmeans_quantize_ann_f
+      (self, assignments, distances, (float const *)data, numData, update) ;
+      break ;
+    case VL_TYPE_DOUBLE :
+      _vl_kmeans_quantize_ann_d
+      (self, assignments, distances, (double const *)data, numData, update) ;
+      break ;
+    default:
+      abort() ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Refine center locations.
+ ** @param self KMeans object.
+ ** @param data data to quantize.
+ ** @param numData number of data points.
+ ** @return K-means energy at the end of optimization.
+ **
+ ** The function calls the underlying K-means quantization algorithm
+ ** (@ref VlKMeansAlgorithm) to quantize the specified data @a data.
+ ** The function assumes that the cluster centers have already
+ ** been assigned by using one of the seeding functions, or by
+ ** setting them.
+ **/
+
+VL_EXPORT double
+vl_kmeans_refine_centers
+(VlKMeans * self,
+ void const * data,
+ vl_size numData)
+{
+  assert (self->centers) ;
+
+  switch (self->dataType) {
+    case VL_TYPE_FLOAT :
+      return
+        _vl_kmeans_refine_centers_f
+        (self, (float const *)data, numData) ;
+    case VL_TYPE_DOUBLE :
+      return
+        _vl_kmeans_refine_centers_d
+        (self, (double const *)data, numData) ;
+    default:
+      abort() ;
+  }
+}
+
+
+/** ------------------------------------------------------------------
+ ** @brief Cluster data.
+ ** @param self KMeans object.
+ ** @param data data to quantize.
+ ** @param dimension data dimension.
+ ** @param numData number of data points.
+ ** @param numCenters number of clusters.
+ ** @return K-means energy at the end of optimization.
+ **
+ ** The function initializes the centers by using the initialization
+ ** algorithm set by ::vl_kmeans_set_initialization and refines them
+ ** by the quantization algorithm set by ::vl_kmeans_set_algorithm.
+ ** The process is repeated one or more times (see
+ ** ::vl_kmeans_set_num_repetitions) and the resutl with smaller
+ ** energy is retained.
+ **/
+
+VL_EXPORT double
+vl_kmeans_cluster (VlKMeans * self,
+                   void const * data,
+                   vl_size dimension,
+                   vl_size numData,
+                   vl_size numCenters)
+{
+  vl_uindex repetition ;
+  double bestEnergy = VL_INFINITY_D ;
+  void * bestCenters = NULL ;
+
+  for (repetition = 0 ; repetition < self->numRepetitions ; ++ repetition) {
+    double energy ;
+    double timeRef ;
+
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: repetition %d of %d\n", repetition + 1, self->numRepetitions) ;
+    }
+
+    timeRef = vl_get_cpu_time() ;
+    switch (self->initialization) {
+      case VlKMeansRandomSelection :
+        vl_kmeans_init_centers_with_rand_data (self,
+                                               data, dimension, numData,
+                                               numCenters) ;
+        break ;
+      case VlKMeansPlusPlus :
+        vl_kmeans_init_centers_plus_plus (self,
+                                          data, dimension, numData,
+                                          numCenters) ;
+        break ;
+      default:
+        abort() ;
+    }
+
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: K-means initialized in %.2f s\n",
+                vl_get_cpu_time() - timeRef) ;
+    }
+
+    timeRef = vl_get_cpu_time () ;
+    energy = vl_kmeans_refine_centers (self, data, numData) ;
+    if (self->verbosity) {
+      VL_PRINTF("kmeans: K-means terminated in %.2f s with energy %g\n",
+                vl_get_cpu_time() - timeRef, energy) ;
+    }
+
+    /* copy centers to output if current solution is optimal */
+    /* check repetition == 0 as well in case energy = NaN, which */
+    /* can happen if the data contain NaNs */
+    if (energy < bestEnergy || repetition == 0) {
+      void * temp ;
+      bestEnergy = energy ;
+
+      if (bestCenters == NULL) {
+        bestCenters = vl_malloc(vl_get_type_size(self->dataType) *
+                                self->dimension *
+                                self->numCenters) ;
+      }
+
+      /* swap buffers */
+      temp = bestCenters ;
+      bestCenters = self->centers ;
+      self->centers = temp ;
+    } /* better energy */
+  } /* next repetition */
+
+  vl_free (self->centers) ;
+  self->centers = bestCenters ;
+  return bestEnergy ;
+}
+
+/* VL_KMEANS_INSTANTIATING */
+#endif
+
+#undef SFX
+#undef TYPE
+#undef FLT
+#undef VL_KMEANS_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/kmeans.h b/opensfm/src/third_party/vlfeat/vl/kmeans.h
new file mode 100644
index 000000000..a3cd17631
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/kmeans.h
@@ -0,0 +1,435 @@
+/** @file kmeans.h
+ ** @brief K-means (@ref kmeans)
+ ** @author Andrea Vedaldi
+ ** @author David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi and David Novotny.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_KMEANS_H
+#define VL_KMEANS_H
+
+#include "generic.h"
+#include "random.h"
+#include "mathop.h"
+#include "kdtree.h"
+
+/* ---------------------------------------------------------------- */
+
+/** @brief K-means algorithms */
+
+typedef enum _VlKMeansAlgorithm {
+  VlKMeansLloyd,       /**< Lloyd algorithm */
+  VlKMeansElkan,       /**< Elkan algorithm */
+  VlKMeansANN          /**< Approximate nearest neighbors */
+} VlKMeansAlgorithm ;
+
+/** @brief K-means initialization algorithms */
+
+typedef enum _VlKMeansInitialization {
+  VlKMeansRandomSelection,  /**< Randomized selection */
+  VlKMeansPlusPlus          /**< Plus plus raondomized selection */
+} VlKMeansInitialization ;
+
+/** ------------------------------------------------------------------
+ ** @brief K-means quantizer
+ **/
+
+typedef struct _VlKMeans
+{
+
+  vl_type dataType ;                      /**< Data type. */
+  vl_size dimension ;                     /**< Data dimensionality. */
+  vl_size numCenters ;                    /**< Number of centers. */
+  vl_size numTrees ;                      /**< Number of trees in forest when using ANN-kmeans. */
+  vl_size maxNumComparisons ;             /**< Maximum number of comparisons when using ANN-kmeans. */
+
+  VlKMeansInitialization initialization ; /**< Initalization algorithm. */
+  VlKMeansAlgorithm algorithm ;           /**< Clustring algorithm. */
+  VlVectorComparisonType distance ;       /**< Distance. */
+  vl_size maxNumIterations ;              /**< Maximum number of refinement iterations. */
+  double minEnergyVariation ;             /**< Minimum energy variation. */
+  vl_size numRepetitions ;                /**< Number of clustering repetitions. */
+  int verbosity ;                         /**< Verbosity level. */
+
+  void * centers ;                        /**< Centers */
+  void * centerDistances ;                /**< Centers inter-distances. */
+
+  double energy ;                         /**< Current solution energy. */
+  VlFloatVectorComparisonFunction floatVectorComparisonFn ;
+  VlDoubleVectorComparisonFunction doubleVectorComparisonFn ;
+} VlKMeans ;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT VlKMeans * vl_kmeans_new (vl_type dataType, VlVectorComparisonType distance) ;
+VL_EXPORT VlKMeans * vl_kmeans_new_copy (VlKMeans const * kmeans) ;
+VL_EXPORT void vl_kmeans_delete (VlKMeans * self) ;
+/** @} */
+
+/** @name Basic data processing
+ ** @{
+ **/
+VL_EXPORT void vl_kmeans_reset (VlKMeans * self) ;
+
+VL_EXPORT double vl_kmeans_cluster (VlKMeans * self,
+                                    void const * data,
+                                    vl_size dimension,
+                                    vl_size numData,
+                                    vl_size numCenters) ;
+
+VL_EXPORT void vl_kmeans_quantize (VlKMeans * self,
+                                   vl_uint32 * assignments,
+                                   void * distances,
+                                   void const * data,
+                                   vl_size numData) ;
+
+VL_EXPORT void vl_kmeans_quantize_ANN (VlKMeans * self,
+                                   vl_uint32 * assignments,
+                                   void * distances,
+                                   void const * data,
+                                   vl_size numData,
+                                   vl_size iteration );
+/** @} */
+
+/** @name Advanced data processing
+ ** @{
+ **/
+VL_EXPORT void vl_kmeans_set_centers (VlKMeans * self,
+                                      void const * centers,
+                                      vl_size dimension,
+                                      vl_size numCenters) ;
+
+VL_EXPORT void vl_kmeans_init_centers_with_rand_data
+                  (VlKMeans * self,
+                   void const * data,
+                   vl_size dimensions,
+                   vl_size numData,
+                   vl_size numCenters) ;
+
+VL_EXPORT void vl_kmeans_init_centers_plus_plus
+                  (VlKMeans * self,
+                   void const * data,
+                   vl_size dimensions,
+                   vl_size numData,
+                   vl_size numCenters) ;
+
+VL_EXPORT double vl_kmeans_refine_centers (VlKMeans * self,
+                                           void const * data,
+                                           vl_size numData) ;
+
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{
+ **/
+VL_INLINE vl_type vl_kmeans_get_data_type (VlKMeans const * self) ;
+VL_INLINE VlVectorComparisonType vl_kmeans_get_distance (VlKMeans const * self) ;
+
+VL_INLINE VlKMeansAlgorithm vl_kmeans_get_algorithm (VlKMeans const * self) ;
+VL_INLINE VlKMeansInitialization vl_kmeans_get_initialization (VlKMeans const * self) ;
+VL_INLINE vl_size vl_kmeans_get_num_repetitions (VlKMeans const * self) ;
+
+VL_INLINE vl_size vl_kmeans_get_dimension (VlKMeans const * self) ;
+VL_INLINE vl_size vl_kmeans_get_num_centers (VlKMeans const * self) ;
+
+VL_INLINE int vl_kmeans_get_verbosity (VlKMeans const * self) ;
+VL_INLINE vl_size vl_kmeans_get_max_num_iterations (VlKMeans const * self) ;
+VL_INLINE double vl_kmeans_get_min_energy_variation (VlKMeans const * self) ;
+VL_INLINE vl_size vl_kmeans_get_max_num_comparisons (VlKMeans const * self) ;
+VL_INLINE vl_size vl_kmeans_get_num_trees (VlKMeans const * self) ;
+VL_INLINE double vl_kmeans_get_energy (VlKMeans const * self) ;
+VL_INLINE void const * vl_kmeans_get_centers (VlKMeans const * self) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_INLINE void vl_kmeans_set_algorithm (VlKMeans * self, VlKMeansAlgorithm algorithm) ;
+VL_INLINE void vl_kmeans_set_initialization (VlKMeans * self, VlKMeansInitialization initialization) ;
+VL_INLINE void vl_kmeans_set_num_repetitions (VlKMeans * self, vl_size numRepetitions) ;
+VL_INLINE void vl_kmeans_set_max_num_iterations (VlKMeans * self, vl_size maxNumIterations) ;
+VL_INLINE void vl_kmeans_set_min_energy_variation (VlKMeans * self, double minEnergyVariation) ;
+VL_INLINE void vl_kmeans_set_verbosity (VlKMeans * self, int verbosity) ;
+VL_INLINE void vl_kmeans_set_max_num_comparisons (VlKMeans * self, vl_size maxNumComparisons) ;
+VL_INLINE void vl_kmeans_set_num_trees (VlKMeans * self, vl_size numTrees) ;
+/** @} */
+
+/** ------------------------------------------------------------------
+ ** @brief Get data type
+ ** @param self KMeans object instance.
+ ** @return data type.
+ **/
+
+VL_INLINE vl_type
+vl_kmeans_get_data_type (VlKMeans const * self)
+{
+  return self->dataType ;
+}
+
+/** @brief Get data dimension
+ ** @param self KMeans object instance.
+ ** @return data dimension.
+ **/
+
+VL_INLINE vl_size
+vl_kmeans_get_dimension (VlKMeans const * self)
+{
+  return self->dimension ;
+}
+
+/** @brief Get data type
+ ** @param self KMeans object instance.
+ ** @return data type.
+ **/
+
+VL_INLINE VlVectorComparisonType
+vl_kmeans_get_distance (VlKMeans const * self)
+{
+  return self->distance ;
+}
+
+/** @brief Get the number of centers (K)
+ ** @param self KMeans object instance.
+ ** @return number of centers.
+ **/
+
+VL_INLINE vl_size
+vl_kmeans_get_num_centers (VlKMeans const * self)
+{
+  return self->numCenters ;
+}
+
+/** @brief Get the number energy of the current fit
+ ** @param self KMeans object instance.
+ ** @return energy.
+ **/
+
+VL_INLINE double
+vl_kmeans_get_energy (VlKMeans const * self)
+{
+  return self->energy ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get verbosity level
+ ** @param self KMeans object instance.
+ ** @return verbosity level.
+ **/
+
+VL_INLINE int
+vl_kmeans_get_verbosity (VlKMeans const * self)
+{
+  return self->verbosity ;
+}
+
+/** @brief Set verbosity level
+ ** @param self KMeans object instance.
+ ** @param verbosity verbosity level.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_verbosity (VlKMeans * self, int verbosity)
+{
+  self->verbosity = verbosity ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get centers
+ ** @param self KMeans object instance.
+ ** @return cluster centers.
+ **/
+
+VL_INLINE void const *
+vl_kmeans_get_centers (VlKMeans const * self)
+{
+  return self->centers ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get maximum number of iterations
+ ** @param self KMeans object instance.
+ ** @return maximum number of iterations.
+ **/
+
+VL_INLINE vl_size
+vl_kmeans_get_max_num_iterations (VlKMeans const * self)
+{
+  return self->maxNumIterations ;
+}
+
+/** @brief Set maximum number of iterations
+ ** @param self KMeans filter.
+ ** @param maxNumIterations maximum number of iterations.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_max_num_iterations (VlKMeans * self, vl_size maxNumIterations)
+{
+  self->maxNumIterations = maxNumIterations ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get maximum number of repetitions.
+ ** @param self KMeans object instance.
+ ** @return current number of repretitions for quantization.
+ **/
+
+VL_INLINE vl_size
+vl_kmeans_get_num_repetitions (VlKMeans const * self)
+{
+  return self->numRepetitions ;
+}
+
+/** @brief Set maximum number of repetitions
+ ** @param self KMeans object instance.
+ ** @param numRepetitions maximum number of repetitions.
+ ** The number of repetitions cannot be smaller than 1.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_num_repetitions (VlKMeans * self,
+                               vl_size numRepetitions)
+{
+  assert (numRepetitions >= 1) ;
+  self->numRepetitions = numRepetitions ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the minimum relative energy variation for convergence.
+ ** @param self KMeans object instance.
+ ** @return minimum energy variation.
+ **/
+
+VL_INLINE double
+vl_kmeans_get_min_energy_variation (VlKMeans const * self)
+{
+  return self->minEnergyVariation ;
+}
+
+/** @brief Set the maximum relative energy variation for convergence.
+ ** @param self KMeans object instance.
+ ** @param minEnergyVariation maximum number of repetitions.
+ ** The variation cannot be negative.
+ **
+ ** The relative energy variation is calculated after the $t$-th update
+ ** to the parameters as:
+ **
+ ** \[ \epsilon_t =  \frac{E_{t-1} - E_t}{E_0 - E_t} \]
+ **
+ ** Note that this quantitiy is non-negative since $E_{t+1} \leq E_t$.
+ ** Hence, $\epsilon_t$ is the improvement to the energy made in the last
+ ** iteration compared to the total improvement so far. The algorithm
+ ** stops if this value is less or equal than @a minEnergyVariation.
+ **
+ ** This test is applied only to the LLoyd and ANN algorithms.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_min_energy_variation (VlKMeans * self,
+                                    double minEnergyVariation)
+{
+  assert (minEnergyVariation >= 0) ;
+  self->minEnergyVariation = minEnergyVariation ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get K-means algorithm
+ ** @param self KMeans object.
+ ** @return algorithm.
+ **/
+
+VL_INLINE VlKMeansAlgorithm
+vl_kmeans_get_algorithm (VlKMeans const * self)
+{
+  return self->algorithm ;
+}
+
+/** @brief Set K-means algorithm
+ ** @param self KMeans object.
+ ** @param algorithm K-means algorithm.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_algorithm (VlKMeans * self, VlKMeansAlgorithm algorithm)
+{
+  self->algorithm = algorithm ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get K-means initialization algorithm
+ ** @param self KMeans object.
+ ** @return algorithm.
+ **/
+
+VL_INLINE VlKMeansInitialization
+vl_kmeans_get_initialization (VlKMeans const * self)
+{
+  return self->initialization ;
+}
+
+/** @brief Set K-means initialization algorithm
+ ** @param self KMeans object.
+ ** @param initialization initialization.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_initialization (VlKMeans * self,
+                              VlKMeansInitialization initialization)
+{
+  self->initialization = initialization ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the maximum number of comparisons in the KD-forest ANN algorithm.
+ ** @param self KMeans object instance.
+ ** @return maximum number of comparisons.
+ **/
+
+VL_INLINE vl_size
+vl_kmeans_get_max_num_comparisons (VlKMeans const * self)
+{
+  return self->maxNumComparisons ;
+}
+
+/** @brief Set maximum number of comparisons in ANN-KD-Tree.
+ ** @param self KMeans filter.
+ ** @param maxNumComparisons maximum number of comparisons.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_max_num_comparisons (VlKMeans * self,
+                              vl_size maxNumComparisons)
+{
+    self->maxNumComparisons = maxNumComparisons;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set the number of trees in the KD-forest ANN algorithm
+ ** @param self KMeans object instance.
+ ** @param numTrees number of trees to use.
+ **/
+
+VL_INLINE void
+vl_kmeans_set_num_trees (VlKMeans * self, vl_size numTrees)
+{
+    self->numTrees = numTrees;
+}
+
+VL_INLINE vl_size
+vl_kmeans_get_num_trees (VlKMeans const * self)
+{
+    return self->numTrees;
+}
+
+
+/* VL_IKMEANS_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/lbp.c b/opensfm/src/third_party/vlfeat/vl/lbp.c
new file mode 100644
index 000000000..6cea7ccd9
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/lbp.c
@@ -0,0 +1,347 @@
+/** @file lbp.c
+ ** @brief Local Binary Patterns (LBP) - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 Andrea Vedaldi.
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page lbp Local Binary Patterns (LBP) descriptor
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref lbp.h implements the Local Binary Pattern (LBP) feature
+descriptor.  The LBP descriptor @cite{ojala10multiresolution} is a
+histogram of quantized LBPs pooled in a local image neighborhood. @ref
+lbp-starting demonstrates how to use the C API to compute the LBP
+descriptors of an image. For further details refer to:
+
+- @subpage lbp-fundamentals - LBP definition and parameters.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section lbp-starting Getting started with LBP
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+To compute the LBP descriptor of an image, start by creating a ::VlLbp
+object instance by specifying the type of LBP quantization. Given the
+configure LBP object, then call ::vl_lbp_process to process a
+grayscale image and obtain the corresponding LBP descriptors. This
+function expects as input a buffer large enough to contain the
+computed features. If the image has size @c width x @c height, there
+are exactly @c floor(width/cellSize) x @c floor(height/cellSize)
+cells, each of which has a histogram of LBPs of size @c dimension (as
+returned by ::vl_lbp_get_dimension). Thus the required buffer has size
+@c floor(width/cellSize) x @c floor(height/cellSize) x @c dimension.
+
+::VlLbp supports computing transposed LPBs as well. A transposed LBP
+is the LBP obtained by transposing the input image (regarded as a
+matrix). This functionality can be useful to compute the features when
+the input image is stored in column major format (e.g. MATLAB) rather
+than row major.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page lbp-fundamentals Local Binary Patterns fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A *Locally Binary Pattern* (LBP) is a local descriptor that captures
+the appearance of an image in a small neighborhood around a pixel.  An
+LBP is a string of bits, with one bit for each of the pixels in the
+neighborhood. Each bit is turned on or off depending on whether the
+intensity of the corresponding pixel is greater than the intensity of
+the central pixel. LBP are seldom used directly, however. Instead, the
+binary string thus produced are further quantized (@ref
+lbp-quantization) and pooled in local histograms (@ref
+lbp-histograms).
+
+While many variants are possible, ::VlLbp implements only the case of
+3 &times; 3 pixel neighborhoods (this setting was found to be optimal
+in several applications). In particular, the LBP centered on pixel
+$(x,y)$ is a string of eight bits. Each bit is equal to one if the
+corresponding pixel is brighter than the central one. Pixels are
+scanned starting from the one to the right in anti-clockwise order.
+For example the first bit is one if, and only if, $I(x+1,y) >
+I(x,y)$, and the second bit is one if, and only if, $I(x+1,y-1) >
+I(x,y)$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section lbp-quantization Quantized LBP
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+For a 3 &times; 3 neighborhood, an LBP is a string of eight bits and
+so there are 256 possible LBPs. These are usually too many for a
+reliable statistics (histogram) to be computed. Therefore the 256
+patterns are further quantized into a smaller number of patterns
+according to one of the following rules:
+
+- <b>Uniform</b> (::VlLbpUniform) There is one quantized pattern for
+  each LBP that has exactly a transitions from 0 to 1 and one from 1
+  to 0 when scanned in anti-clockwise order, plus one quantized
+  pattern comprising the two uniform LBPs, and one quantized pattern
+  comprising all the other LBPs. This yields a total of 58 quantized
+  patterns.
+
+  @image html lbp.png "LBP quantized patterns."
+
+The number of quantized LBPs, which depends on the quantization type,
+can be obtained by ::vl_lbp_get_dimension.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section lbp-histograms Histograms of LBPs
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The quantized LBP patterns are further grouped into local
+histograms. The image is divided into a number of cells of a
+prescribed size (as specified by the parameter @c cellSize passed to
+::vl_lbp_process as described in @ref lbp-starting). Then the
+quantized LBPs are aggregated into histogram by using bilinear
+interpolation along the two spatial dimensions (similar to HOG and
+SIFT).
+**/
+
+#include "lbp.h"
+#include "mathop.h"
+#include "string.h"
+
+/* ---------------------------------------------------------------- */
+/*                                           Initialization helpers */
+/* ---------------------------------------------------------------- */
+
+/*
+ This function creates the LBP quantization table for the uniform LBP
+ patterns. The purpose of this lookup table is to map a 8-bit LBP
+ strings to one of 58 uniform pattern codes.
+
+ Pixels in the 8-neighbourhoods are read in counterclockwise order
+ starting from the east direction, as follows:
+
+ NW(5)  N(6) NE(7)
+ W(4)         E(0)  -> b0 b1 b2 b3 b4 b5 b6 b7
+ SW(3)  S(2) SE(1)
+
+ There are 256 such strings, indexing the lookup table. The table
+ contains the corresponding code, effectively quantizing the 256
+ patterns into 58. There is one bin for constant patterns (all zeros
+ or ones), 8*7 for the uniform ones, and one for all other.
+
+ A uniform pattern is a circular sequence of bit b0b1...b7 such that
+ there is exactly one switch from 0 to 1 and one from 1 to 0.  These
+ uniform patterns are enumerated as follows. The slowest varying index
+ i (0...7) points to the first bit that is on and the slowest varying
+ index j (1...7) to the length of the run of bits equal to one,
+ resulting in the sequence:
+
+ 0:  1000 0000
+ 1:  1100 0000
+ ...
+ 7:  1111 1110
+ 8:  0100 0000
+ 9:  0110 0000
+ ...
+ 56: 1111 1101
+
+ The function also accounts for when the image is stored in transposed
+ format. The sampling function is unchanged, so that the first bit to
+ be read is not the one to the east, but the one to the south, and
+ overall the following sequence is read:
+
+ NW(5)  W(4) SW(3)
+ N(6)         S(2)  -> b2 b1 b0 b7 b6 b5 b4 b3
+ NE(7)  E(0) SE(1)
+
+ In enumerating the uniform patterns, the index j is unchanged as it
+ encodes the runlenght. On the contrary, the index i changes to
+ account for the transposition and for the fact that the beginning and
+ ending of the run are swapped. With modular arithmetic, the i must be
+ transformed as
+
+ ip = - i + 2 - (j - 1)
+ */
+
+static void
+_vl_lbp_init_uniform(VlLbp * self)
+{
+  int i, j ;
+
+  /* overall number of quantized LBPs */
+  self->dimension = 58 ;
+
+  /* all but selected patterns map to bin 57 (the first bin has index 0) */
+  for (i = 0 ; i < 256 ; ++i) {
+    self->mapping[i] = 57 ;
+  }
+
+  /* the uniform (all zeros or ones) patterns map to bin 56 */
+  self->mapping[0x00] = 56 ;
+  self->mapping[0xff] = 56 ;
+
+  /* 56 uniform patterns */
+  for (i = 0 ; i < 8 ; ++i) {
+    for (j = 1 ; j <= 7 ; ++j) {
+      int ip ;
+      int unsigned string ;
+      if (self->transposed) {
+        ip = (- i + 2 - (j - 1) + 16) % 8 ;
+      } else {
+        ip = i ;
+      }
+
+      /* string starting with j ones */
+      string = (1 << j) - 1 ;
+      string <<= ip ;
+      string = (string | (string >> 8)) & 0xff ;
+
+      self->mapping[string] = i * 7 + (j-1) ;
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Create a new LBP object
+ ** @param type type of LBP features.
+ ** @param transposed if @c true, then transpose each LBP pattern.
+ ** @return new VlLbp object instance.
+ **/
+
+VlLbp *
+vl_lbp_new(VlLbpMappingType type, vl_bool transposed)
+{
+  VlLbp * self = vl_malloc(sizeof(VlLbp)) ;
+  if (self == NULL) {
+    vl_set_last_error(VL_ERR_ALLOC, NULL) ;
+    return NULL ;
+  }
+  self->transposed = transposed ;
+  switch (type) {
+    case VlLbpUniform: _vl_lbp_init_uniform(self) ; break ;
+    default: exit(1) ;
+  }
+  return self ;
+}
+
+/** @brief Delete VlLbp object
+ ** @param self object to delete.
+ **/
+
+void
+vl_lbp_delete(VlLbp * self) {
+  vl_free(self) ;
+}
+
+/** @brief Get the dimension of the LBP histograms
+ ** @return dimension of the LBP histograms.
+ ** The dimension depends on the type of quantization used.
+ ** @see ::vl_lbp_new().
+ **/
+
+VL_EXPORT vl_size vl_lbp_get_dimension(VlLbp * self)
+{
+  return self->dimension ;
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Extract LBP features
+ ** @param self LBP object.
+ ** @param features buffer to write the features to.
+ ** @param image image.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param cellSize size of the LBP cells.
+ **
+ ** @a features is a  @c numColumns x @c numRows x @c dimension where
+ ** @c dimension is the dimension of a LBP feature obtained from ::vl_lbp_get_dimension,
+ ** @c numColumns is equal to @c floor(width / cellSize), and similarly
+ ** for @c numRows.
+ **/
+
+VL_EXPORT void
+vl_lbp_process (VlLbp * self,
+                float * features,
+                float * image, vl_size width, vl_size height,
+                vl_size cellSize)
+{
+  vl_size cwidth = width / cellSize;
+  vl_size cheight = height / cellSize ;
+  vl_size cstride = cwidth * cheight ;
+  vl_size cdimension = vl_lbp_get_dimension(self) ;
+  vl_index x,y,cx,cy,k,bin ;
+
+#define at(u,v) (*(image + width * (v) + (u)))
+#define to(u,v,w) (*(features + cstride * (w) + cwidth * (v) + (u)))
+
+  /* clear the output buffer */
+  memset(features, 0, sizeof(float)*cdimension*cstride) ;
+
+  /* accumulate pixel-level measurements into cells */
+  for (y = 1 ; y < (signed)height - 1 ; ++y) {
+    float wy1 = (y + 0.5f) / (float)cellSize - 0.5f ;
+    int cy1 = (int) vl_floor_f(wy1) ;
+    int cy2 = cy1 + 1 ;
+    float wy2 = wy1 - (float)cy1 ;
+    wy1 = 1.0f - wy2 ;
+    if (cy1 >= (signed)cheight) continue ;
+
+    for (x = 1 ; x < (signed)width - 1; ++x) {
+      float wx1 = (x + 0.5f) / (float)cellSize - 0.5f ;
+      int cx1 = (int) vl_floor_f(wx1) ;
+      int cx2 = cx1 + 1 ;
+      float wx2 = wx1 - (float)cx1 ;
+      wx1 = 1.0f - wx2 ;
+      if (cx1 >= (signed)cwidth) continue ;
+
+      {
+        int unsigned bitString = 0 ;
+        float center = at(x,y) ;
+        if(at(x+1,y+0) > center) bitString |= 0x1 << 0; /*  E */
+        if(at(x+1,y+1) > center) bitString |= 0x1 << 1; /* SE */
+        if(at(x+0,y+1) > center) bitString |= 0x1 << 2; /* S  */
+        if(at(x-1,y+1) > center) bitString |= 0x1 << 3; /* SW */
+        if(at(x-1,y+0) > center) bitString |= 0x1 << 4; /*  W */
+        if(at(x-1,y-1) > center) bitString |= 0x1 << 5; /* NW */
+        if(at(x+0,y-1) > center) bitString |= 0x1 << 6; /* N  */
+        if(at(x+1,y-1) > center) bitString |= 0x1 << 7; /* NE */
+        bin = self->mapping[bitString] ;
+      }
+
+      if ((cx1 >= 0) & (cy1 >=0)) {
+        to(cx1,cy1,bin) += wx1 * wy1;
+      }
+      if ((cx2 < (signed)cwidth)  & (cy1 >=0)) {
+        to(cx2,cy1,bin) += wx2 * wy1 ;
+      }
+      if ((cx1 >= 0) & (cy2 < (signed)cheight)) {
+        to(cx1,cy2,bin) += wx1 * wy2 ;
+      }
+      if ((cx2 < (signed)cwidth) & (cy2 < (signed)cheight)) {
+        to(cx2,cy2,bin) += wx2 * wy2 ;
+      }
+    } /* x */
+  } /* y */
+
+  /* normalize cells */
+  for (cy = 0 ; cy < (signed)cheight ; ++cy) {
+    for (cx = 0 ; cx < (signed)cwidth ; ++ cx) {
+      float norm = 0 ;
+      for (k = 0 ; k < (signed)cdimension ; ++k) {
+        norm += features[k * cstride] ;
+      }
+      norm = sqrtf(norm) + 1e-10f; ;
+      for (k = 0 ; k < (signed)cdimension ; ++k) {
+        features[k * cstride] = sqrtf(features[k * cstride]) / norm  ;
+      }
+      features += 1 ;
+    }
+  } /* next cell to normalize */
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/lbp.h b/opensfm/src/third_party/vlfeat/vl/lbp.h
new file mode 100644
index 000000000..d33715b5e
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/lbp.h
@@ -0,0 +1,44 @@
+/** @file lbp.h
+ ** @brief Local Binary Patterns (LBP) descriptor (@ref lbp)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_LBP_H
+#define VL_LBP_H
+
+#include "generic.h"
+
+/** @brief Type of quantization for the LBP descriptors
+ ** @see @ref lbp-quantization
+ **/
+typedef enum _VlLbpMappingType
+{
+  VlLbpUniform     /**< Uniform local binary patterns. */
+} VlLbpMappingType ;
+
+/** @brief Local Binary Pattern extractor */
+typedef struct VlLbp_
+{
+  vl_size dimension ;
+  vl_uint8 mapping [256] ;
+  vl_bool transposed ;
+} VlLbp ;
+
+VL_EXPORT VlLbp * vl_lbp_new(VlLbpMappingType type, vl_bool transposed) ;
+VL_EXPORT void vl_lbp_delete(VlLbp * self) ;
+VL_EXPORT void vl_lbp_process(VlLbp * self,
+                              float * features,
+                              float * image, vl_size width, vl_size height,
+                              vl_size cellSize) ;
+VL_EXPORT vl_size vl_lbp_get_dimension(VlLbp * self) ;
+
+/* VL_LBP_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/liop.c b/opensfm/src/third_party/vlfeat/vl/liop.c
new file mode 100644
index 000000000..ae788ec9d
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/liop.c
@@ -0,0 +1,641 @@
+/** @file liop.c
+ ** @brief Local Intensity Order Pattern (LIOP) descriptor - Definition
+ ** @author Hana Sarbortova
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 Hana Sarbortova and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page liop Local Intensity Order Pattern (LIOP) descriptor
+@author Hana Sarbortova
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref liop.h implements *Local Intensity Order Pattern descriptor*
+(LIOP) of @cite{wang11local}. LIOP is a local image descriptor,
+similarly to the @ref sift "SIFT descriptor".
+
+@ref liop-starting demonstrates how to use the C API to compute the
+LIOP descriptor of a patch. For further details refer to:
+
+- @subpage liop-fundamentals - LIOP definition and parameters.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section liop-starting Getting started with LIOP
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The following code fragment demonstrates how tow to use @ref liop.h in
+a C program in order to compute the LIOP descriptor of an image patch.
+
+@code
+#include <vl/liop.h>
+
+// Create a new object instance (these numbers corresponds to parameter
+// values proposed by authors of the paper, except for 41)
+vl_size sideLength = 41 ;
+VlLiopDesc * liop = vl_liopdesc_new_basic (sideLength);
+
+// allocate the descriptor array
+vl_size dimension = vl_liopdesc_get_dimension(liop) ;
+float * desc = vl_malloc(sizeof(float) * dimension) ;
+
+// compute descriptor from a patch (an array of length sideLegnth *
+// sideLength)
+vl_liopdesc_process(liop, desc, patch) ;
+
+// delete the object
+vl_liopdesc_delete(liop) ;
+@endcode
+
+The image patch must be of odd side length and in single
+precision. There are several parameters affecting the LIOP
+descriptor. An example is the @ref liop-weighing "threshold" used to
+discard low-contrast oder pattern in the computation of the
+statistics. This is changed by using ::vl_liopdesc_set_intensity_threshold.
+**/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page liop-fundamentals LIOP fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The *Local Invariant Order Pattern* (LIOP) descriptor
+@cite{wang11local} is a local image descriptor based on the concept of
+*local order pattern*. An order pattern is simply the order obtained
+by sorting selected image samples by increasing intensity. Consider in
+particular a pixel $\bx$ and $n$ neighbors
+$\bx_1,\bx_2,\dots,\bx_n$. The local order pattern at $\bx$ is the
+permutation $\sigma$ that sorts the neighbours by increasing intensity
+$I(\bx_{\sigma(1)}) \leq I(\bx_{\sigma(2)}) \leq \dots \leq
+I(\bx_{\sigma(2)})$.
+
+An advantage of order patterns is that they are invariant to monotonic
+changes of the image intensity. However, an order pattern describes
+only a small portion of a patch and is not very distinctive. LIOP
+assembles local order patterns computed at all image locations to
+obtain a descriptor that at the same time distinctive and invariant to
+monotonic intensity changes as well as image rotations.
+
+In order to make order patterns rotation invariant, the neighborhood
+of samples around $\bx$ is taken in a rotation-covariant manner. In
+particular, the points $\bx_1,\dots,\bx_n$ are sampled anticlockwise
+on a circle of radius $r$ around $\bx$, as shown in the following
+figure:
+
+@image html liop.png "LIOP descriptor layout: square input patch (shaded area), circular measurement region (white area), local neighborhood of a point (blue)."
+
+Since the sample points do not necessarily have integer coordinates,
+$I(\bx_i)$ is computed using bilinear interpolation.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section liop-spatial-binning Intensity rank spatial binning
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Once local order patterns are computed for all pixels $\bx$ in the
+image, they can be pooled into a histogram to form an image
+descriptor. Pooling discards spatial information resulting in a
+warp-invariant statistics. In practice, there are two restriction on
+which pixels can be used for this purpose:
+
+- A margin of $r$ pixels from the image boundary must be maintained so
+  that neighborhoods fall within the image boundaries.
+- Rotation invariance requires the pooling regions to be rotation
+  co-variant.  A way to do so is to make the shape of the pooling
+  region rotation invariant.
+
+For this reason, the histogram pooling region is restricted to the
+circular region shown with a light color in the figure above.
+
+In order to increase distinctiveness of the descriptor, LIOP pools
+multiple histograms from a number of regions $R_1,\dots,R_m$ (spatial
+pooling). These regions are selected in an illumination-invariant and
+rotation-covariant manner by looking at level sets:
+\[
+R_t = \{\bx :\tau_{t} \leq I(\bx) < \tau_{t+1} \}.
+\]
+In order to be invariant to monotonic changes of the intensity, the
+thresholds $\tau_t$ are selected so that all regions contain the same
+number of pixels. This can be done efficiently by sorting pixels by
+increasing intensity and then partitioning the resulting list into $m$
+equal parts (when $m$ does not divide the number of pixels exactly,
+the remaining pixels are incorporated into the last partition).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section liop-weighing Weighted pooling
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In order to compute a histogram of order pattern occurrences, one
+needs to map permutations to histogram bins. This is obtained by
+sorting permutation in lexycogrpahical order. For example, for $n=4$
+neighbors one has the following $n!=24$ permutations:
+
+Permutation   | Lexycographical rank
+--------------|----------------------
+1 2 3 4       | 1
+1 2 4 3       | 2
+1 3 2 4       | 3
+1 3 4 2       | 4
+...           | ...
+4 3 1 2       | 23
+4 3 2 1       | 24
+
+In the following, $q(\bx) \in [1, n!]$ will denote the index of the
+local order pattern $\sigma$ centered at pixel $\bx$.
+
+The local order patterns $q(\bx)$ in a region $R_t$ are then pooled to
+form a histogram of size $!n$. In this process, patterns are weighted
+based on their stability. The latter is assumed to be proportional to
+the number of pairs of pixels in the neighborhood that have a
+sufficiently large intensity difference:
+
+@f[
+w(\bx) = \sum_{i=1}^n \sum_{j=1}^n [ |I(\bx_{i}) - I(\bx_{j})| >  \Theta) ]
+@f]
+
+where $[\cdot]$ is the indicator function.
+
+In VLFeat LIOP implementation, the threshold $\Theta$ is either set as
+an absolute value, or as a faction of the difference between the
+maximum and minimum intensity in the image (restricted to the pixels
+in the light area in the figure above).
+
+Overall, LIOP consists of $m$ histograms of size $n!$ obtained as
+
+\[
+  h_{qt} = \sum_{\bx : q(\bx) = q \ \wedge\  \bx \in R_t} w(\bx).
+\]
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section liop-normalization Normalization
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+After computing the weighted counts $h_{qt}$, the LIOP descriptor is
+obtained by stacking the values $\{h_{qt}\}$ into a vector
+$\mathbf{h}$ and then normalising it:
+
+\[
+  \Phi = \frac{\mathbf{h}}{\|\mathbf{h}\|_2}
+\]
+
+The dimensionality is therefore $m n!$, where $m$ is the @c
+numSpatialBins number of spatial bins and $n$ is the @c numNeighbours
+number of neighbours (see ::vl_liopdesc_new). By default, this
+descriptor is stored in @c single format. It can be stored as a
+sequence of bytes by premultiplying the values by the constant 255 and
+then rounding:
+
+\[
+ \operatorname{round}\left[ 255\, \times \Phi\right].
+\]
+
+*/
+
+#include "liop.h"
+#include "mathop.h"
+#include "imopv.h"
+#include <string.h>
+
+#define DEFAULT_INTENSITY_THRESHOLD -(5.0/255)
+#define DEFAULT_RADIUS 6.0
+#define DEFAULT_NUM_SPATIAL_BINS 6
+#define DEFAULT_NUM_NEIGHBOURS 4
+
+/* ---------------------------------------------------------------- */
+/*                                                 Helper functions */
+/* ---------------------------------------------------------------- */
+
+static
+vl_int factorial(vl_int num)
+{
+  vl_int result = 1;
+  while(num > 1){
+    result = num*result;
+    num--;
+  }
+  return result ;
+}
+
+/** @internal @brief Compute permutation index.
+ ** @param permutation array containing all values from 0 to (size - 1) (input/output).
+ ** @param size size of the permutation array.
+ ** @return permutation index.
+ **
+ ** Compute the position of @a permutation in the lexycographcial
+ ** sorting of permutations of the given @a size.
+ **
+ ** For example, in the lexicographical ordering, permutations of four elements
+ ** are listed as [1 2 3 4], [1 2 4 3], [1 3 2 4], [1 3 4 2], [1 4 2 3],
+ ** [1 4 3 2], [2 1 3 4], ..., [4 3 2 1].
+ **
+ ** The index can be computed as follows. First pick the first digit
+ ** perm[1]. This is either 1,2,...,n. For each
+ ** choice of the first digits, there are (n-1)! other permutations, separated
+ ** therefore by (n-1)! elements in lexicographical order.
+ **
+ ** Process then the second digit perm[2]. This can be though as finding
+ ** the lexycotraphical index of perm[2], ..., perm[n], a permutation of
+ ** n-1 elements. This can be explicitly obtained by taking out 1 from
+ ** all elements perm[i] > perm[1]. */
+
+VL_INLINE vl_index get_permutation_index(vl_uindex *permutation, vl_size size){
+  vl_index index = 0 ;
+  vl_index i ;
+  vl_index j ;
+
+  for (i = 0 ; i < (signed)size ; ++i) {
+    index = index * ((signed)size - i) + permutation[i] ;
+    for (j = i + 1 ; j < (signed)size ; ++j) {
+      if (permutation[j] > permutation[i]) { permutation[j] -- ; }
+    }
+  }
+  return index ;
+}
+
+/* instantiate two quick sort algorithms */
+VL_INLINE float patch_cmp (VlLiopDesc * liop, vl_index i, vl_index j)
+{
+  vl_index ii = liop->patchPermutation[i] ;
+  vl_index jj = liop->patchPermutation[j] ;
+  return liop->patchIntensities[ii] - liop->patchIntensities[jj] ;
+}
+
+VL_INLINE void patch_swap (VlLiopDesc * liop, vl_index i, vl_index j)
+{
+  vl_index tmp = liop->patchPermutation[i] ;
+  liop->patchPermutation[i] = liop->patchPermutation[j] ;
+  liop->patchPermutation[j] = tmp ;
+}
+
+#define VL_QSORT_prefix patch
+#define VL_QSORT_array VlLiopDesc*
+#define VL_QSORT_cmp patch_cmp
+#define VL_QSORT_swap patch_swap
+#include "qsort-def.h"
+
+VL_INLINE float neigh_cmp (VlLiopDesc * liop, vl_index i, vl_index j)
+{
+  vl_index ii = liop->neighPermutation[i] ;
+  vl_index jj = liop->neighPermutation[j] ;
+  return liop->neighIntensities[ii] - liop->neighIntensities[jj] ;
+}
+
+VL_INLINE void neigh_swap (VlLiopDesc * liop, vl_index i, vl_index j)
+{
+  vl_index tmp = liop->neighPermutation[i] ;
+  liop->neighPermutation[i] = liop->neighPermutation[j] ;
+  liop->neighPermutation[j] = tmp ;
+}
+
+#define VL_QSORT_prefix neigh
+#define VL_QSORT_array VlLiopDesc*
+#define VL_QSORT_cmp neigh_cmp
+#define VL_QSORT_swap neigh_swap
+#include "qsort-def.h"
+
+/* ---------------------------------------------------------------- */
+/*                                            Construct and destroy */
+/* ---------------------------------------------------------------- */
+
+/** @brief Create a new LIOP object instance.
+ ** @param numNeighbours number of neighbours.
+ ** @param numSpatialBins number of bins.
+ ** @param radius radius of the cirucal sample neighbourhoods.
+ ** @param sideLength width of the input image patch (the patch is square).
+ ** @return new object instance.
+ **
+ ** The value of @a radius should be at least less than half the @a
+ ** sideLength of the patch.
+ **/
+
+VlLiopDesc *
+vl_liopdesc_new (vl_int numNeighbours, vl_int numSpatialBins,
+                 float radius, vl_size sideLength)
+{
+  vl_index i, t ;
+  VlLiopDesc * self = vl_calloc(sizeof(VlLiopDesc), 1);
+
+  assert(radius <= sideLength/2) ;
+
+  self->numNeighbours = numNeighbours ;
+  self->numSpatialBins = numSpatialBins ;
+  self->neighRadius = radius ;
+  self->intensityThreshold = DEFAULT_INTENSITY_THRESHOLD ;
+
+  self->dimension = factorial(numNeighbours) * numSpatialBins ;
+
+  /*
+   Precompute a list of pixels within a circular patch inside
+   the square image. Leave a suitable marging for sampling around
+   these pixels.
+   */
+
+  self->patchSize = 0 ;
+  self->patchPixels = vl_malloc(sizeof(vl_uindex)*sideLength*sideLength) ;
+  self->patchSideLength = sideLength ;
+
+  {
+    vl_index x, y ;
+    vl_index center = (sideLength - 1) / 2 ;
+    double t = center - radius + 0.6 ;
+    vl_index t2 = (vl_index) (t * t) ;
+    for (y = 0 ; y < (signed)sideLength ; ++y) {
+      for (x = 0 ; x < (signed)sideLength ; ++x) {
+        vl_index dx = x - center ;
+        vl_index dy = y - center ;
+        if (x == 0 && y == 0) continue ;
+        if (dx*dx + dy*dy <= t2) {
+          self->patchPixels[self->patchSize++] = x + y * sideLength ;
+        }
+      }
+    }
+  }
+
+  self->patchIntensities = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
+  self->patchPermutation = vl_malloc(sizeof(vl_uindex)*self->patchSize) ;
+
+  /*
+   Precompute the samples in the circular neighbourhood of each
+   measurement point.
+   */
+
+  self->neighPermutation = vl_malloc(sizeof(vl_uindex) * self->numNeighbours) ;
+  self->neighIntensities = vl_malloc(sizeof(float) * self->numNeighbours) ;
+  self->neighSamplesX = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
+  self->neighSamplesY = vl_calloc(sizeof(double), self->numNeighbours * self->patchSize) ;
+
+  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
+    vl_index pixel ;
+    double x, y ;
+    double dangle = 2*VL_PI / (double)self->numNeighbours ;
+    double angle0 ;
+    vl_index center = (sideLength - 1) / 2 ;
+
+    pixel = self->patchPixels[i] ;
+    x = (pixel % (signed)self->patchSideLength) - center ;
+    y = (pixel / (signed)self->patchSideLength) - center ;
+
+    angle0 = atan2(y,x) ;
+
+    for (t = 0 ; t < (signed)self->numNeighbours ; ++t) {
+      double x1 = x + radius * cos(angle0 + dangle * t) + center ;
+      double y1 = y + radius * sin(angle0 + dangle * t) + center ;
+      self->neighSamplesX[t + (signed)self->numNeighbours * i] = x1 ;
+      self->neighSamplesY[t + (signed)self->numNeighbours * i] = y1 ;
+    }
+  }
+  return self ;
+}
+
+/** @brief Create a new object with default parameters
+ ** @param sideLength size of the patches to be processed.
+ ** @return new object.
+ **
+ ** @see ::vl_liopdesc_new. */
+
+VlLiopDesc * vl_liopdesc_new_basic (vl_size sideLength)
+{
+  return vl_liopdesc_new(DEFAULT_NUM_NEIGHBOURS,
+                         DEFAULT_NUM_SPATIAL_BINS,
+                         DEFAULT_RADIUS,
+                         sideLength) ;
+}
+
+/** @brief Delete object instance.
+ ** @param self object instance. */
+
+void
+vl_liopdesc_delete (VlLiopDesc * self)
+{
+  vl_free (self->patchPixels) ;
+  vl_free (self->patchIntensities) ;
+  vl_free (self->patchPermutation) ;
+  vl_free (self->neighPermutation) ;
+  vl_free (self->neighIntensities) ;
+  vl_free (self->neighSamplesX) ;
+  vl_free (self->neighSamplesY) ;
+  vl_free (self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                          Compute LIOP descriptor */
+/* ---------------------------------------------------------------- */
+
+/** @brief Compute liop descriptor for a patch
+ ** @param self object instance
+ ** @param desc descriptor to be computed (output).
+ ** @param patch patch to process
+ **
+ ** Use ::vl_liopdesc_get_dimension to get the size of the descriptor
+ ** @a desc. */
+
+void
+vl_liopdesc_process (VlLiopDesc * self, float * desc, float const * patch)
+{
+  vl_index i,t ;
+  vl_index offset,numPermutations ;
+  vl_index spatialBinArea, spatialBinEnd, spatialBinIndex ;
+  float threshold ;
+
+  memset(desc, 0, sizeof(float) * self->dimension) ;
+
+  /*
+   * Sort pixels in the patch by increasing intensity.
+   */
+
+  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
+    vl_index pixel = self->patchPixels[i] ;
+    self->patchIntensities[i] = patch[pixel] ;
+    self->patchPermutation[i] = i ;
+  }
+  patch_sort(self, self->patchSize) ;
+
+  /*
+   * Tune the threshold if needed.
+   */
+
+  if (self->intensityThreshold < 0) {
+    i = self->patchPermutation[0] ;
+    t = self->patchPermutation[self->patchSize-1] ;
+    threshold = - self->intensityThreshold
+    * (self->patchIntensities[t] - self->patchIntensities[i]);
+  } else {
+    threshold = self->intensityThreshold ;
+  }
+
+  /*
+   * Process pixels in order of increasing intenisity, dividing them into
+   * spatial bins on the fly.
+   */
+
+  numPermutations = factorial(self->numNeighbours) ;
+  spatialBinArea = self->patchSize / self->numSpatialBins ;
+  spatialBinEnd = spatialBinArea ;
+  spatialBinIndex = 0 ;
+  offset = 0 ;
+
+  for (i = 0 ; i < (signed)self->patchSize ; ++i) {
+    vl_index permIndex ;
+    double *sx, *sy ;
+
+    /* advance to the next spatial bin if needed */
+    if (i >= (signed)spatialBinEnd && spatialBinIndex < (signed)self->numSpatialBins - 1) {
+      spatialBinEnd += spatialBinArea ;
+      spatialBinIndex ++ ;
+      offset += numPermutations ;
+    }
+
+    /* get intensities of neighbours of the current patch element and sort them */
+    sx = self->neighSamplesX + self->numNeighbours * self->patchPermutation[i] ;
+    sy = self->neighSamplesY + self->numNeighbours * self->patchPermutation[i] ;
+    for (t = 0 ; t < self->numNeighbours ; ++t) {
+      double x = *sx++ ;
+      double y = *sy++ ;
+
+      /* bilinear interpolation */
+      vl_index ix = vl_floor_d(x) ;
+      vl_index iy = vl_floor_d(y) ;
+
+      double wx = x - ix ;
+      double wy = y - iy ;
+
+      double a = 0, b = 0, c = 0, d = 0 ;
+
+      int L = (int) self->patchSideLength ;
+
+      if (ix >= 0   && iy >= 0  ) { a = patch[ix   + iy * L] ; }
+      if (ix <  L-1 && iy >= 0  ) { b = patch[ix+1 + iy * L] ; }
+      if (ix >= 0   && iy <  L-1) { c = patch[ix   + (iy+1) * L] ; }
+      if (ix <  L-1 && iy <  L-1) { d = patch[ix+1 + (iy+1) * L] ; }
+
+      self->neighPermutation[t] = t;
+      self->neighIntensities[t] = (1 - wy) * (a + (b - a) * wx) + wy * (c + (d - c) * wx) ;
+    }
+    neigh_sort (self, self->numNeighbours) ;
+
+    /* get permutation index */
+    permIndex = get_permutation_index(self->neighPermutation, self->numNeighbours);
+
+    /*
+     * Compute weight according to difference in intensity values and
+     * accumulate.
+     */
+    {
+      int k, t ;
+      float weight = 0 ;
+      for(k = 0; k < self->numNeighbours ; ++k) {
+        for(t = k + 1; t < self->numNeighbours; ++t){
+          double a = self->neighIntensities[k] ;
+          double b = self->neighIntensities[t] ;
+          weight += (a > b + threshold || b > a + threshold) ;
+        }
+      }
+      desc[permIndex + offset] += weight ;
+    }
+  }
+
+  /* normalization */
+  {
+    float norm = 0;
+    for(i = 0; i < (signed)self->dimension; i++) {
+      norm += desc[i]*desc[i];
+    }
+    norm = VL_MAX(sqrt(norm), 1e-12) ;
+    for(i = 0; i < (signed)self->dimension; i++){
+      desc[i] /= norm ;
+    }
+  }
+}
+
+
+/* ---------------------------------------------------------------- */
+/*                                              Getters and setters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get the dimension of a LIOP descriptor.
+ ** @param self object.
+ ** @return dimension. */
+
+vl_size
+vl_liopdesc_get_dimension (VlLiopDesc const * self)
+{
+  return self->dimension ;
+}
+
+
+/** @brief Get the number of neighbours.
+ ** @param self object.
+ ** @return number of neighbours.
+ **/
+
+vl_size
+vl_liopdesc_get_num_neighbours (VlLiopDesc const * self)
+{
+  assert(self) ;
+  return self->numNeighbours ;
+}
+
+/** @brief Get the intensity threshold
+ ** @param self object.
+ ** @return intensity threshold.
+ ** @see liop-weighing
+ **/
+
+float
+vl_liopdesc_get_intensity_threshold (VlLiopDesc const * self)
+{
+  assert(self) ;
+  return self->intensityThreshold ;
+}
+
+/** @brief Set the intensity threshold
+ ** @param self object.
+ ** @param x intensity threshold.
+ **
+ ** If non-negative, the threshold as is is used when comparing
+ ** intensities. If negative, the absolute value of the specified
+ ** number is multipled by the maximum intensity difference inside a
+ ** patch to obtain the threshold.
+ **
+ ** @see liop-weighing
+ **/
+
+void
+vl_liopdesc_set_intensity_threshold (VlLiopDesc * self, float x)
+{
+  assert(self) ;
+  self->intensityThreshold = x ;
+}
+
+/** @brief Get the neighbourhood radius.
+ ** @param self object.
+ ** @return neighbourhood radius.
+ **/
+
+double
+vl_liopdesc_get_neighbourhood_radius (VlLiopDesc const * self)
+{
+  assert(self) ;
+  return self->neighRadius ;
+}
+
+/** @brief Get the number of spatial bins.
+ ** @param self object.
+ ** @return number of spatial bins.
+ **/
+
+vl_size
+vl_liopdesc_get_num_spatial_bins (VlLiopDesc const * self)
+{
+  assert(self) ;
+  return self->numSpatialBins ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/liop.h b/opensfm/src/third_party/vlfeat/vl/liop.h
new file mode 100644
index 000000000..d96de915d
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/liop.h
@@ -0,0 +1,78 @@
+/** @file liop.h
+ ** @brief Local Intensity Order Pattern (LIOP) descriptor (@ref liop)
+ ** @author Hana Sarbortova
+ ** @author Andrea Vedaldi
+ ** @see @ref liop
+ **/
+
+/*
+Copyright (C) 2013 Hana Sarbortova and Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_LIOP_H
+#define VL_LIOP_H
+
+#include "generic.h"
+
+/** @brief LIOP descriptor extractor object */
+typedef struct _VlLiopDesc
+{
+  vl_int numNeighbours; /**< Number of neighbours. */
+  vl_int numSpatialBins; /**< Number of bins. */
+  float intensityThreshold; /**< Weight threshold. */
+  vl_size dimension; /**< LIOP descriptor size. */
+
+  /* Pixels in the circular patch */
+  vl_size patchSideLength ;
+  vl_size patchSize ; /* only circular neighbourhood */
+  vl_uindex * patchPixels ;
+  float * patchIntensities ;
+  vl_uindex * patchPermutation ;
+
+  /* Neighbourhoods of each pixel (samples in a circle) */
+  float neighRadius; /**< Point to neighbour radius (distance). */
+
+  float * neighIntensities ;
+  vl_uindex * neighPermutation ;
+  double * neighSamplesX ;
+  double * neighSamplesY ;
+
+} VlLiopDesc ;
+
+/** @name Construct and destroy
+ ** @{ */
+VL_EXPORT
+VlLiopDesc * vl_liopdesc_new (vl_int numNeighbours,
+                              vl_int numSpatialBins,
+                              float radius,
+                              vl_size sideLength) ;
+
+VL_EXPORT
+VlLiopDesc * vl_liopdesc_new_basic (vl_size sideLength) ;
+
+VL_EXPORT
+void vl_liopdesc_delete (VlLiopDesc * self) ;
+/** @} */
+
+/**  @name Get data and parameters
+ **  @{ */
+VL_EXPORT vl_size vl_liopdesc_get_dimension (VlLiopDesc const * self) ;
+VL_EXPORT vl_size vl_liopdesc_get_num_neighbours (VlLiopDesc const * self) ;
+VL_EXPORT float vl_liopdesc_get_intensity_threshold (VlLiopDesc const * self) ;
+VL_EXPORT vl_size vl_liopdesc_get_num_spatial_bins (VlLiopDesc const * self) ;
+VL_EXPORT double vl_liopdesc_get_neighbourhood_radius (VlLiopDesc const * self) ;
+VL_EXPORT void vl_liopdesc_set_intensity_threshold (VlLiopDesc * self, float x) ;
+/** @} */
+
+/**  @name Compute LIOP descriptor
+ **  @{ */
+VL_EXPORT
+void vl_liopdesc_process (VlLiopDesc * liop, float * desc, float const * patch) ;
+/** @} */
+
+/* VL_LIOP_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop.c b/opensfm/src/third_party/vlfeat/vl/mathop.c
new file mode 100644
index 000000000..d2a292697
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop.c
@@ -0,0 +1,1032 @@
+/** @file mathop.c
+ ** @brief Math operations - Definition
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2014 Andrea Vedaldi.
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@page mathop Mathematical operations
+@author Andrea Vedaldi
+@author Brian Fulkerson
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+VLFeat include several low-level routines to speedup common
+mathematical operations used throughout the library. Most are
+collected in the @ref mathop.h module.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section mathop-usage-vector-comparison Comparing vectors
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+@ref mathop.h includes a number of functions to quickly compute
+distances or similarity of pairs of vector. Applications include
+clustering and evaluation of SVM-like classifiers.
+
+Use ::vl_get_vector_comparison_function_f or
+::vl_get_vector_comparison_function_d obtain an approprite function
+to comprare vectors of floats or doubles, respectively.  Such
+functions are usually optimized (for instance, on X86 platforms they
+use the SSE vector extension) and are several times faster than a
+naive implementation.  ::vl_eval_vector_comparison_on_all_pairs_f and
+::vl_eval_vector_comparison_on_all_pairs_d can be used to evaluate
+the comparison function on all pairs of one or two sequences of
+vectors.
+
+Let @f$ \mathbf{x} = (x_1,\dots,x_d) @f$ and @f$ \mathbf{y} =
+(y_1,\dots,y_d) @f$ be two vectors.  The following comparison
+functions are supported:
+
+<table>
+<tr>
+<td>@f$ l^1 @f$</td>
+<td>::VlDistanceL1</td>
+<td>@f$ \sum_{i=1}^d |x_i - y_i| @f$</td>
+<td>l1 distance (squared intersection metric)</td>
+</tr>
+<tr>
+<td>@f$ l^2 @f$</td>
+<td>::VlDistanceL2</td>
+<td>@f$\sum_{i=1}^d (x_i - y_i)^2@f$</td>
+<td>Squared Euclidean disance</td>
+</tr>
+<tr>
+<td>@f$ \chi^2 @f$</td>
+<td>::VlDistanceChi2</td>
+<td>@f$\sum_{i=1}^d \frac{(x_i - y_i)^2}{x_i + y_i}@f$</td>
+<td>Squared chi-square distance</td>
+</tr>
+<tr>
+<td>-</td>
+<td>::VlDistanceHellinger</td>
+<td>@f$\sum_{i=1}^d (\sqrt{x_i} - \sqrt{y_i})^2@f$</td>
+<td>Squared Hellinger's distance</td>
+</tr>
+<tr>
+<td>-</td>
+<td>::VlDistanceJS</td>
+<td>@f$
+\sum_{i=1}^d
+\left(
+  x_i \log\frac{2x_i}{x_i+y_i}
++ y_i \log\frac{2y_i}{x_i+y_i}
+\right)
+@f$
+</td>
+<td>Squared Jensen-Shannon distance</td>
+</tr>
+<tr>
+<td>@f$ l^1 @f$</td>
+<td>::VlKernelL1</td>
+<td>@f$ \sum_{i=1}^d \min\{ x_i, y_i \} @f$</td>
+<td>intersection kernel</td>
+</tr>
+<tr>
+<td>@f$ l^2 @f$</td>
+<td>::VlKernelL2</td>
+<td>@f$\sum_{i=1}^d x_iy_i @f$</td>
+<td>linear kernel</td>
+</tr>
+<tr>
+<td>@f$ \chi^2 @f$</td>
+<td>::VlKernelChi2</td>
+<td>@f$\sum_{i=1}^d 2 \frac{x_iy_i}{x_i + y_i}@f$</td>
+<td>chi-square kernel</td>
+</tr>
+<tr>
+<td>-</td>
+<td>::VlKernelHellinger</td>
+<td>@f$\sum_{i=1}^d 2 \sqrt{x_i y_i}@f$</td>
+<td>Hellinger's kernel (Bhattacharya coefficient)</td>
+</tr>
+<tr>
+<td>-</td>
+<td>::VlKernelJS</td>
+<td>@f$
+\sum_{i=1}^d
+\left(
+  \frac{x_i}{2} \log_2\frac{x_i+y_i}{x_i}
++ \frac{y_i}{2} \log_2\frac{x_i+y_i}{y_i}
+\right)
+@f$
+</td>
+<td>Jensen-Shannon kernel</td>
+</tr>
+</table>
+
+@remark The definitions have been choosen so that corresponding kernels and
+distances are related by the equation:
+@f[
+ d^2(\mathbf{x},\mathbf{y})
+ =
+ k(\mathbf{x},\mathbf{x})
+ +k(\mathbf{y},\mathbf{y})
+ -k(\mathbf{x},\mathbf{y})
+ -k(\mathbf{y},\mathbf{x})
+@f]
+This means that each of these distances can be interpreted as a
+squared distance or metric in the corresponding reproducing kernel
+Hilbert space. Notice in particular that the @f$ l^1 @f$ or Manhattan
+distance is also a <em>squared</em> distance in this sense.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section mathop-integer-ops Fast basic functions operations
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+In certain algorithm it is useful to quickly compute integer
+approximation of certain mathematical operations. Presently, VLFeat
+includes and implementations of:
+
+- Fast single precision atan2: ::vl_fast_sqrt_f.
+- Fast inverse square root: ::vl_fast_resqrt_f, ::vl_fast_resqrt_d.
+- Fast square root: ::vl_fast_sqrt_f, ::vl_fast_sqrt_d.
+- Fast integer square root: ::vl_fast_sqrt_ui16, ::vl_fast_sqrt_ui32,
+  ::vl_fast_sqrt_ui64 (see also @subpage mathop-sqrti).
+**/
+
+/** @fn vl_get_vector_comparison_function_f(VlVectorComparisonType)
+ **
+ ** @brief Get vector comparison function from comparison type
+ ** @param type vector comparison type.
+ ** @return comparison function.
+ **/
+
+/** @fn vl_get_vector_comparison_function_d(VlVectorComparisonType)
+ ** @brief Get vector comparison function from comparison type
+ ** @sa vl_get_vector_comparison_function_f
+ **/
+
+/** @fn vl_eval_vector_comparison_on_all_pairs_f(float*,vl_size,
+ **     float const*,vl_size,float const*,vl_size,VlFloatVectorComparisonFunction)
+ **
+ ** @brief Evaluate vector comparison function on all vector pairs
+ ** @param result comparison matrix (output).
+ ** @param dimension number of vector components (rows of @a X and @a Y).
+ ** @param X data matrix X.
+ ** @param Y data matrix Y.
+ ** @param numDataX number of vectors in @a X (columns of @a X)
+ ** @param numDataY number of vectros in @a Y (columns of @a Y)
+ ** @param function vector comparison function.
+ **
+ ** The function evaluates @a function on all pairs of columns
+ ** from matrices @a X and @a Y, filling a @a numDataX by @a numDataY
+ ** matrix.
+ **
+ ** If @a Y is a null pointer the function compares all columns from
+ ** @a X with themselves.
+ **/
+
+/** @fn vl_eval_vector_comparison_on_all_pairs_d(double*,vl_size,
+ **     double const*,vl_size,double const*,vl_size,VlDoubleVectorComparisonFunction)
+ ** @brief Evaluate vector comparison function on all vector pairs
+ ** @sa vl_eval_vector_comparison_on_all_pairs_f
+ **/
+
+/**
+@page mathop-sqrti Fast integer square root algorithm
+@tableofcontents
+
+This section describes the fast integer square root algorithm used by
+vl_fast_sqrt_ui8, ::vl_fast_sqrt_ui16, ::vl_fast_sqrt_ui32,
+::vl_fast_sqrt_ui64.
+
+Given a non-negative integer $x \in \mathbb{Z}_+$, the goal of this
+algorithm is to quickly compute the integer approximation of the
+square root of an integer number:
+
+\[
+y = \max_{\bar y\in\mathbb{Z}} \bar y, \qquad \text{such that}\  \bar y^2 \leq x.
+\]
+
+Consider determining the k-th bit of $y$. To this end, decompose $y$
+in three parts:
+
+\[
+y = y_{k+1} + q 2^k + r,
+\qquad \text{where}\   y_{k+1} \geq 2^{k+1}, r < 2^k,
+\]
+
+and $q\in\{0,1\}$ is the bit to be determined. Here $y_{k+1}$ is a part
+of the result $y$ that has already been determined, while the bit $q$
+and the remainder $r$ are still unknown. Recall that the goal is to
+find the largest $y^2$ such that $y^2 \leq x$. Expanding $y^2$ this
+condition becomes
+
+\[
+q (2^{2k} + 2 y_{k+1} 2^k) + r(r + 2q 2^k + 2 y_{k+1}) \leq x - y_{k+1}^2.
+\]
+
+We can now determine if $q=1$ or $q=0$ based on the value of the
+residual $x - y_{k+1}^2$. Specifically, $q=1$ requires that:
+
+\[
+\boxed{
+2^{2k} + 2a2^k \leq x - y_{k+1}^2.
+}
+\]
+
+On the other hand, if this equation is satisfied, then setting $r=0$
+shows that there exists at least one $y$ such that $q=1$ and $y^2 \leq
+x$. In particular, greedily choosing $q=1$ in $x=y_{k+1} + 2^k q + r$ is
+optimal because $2^k > r$. This yields the algorithm:
+
+1. Note that if $x$ is stored in $n$ bits and $n$ is even, then the
+   integer square root $y$ does not require more than $m = n / 2$ bit
+   to be stored. Thus the first bit to be determined is $k \leftarrow
+   m - 1 = n/2 - 1$ and $y_{n/2}=0$.
+2. The algorithm stores and updates $y_k/2^{k}$ and $x - y_{k}^2$ for
+   convenience.
+3. During iteration $k$, $y_k$ is determined. On entering the
+   iteration, the first step is to compute $y_{k+1}/2^k = 2
+   y_{k+1}/2^{k+1}$.
+4. Then the bound $t = (2^{2k} + 2 y_{k+1})2^k = 2^{2k}(1 + 2
+   y_{k+1}/2^k)$.
+5. If $t \geq x - y_{k+1}$, the $k$-th bit of $y_k$ is set to
+   one. This means applying the update $\hat y_{k}/2^k \leftarrow
+   y_{k+1}/2^k + 1$. This also requires computing $x - y_{k}^2
+   \leftarrow x - y_{k+1}^2 - t$.
+6. Decrement $k \leftarrow k -1$ and, if $k\geq 0$, continue from 3.
+
+**/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_MATHOP_INSTANTIATING
+
+#include "mathop.h"
+#include "mathop_sse2.h"
+ #include "mathop_avx.h"
+#include <math.h>
+
+#undef FLT
+#define FLT VL_TYPE_FLOAT
+#define VL_MATHOP_INSTANTIATING
+#include "mathop.c"
+
+#undef FLT
+#define FLT VL_TYPE_DOUBLE
+#define VL_MATHOP_INSTANTIATING
+#include "mathop.c"
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifdef VL_MATHOP_INSTANTIATING
+#include "float.h"
+
+#undef COMPARISONFUNCTION_TYPE
+#undef COMPARISONFUNCTION3_TYPE
+#if (FLT == VL_TYPE_FLOAT)
+#  define COMPARISONFUNCTION_TYPE VlFloatVectorComparisonFunction
+#  define COMPARISONFUNCTION3_TYPE VlFloatVector3ComparisonFunction
+#else
+#  define COMPARISONFUNCTION_TYPE VlDoubleVectorComparisonFunction
+#  define COMPARISONFUNCTION3_TYPE VlDoubleVector3ComparisonFunction
+#endif
+
+/* ---------------------------------------------------------------- */
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T d = *X++ - *Y++ ;
+    acc += d * d ;
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l1_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T d = *X++ - *Y++ ;
+    acc += VL_MAX(d, -d) ;
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_chi2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    T denom = (a + b) ;
+    T numer = delta * delta ;
+    if (denom) {
+      T ratio = numer / denom ;
+      acc += ratio ;
+    }
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_hellinger_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+#if (FLT == VL_TYPE_FLOAT)
+    acc += a + b - 2.0 * sqrtf (a*b) ;
+#else
+    acc += a + b - 2.0 * sqrt (a*b) ;
+#endif
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_js_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T x = *X++ ;
+    T y = *Y++ ;
+    if (x) acc += x - x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
+    if (y) acc += y - y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    acc += a * b ;
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l1_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
+    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
+    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
+  }
+  return acc / ((T)2) ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_chi2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T denom = (a + b) ;
+    if (denom) {
+      T numer = 2 * a * b ;
+      T ratio = numer / denom ;
+      acc += ratio ;
+    }
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_hellinger_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+#if (FLT == VL_TYPE_FLOAT)
+    acc += sqrtf (a*b) ;
+#else
+    acc += sqrt (a*b) ;
+#endif
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_js_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T x = *X++ ;
+    T y = *Y++ ;
+    if (x) acc += x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
+    if (y) acc += y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
+  }
+  return (T)0.5 * acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_mahalanobis_sq_, SFX)
+(vl_size dimension, T const * X, T const * MU, T const * S)
+{
+  T const * X_end = X + dimension ;
+  T acc = 0.0 ;
+  while (X < X_end) {
+    T d = *X++ - *MU++ ;
+    acc += d * d * (*S++) ;
+  }
+  return acc ;
+}
+
+/* ---------------------------------------------------------------- */
+
+VL_EXPORT COMPARISONFUNCTION_TYPE
+VL_XCAT(vl_get_vector_comparison_function_, SFX)(VlVectorComparisonType type)
+{
+  COMPARISONFUNCTION_TYPE function = 0 ;
+  switch (type) {
+    case VlDistanceL2        : function = VL_XCAT(_vl_distance_l2_,             SFX) ; break ;
+    case VlDistanceL1        : function = VL_XCAT(_vl_distance_l1_,             SFX) ; break ;
+    case VlDistanceChi2      : function = VL_XCAT(_vl_distance_chi2_,           SFX) ; break ;
+    case VlDistanceHellinger : function = VL_XCAT(_vl_distance_hellinger_,      SFX) ; break ;
+    case VlDistanceJS        : function = VL_XCAT(_vl_distance_js_,             SFX) ; break ;
+    case VlKernelL2          : function = VL_XCAT(_vl_kernel_l2_,               SFX) ; break ;
+    case VlKernelL1          : function = VL_XCAT(_vl_kernel_l1_,               SFX) ; break ;
+    case VlKernelChi2        : function = VL_XCAT(_vl_kernel_chi2_,             SFX) ; break ;
+    case VlKernelHellinger   : function = VL_XCAT(_vl_kernel_hellinger_,        SFX) ; break ;
+    case VlKernelJS          : function = VL_XCAT(_vl_kernel_js_,               SFX) ; break ;
+    default: abort() ;
+  }
+
+#ifndef VL_DISABLE_SSE2
+  /* if a SSE2 implementation is available, use it */
+  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
+    switch (type) {
+      case VlDistanceL2    : function = VL_XCAT(_vl_distance_l2_sse2_,             SFX) ; break ;
+      case VlDistanceL1    : function = VL_XCAT(_vl_distance_l1_sse2_,             SFX) ; break ;
+      case VlDistanceChi2  : function = VL_XCAT(_vl_distance_chi2_sse2_,           SFX) ; break ;
+      case VlKernelL2      : function = VL_XCAT(_vl_kernel_l2_sse2_,               SFX) ; break ;
+      case VlKernelL1      : function = VL_XCAT(_vl_kernel_l1_sse2_,               SFX) ; break ;
+      case VlKernelChi2    : function = VL_XCAT(_vl_kernel_chi2_sse2_,             SFX) ; break ;
+      default: break ;
+    }
+  }
+#endif
+
+#ifndef VL_DISABLE_AVX
+  /* if an AVX implementation is available, use it */
+  if (vl_cpu_has_avx() && vl_get_simd_enabled()) {
+    switch (type) {
+      case VlDistanceL2    : function = VL_XCAT(_vl_distance_l2_avx_,             SFX) ; break ;
+      default: break ;
+    }
+  }
+#endif
+
+  return function ;
+}
+
+/* ---------------------------------------------------------------- */
+
+VL_EXPORT COMPARISONFUNCTION3_TYPE
+VL_XCAT(vl_get_vector_3_comparison_function_, SFX)(VlVectorComparisonType type)
+{
+  COMPARISONFUNCTION3_TYPE function = 0 ;
+  switch (type) {
+    case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_, SFX) ; break ;
+    default: abort() ;
+  }
+
+#ifndef VL_DISABLE_SSE2
+  /* if a SSE2 implementation is available, use it */
+  if (vl_cpu_has_sse2() && vl_get_simd_enabled()) {
+    switch (type) {
+      case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX) ; break ;
+      default: break ;
+    }
+  }
+#endif
+
+#ifndef VL_DISABLE_AVX
+  /* if an AVX implementation is available, use it */
+  if (vl_cpu_has_avx() && vl_get_simd_enabled()) {
+    switch (type) {
+      case VlDistanceMahalanobis : function = VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX) ; break ;
+      default: break ;
+    }
+  }
+#endif
+
+  return function ;
+}
+
+/* ---------------------------------------------------------------- */
+
+VL_EXPORT void
+VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)
+(T * result, vl_size dimension,
+ T const * X, vl_size numDataX,
+ T const * Y, vl_size numDataY,
+ COMPARISONFUNCTION_TYPE function)
+{
+  vl_uindex xi ;
+  vl_uindex yi ;
+
+  if (dimension == 0) return ;
+  if (numDataX == 0) return ;
+  assert (X) ;
+
+  if (Y) {
+    if (numDataY == 0) return ;
+    for (yi = 0 ; yi < numDataY ; ++ yi) {
+      for (xi = 0 ; xi < numDataX ; ++ xi) {
+        *result++ = (*function)(dimension, X, Y) ;
+        X += dimension ;
+      }
+      X -= dimension * numDataX ;
+      Y += dimension ;
+    }
+  } else {
+    T * resultTransp = result ;
+    Y = X ;
+    for (yi = 0 ; yi < numDataX ; ++ yi) {
+      for (xi = 0 ; xi <= yi ; ++ xi) {
+        T z = (*function)(dimension, X, Y) ;
+        X += dimension ;
+        *result       = z ;
+        *resultTransp = z ;
+        result        += 1 ;
+        resultTransp  += numDataX ;
+      }
+      X -= dimension * (yi + 1) ;
+      Y += dimension ;
+      result       += numDataX - (yi + 1) ;
+      resultTransp += 1        - (yi + 1) * numDataX ;
+    }
+  }
+}
+
+/* VL_MATHOP_INSTANTIATING */
+#endif
+
+
+/* ---------------------------------------------------------------- */
+/*                                               Numerical analysis */
+/* ---------------------------------------------------------------- */
+
+#ifndef VL_MATHOP_INSTANTIATING
+
+/** @brief SVD of a 2x2 real matrix
+ ** @param S 2x2 real diagonal matrix of the singular values (out).
+ ** @param U first 2x2 real orthonormal matrix (out).
+ ** @param V second 2x2 real orthonormal matrix (out).
+ ** @param M 2x2 matrix.
+ **
+ ** The function comptues the SVD decomposition of the 2x2
+ ** real matrix @f$ M @f$:
+ ** @f[
+ **    M = U \operatorname S V^\top
+ ** @f]
+ ** where @f$ U @f$ and @f$ V @f$ are real orthonormal matrices
+ ** and @f$ S @f$ is the diagonal matrix of the singular values
+ ** in decreasing order.
+ **
+ ** @par Algorithm
+ **
+ ** The fist step is to find rotation matrices @f$ U_1 @f$ and
+ ** @f$ V_1 @f$ such taht
+ ** @f[
+ **     M = U_1 R V_1^\top, \quad
+ **     U_1 = \begin{barray} c_{u1} & - s_{u1} \\ s_{u1} & c_{u1} \end{barray}, \quad
+ **     V_1 = \begin{barray} c_{v1} & - s_{v1} \\ s_{v1} & c_{v1} \end{barray}, \quad
+ **     R = \begin{barray} f & g \\ 0 & h \end{barray}.
+ ** @f]
+ ** Gives a 2x2 triangular matrix. The second step is to call
+ ** ::vl_lapack_dlasv2 on the matrix @f$ R @f$ obtaining
+ ** @f[
+ **   M = U_1 (U_2 S V_2^\top) V_2.
+ ** @f]
+ **/
+
+void
+vl_svd2 (double* S, double *U, double *V, double const *M)
+{
+  double m11 = M[0] ;
+  double m21 = M[1] ;
+  double m12 = M[2] ;
+  double m22 = M[3] ;
+  double cu1 = m11 ;
+  double su1 = m21 ;
+  double norm = sqrt(cu1*cu1 + su1*su1) ;
+  double cu2, su2, cv2, sv2 ;
+  double f, g, h ;
+  double smin, smax ;
+  cu1 /= norm ;
+  su1 /= norm ;
+
+  f = cu1 * m11 + su1 * m21 ;
+  g = cu1 * m12 + su1 * m22 ;
+  h = - su1 * m12 + cu1 * m22 ;
+
+  vl_lapack_dlasv2 (&smin, &smax,
+                    &sv2, &cv2,
+                    &su2, &cu2,
+                    f, g, h) ;
+
+  assert(S) ;
+  S[0] = smax ;
+  S[1] = 0 ;
+  S[2] = 0 ;
+  S[3] = smin ;
+
+  if (U) {
+    U[0] = cu2*cu1 - su2*su1 ;
+    U[1] = su2*cu1 + cu2*su1 ;
+    U[2] = - cu2*su1 - su2*cu1 ;
+    U[3] = - su2*su1 + cu2*cu1 ;
+  }
+  if (V) {
+    V[0] = cv2 ;
+    V[1] = sv2 ;
+    V[2] = - sv2 ;
+    V[3] = cv2 ;
+  }
+}
+
+/** @brief SVD of a 2x2 upper triangular matrix (LAPACK @c dlasv2 equivalent)
+ ** @param smin smallest (in modulus) singular value (out).
+ ** @param smax largest (in modulus) singuarl value (out).
+ ** @param sv second component of the right singular vector of @c smax (out).
+ ** @param cv first component of the right singular vector of @c smax (out).
+ ** @param su second component of the left singular vector of @c smax (out).
+ ** @param cu first component of the left singular vector of @c smax (out).
+ ** @param f first entry of the upper triangular matrix.
+ ** @param g second entry of the upper triangular matrix.
+ ** @param h third entry of the upper triangular matrix.
+ **
+ ** @f[
+ **  \begin{bmatrix} f & g \\ 0 & h \end{bmatrix}
+ **  =
+ **  \begin{bmatrix} cv & - sv \\ sv & cv \end{bmatrix}
+ **  \begon{bmatrix} smax & 0 \\ 0 & smin \end{bmatrix}
+ **  \begin{bmatrix} cv & - sv \\ sv & cv \end{bmatrix}
+ ** @f]
+ **
+ ** Z.Bai and J.Demmel,
+ ** "Computing the Generalized Singular Value Decomposition",
+ ** SIAM J. Sci. Comput., Vol. 14, No. 6, pp. 1464-1486, November 1993
+ **/
+
+#define isign(i) ((i)<0 ? (-1) : (+1))  /* integer sign function */
+#define sign(x) ((x)<0.0 ? (-1) : (+1)) /* double sign function */
+
+void
+vl_lapack_dlasv2 (double *smin,
+                  double *smax,
+                  double *sv,
+                  double *cv,
+                  double *su,
+                  double *cu,
+                  double f,
+                  double g,
+                  double h)
+{
+  double svt, cvt, sut, cut; /* temporary sv, cv, su, and cu */
+  double ft = f, gt = g, ht = h; /* temporary f, g, h */
+  double fa = fabs(f), ga = fabs(g), ha = fabs(h); /* |f|, |g|, and |h| */
+  int pmax = 1 ; /* pointer to max abs entry */
+  int swap = 0 ; /* is swapped */
+  int glarge = 0 ; /* is g very large */
+  int tsign ; /* tmp sign */
+  double fmh ; /* |f| -|h| */
+  double d ; /* (|f| -|h|)/|f| */
+  double dd ; /* d*d */
+  double q ; /* g/f */
+  double qq ; /* q*q */
+  double s ; /* (|f| + |h|)/|f| */
+  double ss ; /* s*s */
+  double spq ; /* sqrt(ss + qq) */
+  double dpq ; /* sqrt(dd + qq) */
+  double a ; /* (spq + dpq)/2 */
+  double tmp ; /* temporaries */
+  double tt;
+
+  /* make fa >= ha */
+  if (fa < ha) {
+    pmax = 3 ;
+    tmp =ft ; ft = ht ; ht = tmp ; /* swap ft and ht */
+    tmp =fa ; fa = ha ; ha = tmp ; /* swap fa and ha */
+    swap = 1 ;
+  }
+
+  if (ga == 0.0) { /* diagonal */
+    *smin = ha ;
+    *smax = fa ;
+    /* identity matrix */
+    cut = 1.0 ; sut = 0.0 ;
+    cvt = 1.0 ; svt = 0.0 ;
+  }
+  else { /* not diagonal */
+    if (ga > fa) { /* g is the largest entry */
+      pmax = 2 ;
+      if ((fa / ga) < VL_EPSILON_D) { /* g is very large */
+        glarge = 1 ;
+        *smax = ga ; /* 1 ulp */
+        if (ha > 1.0) {
+          *smin = fa / (ga / ha) ; /* 2 ulps */
+        } else {
+          *smin = (fa / ga) * ha ; /* 2 ulps */
+        }
+        cut = 1.0 ; sut = ht / gt ;
+        cvt = 1.0 ; svt = ft / gt ;
+      }
+    }
+
+    if (glarge == 0) { /* normal case */
+      fmh = fa - ha ; /* 1ulp */
+      if (fmh == fa) {  /* cope with infinite f or h */
+        d = 1.0 ;
+      } else {
+        d = fmh / fa ; /* note 0<=d<=1.0, 2 ulps */
+      }
+      q = gt / ft ; /* note |q|<1/EPS, 1 ulp */
+      s = 2.0 - d ; /* note s>=1.0, 3 ulps */
+      dd = d*d ;
+      qq = q*q ;
+      ss = s*s ;
+      spq = sqrt(ss + qq) ; /* note 1<=spq<=1+1/EPS, 5 ulps */
+      if (d == 0.0) {
+        dpq = fabs(q) ; /* 0 ulp */
+      } else {
+        dpq = sqrt(dd + qq) ; /* note 0<=dpq<=1+1/EPS, 3.5 ulps */
+      }
+      a = 0.5 * (spq + dpq) ; /* note 1<=a<=1 + |q|, 6 ulps */
+      *smin = ha / a; /* 7 ulps */
+      *smax = fa * a; /* 7 ulps */
+      if (qq==0.0) { /* qq underflow */
+        if (d==0.0) {
+          tmp = sign(ft)*2*sign(gt); /* 0ulp */
+        }
+        else {
+          tmp = gt/(sign(ft)*fmh) + q/s; /* 6 ulps */
+        }
+      } else {
+        tmp = (q/(spq + s) + q/(dpq + d))*(1.0 + a);  /* 17 ulps */
+      }
+      /* if qq */
+      tt = sqrt(tmp*tmp + 4.0) ; /* 18.5 ulps */
+      cvt = 2.0 / tt ; /* 19.5 ulps */
+      svt = tmp / tt ; /* 36.5 ulps */
+      cut = (cvt + svt*q) / a ; /* 46.5 ulps */
+      sut = (ht / ft) * svt / a ; /* 45.5 ulps */
+    } /* if g not large */
+  } /* if ga */
+  if (swap == 1) {
+    *cu = svt ; *su = cvt ;
+    *cv = sut ; *sv = cut ;
+  } else {
+    *cu = cut ; *su = sut ;
+    *cv = cvt ; *sv = svt ;
+  }
+  /* correct the signs of smax and smin */
+  if (pmax==1) { tsign = sign(*cv) * sign(*cu) * sign(f) ; }
+  if (pmax==2) { tsign = sign(*sv) * sign(*cu) * sign(g) ; }
+  if (pmax==3) { tsign = sign(*sv) * sign(*su) * sign(h) ; }
+  *smax = isign(tsign) * (*smax);
+  *smin = isign(tsign * sign(f) * sign(h)) * (*smin) ;
+}
+
+
+/** @brief Solve a 3x3 linear system
+ ** @param x result.
+ ** @param A system matrix.
+ ** @param b coefficients.
+ **
+ ** The function computes a solution to @f$ Ax =b @f$ for a 3x3
+ ** matrix.
+ **/
+
+VL_EXPORT int
+vl_solve_linear_system_3 (double * x, double const * A, double const *b)
+{
+  int err ;
+  double M[3*4] ;
+  M[0] = A[0] ;
+  M[1] = A[1] ;
+  M[2] = A[2] ;
+  M[3] = A[3] ;
+  M[4] = A[4] ;
+  M[5] = A[5] ;
+  M[6] = A[6] ;
+  M[7] = A[7] ;
+  M[8] = A[8] ;
+  M[9] = b[0] ;
+  M[10] = b[1] ;
+  M[11] = b[2] ;
+  err = vl_gaussian_elimination(M,3,4) ;
+  x[0] = M[9] ;
+  x[1] = M[10] ;
+  x[2] = M[11] ;
+  return err ;
+}
+
+/** @brief Solve a 2x2 linear system
+ ** @param x result.
+ ** @param A system matrix.
+ ** @param b coefficients.
+ **
+ ** The function computes a solution to @f$ Ax =b @f$ for a 2x2
+ ** matrix.
+ **/
+
+VL_EXPORT int
+vl_solve_linear_system_2 (double * x, double const * A, double const *b)
+{
+  int err ;
+  double M[2*3] ;
+  M[0] = A[0] ;
+  M[1] = A[1] ;
+  M[2] = A[2] ;
+  M[3] = A[3] ;
+  M[4] = b[0];
+  M[5] = b[1] ;
+  err = vl_gaussian_elimination(M,2,3) ;
+  x[0] = M[4] ;
+  x[1] = M[5] ;
+  return err ;
+}
+
+/** @brief Gaussian elimination
+ ** @param M matrix.
+ ** @param numRows number of rows of @c M.
+ ** @param numColumns number of columns of @c M.
+ **
+ ** The function runs Gaussian elimination with pivoting
+ ** on the matrix @a M in place.
+ ** @c numRows must be not larger than @c numColumns.
+ **
+ ** Let @f$ M = [A, b] @f$ to obtain the solution to the linear
+ ** system @f$ Ax=b @f$ (as the last column of @c M after
+ ** elimination).
+ **
+ ** Let @f$ M = [A, I] @f$ to compute the inverse of @c A in
+ ** a similar manner.
+ **/
+
+VL_EXPORT vl_bool
+vl_gaussian_elimination (double * A, vl_size numRows, vl_size numColumns)
+{
+  vl_index i, j, ii, jj ;
+  assert(A) ;
+  assert(numRows <= numColumns) ;
+
+#define Aat(i,j) A[(i) + (j)*numRows]
+
+  /* Gauss elimination */
+  for(j = 0 ; j < (signed)numRows ; ++j) {
+    double maxa = 0 ;
+    double maxabsa = 0 ;
+    vl_index maxi = -1 ;
+    double tmp ;
+
+#if 0
+    {
+      vl_index iii, jjj ;
+      for (iii = 0 ; iii < 2 ; ++iii) {
+        for (jjj = 0 ; jjj < 3 ; ++jjj) {
+          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
+
+        }
+        VL_PRINTF("\n") ;
+      }
+      VL_PRINTF("\n") ;
+    }
+#endif
+
+    /* look for the maximally stable pivot */
+    for (i = j ; i < (signed)numRows ; ++i) {
+      double a = Aat(i,j) ;
+      double absa = vl_abs_d (a) ;
+      if (absa > maxabsa) {
+        maxa = a ;
+        maxabsa = absa ;
+        maxi = i ;
+      }
+    }
+    i = maxi ;
+
+    /* if singular give up */
+    if (maxabsa < 1e-10) return VL_ERR_OVERFLOW ;
+
+    /* swap j-th row with i-th row and normalize j-th row */
+    for(jj = j ; jj < (signed)numColumns ; ++jj) {
+      tmp = Aat(i,jj) ; Aat(i,jj) = Aat(j,jj) ; Aat(j,jj) = tmp ;
+      Aat(j,jj) /= maxa ;
+    }
+
+#if 0
+    {
+      vl_index iii, jjj ;
+      VL_PRINTF("after swap %d %d\n", j, i);
+      for (iii = 0 ; iii < 2 ; ++iii) {
+        for (jjj = 0 ; jjj < 3 ; ++jjj) {
+          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
+
+        }
+        VL_PRINTF("\n") ;
+      }
+      VL_PRINTF("\n") ;
+    }
+#endif
+
+    /* elimination */
+    for (ii = j+1 ; ii < (signed)numRows ; ++ii) {
+      double x = Aat(ii,j) ;
+      for (jj = j ; jj < (signed)numColumns ; ++jj) {
+        Aat(ii,jj) -= x * Aat(j,jj) ;
+      }
+    }
+
+#if 0
+    {
+      VL_PRINTF("after elimination\n");
+
+      vl_index iii, jjj ;
+      for (iii = 0 ; iii < 2 ; ++iii) {
+        for (jjj = 0 ; jjj < 3 ; ++jjj) {
+          VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
+
+        }
+        VL_PRINTF("\n") ;
+      }
+      VL_PRINTF("\n") ;
+    }
+#endif
+
+  }
+
+  /* backward substitution */
+  for (i = numRows - 1 ; i > 0 ; --i) {
+    /* substitute in all rows above */
+    for (ii = i - 1 ; ii >= 0 ; --ii) {
+      double x = Aat(ii,i) ;
+      /* j = numRows */
+      for (j = numRows ; j < (signed)numColumns ; ++j) {
+        Aat(ii,j) -= x * Aat(i,j) ;
+      }
+    }
+  }
+
+#if 0
+  {
+    VL_PRINTF("after substitution\n");
+
+    vl_index iii, jjj ;
+    for (iii = 0 ; iii < 2 ; ++iii) {
+      for (jjj = 0 ; jjj < 3 ; ++jjj) {
+        VL_PRINTF("%5.2g ", Aat(iii,jjj)) ;
+
+      }
+      VL_PRINTF("\n") ;
+    }
+    VL_PRINTF("\n") ;
+  }
+#endif
+
+
+  return VL_ERR_OK ;
+}
+
+/* VL_MATHOP_INSTANTIATING */
+#endif
+
+#undef VL_MATHOP_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop.h b/opensfm/src/third_party/vlfeat/vl/mathop.h
new file mode 100644
index 000000000..6a1df8058
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop.h
@@ -0,0 +1,719 @@
+/** @file mathop.h
+ ** @brief Math operations (@ref mathop)
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_MATHOP_H
+#define VL_MATHOP_H
+
+#include "generic.h"
+#include <math.h>
+#include <float.h>
+
+/** @brief Euler constant*/
+#define VL_E 2.718281828459045
+
+/** @brief Logarithm of 2 (math constant)*/
+#define VL_LOG_OF_2 0.693147180559945
+
+/** @brief Pi (math constant) */
+#define VL_PI 3.141592653589793
+
+/** @brief IEEE single precision epsilon (math constant)
+ **
+ ** <code>1.0F + VL_EPSILON_F</code> is the smallest representable
+ ** single precision number greater than @c 1.0F. Numerically,
+ ** ::VL_EPSILON_F is equal to @f$ 2^{-23} @f$.
+ **
+ **/
+#define VL_EPSILON_F 1.19209290E-07F
+
+/** @brief IEEE double precision epsilon (math constant)
+ **
+ ** <code>1.0 + VL_EPSILON_D</code> is the smallest representable
+ ** double precision number greater than @c 1.0. Numerically,
+ ** ::VL_EPSILON_D is equal to @f$ 2^{-52} @f$.
+ **/
+#define VL_EPSILON_D 2.220446049250313e-16
+
+/*
+   For the code below: An ANSI C compiler takes the two expressions,
+   LONG_VAR and CHAR_VAR, and implicitly casts them to the type of the
+   first member of the union. Refer to K&R Second Edition Page 148,
+   last paragraph.
+*/
+
+/** @internal @brief IEEE single precision quiet NaN constant */
+static union { vl_uint32 raw ; float value ; }
+  const vl_nan_f =
+    { 0x7FC00000UL } ;
+
+/** @internal @brief IEEE single precision infinity constant */
+static union { vl_uint32 raw ; float value ; }
+  const vl_infinity_f =
+    { 0x7F800000UL } ;
+
+/** @internal @brief IEEE double precision quiet NaN constant */
+static union { vl_uint64 raw ; double value ; }
+  const vl_nan_d =
+#ifdef VL_COMPILER_MSC
+    { 0x7FF8000000000000ui64 } ;
+#else
+    { 0x7FF8000000000000ULL } ;
+#endif
+
+/** @internal @brief IEEE double precision infinity constant */
+static union { vl_uint64 raw ; double value ; }
+  const vl_infinity_d =
+#ifdef VL_COMPILER_MSC
+    { 0x7FF0000000000000ui64 } ;
+#else
+    { 0x7FF0000000000000ULL } ;
+#endif
+
+/** @brief IEEE single precision NaN (not signaling) */
+#define VL_NAN_F (vl_nan_f.value)
+
+/** @brief IEEE single precision positive infinity (not signaling) */
+#define VL_INFINITY_F (vl_infinity_f.value)
+
+/** @brief IEEE double precision NaN (not signaling) */
+#define VL_NAN_D (vl_nan_d.value)
+
+/** @brief IEEE double precision positive infinity (not signaling) */
+#define VL_INFINITY_D (vl_infinity_d.value)
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Fast <code>mod(x, 2 * VL_PI)</code>
+ **
+ ** @param x input value.
+ ** @return <code>mod(x, 2 * VL_PI)</code>
+ **
+ ** The function is optimized for small absolute values of @a x.
+ **
+ ** The result is guaranteed to be not smaller than 0. However, due to
+ ** finite numerical precision and rounding errors, the result can be
+ ** equal to 2 * VL_PI (for instance, if @c x is a very small negative
+ ** number).
+ **/
+
+VL_INLINE float
+vl_mod_2pi_f (float x)
+{
+  while (x > (float)(2 * VL_PI)) x -= (float) (2 * VL_PI) ;
+  while (x < 0.0F) x += (float) (2 * VL_PI);
+  return x ;
+}
+
+/** @brief Fast <code>mod(x, 2 * VL_PI)</code>
+ ** @see vl_mod_2pi_f
+ **/
+
+VL_INLINE double
+vl_mod_2pi_d (double x)
+{
+  while (x > 2.0 * VL_PI) x -= 2 * VL_PI ;
+  while (x < 0.0) x += 2 * VL_PI ;
+  return x ;
+}
+
+/** @brief Floor and convert to integer
+ ** @param x argument.
+ ** @return Similar to @c (int) floor(x)
+ **/
+
+VL_INLINE long int
+vl_floor_f (float x)
+{
+  long int xi = (long int) x ;
+  if (x >= 0 || (float) xi == x) return xi ;
+  else return xi - 1 ;
+}
+
+/** @brief Floor and convert to integer
+ ** @see vl_floor_f
+ **/
+
+VL_INLINE long int
+vl_floor_d (double x)
+{
+  long int xi = (long int) x ;
+  if (x >= 0 || (double) xi == x) return xi ;
+  else return xi - 1 ;
+}
+
+/** @brief Ceil and convert to integer
+ ** @param x argument.
+ ** @return @c lceilf(x)
+ **/
+
+VL_INLINE long int
+vl_ceil_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return (long int) __builtin_ceilf(x) ;
+#else
+  return (long int) ceilf(x) ;
+#endif
+}
+
+/** @brief Ceil and convert to integer
+ ** @see vl_ceil_f
+ **/
+
+VL_INLINE long int
+vl_ceil_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_ceil(x) ;
+#else
+  return (long int) ceil(x) ;
+#endif
+}
+
+/** @brief Round
+ ** @param x argument.
+ ** @return @c lroundf(x)
+ ** This function is either the same or similar to C99 @c lroundf().
+ **/
+
+VL_INLINE long int
+vl_round_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_lroundf(x) ;
+#elif VL_COMPILER_MSC
+  if (x >= 0.0F) {
+    return vl_floor_f(x + 0.5F) ;
+  } else {
+    return vl_ceil_f(x - 0.5F) ;
+  }
+#else
+  return lroundf(x) ;
+#endif
+}
+
+/** @brief Round
+ ** @param x argument.
+ ** @return @c lround(x)
+ ** This function is either the same or similar to C99 @c lround().
+ **/
+
+VL_INLINE long int
+vl_round_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_lround(x) ;
+#elif VL_COMPILER_MSC
+  if (x >= 0.0) {
+    return vl_floor_d(x + 0.5) ;
+  } else {
+    return vl_ceil_d(x - 0.5) ;
+  }
+#else
+  return lround(x) ;
+#endif
+}
+
+/** @brief Fast @c abs(x)
+ ** @param x argument.
+ ** @return @c abs(x)
+ **/
+
+VL_INLINE float
+vl_abs_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_fabsf (x) ;
+#else
+  return fabsf(x) ;
+#endif
+}
+
+/** @brief Fast @c abs(x)
+ ** @sa vl_abs_f
+ **/
+
+VL_INLINE double
+vl_abs_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_fabs (x) ;
+#else
+  return fabs(x) ;
+#endif
+}
+
+/** @brief Base-2 logaritghm
+ ** @param x argument.
+ ** @return @c log(x).
+ **/
+
+VL_INLINE double
+vl_log2_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_log2(x) ;
+#elif VL_COMPILER_MSC
+  return log(x) / 0.693147180559945 ;
+#else
+  return log2(x) ;
+#endif
+}
+
+/** @copydoc vl_log2_d */
+VL_INLINE float
+vl_log2_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_log2f (x) ;
+#elif VL_COMPILER_MSC
+  return logf(x) / 0.6931472F ;
+#else
+  return log2(x) ;
+#endif
+}
+
+/** @brief Square root.
+ ** @param x argument.
+ ** @return @c sqrt(x).
+ **/
+
+VL_INLINE double
+vl_sqrt_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_sqrt(x) ;
+#else
+  return sqrt(x) ;
+#endif
+}
+
+/** @copydoc vl_sqrt_d */
+VL_INLINE float
+vl_sqrt_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_sqrtf(x) ;
+#else
+  return sqrtf(x) ;
+#endif
+}
+
+
+/** @brief Check whether a floating point value is NaN
+ ** @param x argument.
+ ** @return true if @a x is NaN.
+ **/
+VL_INLINE vl_bool
+vl_is_nan_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_isnan (x) ;
+#elif VL_COMPILER_MSC
+  return _isnan(x) ;
+#else
+  return isnan(x) ;
+#endif
+}
+
+/** @copydoc vl_is_nan_f */
+VL_INLINE vl_bool
+vl_is_nan_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_isnan (x) ;
+#elif VL_COMPILER_MSC
+  return _isnan(x) ;
+#else
+  return isnan(x) ;
+#endif
+}
+
+/** @brief Check whether a floating point value is infinity
+ ** @param x argument.
+ ** @return true if @a x is infinity.
+ **/
+VL_INLINE vl_bool
+vl_is_inf_f (float x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_isinf (x) ;
+#elif VL_COMPILER_MSC
+  return ! _finite(x) ;
+#else
+  return isinf(x) ;
+#endif
+}
+
+/** @copydoc vl_is_inf_f */
+VL_INLINE vl_bool
+vl_is_inf_d (double x)
+{
+#ifdef VL_COMPILER_GNUC
+  return __builtin_isinf (x) ;
+#elif VL_COMPILER_MSC
+  return ! _finite(x) ;
+#else
+  return isinf(x) ;
+#endif
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Fast @c atan2 approximation
+ ** @param y argument.
+ ** @param x argument.
+ **
+ ** The function computes a relatively rough but fast approximation of
+ ** @c atan2(y,x).
+ **
+ ** @par Algorithm
+ **
+ ** The algorithm approximates the function @f$ f(r)=atan((1-r)/(1+r))
+ ** @f$, @f$ r \in [-1,1] @f$ with a third order polynomial @f$
+ ** f(r)=c_0 + c_1 r + c_2 r^2 + c_3 r^3 @f$.  To fit the polynomial
+ ** we impose the constraints
+ **
+ ** @f{eqnarray*}
+ ** f(+1) &=& c_0 + c_1 + c_2 + c_3  = atan(0)       = 0,\\
+ ** f(-1) &=& c_0 - c_1 + c_2 - c_3  = atan(\infty)  = \pi/2,\\
+ ** f(0)  &=& c_0                    = atan(1)       = \pi/4.
+ ** @f}
+ **
+ ** The last degree of freedom is fixed by minimizing the @f$
+ ** l^{\infty} @f$ error, which yields
+ **
+ ** @f[
+ ** c_0=\pi/4, \quad
+ ** c_1=-0.9675, \quad
+ ** c_2=0, \quad
+ ** c_3=0.1821,
+ ** @f]
+ **
+ ** with maximum error of 0.0061 radians at 0.35 degrees.
+ **
+ ** @return Approximation of @c atan2(y,x).
+ **/
+
+VL_INLINE float
+vl_fast_atan2_f (float y, float x)
+{
+  float angle, r ;
+  float const c3 = 0.1821F ;
+  float const c1 = 0.9675F ;
+  float abs_y    = vl_abs_f (y) + VL_EPSILON_F ;
+
+  if (x >= 0) {
+    r = (x - abs_y) / (x + abs_y) ;
+    angle = (float) (VL_PI / 4) ;
+  } else {
+    r = (x + abs_y) / (abs_y - x) ;
+    angle = (float) (3 * VL_PI / 4) ;
+  }
+  angle += (c3*r*r - c1) * r ;
+  return (y < 0) ? - angle : angle ;
+}
+
+/** @brief Fast @c atan2 approximation
+ ** @sa vl_fast_atan2_f
+ **/
+
+VL_INLINE double
+vl_fast_atan2_d (double y, double x)
+{
+  double angle, r ;
+  double const c3 = 0.1821 ;
+  double const c1 = 0.9675 ;
+  double abs_y = vl_abs_d (y) + VL_EPSILON_D ;
+
+  if (x >= 0) {
+    r = (x - abs_y) / (x + abs_y) ;
+    angle = VL_PI / 4 ;
+  } else {
+    r = (x + abs_y) / (abs_y - x) ;
+    angle = 3 * VL_PI / 4 ;
+  }
+  angle += (c3*r*r - c1) * r ;
+  return (y < 0) ? - angle : angle ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Fast @c resqrt approximation
+ ** @param x argument.
+ ** @return approximation of @c resqrt(x).
+ **
+ ** The function quickly computes an approximation of @f$ x^{-1/2}
+ ** @f$.
+ **
+ ** @par Algorithm
+ **
+ ** The goal is to compute @f$ y = x^{-1/2} @f$, which we do by
+ ** finding the solution of @f$ 0 = f(y) = y^{-2} - x @f$ by two Newton
+ ** steps. Each Newton iteration is given by
+ **
+ ** @f[
+ **   y \leftarrow
+ **   y - \frac{f(y)}{\frac{df(y)}{dy}} =
+ **   y + \frac{1}{2} (y-xy^3) =
+ **   \frac{y}{2} \left( 3 - xy^2 \right)
+ ** @f]
+ **
+ ** which yields a simple polynomial update rule.
+ **
+ ** The clever bit (attributed to either J. Carmack or G. Tarolli) is
+ ** the way an initial guess @f$ y \approx x^{-1/2} @f$ is chosen.
+ **
+ ** @see <a href="http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf">Inverse Sqare Root</a>.
+ **
+ **/
+
+VL_INLINE float
+vl_fast_resqrt_f (float x)
+{
+  /* 32-bit version */
+  union {
+    float x ;
+    vl_int32  i ;
+  } u ;
+
+  float xhalf = (float) 0.5 * x ;
+
+  /* convert floating point value in RAW integer */
+  u.x = x ;
+
+  /* gives initial guess y0 */
+  u.i = 0x5f3759df - (u.i >> 1);
+  /*u.i = 0xdf59375f - (u.i>>1);*/
+
+  /* two Newton steps */
+  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
+  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
+  return u.x ;
+}
+
+/** @brief Fast @c resqrt approximation
+ ** @sa vl_fast_resqrt_d
+ **/
+
+VL_INLINE double
+vl_fast_resqrt_d (double x)
+{
+  /* 64-bit version */
+  union {
+    double x ;
+    vl_int64  i ;
+  } u ;
+
+  double xhalf = (double) 0.5 * x ;
+
+  /* convert floating point value in RAW integer */
+  u.x = x ;
+
+  /* gives initial guess y0 */
+#ifdef VL_COMPILER_MSC
+  u.i = 0x5fe6ec85e7de30dai64 - (u.i >> 1) ;
+#else
+  u.i = 0x5fe6ec85e7de30daLL - (u.i >> 1) ;
+#endif
+
+  /* two Newton steps */
+  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
+  u.x = u.x * ( (double) 1.5  - xhalf*u.x*u.x) ;
+  return u.x ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Fast @c sqrt approximation
+ ** @param x argument.
+ ** @return approximation of @c sqrt(x).
+ **
+ ** The function uses ::vl_fast_resqrt_f
+ ** (or ::vl_fast_resqrt_d) to compute <code>x *
+ ** vl_fast_resqrt_f(x)</code>.
+ **/
+
+VL_INLINE float
+vl_fast_sqrt_f (float x)
+{
+  return (x < 1e-8) ? 0 : x * vl_fast_resqrt_f (x) ;
+}
+
+/** @brief Fast @c sqrt approximation
+ ** @copydoc vl_fast_sqrt_f
+ **/
+
+VL_INLINE double
+vl_fast_sqrt_d (float x)
+{
+  return (x < 1e-8) ? 0 : x * vl_fast_resqrt_d (x) ;
+}
+
+/** @brief Fast integer @c sqrt approximation
+ ** @param x non-negative integer.
+ ** @return largest integer $y$ such that $y^2 \leq x$.
+ ** @sa @ref mathop-sqrti "Algorithm"
+ **/
+VL_INLINE vl_uint64 vl_fast_sqrt_ui64 (vl_uint64 x) ;
+
+/** @brief Fast @c sqrt approximation
+ ** @copydoc vl_fast_sqrt_ui64 */
+VL_INLINE vl_uint32 vl_fast_sqrt_ui32 (vl_uint32 x) ;
+
+/** @brief Fast @c sqrt approximation
+ ** @copydoc vl_fast_sqrt_ui64 */
+VL_INLINE vl_uint16 vl_fast_sqrt_ui16 (vl_uint16 x) ;
+
+/** @brief Fast @c sqrt approximation
+ ** @copydoc vl_fast_sqrt_ui64 */
+VL_INLINE vl_uint8  vl_fast_sqrt_ui8  (vl_uint8  x) ;
+
+#define VL_FAST_SQRT_UI(T,SFX)                                       \
+VL_INLINE T                                                          \
+vl_fast_sqrt_ ## SFX (T x)                                           \
+{                                                                    \
+  T y = 0 ;                                                          \
+  T tmp = 0 ;                                                        \
+  int twice_k ;                                                      \
+  for (twice_k = 8 * sizeof(T) - 2 ;                                 \
+       twice_k >= 0 ; twice_k -= 2) {                                \
+    y <<= 1 ; /* y = 2 * y */                                        \
+    tmp = (2*y + 1) << twice_k ;                                     \
+    if (x >= tmp) {                                                  \
+      x -= tmp ;                                                     \
+      y += 1 ;                                                       \
+    }                                                                \
+  }                                                                  \
+  return y ;                                                         \
+}
+
+VL_FAST_SQRT_UI(vl_uint64,ui64)
+VL_FAST_SQRT_UI(vl_uint32,ui32)
+VL_FAST_SQRT_UI(vl_uint16,ui16)
+VL_FAST_SQRT_UI(vl_uint8,ui8)
+
+/* ---------------------------------------------------------------- */
+/*                                Vector distances and similarities */
+/* ---------------------------------------------------------------- */
+
+/** @typedef VlFloatVectorComparisonFunction
+ ** @brief Pointer to a function to compare vectors of floats
+ **/
+typedef float (*VlFloatVectorComparisonFunction)(vl_size dimension, float const * X, float const * Y) ;
+
+/** @typedef VlDoubleVectorComparisonFunction
+ ** @brief Pointer to a function to compare vectors of doubles
+ **/
+typedef double (*VlDoubleVectorComparisonFunction)(vl_size dimension, double const * X, double const * Y) ;
+
+/** @typedef VlFloatVector3ComparisonFunction
+ ** @brief Pointer to a function to compare 3 vectors of doubles
+ **/
+typedef float (*VlFloatVector3ComparisonFunction)(vl_size dimension, float const * X, float const * Y, float const * Z) ;
+
+/** @typedef VlDoubleVector3ComparisonFunction
+ ** @brief Pointer to a function to compare 3 vectors of doubles
+ **/
+typedef double (*VlDoubleVector3ComparisonFunction)(vl_size dimension, double const * X, double const * Y, double const * Z) ;
+
+/** @brief Vector comparison types */
+enum _VlVectorComparisonType {
+  VlDistanceL1,        /**< l1 distance (squared intersection metric) */
+  VlDistanceL2,        /**< squared l2 distance */
+  VlDistanceChi2,      /**< squared Chi2 distance */
+  VlDistanceHellinger, /**< squared Hellinger's distance */
+  VlDistanceJS,        /**< squared Jensen-Shannon distance */
+  VlDistanceMahalanobis,     /**< squared mahalanobis distance */
+  VlKernelL1,          /**< intersection kernel */
+  VlKernelL2,          /**< l2 kernel */
+  VlKernelChi2,        /**< Chi2 kernel */
+  VlKernelHellinger,   /**< Hellinger's kernel */
+  VlKernelJS           /**< Jensen-Shannon kernel */
+} ;
+
+/** @brief Vector comparison types */
+typedef enum _VlVectorComparisonType VlVectorComparisonType ;
+
+/** @brief Get the symbolic name of a vector comparison type
+ ** @param type vector comparison type.
+ ** @return data symbolic name.
+ **/
+
+VL_INLINE char const *
+vl_get_vector_comparison_type_name (int type)
+{
+  switch (type) {
+    case VlDistanceL1   : return "l1" ;
+    case VlDistanceL2   : return "l2" ;
+    case VlDistanceChi2 : return "chi2" ;
+    case VlDistanceMahalanobis  : return "mahalanobis" ;
+    case VlKernelL1     : return "kl1" ;
+    case VlKernelL2     : return "kl2" ;
+    case VlKernelChi2   : return "kchi2" ;
+    default: return NULL ;
+  }
+}
+
+VL_EXPORT VlFloatVectorComparisonFunction
+vl_get_vector_comparison_function_f (VlVectorComparisonType type) ;
+
+VL_EXPORT VlDoubleVectorComparisonFunction
+vl_get_vector_comparison_function_d (VlVectorComparisonType type) ;
+
+VL_EXPORT VlFloatVector3ComparisonFunction
+vl_get_vector_3_comparison_function_f (VlVectorComparisonType type) ;
+
+VL_EXPORT VlDoubleVector3ComparisonFunction
+vl_get_vector_3_comparison_function_d (VlVectorComparisonType type) ;
+
+
+VL_EXPORT void
+vl_eval_vector_comparison_on_all_pairs_f (float * result, vl_size dimension,
+                                          float const * X, vl_size numDataX,
+                                          float const * Y, vl_size numDataY,
+                                          VlFloatVectorComparisonFunction function) ;
+
+VL_EXPORT void
+vl_eval_vector_comparison_on_all_pairs_d (double * result, vl_size dimension,
+                                          double const * X, vl_size numDataX,
+                                          double const * Y, vl_size numDataY,
+                                          VlDoubleVectorComparisonFunction function) ;
+
+/* ---------------------------------------------------------------- */
+/*                                               Numerical analysis */
+/* ---------------------------------------------------------------- */
+
+VL_EXPORT void
+vl_svd2 (double* S, double *U, double *V, double const *M) ;
+
+VL_EXPORT void
+vl_lapack_dlasv2 (double *smin,
+                  double *smax,
+                  double *sv,
+                  double *cv,
+                  double *su,
+                  double *cu,
+                  double f,
+                  double g,
+                  double h) ;
+
+
+VL_EXPORT int
+vl_solve_linear_system_3 (double * x, double const * A, double const *b) ;
+
+VL_EXPORT int
+vl_solve_linear_system_2 (double * x, double const * A, double const *b) ;
+
+VL_EXPORT int
+vl_gaussian_elimination (double * A, vl_size numRows, vl_size numColumns) ;
+
+/* VL_MATHOP_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_avx.c b/opensfm/src/third_party/vlfeat/vl/mathop_avx.c
new file mode 100644
index 000000000..03dba22d8
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop_avx.c
@@ -0,0 +1,275 @@
+/** @file mathop_avx.c
+ ** @brief mathop for AVX - Definition
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/* ---------------------------------------------------------------- */
+#if ! defined(VL_MATHOP_AVX_INSTANTIATING)
+
+#include "mathop_avx.h"
+
+#undef FLT
+#define FLT VL_TYPE_DOUBLE
+#define VL_MATHOP_AVX_INSTANTIATING
+#include "mathop_avx.c"
+
+#undef FLT
+#define FLT VL_TYPE_FLOAT
+#define VL_MATHOP_AVX_INSTANTIATING
+#include "mathop_avx.c"
+
+/* ---------------------------------------------------------------- */
+/* VL_MATHOP_AVX_INSTANTIATING */
+#else
+#ifndef VL_DISABLE_AVX
+
+#ifndef __AVX__
+#error Compiling AVX functions but AVX does not seem to be supported by the compiler.
+#endif
+
+#include <immintrin.h>
+#include "generic.h"
+#include "mathop.h"
+#include "float.h"
+
+VL_INLINE T
+VL_XCAT(_vl_vhsum_avx_, SFX)(VTYPEavx x)
+{
+  T acc ;
+#if (VSIZEavx == 8)
+  {
+    //VTYPEavx hsum = _mm256_hadd_ps(x, x);
+    //hsum = _mm256_add_ps(hsum, _mm256_permute2f128_ps(hsum, hsum, 0x1));
+    //_mm_store_ss(&acc, _mm_hadd_ps( _mm256_castps256_ps128(hsum), _mm256_castps256_ps128(hsum) ) );
+    VTYPEavx hsum = VHADD2avx(x, x);
+    hsum = VADDavx(hsum, VPERMavx(hsum, hsum, 0x1));
+    VST1(&acc, VHADDavx( VCSTavx(hsum), VCSTavx(hsum) ) );
+  }
+#else
+  {
+    //VTYPEavx hsum = _mm256_add_pd(x, _mm256_permute2f128_pd(x, x, 0x1));
+    VTYPEavx hsum = VADDavx(x, VPERMavx(x, x, 0x1));
+
+    //_mm_store_sd(&acc, _mm_hadd_pd( _mm256_castpd256_pd128(hsum), _mm256_castpd256_pd128(hsum) ) );
+    VST1(&acc, VHADDavx( VCSTavx(hsum), VCSTavx(hsum) ) );
+  }
+#endif
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l2_avx_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZEavx + 1 ;
+  T acc ;
+  VTYPEavx vacc = VSTZavx() ;
+  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPEavx a = *(VTYPEavx*)X ;
+      VTYPEavx b = *(VTYPEavx*)Y ;
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      vacc = VADDavx(vacc, delta2) ;
+      X += VSIZEavx ;
+      Y += VSIZEavx ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPEavx a = VLDUavx(X) ;
+      VTYPEavx b = VLDUavx(Y) ;
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      vacc = VADDavx(vacc, delta2) ;
+      X += VSIZEavx ;
+      Y += VSIZEavx ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_avx_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    acc += delta * delta ;
+  }
+
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX)
+(vl_size dimension, T const * X, T const * MU, T const * S)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZEavx + 1 ;
+  T acc ;
+  VTYPEavx vacc = VSTZavx() ;
+  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(MU) & VALIGNEDavx(S);
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPEavx a = *(VTYPEavx*)X ;
+      VTYPEavx b = *(VTYPEavx*)MU ;
+      VTYPEavx c = *(VTYPEavx*)S ;
+
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      VTYPEavx delta2div = VMULavx(delta2,c);
+
+      vacc = VADDavx(vacc, delta2div) ;
+
+      X  += VSIZEavx ;
+      MU += VSIZEavx ;
+      S  += VSIZEavx ;
+    }
+  } else {
+    while (X < X_vec_end) {
+
+      VTYPEavx a = VLDUavx(X) ;
+      VTYPEavx b = VLDUavx(MU) ;
+      VTYPEavx c = VLDUavx(S) ;
+
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      VTYPEavx delta2div = VMULavx(delta2,c);
+
+      vacc = VADDavx(vacc, delta2div) ;
+
+      X  += VSIZEavx ;
+      MU += VSIZEavx ;
+      S  += VSIZEavx ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_avx_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *MU++ ;
+    T c = *S++ ;
+    T delta = a - b ;
+    acc += (delta * delta) * c;
+  }
+
+  return acc ;
+}
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_mean_avx_, SFX)
+(vl_size dimension, T * MU, T const * X, T const  W)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZEavx + 1 ;
+
+  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(MU);
+  VTYPEavx w = VLD1avx (&W) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPEavx a = *(VTYPEavx*)X ;
+      VTYPEavx mu = *(VTYPEavx*)MU ;
+
+      VTYPEavx aw = VMULavx(a, w) ;
+      VTYPEavx meanStore = VADDavx(aw, mu);
+
+      *(VTYPEavx *)MU = meanStore;
+
+      X += VSIZEavx ;
+      MU += VSIZEavx ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPEavx a  = VLDUavx(X) ;
+      VTYPEavx mu = VLDUavx(MU) ;
+
+      VTYPEavx aw = VMULavx(a, w) ;
+      VTYPEavx meanStore = VADDavx(aw, mu);
+
+      VST2Uavx(MU,meanStore);
+
+      X += VSIZEavx ;
+      MU += VSIZEavx ;
+    }
+  }
+
+  while (X < X_end) {
+    T a = *X++ ;
+    *MU += a * W ;
+    MU++;
+  }
+}
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_sigma_avx_, SFX)
+(vl_size dimension, T * S, T const * X, T const * Y, T const W)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZEavx + 1 ;
+
+  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) & VALIGNEDavx(S);
+
+  VTYPEavx w = VLD1avx (&W) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPEavx a = *(VTYPEavx*)X ;
+      VTYPEavx b = *(VTYPEavx*)Y ;
+      VTYPEavx s = *(VTYPEavx*)S ;
+
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      VTYPEavx delta2w = VMULavx(delta2, w) ;
+      VTYPEavx sigmaStore = VADDavx(s,delta2w);
+
+      *(VTYPEavx *)S = sigmaStore;
+
+      X += VSIZEavx ;
+      Y += VSIZEavx ;
+      S += VSIZEavx ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPEavx a = VLDUavx(X) ;
+      VTYPEavx b = VLDUavx(Y) ;
+      VTYPEavx s = VLDUavx(S) ;
+
+      VTYPEavx delta = VSUBavx(a, b) ;
+      VTYPEavx delta2 = VMULavx(delta, delta) ;
+      VTYPEavx delta2w = VMULavx(delta2, w) ;
+      VTYPEavx sigmaStore = VADDavx(s,delta2w);
+
+      VST2Uavx(S,sigmaStore);
+
+      X += VSIZEavx ;
+      Y += VSIZEavx ;
+      S += VSIZEavx ;
+    }
+  }
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    *S += ((delta * delta)*W) ;
+    S++;
+  }
+}
+
+/* VL_DISABLE_AVX */
+#endif
+#undef VL_MATHOP_AVX_INSTANTIATING
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_avx.h b/opensfm/src/third_party/vlfeat/vl/mathop_avx.h
new file mode 100644
index 000000000..2acebf0fd
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop_avx.h
@@ -0,0 +1,61 @@
+/** @file mathop_avx.h
+ ** @brief mathop for avx
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_MATHOP_AVX_H_INSTANTIATING
+
+#ifndef VL_MATHOP_AVX_H
+#define VL_MATHOP_AVX_H
+
+#undef FLT
+#define FLT VL_TYPE_DOUBLE
+#define VL_MATHOP_AVX_H_INSTANTIATING
+#include "mathop_avx.h"
+
+#undef FLT
+#define FLT VL_TYPE_FLOAT
+#define VL_MATHOP_AVX_H_INSTANTIATING
+#include "mathop_avx.h"
+
+/* VL_MATHOP_AVX_H */
+#endif
+
+/* ---------------------------------------------------------------- */
+/* VL_MATHOP_AVX_H_INSTANTIATING */
+#else
+
+#ifndef VL_DISABLE_AVX
+#include "generic.h"
+#include "float.h"
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_mahalanobis_sq_avx_, SFX)
+(vl_size dimension, T const * X, T const * MU, T const * S);
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l2_avx_, SFX)
+(vl_size dimension, T const * X, T const * Y);
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_sigma_avx_, SFX)
+(vl_size dimension, T * S, T const * X, T const * Y, T const W);
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_mean_avx_, SFX)
+(vl_size dimension, T * MU, T const * X, T const W);
+
+/* ! VL_DISABLE_AVX */
+#endif
+
+#undef VL_MATHOP_AVX_H_INSTANTIATING
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
new file mode 100644
index 000000000..dd98a5bea
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.c
@@ -0,0 +1,564 @@
+/** @file mathop_sse2.c
+ ** @brief mathop for SSE2 - Definition
+ ** @author Andrea Vedaldi, David Novotny
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_MATHOP_SSE2_INSTANTIATING
+
+#include "mathop_sse2.h"
+
+#undef FLT
+#define FLT VL_TYPE_DOUBLE
+#define VL_MATHOP_SSE2_INSTANTIATING
+#include "mathop_sse2.c"
+
+#undef FLT
+#define FLT VL_TYPE_FLOAT
+#define VL_MATHOP_SSE2_INSTANTIATING
+#include "mathop_sse2.c"
+
+/* ---------------------------------------------------------------- */
+/* VL_MATHOP_SSE2_INSTANTIATING */
+#else
+#ifndef VL_DISABLE_SSE2
+
+#ifndef __SSE2__
+#error Compiling SSE2 functions but SSE2 does not to be supported by the compiler.
+#endif
+
+#include <emmintrin.h>
+#include "mathop.h"
+#include "generic.h"
+#include "float.h"
+
+VL_INLINE T
+VL_XCAT(_vl_vhsum_sse2_, SFX)(VTYPE x)
+{
+  T acc ;
+#if (VSIZE == 4)
+  {
+    VTYPE sum ;
+    VTYPE shuffle ;
+    /* shuffle = [1 0 3 2] */
+    /* sum     = [3+1 2+0 1+3 0+2] */
+    /* shuffle = [2+0 3+1 0+2 1+3] */
+    /* vacc    = [3+1+2+0 3+1+2+0 1+3+0+2 0+2+1+3] */
+    shuffle = VSHU (x, x, _MM_SHUFFLE(1, 0, 3, 2)) ;
+    sum     = VADD (x, shuffle) ;
+    shuffle = VSHU (sum, sum, _MM_SHUFFLE(2, 3, 0, 1)) ;
+    x       = VADD (sum, shuffle) ;
+  }
+#else
+  {
+    VTYPE shuffle ;
+    /* acc     = [1   0  ] */
+    /* shuffle = [0   1  ] */
+    /* sum     = [1+0 0+1] */
+    shuffle = VSHU (x, x, _MM_SHUFFLE2(0, 1)) ;
+    x       = VADD (x, shuffle) ;
+  }
+#endif
+  VST1(&acc, x);
+  return acc ;
+}
+
+
+
+VL_EXPORT T
+VL_XCAT(_vl_dot_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE d = VMUL(a, b) ;
+      vacc = VADD(vacc, d) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE d = VMUL(a, b) ;
+      vacc = VADD(vacc, d) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    acc += a * b ;
+  }
+
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      vacc = VADD(vacc, delta2) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      vacc = VADD(vacc, delta2) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    acc += delta * delta ;
+  }
+
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX)
+(vl_size dimension, T const * X, T const * MU, T const * S)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(MU) & VALIGNED(S);
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)MU ;
+      VTYPE c = *(VTYPE*)S ;
+
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      VTYPE delta2div = VMUL(delta2,c);
+
+      vacc = VADD(vacc, delta2div) ;
+
+      X  += VSIZE ;
+      MU += VSIZE ;
+      S  += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(MU) ;
+      VTYPE c = VLDU(S) ;
+
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      VTYPE delta2div = VMUL(delta2,c);
+
+      vacc = VADD(vacc, delta2div) ;
+
+      X  += VSIZE ;
+      MU += VSIZE ;
+      S  += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *MU++ ;
+    T c = *S++ ;
+    T delta = a - b ;
+    acc += (delta * delta) * c;
+  }
+
+  return acc ;
+}
+
+
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l1_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X + dimension - VSIZE ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ; /* sign bit */
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE delta = VSUB(a, b) ;
+      vacc = VADD(vacc, VANDN(vminus, delta)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE delta = VSUB(a, b) ;
+      vacc = VADD(vacc, VANDN(vminus, delta)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    acc += VL_MAX(delta, - delta) ;
+  }
+
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_chi2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X + dimension - VSIZE ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE denom = VADD(a, b) ;
+      VTYPE numer = VMUL(delta, delta) ;
+      VTYPE ratio = VDIV(numer, denom) ;
+      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
+      vacc = VADD(vacc, ratio) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE denom = VADD(a, b) ;
+      VTYPE numer = VMUL(delta, delta) ;
+      VTYPE ratio = VDIV(numer, denom) ;
+      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
+      vacc = VADD(vacc, ratio) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    T denom = a + b ;
+    T numer = delta * delta ;
+    if (denom) {
+      T ratio = numer / denom ;
+      acc += ratio ;
+    }
+  }
+  return acc ;
+}
+
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      vacc = VADD(vacc, VMUL(a,b)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      vacc = VADD(vacc, VMUL(a,b)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    acc += a * b ;
+  }
+  return acc ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l1_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE a_ = VANDN(vminus, a) ;
+      VTYPE b_ = VANDN(vminus, b) ;
+      VTYPE sum = VADD(a_,b_) ;
+      VTYPE diff = VSUB(a, b) ;
+      VTYPE diff_ = VANDN(vminus, diff) ;
+      vacc = VADD(vacc, VSUB(sum, diff_)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE a_ = VANDN(vminus, a) ;
+      VTYPE b_ = VANDN(vminus, b) ;
+      VTYPE sum = VADD(a_,b_) ;
+      VTYPE diff = VSUB(a, b) ;
+      VTYPE diff_ = VANDN(vminus, diff) ;
+      vacc = VADD(vacc, VSUB(sum, diff_)) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
+    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
+    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
+  }
+
+  return acc / ((T)2) ;
+}
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_chi2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X + dimension - VSIZE ;
+  T acc ;
+  VTYPE vacc = VSTZ() ;
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE denom = VADD(a, b) ;
+      VTYPE numer = VMUL(a,b) ;
+      VTYPE ratio = VDIV(numer, denom) ;
+      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
+      vacc = VADD(vacc, ratio) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE denom = VADD(a, b) ;
+      VTYPE numer = VMUL(a,b) ;
+      VTYPE ratio = VDIV(numer, denom) ;
+      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
+      vacc = VADD(vacc, ratio) ;
+      X += VSIZE ;
+      Y += VSIZE ;
+    }
+  }
+
+  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T denom = a + b ;
+    if (denom) {
+      T ratio = a * b / denom ;
+      acc += ratio ;
+    }
+  }
+  return ((T)2) * acc ;
+}
+//
+VL_EXPORT void
+VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
+(vl_size dimension, T * S, T const * X, T const * Y, T const W)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) & VALIGNED(S);
+
+  VTYPE w = VLD1 (&W) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE b = *(VTYPE*)Y ;
+      VTYPE s = *(VTYPE*)S ;
+
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      VTYPE delta2w = VMUL(delta2, w) ;
+      VTYPE sigmaStore = VADD(s,delta2w);
+
+      *(VTYPE *)S = sigmaStore;
+
+      X += VSIZE ;
+      Y += VSIZE ;
+      S += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a = VLDU(X) ;
+      VTYPE b = VLDU(Y) ;
+      VTYPE s = VLDU(S) ;
+
+      VTYPE delta = VSUB(a, b) ;
+      VTYPE delta2 = VMUL(delta, delta) ;
+      VTYPE delta2w = VMUL(delta2, w) ;
+      VTYPE sigmaStore = VADD(s,delta2w);
+
+      VST2U(S,sigmaStore);
+
+      X += VSIZE ;
+      Y += VSIZE ;
+      S += VSIZE ;
+    }
+  }
+
+
+  while (X < X_end) {
+    T a = *X++ ;
+    T b = *Y++ ;
+    T delta = a - b ;
+    *S += ((delta * delta)*W) ;
+    S++;
+  }
+}
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_mean_sse2_, SFX)
+(vl_size dimension, T * MU, T const * X, T const W)
+{
+  T const * X_end = X + dimension ;
+  T const * X_vec_end = X_end - VSIZE + 1 ;
+
+  vl_bool dataAligned = VALIGNED(X) & VALIGNED(MU);
+  VTYPE w = VLD1 (&W) ;
+
+  if (dataAligned) {
+    while (X < X_vec_end) {
+      VTYPE a = *(VTYPE*)X ;
+      VTYPE mu = *(VTYPE*)MU ;
+
+      VTYPE aw = VMUL(a, w) ;
+      VTYPE meanStore = VADD(aw, mu);
+
+      *(VTYPE *)MU = meanStore;
+
+      X += VSIZE ;
+      MU += VSIZE ;
+    }
+  } else {
+    while (X < X_vec_end) {
+      VTYPE a  = VLDU(X) ;
+      VTYPE mu = VLDU(MU) ;
+
+      VTYPE aw = VMUL(a, w) ;
+      VTYPE meanStore = VADD(aw, mu);
+
+      VST2U(MU,meanStore);
+
+      X += VSIZE ;
+      MU += VSIZE ;
+    }
+  }
+
+  while (X < X_end) {
+    T a = *X++ ;
+    *MU += a * W ;
+    MU++;
+  }
+}
+
+/* VL_DISABLE_SSE2 */
+#endif
+#undef VL_MATHOP_SSE2_INSTANTIATING
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
new file mode 100644
index 000000000..553cea12f
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mathop_sse2.h
@@ -0,0 +1,85 @@
+/** @file mathop_sse2.h
+ ** @brief mathop for sse2
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_MATHOP_SSE2_H_INSTANTIATING
+
+#ifndef VL_MATHOP_SSE2_H
+#define VL_MATHOP_SSE2_H
+
+#undef FLT
+#define FLT VL_TYPE_DOUBLE
+#define VL_MATHOP_SSE2_H_INSTANTIATING
+#include "mathop_sse2.h"
+
+#undef FLT
+#define FLT VL_TYPE_FLOAT
+#define VL_MATHOP_SSE2_H_INSTANTIATING
+#include "mathop_sse2.h"
+
+/* VL_MATHOP_SSE2_H */
+#endif
+
+/* ---------------------------------------------------------------- */
+/* VL_MATHOP_SSE2_H_INSTANTIATING */
+#else
+
+#ifndef VL_DISABLE_SSE2
+
+#include "generic.h"
+#include "float.h"
+
+VL_EXPORT T
+VL_XCAT(_vl_dot_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_l1_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_chi2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_l1_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_kernel_chi2_sse2_, SFX)
+(vl_size dimension, T const * X, T const * Y) ;
+
+VL_EXPORT T
+VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX)
+(vl_size dimension, T const * X, T const * MU, T const * S);
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
+(vl_size dimension, T * S, T const * X, T const * Y, T const W);
+
+VL_EXPORT void
+VL_XCAT(_vl_weighted_mean_sse2_, SFX)
+(vl_size dimension, T * MU, T const * X, T const W);
+
+/* ! VL_DISABLE_SSE2 */
+#endif
+#undef VL_MATHOP_SSE2_INSTANTIATING
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/mser.c b/opensfm/src/third_party/vlfeat/vl/mser.c
new file mode 100644
index 000000000..e6e879e50
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mser.c
@@ -0,0 +1,1001 @@
+/** @file mser.c
+ ** @brief MSER - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page mser Maximally Stable Extremal Regions (MSER)
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref mser.h implements the *Maximally Stable Extremal Regions* (MSER)
+local feature detector of @cite{matas03robust}. This detector extracts
+as features the the connected components of the level sets of the
+input intensity image. Among all such regions, the ones that are
+locally maximally stable are selected. MSERs are affine co-variant, as
+well as largely co-variant to generic diffeomorphic transformations.
+
+See @ref mser-starting for an introduction on how to use the detector
+from the C API. For further details refer to:
+
+- @subpage mser-fundamentals - MSER definition and parameters.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section mser-starting Getting started with the MSER detector
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Running the MSER filter usually involves the following steps:
+
+- Initialize the MSER filter by ::vl_mser_new(). The
+  filter can be reused for images of the same size.
+- Compute the MSERs by ::vl_mser_process().
+- Optionally fit ellipsoids to the MSERs by  ::vl_mser_ell_fit().
+- Retrieve the results by ::vl_mser_get_regions() (and optionally ::vl_mser_get_ell()).
+- Optionally retrieve filter statistics by ::vl_mser_get_stats().
+- Delete the MSER filter by ::vl_mser_delete().
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page mser-fundamentals MSER fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The *extermal regions* of an image are the connected components of the
+level sets $S_l = \{ x : I(x) \leq l \}, l \in \real$ of the image
+$I(x)$. Consider a discretization of the intensity levels $l$
+consisting of $M$ samples $\mathcal{L}=\{0,\dots,M-1\}$. The extremal
+regions $R_l \subset S_l$ of the level sets $S_l, l \in \mathcal{L}$
+can be arranged in a tree, where a region $R_l$ is a children of a
+region $R_{l+1}$ if $R_l \subset R_{l+1}$. The following figures shows
+a 1D example where the regions are denoted by dark thick lines:
+
+@image html mser-tree.png "Connected components of the image level sets arranged in a tree."
+
+Note that, depending on the image, regions at different levels can be
+identical as sets:
+
+@image html mser-er-step.png "Connected components when the image contains step changes."
+
+A *stable extremal region* is an extremal region that does not change
+much as the index $l$ is varied. Here we use a criterion which is
+similar but not identical to the original paper. This definition is
+somewhat simpler both to understand and code.
+
+Let $B(R_l)=(R_l,R_{l+1},\dots,R_{l+\Delta})$ be the branch of the
+tree $R_l \subset R_{l+1} \subset \dots \subset R_{l + \Delta}$
+rooted at $R_l$. We associate to the branch the (in)stability score
+
+@f[
+  v(R_l) = \frac{|R_{l+\Delta} - R_l|}{|R_l|}.
+@f]
+
+This score is a relative measure of how much $R_l$ changes as the
+index is increased from $l$ to $l+\Delta$, as illustrated in the
+following figure.
+
+@image html mser-er.png "Stability is measured by looking at how much a region changes with the intensity level."
+
+The score is low if the regions along the branch have similar area
+(and thus similar shape). We aim to select maximally stable
+branches; then a maximally stable region is just a representative
+region selected from a maximally stable branch (for simplicity we
+select $R_l$, but one could choose for example
+$R_{l+\Delta/2}$).
+
+Roughly speaking, a branch is maximally stable if it is a local
+minimum of the (in)stability score. More accurately, we start by
+assuming that all branches are maximally stable. Then we consider
+each branch $B(R_{l})$ and its parent branch
+$B(R_{l+1}):R_{l+1}\supset R_l$ (notice that, due to the
+discrete nature of the calculations, they might be geometrically
+identical) and we mark as unstable the less stable one, i.e.:
+
+  - if $v(R_l)<v(R_{l+1})$, mark $R_{l+1}$ as unstable;
+  - if $v(R_l)>v(R_{l+1})$, mark $R_{l}$ as unstable;
+  - otherwise, do nothing.
+
+This criterion selects among nearby regions the ones that are more
+stable. We optionally refine the selection by running (starting
+from the bigger and going to the smaller regions) the following
+tests:
+
+- $a_- \leq |R_{l}|/|R_{\infty}| \leq a_+$: exclude MSERs too
+  small or too big ($|R_{\infty}|$ is the area of the image).
+
+- $v(R_{l}) < v_+$: exclude MSERs too unstable.
+
+- For any MSER $R_l$, find the parent MSER $R_{l'}$ and check
+  if
+  $|R_{l'} - R_l|/|R_l'| < d_+$: remove duplicated MSERs.
+
+ <table>
+ <tr>
+  <td>parameter</td>
+  <td>alt. name</td>
+  <td>standard value</td>
+  <td>set by</td>
+ </tr>
+ <tr>
+   <td>$\Delta$</td>
+   <td>@c delta</td>
+   <td>5</td>
+   <td>::vl_mser_set_delta()</td>
+ </tr>
+ <tr>
+   <td>$a_+$</td>
+   <td>@c max_area</td>
+   <td>0.75</td>
+   <td>::vl_mser_set_max_area()</td>
+ </tr>
+ <tr>
+   <td>$a_-$</td>
+   <td>@c min_area</td>
+   <td>3.0/$|R_\infty|$</td>
+   <td>::vl_mser_set_min_area()</td>
+ </tr>
+ <tr>
+   <td>$v_+$</td>
+   <td>@c max_var</td>
+   <td>0.25</td>
+   <td>::vl_mser_set_max_variation()</td>
+ </tr>
+ <tr>
+   <td>$d_+$</td>
+   <td>@c min_diversity</td>
+   <td>0.2</td>
+   <td>::vl_mser_set_min_diversity()</td>
+ </tr>
+</table>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section mser-vol Volumetric images
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The code supports images of arbitrary dimension. For instance, it
+is possible to find the MSER regions of volumetric images or time
+sequences. See ::vl_mser_new() for further details
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section mser-ell Ellipsoids
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Usually extremal regions are returned as a set of ellipsoids
+fitted to the actual regions (which have arbitrary shape). The fit
+is done by calculating the mean and variance of the pixels
+composing the region:
+@f[
+\mu_l = \frac{1}{|R_l|}\sum_{x\in R_l}x,
+\qquad
+\Sigma_l = \frac{1}{|R_l|}\sum_{x\in R_l} (x-\mu_l)^\top(x-\mu_l)
+@f]
+Ellipsoids are fitted by ::vl_mser_ell_fit().  Notice that for a
+<em>n</em> dimensional image, the mean has <em>n</em> components
+and the variance has <em>n(n+1)/2</em> independent components. The
+total number of components is obtained by ::vl_mser_get_ell_dof()
+and the total number of fitted ellipsoids by
+::vl_mser_get_ell_num(). A matrix with an ellipsoid per column is
+returned by ::vl_mser_get_ell(). The column is the stacking of the
+mean and of the independent components of the variance, in the
+order <em>(1,1),(1,2),..,(1,n), (2,2),(2,3)...</em>. In the
+calculations, the pixel coordinate $x=(x_1,...,x_n)$ use the
+standard index order and ranges.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section mser-algo Algorithm
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The algorithm is quite efficient. While some details may be
+tricky, the overall idea is easy to grasp.
+
+- Pixels are sorted by increasing intensity.
+- Pixels are added to a forest by increasing intensity. The forest has the
+  following properties:
+  - All the descendent of a certain pixels are subset of an extremal region.
+  - All the extremal regions are the descendants of some pixels.
+- Extremal regions are extracted from the region tree and the extremal regions tree is
+  calculated.
+- Stable regions are marked.
+- Duplicates and other bad regions are removed.
+
+@remark The extremal region tree which is calculated is a subset
+of the actual extremal region tree. In particular, it does not
+contain redundant entries extremal regions that coincide as
+sets. So, for example, in the calculated extremal region tree, the
+parent $R_q$ of an extremal region $R_{l}$ may or may
+<em>not</em> correspond to $R_{l+1}$, depending whether
+$q\leq l+1$ or not. These subtleties are important when
+calculating the stability tests.
+
+**/
+
+#include "mser.h"
+#include<stdlib.h>
+#include<string.h>
+#include<assert.h>
+
+/** -------------------------------------------------------------------
+ ** @brief Advance N-dimensional subscript
+ **
+ ** The function increments by one the subscript @a subs indexing an
+ ** array the @a ndims dimensions @a dims.
+ **
+ ** @param ndims number of dimensions.
+ ** @param dims dimensions.
+ ** @param subs subscript to advance.
+ **/
+
+VL_INLINE void
+adv(int ndims, int const *dims, int *subs)
+{
+  int d = 0 ;
+  while(d < ndims) {
+    if( ++subs[d]  < dims[d] ) return ;
+    subs[d++] = 0 ;
+  }
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Climb the region forest to reach aa root
+ **
+ ** The function climbs the regions forest @a r starting from the node
+ ** @a idx to the corresponding root.
+ **
+ ** To speed-up the operation, the function uses the
+ ** VlMserReg::shortcut field to quickly jump to the root. After the
+ ** root is reached, all the used shortcut are updated.
+ **
+ ** @param r regions' forest.
+ ** @param idx stating node.
+ ** @return index of the reached root.
+ **/
+
+VL_INLINE vl_uint
+climb (VlMserReg* r, vl_uint idx)
+{
+
+  vl_uint prev_idx = idx ;
+  vl_uint next_idx ;
+  vl_uint root_idx ;
+
+  /* move towards root to find it */
+  while (1) {
+
+    /* next jump to the root */
+    next_idx = r [idx] .shortcut ;
+
+    /* recycle shortcut to remember how we came here */
+    r [idx] .shortcut = prev_idx ;
+
+    /* stop if the root is found */
+    if( next_idx == idx ) break ;
+
+    /* next guy */
+    prev_idx = idx ;
+    idx      = next_idx ;
+  }
+
+  root_idx = idx ;
+
+  /* move backward to update shortcuts */
+  while (1) {
+
+    /* get previously visited one */
+    prev_idx = r [idx] .shortcut ;
+
+    /* update shortcut to point to the new root */
+    r [idx] .shortcut = root_idx ;
+
+    /* stop if the first visited node is reached */
+    if( prev_idx == idx ) break ;
+
+    /* next guy */
+    idx = prev_idx ;
+  }
+
+  return root_idx ;
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Create a new MSER filter
+ **
+ ** Initializes a new MSER filter for images of the specified
+ ** dimensions. Images are @a ndims -dimensional arrays of dimensions
+ ** @a dims.
+ **
+ ** @param ndims number of dimensions.
+ ** @param dims  dimensions.
+ **/
+VL_EXPORT
+VlMserFilt*
+vl_mser_new (int ndims, int const* dims)
+{
+  VlMserFilt* f ;
+  int *strides, k ;
+
+  f = vl_calloc (sizeof(VlMserFilt), 1) ;
+
+  f-> ndims   = ndims ;
+  f-> dims    = vl_malloc (sizeof(int) * ndims) ;
+  f-> subs    = vl_malloc (sizeof(int) * ndims) ;
+  f-> dsubs   = vl_malloc (sizeof(int) * ndims) ;
+  f-> strides = vl_malloc (sizeof(int) * ndims) ;
+
+  /* shortcuts */
+  strides = f-> strides ;
+
+  /* copy dims to f->dims */
+  for(k = 0 ; k < ndims ; ++k) {
+    f-> dims [k] = dims [k] ;
+  }
+
+  /* compute strides to move into the N-dimensional image array */
+  strides [0] = 1 ;
+  for(k = 1 ; k < ndims ; ++k) {
+    strides [k] = strides [k-1] * dims [k-1] ;
+  }
+
+  /* total number of pixels */
+  f-> nel = strides [ndims-1] * dims [ndims-1] ;
+
+  /* dof of ellipsoids */
+  f-> dof = ndims * (ndims + 1) / 2 + ndims ;
+
+  /* more buffers */
+  f-> perm   = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
+  f-> joins  = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
+  f-> r      = vl_malloc (sizeof(VlMserReg) * f-> nel) ;
+
+  f-> er     = 0 ;
+  f-> rer    = 0 ;
+  f-> mer    = 0 ;
+  f-> rmer   = 0 ;
+  f-> ell    = 0 ;
+  f-> rell   = 0 ;
+
+  /* other parameters */
+  f-> delta         = 5 ;
+  f-> max_area      = 0.75 ;
+  f-> min_area      = 3.0 / f-> nel ;
+  f-> max_variation = 0.25 ;
+  f-> min_diversity = 0.2 ;
+
+  return f ;
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Delete MSER filter
+ **
+ ** The function releases the MSER filter @a f and all its resources.
+ **
+ ** @param f MSER filter to be deleted.
+ **/
+VL_EXPORT
+void
+vl_mser_delete (VlMserFilt* f)
+{
+  if(f) {
+    if(f-> acc   )  vl_free( f-> acc    ) ;
+    if(f-> ell   )  vl_free( f-> ell    ) ;
+
+    if(f-> er    )  vl_free( f-> er     ) ;
+    if(f-> r     )  vl_free( f-> r      ) ;
+    if(f-> joins )  vl_free( f-> joins  ) ;
+    if(f-> perm  )  vl_free( f-> perm   ) ;
+
+    if(f-> strides) vl_free( f-> strides) ;
+    if(f-> dsubs  ) vl_free( f-> dsubs  ) ;
+    if(f-> subs   ) vl_free( f-> subs   ) ;
+    if(f-> dims   ) vl_free( f-> dims   ) ;
+
+    if(f-> mer    ) vl_free( f-> mer    ) ;
+    vl_free (f) ;
+  }
+}
+
+
+/** -------------------------------------------------------------------
+ ** @brief Process image
+ **
+ ** The functions calculates the Maximally Stable Extremal Regions
+ ** (MSERs) of image @a im using the MSER filter @a f.
+ **
+ ** The filter @a f must have been initialized to be compatible with
+ ** the dimensions of @a im.
+ **
+ ** @param f MSER filter.
+ ** @param im image data.
+ **/
+VL_EXPORT
+void
+vl_mser_process (VlMserFilt* f, vl_mser_pix const* im)
+{
+  /* shortcuts */
+  vl_uint        nel     = f-> nel  ;
+  vl_uint       *perm    = f-> perm ;
+  vl_uint       *joins   = f-> joins ;
+  int            ndims   = f-> ndims ;
+  int           *dims    = f-> dims ;
+  int           *subs    = f-> subs ;
+  int           *dsubs   = f-> dsubs ;
+  int           *strides = f-> strides ;
+  VlMserReg     *r       = f-> r ;
+  VlMserExtrReg *er      = f-> er ;
+  vl_uint       *mer     = f-> mer ;
+  int            delta   = f-> delta ;
+
+  int njoins = 0 ;
+  int ner    = 0 ;
+  int nmer   = 0 ;
+  int nbig   = 0 ;
+  int nsmall = 0 ;
+  int nbad   = 0 ;
+  int ndup   = 0 ;
+
+  int i, j, k ;
+
+  /* delete any previosuly computed ellipsoid */
+  f-> nell = 0 ;
+
+  /* -----------------------------------------------------------------
+   *                                          Sort pixels by intensity
+   * -------------------------------------------------------------- */
+
+  {
+    vl_uint buckets [ VL_MSER_PIX_MAXVAL ] ;
+
+    /* clear buckets */
+    memset (buckets, 0, sizeof(vl_uint) * VL_MSER_PIX_MAXVAL ) ;
+
+    /* compute bucket size (how many pixels for each intensity
+       value) */
+    for(i = 0 ; i < (int) nel ; ++i) {
+      vl_mser_pix v = im [i] ;
+      ++ buckets [v] ;
+    }
+
+    /* cumulatively add bucket sizes */
+    for(i = 1 ; i < VL_MSER_PIX_MAXVAL ; ++i) {
+      buckets [i] += buckets [i-1] ;
+    }
+
+    /* empty buckets computing pixel ordering */
+    for(i = nel ; i >= 1 ; ) {
+      vl_mser_pix v = im [ --i ] ;
+      vl_uint j = -- buckets [v] ;
+      perm [j] = i ;
+    }
+  }
+
+  /* initialize the forest with all void nodes */
+  for(i = 0 ; i < (int) nel ; ++i) {
+    r [i] .parent = VL_MSER_VOID_NODE ;
+  }
+
+  /* -----------------------------------------------------------------
+   *                        Compute regions and count extremal regions
+   * -------------------------------------------------------------- */
+  /*
+     In the following:
+
+     idx    : index of the current pixel
+     val    : intensity of the current pixel
+     r_idx  : index of the root of the current pixel
+     n_idx  : index of the neighbors of the current pixel
+     nr_idx : index of the root of the neighbor of the current pixel
+
+  */
+
+  /* process each pixel by increasing intensity */
+  for(i = 0 ; i < (int) nel ; ++i) {
+
+    /* pop next node xi */
+    vl_uint     idx = perm [i] ;
+    vl_mser_pix val = im [idx] ;
+    vl_uint     r_idx ;
+
+    /* add the pixel to the forest as a root for now */
+    r [idx] .parent   = idx ;
+    r [idx] .shortcut = idx ;
+    r [idx] .area     = 1 ;
+    r [idx] .height   = 1 ;
+
+    r_idx = idx ;
+
+    /* convert the index IDX into the subscript SUBS; also initialize
+       DSUBS to (-1,-1,...,-1) */
+    {
+      vl_uint temp = idx ;
+      for(k = ndims - 1 ; k >= 0 ; --k) {
+        dsubs [k] = -1 ;
+        subs  [k] = temp / strides [k] ;
+        temp      = temp % strides [k] ;
+      }
+    }
+
+    /* examine the neighbors of the current pixel */
+    while (1) {
+      vl_uint n_idx = 0 ;
+      vl_bool good = 1 ;
+
+      /*
+         Compute the neighbor subscript as NSUBS+SUB, the
+         corresponding neighbor index NINDEX and check that the
+         neighbor is within the image domain.
+      */
+      for(k = 0 ; k < ndims && good ; ++k) {
+        int temp  = dsubs [k] + subs [k] ;
+        good     &= (0 <= temp) && (temp < dims [k]) ;
+        n_idx    += temp * strides [k] ;
+      }
+
+      /*
+         The neighbor should be processed if the following conditions
+         are met:
+
+         1. The neighbor is within image boundaries.
+
+         2. The neighbor is indeed different from the current node
+            (the opposite happens when DSUB=(0,0,...,0)).
+
+         3. The neighbor is already in the forest, meaning that it has
+            already been processed.
+      */
+      if (good &&
+          n_idx != idx &&
+          r [n_idx] .parent != VL_MSER_VOID_NODE ) {
+
+        vl_mser_pix nr_val = 0 ;
+        vl_uint     nr_idx = 0 ;
+        int         hgt   = r [ r_idx] .height ;
+        int         n_hgt = r [nr_idx] .height ;
+
+        /*
+          Now we join the two subtrees rooted at
+
+           R_IDX = ROOT(  IDX)
+          NR_IDX = ROOT(N_IDX).
+
+          Note that R_IDX = ROOT(IDX) might change as we process more
+          neighbors, so we need keep updating it.
+        */
+
+         r_idx = climb(r,   idx) ;
+        nr_idx = climb(r, n_idx) ;
+
+        /*
+          At this point we have three possibilities:
+
+          (A) ROOT(IDX) == ROOT(NR_IDX). In this case the two trees
+              have already been joined and we do not do anything.
+
+          (B) I(ROOT(IDX)) == I(ROOT(NR_IDX)). In this case the pixel
+              IDX is extending an extremal region with the same
+              intensity value. Since ROOT(NR_IDX) will NOT be an
+              extremal region of the full image, ROOT(IDX) can be
+              safely added as children of ROOT(NR_IDX) if this
+              reduces the height according to the union rank
+              heuristic.
+
+          (C) I(ROOT(IDX)) > I(ROOT(NR_IDX)). In this case the pixel
+              IDX is starting a new extremal region. Thus ROOT(NR_IDX)
+              WILL be an extremal region of the final image and the
+              only possibility is to add ROOT(NR_IDX) as children of
+              ROOT(IDX), which becomes parent.
+        */
+
+        if( r_idx != nr_idx ) { /* skip if (A) */
+
+          nr_val = im [nr_idx] ;
+
+          if( nr_val == val && hgt < n_hgt ) {
+
+            /* ROOT(IDX) becomes the child */
+            r [r_idx]  .parent   = nr_idx ;
+            r [r_idx]  .shortcut = nr_idx ;
+            r [nr_idx] .area    += r [r_idx] .area ;
+            r [nr_idx] .height   = VL_MAX(n_hgt, hgt+1) ;
+
+            joins [njoins++] = r_idx ;
+
+          } else {
+
+            /* cases ROOT(IDX) becomes the parent */
+            r [nr_idx] .parent   = r_idx ;
+            r [nr_idx] .shortcut = r_idx ;
+            r [r_idx]  .area    += r [nr_idx] .area ;
+            r [r_idx]  .height   = VL_MAX(hgt, n_hgt + 1) ;
+
+            joins [njoins++] = nr_idx ;
+
+            /* count if extremal */
+            if (nr_val != val) ++ ner ;
+
+          } /* check b vs c */
+        } /* check a vs b or c */
+      } /* neighbor done */
+
+      /* move to next neighbor */
+      k = 0 ;
+      while(++ dsubs [k] > 1) {
+        dsubs [k++] = -1 ;
+        if(k == ndims) goto done_all_neighbors ;
+      }
+    } /* next neighbor */
+  done_all_neighbors : ;
+  } /* next pixel */
+
+  /* the last root is extremal too */
+  ++ ner ;
+
+  /* save back */
+  f-> njoins = njoins ;
+
+  f-> stats. num_extremal = ner ;
+
+  /* -----------------------------------------------------------------
+   *                                          Extract extremal regions
+   * -------------------------------------------------------------- */
+
+  /*
+     Extremal regions are extracted and stored into the array ER.  The
+     structure R is also updated so that .SHORTCUT indexes the
+     corresponding extremal region if any (otherwise it is set to
+     VOID).
+  */
+
+  /* make room */
+  if (f-> rer < ner) {
+    if (er) vl_free (er) ;
+    f->er  = er = vl_malloc (sizeof(VlMserExtrReg) * ner) ;
+    f->rer = ner ;
+  } ;
+
+  /* save back */
+  f-> nmer = ner ;
+
+  /* count again */
+  ner = 0 ;
+
+  /* scan all regions Xi */
+  for(i = 0 ; i < (int) nel ; ++i) {
+
+    /* pop next node xi */
+    vl_uint     idx = perm [i] ;
+
+    vl_mser_pix val   = im [idx] ;
+    vl_uint     p_idx = r  [idx] .parent ;
+    vl_mser_pix p_val = im [p_idx] ;
+
+    /* is extremal ? */
+    vl_bool is_extr = (p_val > val) || idx == p_idx ;
+
+    if( is_extr ) {
+
+      /* if so, add it */
+      er [ner] .index      = idx ;
+      er [ner] .parent     = ner ;
+      er [ner] .value      = im [idx] ;
+      er [ner] .area       = r  [idx] .area ;
+
+      /* link this region to this extremal region */
+      r [idx] .shortcut = ner ;
+
+      /* increase count */
+      ++ ner ;
+    } else {
+      /* link this region to void */
+      r [idx] .shortcut =   VL_MSER_VOID_NODE ;
+    }
+  }
+
+  /* -----------------------------------------------------------------
+   *                                   Link extremal regions in a tree
+   * -------------------------------------------------------------- */
+
+  for(i = 0 ; i < ner ; ++i) {
+
+    vl_uint idx = er [i] .index ;
+
+    do {
+      idx = r[idx] .parent ;
+    } while (r[idx] .shortcut == VL_MSER_VOID_NODE) ;
+
+    er[i] .parent   = r[idx] .shortcut ;
+    er[i] .shortcut = i ;
+  }
+
+  /* -----------------------------------------------------------------
+   *                            Compute variability of +DELTA branches
+   * -------------------------------------------------------------- */
+  /* For each extremal region Xi of value VAL we look for the biggest
+   * parent that has value not greater than VAL+DELTA. This is dubbed
+   * `top parent'. */
+
+  for(i = 0 ; i < ner ; ++i) {
+
+    /* Xj is the current region the region and Xj are the parents */
+    int     top_val = er [i] .value + delta ;
+    int     top     = er [i] .shortcut ;
+
+    /* examine all parents */
+    while (1) {
+      int next     = er [top]  .parent ;
+      int next_val = er [next] .value ;
+
+      /* Break if:
+       * - there is no node above the top or
+       * - the next node is above the top value.
+       */
+      if (next == top || next_val > top_val) break ;
+
+      /* so next could be the top */
+      top = next ;
+    }
+
+    /* calculate branch variation */
+    {
+      int area     = er [i  ] .area ;
+      int area_top = er [top] .area ;
+      er [i] .variation  = (float) (area_top - area) / area ;
+      er [i] .max_stable = 1 ;
+    }
+
+    /* Optimization: since extremal regions are processed by
+     * increasing intensity, all next extremal regions being processed
+     * have value at least equal to the one of Xi. If any of them has
+     * parent the parent of Xi (this comprises the parent itself), we
+     * can safely skip most intermediate node along the branch and
+     * skip directly to the top to start our search. */
+    {
+      int parent = er [i] .parent ;
+      int curr   = er [parent] .shortcut ;
+      er [parent] .shortcut =  VL_MAX (top, curr) ;
+    }
+  }
+
+  /* -----------------------------------------------------------------
+   *                                  Select maximally stable branches
+   * -------------------------------------------------------------- */
+
+  nmer = ner ;
+  for(i = 0 ; i < ner ; ++i) {
+    vl_uint    parent = er [i     ] .parent ;
+    vl_mser_pix   val = er [i     ] .value ;
+    float     var = er [i     ] .variation ;
+    vl_mser_pix p_val = er [parent] .value ;
+    float   p_var = er [parent] .variation ;
+    vl_uint     loser ;
+
+    /*
+       Notice that R_parent = R_{l+1} only if p_val = val + 1. If not,
+       this and the parent region coincide and there is nothing to do.
+    */
+    if(p_val > val + 1) continue ;
+
+    /* decide which one to keep and put that in loser */
+    if(var < p_var) loser = parent ; else loser = i ;
+
+    /* make loser NON maximally stable */
+    if(er [loser] .max_stable) {
+      -- nmer ;
+      er [loser] .max_stable = 0 ;
+    }
+  }
+
+  f-> stats. num_unstable = ner - nmer ;
+
+  /* -----------------------------------------------------------------
+   *                                                 Further filtering
+   * -------------------------------------------------------------- */
+  /* It is critical for correct duplicate detection to remove regions
+   * from the bottom (smallest one first).                          */
+  {
+    float max_area = (float) f-> max_area * nel ;
+    float min_area = (float) f-> min_area * nel ;
+    float max_var  = (float) f-> max_variation ;
+    float min_div  = (float) f-> min_diversity ;
+
+    /* scan all extremal regions (intensity value order) */
+    for(i = ner-1 ; i >= 0L  ; --i) {
+
+      /* process only maximally stable extremal regions */
+      if (! er [i] .max_stable) continue ;
+
+      if (er [i] .variation >= max_var ) { ++ nbad ;   goto remove ; }
+      if (er [i] .area      >  max_area) { ++ nbig ;   goto remove ; }
+      if (er [i] .area      <  min_area) { ++ nsmall ; goto remove ; }
+
+      /*
+       * Remove duplicates
+       */
+      if (min_div < 1.0) {
+        vl_uint   parent = er [i] .parent ;
+        int       area, p_area ;
+        float div ;
+
+        /* check all but the root mser */
+        if((int) parent != i) {
+
+          /* search for the maximally stable parent region */
+          while(! er [parent] .max_stable) {
+            vl_uint next = er [parent] .parent ;
+            if(next == parent) break ;
+            parent = next ;
+          }
+
+          /* Compare with the parent region; if the current and parent
+           * regions are too similar, keep only the parent. */
+          area    = er [i]      .area ;
+          p_area  = er [parent] .area ;
+          div     = (float) (p_area - area) / (float) p_area ;
+
+          if (div < min_div) { ++ ndup ; goto remove ; }
+        } /* remove dups end */
+
+      }
+      continue ;
+    remove :
+      er [i] .max_stable = 0 ;
+      -- nmer ;
+    } /* check next region */
+
+    f-> stats .num_abs_unstable = nbad ;
+    f-> stats .num_too_big      = nbig ;
+    f-> stats .num_too_small    = nsmall ;
+    f-> stats .num_duplicates   = ndup ;
+  }
+  /* -----------------------------------------------------------------
+   *                                                   Save the result
+   * -------------------------------------------------------------- */
+
+  /* make room */
+  if (f-> rmer < nmer) {
+    if (mer) vl_free (mer) ;
+    f->mer  = mer = vl_malloc( sizeof(vl_uint) * nmer) ;
+    f->rmer = nmer ;
+  }
+
+  /* save back */
+  f-> nmer = nmer ;
+
+  j = 0 ;
+  for (i = 0 ; i < ner ; ++i) {
+    if (er [i] .max_stable) mer [j++] = er [i] .index ;
+  }
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Fit ellipsoids
+ **
+ ** @param f MSER filter.
+ **
+ ** @sa @ref mser-ell
+ **/
+
+VL_EXPORT
+void
+vl_mser_ell_fit (VlMserFilt* f)
+{
+  /* shortcuts */
+  int                nel = f-> nel ;
+  int                dof = f-> dof ;
+  int              *dims = f-> dims ;
+  int              ndims = f-> ndims ;
+  int              *subs = f-> subs ;
+  int             njoins = f-> njoins ;
+  vl_uint         *joins = f-> joins ;
+  VlMserReg           *r = f-> r ;
+  vl_uint           *mer = f-> mer ;
+  int               nmer = f-> nmer ;
+  vl_mser_acc       *acc = f-> acc ;
+  vl_mser_acc       *ell = f-> ell ;
+
+  int d, index, i, j ;
+
+  /* already fit ? */
+  if (f->nell == f->nmer) return ;
+
+  /* make room */
+  if (f->rell < f->nmer) {
+    if (f->ell) vl_free (f->ell) ;
+    f->ell  = vl_malloc (sizeof(float) * f->nmer * f->dof) ;
+    f->rell = f-> nmer ;
+  }
+
+  if (f->acc == 0) {
+    f->acc = vl_malloc (sizeof(float) * f->nel) ;
+  }
+
+  acc = f-> acc ;
+  ell = f-> ell ;
+
+  /* -----------------------------------------------------------------
+   *                                                 Integrate moments
+   * -------------------------------------------------------------- */
+
+  /* for each dof */
+  for(d = 0 ; d < f->dof ; ++d) {
+
+    /* start from the upper-left pixel (0,0,...,0) */
+    memset (subs, 0, sizeof(int) * ndims) ;
+
+    /* step 1: fill acc pretending that each region has only one pixel */
+    if(d < ndims) {
+      /* 1-order ................................................... */
+
+      for(index = 0 ; index < nel ; ++ index) {
+        acc [index] = subs [d] ;
+        adv(ndims, dims, subs) ;
+      }
+    }
+    else {
+      /* 2-order ................................................... */
+
+      /* map the dof d to a second order moment E[x_i x_j] */
+      i = d - ndims ;
+      j = 0 ;
+      while(i > j) {
+        i -= j + 1 ;
+        j ++ ;
+      }
+      /* initialize acc with  x_i * x_j */
+      for(index = 0 ; index < nel ; ++ index){
+        acc [index] = subs [i] * subs [j] ;
+        adv(ndims, dims, subs) ;
+      }
+    }
+
+    /* step 2: integrate */
+    for(i = 0 ; i < njoins ; ++i) {
+      vl_uint index  = joins [i] ;
+      vl_uint parent = r [index] .parent ;
+      acc [parent] += acc [index] ;
+    }
+
+    /* step 3: save back to ellpises */
+    for(i = 0 ; i < nmer ; ++i) {
+      vl_uint idx = mer [i] ;
+      ell [d + dof*i] = acc [idx] ;
+    }
+
+  }  /* next dof */
+
+  /* -----------------------------------------------------------------
+   *                                           Compute central moments
+   * -------------------------------------------------------------- */
+
+  for(index = 0 ; index < nmer ; ++index) {
+    float  *pt  = ell + index * dof ;
+    vl_uint    idx  = mer [index] ;
+    float  area = r [idx] .area ;
+
+    for(d = 0 ; d < dof ; ++d) {
+
+      pt [d] /= area ;
+
+      if(d >= ndims) {
+        /* remove squared mean from moment to get variance */
+        i = d - ndims ;
+        j = 0 ;
+        while(i > j) {
+          i -= j + 1 ;
+          j ++ ;
+        }
+        pt [d] -= pt [i] * pt [j] ;
+      }
+
+    }
+  }
+
+  /* save back */
+  f-> nell = nmer ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/mser.h b/opensfm/src/third_party/vlfeat/vl/mser.h
new file mode 100644
index 000000000..bd63cedb1
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/mser.h
@@ -0,0 +1,424 @@
+/** @file mser.h
+ ** @brief MSER (@ref mser)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_MSER
+#define VL_MSER
+
+#include "generic.h"
+
+/** @brief MSER image data type
+ **
+ ** This is the data type of the image pixels. It has to be an
+ ** integer.
+ **/
+typedef vl_uint8 vl_mser_pix ;
+
+/** @brief Maximum value
+ **
+ ** Maximum value of the integer type ::vl_mser_pix.
+ **/
+#define VL_MSER_PIX_MAXVAL 256
+
+/** @brief MSER Filter
+ **
+ ** The MSER filter computes the Maximally Stable Extremal Regions of
+ ** an image.
+ **
+ ** @sa @ref mser
+ **/
+typedef struct _VlMserFilt VlMserFilt ;
+
+/** @brief MSER filter statistics */
+typedef struct _VlMserStats VlMserStats ;
+
+/** @brief MSER filter statistics definition */
+struct _VlMserStats
+{
+  int num_extremal ;      /**< number of extremal regions                                */
+  int num_unstable ;      /**< number of unstable extremal regions                       */
+  int num_abs_unstable ;  /**< number of regions that failed the absolute stability test */
+  int num_too_big ;       /**< number of regions that failed the maximum size test       */
+  int num_too_small ;     /**< number of regions that failed the minimum size test       */
+  int num_duplicates ;    /**< number of regions that failed the duplicate test          */
+} ;
+
+/** @name Construction and Destruction
+ ** @{
+ **/
+VL_EXPORT VlMserFilt*      vl_mser_new     (int ndims, int const* dims) ;
+VL_EXPORT void             vl_mser_delete  (VlMserFilt *f) ;
+/** @} */
+
+/** @name Processing
+ ** @{
+ **/
+VL_EXPORT void             vl_mser_process (VlMserFilt *f,
+                                            vl_mser_pix const *im) ;
+VL_EXPORT void             vl_mser_ell_fit (VlMserFilt *f) ;
+/** @} */
+
+/** @name Retrieving data
+ ** @{
+ **/
+VL_INLINE vl_uint          vl_mser_get_regions_num  (VlMserFilt const *f) ;
+VL_INLINE vl_uint const*   vl_mser_get_regions      (VlMserFilt const *f) ;
+VL_INLINE float const*     vl_mser_get_ell          (VlMserFilt const *f) ;
+VL_INLINE vl_uint          vl_mser_get_ell_num      (VlMserFilt const *f) ;
+VL_INLINE vl_uint          vl_mser_get_ell_dof      (VlMserFilt const *f) ;
+VL_INLINE VlMserStats const*  vl_mser_get_stats     (VlMserFilt const *f) ;
+/** @} */
+
+/** @name Retrieving parameters
+ ** @{
+ **/
+VL_INLINE vl_mser_pix  vl_mser_get_delta          (VlMserFilt const *f) ;
+VL_INLINE double       vl_mser_get_min_area       (VlMserFilt const *f) ;
+VL_INLINE double       vl_mser_get_max_area       (VlMserFilt const *f) ;
+VL_INLINE double       vl_mser_get_max_variation  (VlMserFilt const *f) ;
+VL_INLINE double       vl_mser_get_min_diversity  (VlMserFilt const *f) ;
+/** @} */
+
+/** @name Setting parameters
+ ** @{
+ **/
+VL_INLINE void  vl_mser_set_delta           (VlMserFilt *f, vl_mser_pix x) ;
+VL_INLINE void  vl_mser_set_min_area        (VlMserFilt *f, double      x) ;
+VL_INLINE void  vl_mser_set_max_area        (VlMserFilt *f, double      x) ;
+VL_INLINE void  vl_mser_set_max_variation   (VlMserFilt *f, double      x) ;
+VL_INLINE void  vl_mser_set_min_diversity   (VlMserFilt *f, double      x) ;
+/** @} */
+
+/* ====================================================================
+ *                                                   INLINE DEFINITIONS
+ * ================================================================== */
+
+/** @internal
+ ** @brief MSER accumulator data type
+ **
+ ** This is a large integer type. It should be large enough to contain
+ ** a number equal to the area (volume) of the image by the image
+ ** width by the image height (for instance, if the image is a square
+ ** of side 256, the maximum value is 256 x 256 x 256).
+ **/
+typedef float vl_mser_acc ;
+
+/** @internal @brief Basic region flag: null region */
+#ifdef VL_COMPILER_MSC
+#define VL_MSER_VOID_NODE ((1ui64<<32) - 1)
+#else
+#define VL_MSER_VOID_NODE ((1ULL<<32) - 1)
+#endif
+
+/* ----------------------------------------------------------------- */
+/** @internal
+ ** @brief MSER: basic region (declaration)
+ **
+ ** Extremal regions and maximally stable extremal regions are
+ ** instances of image regions.
+ **
+ ** There is an image region for each pixel of the image. Each region
+ ** is represented by an instance of this structure.  Regions are
+ ** stored into an array in pixel order.
+ **
+ ** Regions are arranged into a forest. VlMserReg::parent points to
+ ** the parent node, or to the node itself if the node is a root.
+ ** VlMserReg::parent is the index of the node in the node array
+ ** (which therefore is also the index of the corresponding
+ ** pixel). VlMserReg::height is the distance of the fartest leaf. If
+ ** the node itself is a leaf, then VlMserReg::height is zero.
+ **
+ ** VlMserReg::area is the area of the image region corresponding to
+ ** this node.
+ **
+ ** VlMserReg::region is the extremal region identifier. Not all
+ ** regions are extremal regions however; if the region is NOT
+ ** extremal, this field is set to ....
+ **/
+struct _VlMserReg
+{
+  vl_uint parent ;   /**< points to the parent region.            */
+  vl_uint shortcut ; /**< points to a region closer to a root.    */
+  vl_uint height ;   /**< region height in the forest.            */
+  vl_uint area ;     /**< area of the region.                     */
+} ;
+
+/** @internal @brief MSER: basic region */
+typedef struct _VlMserReg VlMserReg ;
+
+/* ----------------------------------------------------------------- */
+/** @internal
+ ** @brief MSER: extremal region (declaration)
+ **
+ ** Extremal regions (ER) are extracted from the region forest. Each
+ ** region is represented by an instance of this structure. The
+ ** structures are stored into an array, in arbitrary order.
+ **
+ ** ER are arranged into a tree. @a parent points to the parent ER, or
+ ** to itself if the ER is the root.
+ **
+ ** An instance of the structure represents the extremal region of the
+ ** level set of intensity VlMserExtrReg::value and containing the
+ ** pixel VlMserExtReg::index.
+ **
+ ** VlMserExtrReg::area is the area of the extremal region and
+ ** VlMserExtrReg::area_top is the area of the extremal region
+ ** containing this region in the level set of intensity
+ ** VlMserExtrReg::area + @c delta.
+ **
+ ** VlMserExtrReg::variation is the relative area variation @c
+ ** (area_top-area)/area.
+ **
+ ** VlMserExtrReg::max_stable is a flag signaling whether this extremal
+ ** region is also maximally stable.
+ **/
+struct _VlMserExtrReg
+{
+  int          parent ;     /**< index of the parent region                   */
+  int          index ;      /**< index of pivot pixel                         */
+  vl_mser_pix  value ;      /**< value of pivot pixel                         */
+  vl_uint      shortcut ;   /**< shortcut used when building a tree           */
+  vl_uint      area ;       /**< area of the region                           */
+  float        variation ;  /**< rel. area variation                          */
+  vl_uint      max_stable ; /**< max stable number (=0 if not maxstable)      */
+} ;
+
+/** @internal
+ ** @brief MSER: extremal region */
+typedef struct _VlMserExtrReg VlMserExtrReg ;
+
+/* ----------------------------------------------------------------- */
+/** @internal
+ ** @brief MSER filter
+ ** @see @ref mser
+ **/
+struct _VlMserFilt
+{
+
+  /** @name Image data and meta data @internal */
+  /*@{*/
+  int                ndims ;   /**< number of dimensions                    */
+  int               *dims ;    /**< dimensions                              */
+  int                nel ;     /**< number of image elements (pixels)       */
+  int               *subs ;    /**< N-dimensional subscript                 */
+  int               *dsubs ;   /**< another subscript                       */
+  int               *strides ; /**< strides to move in image data           */
+  /*@}*/
+
+  vl_uint           *perm ;    /**< pixel ordering                          */
+  vl_uint           *joins ;   /**< sequence of join ops                    */
+  int                njoins ;  /**< number of join ops                      */
+
+  /** @name Regions */
+  /*@{*/
+  VlMserReg         *r ;       /**< basic regions                           */
+  VlMserExtrReg     *er ;      /**< extremal tree                           */
+  vl_uint           *mer ;     /**< maximally stable extremal regions       */
+  int                ner ;     /**< number of extremal regions              */
+  int                nmer ;    /**< number of maximally stable extr. reg.   */
+  int                rer ;     /**< size of er buffer                       */
+  int                rmer ;    /**< size of mer buffer                      */
+  /*@}*/
+
+  /** @name Ellipsoids fitting */
+  /*@{*/
+  float             *acc ;     /**< moment accumulator.                    */
+  float             *ell ;     /**< ellipsoids list.                       */
+  int                rell ;    /**< size of ell buffer                     */
+  int                nell ;    /**< number of ellipsoids extracted         */
+  int                dof ;     /**< number of dof of ellipsoids.           */
+
+  /*@}*/
+
+  /** @name Configuration */
+  /*@{*/
+  vl_bool   verbose ;          /**< be verbose                             */
+  int       delta ;            /**< delta filter parameter                 */
+  double    max_area ;         /**< badness test parameter                 */
+  double    min_area ;         /**< badness test parameter                 */
+  double    max_variation ;    /**< badness test parameter                 */
+  double    min_diversity ;    /**< minimum diversity                      */
+  /*@}*/
+
+  VlMserStats stats ;          /** run statistic                           */
+} ;
+
+/* ----------------------------------------------------------------- */
+/** @brief Get delta
+ ** @param f MSER filter.
+ ** @return value of @c delta.
+ **/
+VL_INLINE vl_mser_pix
+vl_mser_get_delta (VlMserFilt const *f)
+{
+  return f-> delta ;
+}
+
+/** @brief Set delta
+ ** @param f MSER filter.
+ ** @param x value of @c delta.
+ **/
+VL_INLINE void
+vl_mser_set_delta (VlMserFilt *f, vl_mser_pix x)
+{
+  f-> delta = x ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get minimum diversity
+ ** @param  f MSER filter.
+ ** @return value of @c minimum diversity.
+ **/
+VL_INLINE double
+vl_mser_get_min_diversity (VlMserFilt const *f)
+{
+  return f-> min_diversity ;
+}
+
+/** @brief Set minimum diversity
+ ** @param f MSER filter.
+ ** @param x value of @c minimum diversity.
+ **/
+VL_INLINE void
+vl_mser_set_min_diversity (VlMserFilt *f, double x)
+{
+  f-> min_diversity = x ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get statistics
+ ** @param f MSER filter.
+ ** @return statistics.
+ **/
+VL_INLINE VlMserStats const*
+vl_mser_get_stats (VlMserFilt const *f)
+{
+  return & f-> stats ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get maximum region area
+ ** @param f MSER filter.
+ ** @return maximum region area.
+ **/
+VL_INLINE double
+vl_mser_get_max_area (VlMserFilt const *f)
+{
+  return f-> max_area ;
+}
+
+/** @brief Set maximum region area
+ ** @param f MSER filter.
+ ** @param x maximum region area.
+ **/
+VL_INLINE void
+vl_mser_set_max_area (VlMserFilt *f, double x)
+{
+  f-> max_area = x ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get minimum region area
+ ** @param f MSER filter.
+ ** @return minimum region area.
+ **/
+VL_INLINE double
+vl_mser_get_min_area (VlMserFilt const *f)
+{
+  return f-> min_area ;
+}
+
+/** @brief Set minimum region area
+ ** @param f MSER filter.
+ ** @param x minimum region area.
+ **/
+VL_INLINE void
+vl_mser_set_min_area (VlMserFilt *f, double x)
+{
+  f-> min_area = x ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get maximum region variation
+ ** @param f MSER filter.
+ ** @return maximum region variation.
+ **/
+VL_INLINE double
+vl_mser_get_max_variation (VlMserFilt const *f)
+{
+  return f-> max_variation ;
+}
+
+/** @brief Set maximum region variation
+ ** @param f MSER filter.
+ ** @param x maximum region variation.
+ **/
+VL_INLINE void
+vl_mser_set_max_variation (VlMserFilt *f, double x)
+{
+  f-> max_variation = x ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get maximally stable extremal regions
+ ** @param f MSER filter.
+ ** @return array of MSER pivots.
+ **/
+VL_INLINE vl_uint const *
+vl_mser_get_regions (VlMserFilt const* f)
+{
+  return f-> mer ;
+}
+
+/** @brief Get number of maximally stable extremal regions
+ ** @param f MSER filter.
+ ** @return number of MSERs.
+ **/
+VL_INLINE vl_uint
+vl_mser_get_regions_num (VlMserFilt const* f)
+{
+  return f-> nmer ;
+}
+
+/* ----------------------------------------------------------------- */
+/** @brief Get ellipsoids
+ ** @param f MSER filter.
+ ** @return ellipsoids.
+ **/
+VL_INLINE float const *
+vl_mser_get_ell (VlMserFilt const* f)
+{
+  return f-> ell ;
+}
+
+/** @brief Get number of degrees of freedom of ellipsoids
+ ** @param f MSER filter.
+ ** @return number of degrees of freedom.
+ **/
+VL_INLINE vl_uint
+vl_mser_get_ell_dof (VlMserFilt const* f)
+{
+  return f-> dof ;
+}
+
+/** @brief Get number of ellipsoids
+ ** @param f MSER filter.
+ ** @return number of ellipsoids
+ **/
+VL_INLINE vl_uint
+vl_mser_get_ell_num (VlMserFilt const* f)
+{
+  return f-> nell ;
+}
+
+/* VL_MSER */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/pgm.c b/opensfm/src/third_party/vlfeat/vl/pgm.c
new file mode 100644
index 000000000..81a3e3daf
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/pgm.c
@@ -0,0 +1,542 @@
+/** @file pgm.c
+ ** @brief Portable graymap format (PGM) parser - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file pgm.h
+
+This module implements basic input and ouptut of images in PGM
+format.
+
+Extracting an image encoded in PGM format from an imput
+file stream involves the following steps:
+
+- use ::vl_pgm_extract_head to extract the image meta data
+  (size and bit depth);
+- allocate a buffer to store the image data;
+- use ::vl_pgm_extract_data to extract the image data to the allocated
+  buffer.
+
+Writing an image in PGM format to an ouptut file stream
+can be done by using ::vl_pgm_insert.
+
+To quickly read/write a PGM image from/to a given file, use
+::vl_pgm_read_new() and ::vl_pgm_write(). To to the same from a
+buffer in floating point format use ::vl_pgm_read_new_f() and
+::vl_pgm_write_f().
+
+**/
+
+#include "pgm.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Remove all characters to the next new-line.
+ ** @param f file to strip.
+ ** @return number of characters removed.
+ **/
+
+static int
+remove_line(FILE* f)
+{
+  int count = 0 ;
+  int c ;
+
+  while (1) {
+    c = fgetc(f) ;
+    ++ count ;
+
+    switch(c) {
+    case '\n' :
+      goto quit_remove_line ;
+
+    case EOF :
+      -- count ;
+      goto quit_remove_line ;
+    }
+  }
+ quit_remove_line :
+  return count ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Remove white-spaces and comments.
+ ** @param f file to strip.
+ ** @return number of characters removed.
+ **/
+
+static int
+remove_blanks(FILE* f)
+{
+  int count = 0 ;
+  int c ;
+
+  while (1) {
+    c = fgetc(f) ;
+
+    switch(c) {
+
+    case '\t' : case '\n' :
+    case '\r' : case ' '  :
+      ++ count ;
+      break ;
+
+    case '#' :
+      count += 1 + remove_line(f) ;
+      break ;
+
+    case EOF :
+      goto quit_remove_blanks ;
+
+    default:
+      ungetc(c, f) ;
+      goto quit_remove_blanks ;
+    }
+  }
+ quit_remove_blanks:
+  return count ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get PGM image number of pixels.
+ ** @param im PGM image descriptor.
+ ** @return number of pixels of the image.
+ **
+ ** The functions returns the number of pixels of the PGM image @a im.
+ **
+ ** To calculate the image data size in bytes, this value must be
+ ** multiplied by the number of byte per pixels (see
+ ** ::vl_pgm_get_bpp()).
+ **/
+
+VL_EXPORT vl_size
+vl_pgm_get_npixels (VlPgmImage const *im)
+{
+  return im->width * im->height ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get PGM image bytes per pixel.
+ ** @param im PGM image descriptor.
+ ** @return number of bytes per pixel.
+ **
+ ** The function returns the number of bytes for each pixel of the
+ ** PGM image @a im.
+ **/
+
+VL_EXPORT vl_size
+vl_pgm_get_bpp (VlPgmImage const *im)
+{
+  return (im->max_value >= 256) + 1 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Extract PGM header from stream.
+ ** @param f  input file.
+ ** @param im image structure to fill.
+ ** @return error code.
+ **
+ ** The function extracts from the file @a f the meta-data section of
+ ** an image encoded in PGM format. The function fills the structure
+ ** ::VlPgmImage accordingly.
+ **
+ ** The error may be either ::VL_ERR_PGM_INV_HEAD or ::VL_ERR_PGM_INV_META
+ ** depending whether the error occurred in decoding the header or
+ ** meta section of the PGM file.
+ **/
+
+VL_EXPORT int
+vl_pgm_extract_head (FILE* f, VlPgmImage *im)
+{
+  char magic [2] ;
+  int c ;
+  int is_raw ;
+  int width ;
+  int height ;
+  int max_value ;
+  size_t sz ;
+  vl_bool good ;
+
+  /* -----------------------------------------------------------------
+   *                                                check magic number
+   * -------------------------------------------------------------- */
+  sz = fread(magic, 1, 2, f) ;
+
+  if (sz < 2) {
+    return vl_set_last_error(VL_ERR_PGM_INV_HEAD, "Invalid PGM header") ;
+  }
+
+  good = magic [0] == 'P' ;
+
+  switch (magic [1]) {
+  case '2' : /* ASCII format */
+    is_raw = 0 ;
+    break ;
+
+  case '5' : /* RAW format */
+    is_raw = 1 ;
+    break ;
+
+  default :
+    good = 0 ;
+    break ;
+  }
+
+  if( ! good ) {
+    return vl_set_last_error(VL_ERR_PGM_INV_HEAD, "Invalid PGM header") ;
+  }
+
+  /* -----------------------------------------------------------------
+   *                                    parse width, height, max_value
+   * -------------------------------------------------------------- */
+  good = 1 ;
+
+  c = remove_blanks(f) ;
+  good &= c > 0 ;
+
+  c = fscanf(f, "%d", &width) ;
+  good &= c == 1 ;
+
+  c = remove_blanks(f) ;
+  good &= c > 0 ;
+
+  c = fscanf(f, "%d", &height) ;
+  good &= c == 1 ;
+
+  c = remove_blanks(f) ;
+  good &= c > 0 ;
+
+  c = fscanf(f, "%d", &max_value) ;
+  good &= c == 1 ;
+
+  /* must end with a single blank */
+  c = fgetc(f) ;
+  good &=
+    c == '\n' ||
+    c == '\t' ||
+    c == ' '  ||
+    c == '\r' ;
+
+  if(! good) {
+    return vl_set_last_error(VL_ERR_PGM_INV_META, "Invalid PGM meta information");
+  }
+
+  if(! max_value >= 65536) {
+    return vl_set_last_error(VL_ERR_PGM_INV_META, "Invalid PGM meta information");
+  }
+
+  /* exit */
+  im-> width     = width ;
+  im-> height    = height ;
+  im-> max_value = max_value ;
+  im-> is_raw    = is_raw ;
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Extract PGM data from stream.
+ ** @param f input file.
+ ** @param im PGM image descriptor.
+ ** @param data data buffer to fill.
+ ** @return error code.
+ **
+ ** The function extracts from the file @a f the data section of an
+ ** image encoded in PGM format. The function fills the buffer @a data
+ ** according. The buffer @a data should be ::vl_pgm_get_npixels() by
+ ** ::vl_pgm_get_bpp() bytes large.
+ **/
+
+VL_EXPORT
+int
+vl_pgm_extract_data (FILE* f, VlPgmImage const *im, void *data)
+{
+  vl_size bpp = vl_pgm_get_bpp(im) ;
+  vl_size data_size = vl_pgm_get_npixels(im) ;
+  vl_bool good = 1 ;
+  size_t c ;
+
+  /* -----------------------------------------------------------------
+   *                                                         read data
+   * -------------------------------------------------------------- */
+
+  /*
+     In RAW mode we read directly an array of bytes or shorts.  In
+     the latter case, however, we must take care of the
+     endianess. PGM files are sorted in big-endian format. If our
+     architecture is little endian, we must do a conversion.
+  */
+  if (im->is_raw) {
+
+    c = fread( data,
+               bpp,
+               data_size,
+               f ) ;
+    good = (c == data_size) ;
+
+    /* adjust endianess */
+#if defined(VL_ARCH_LITTLE_ENDIAN)
+    if (bpp == 2) {
+      vl_uindex i ;
+      vl_uint8 *pt = (vl_uint8*) data ;
+      for(i = 0 ; i < 2 * data_size ; i += 2) {
+        vl_uint8 tmp = pt [i] ;
+        pt [i]   = pt [i+1] ;
+        pt [i+1] = tmp ;
+      }
+    }
+#endif
+  }
+  /*
+     In ASCII mode we read a sequence of decimal numbers separated
+     by whitespaces.
+  */
+  else {
+    vl_uindex i ;
+    int unsigned v ;
+    for(good = 1, i = 0 ;
+        i < data_size && good ;
+        ++i) {
+      c = fscanf(f, " %ud", &v) ;
+      if (bpp == 1) {
+        * ((vl_uint8* )  data + i) = (vl_uint8)  v ;
+      } else {
+        * ((vl_uint16*)  data + i) = (vl_uint16) v ;
+      }
+      good &= c == 1 ;
+    }
+  }
+
+  if(! good ) {
+    return vl_set_last_error(VL_ERR_PGM_INV_DATA, "Invalid PGM data") ;
+  }
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Insert a PGM image into a stream.
+ ** @param f output file.
+ ** @param im   PGM image meta-data.
+ ** @param data image data.
+ ** @return error code.
+ **/
+
+VL_EXPORT
+int
+vl_pgm_insert(FILE* f, VlPgmImage const *im, void const *data)
+{
+  vl_size bpp = vl_pgm_get_bpp (im) ;
+  vl_size data_size = vl_pgm_get_npixels (im) ;
+  size_t c ;
+
+  /* write preamble */
+  fprintf(f,
+          "P5\n%d\n%d\n%d\n",
+          (signed)im->width,
+          (signed)im->height,
+          (signed)im->max_value) ;
+
+  /* take care of endianness */
+#if defined(VL_ARCH_LITTLE_ENDIAN)
+  if (bpp == 2) {
+    vl_uindex i ;
+    vl_uint8* temp = vl_malloc (2 * data_size) ;
+    memcpy(temp, data, 2 * data_size) ;
+    for(i = 0 ; i < 2 * data_size ; i += 2) {
+      vl_uint8 tmp = temp [i] ;
+      temp [i]   = temp [i+1] ;
+      temp [i+1] = tmp ;
+    }
+    c = fwrite(temp, 2, data_size, f) ;
+    vl_free (temp) ;
+  }
+  else {
+#endif
+    c = fwrite(data, bpp, data_size, f) ;
+#if defined(VL_ARCH_LITTLE_ENDIAN)
+  }
+#endif
+
+  if(c != data_size) {
+    return vl_set_last_error(VL_ERR_PGM_IO, "Error writing PGM data") ;
+  }
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Read a PGM file.
+ ** @param name file name.
+ ** @param im a pointer to the PGM image structure to fill.
+ ** @param data a pointer to the pointer to the allocated buffer.
+ ** @return error code.
+ **
+ ** The function reads a PGM image from file @a name and initializes
+ ** the structure @a im and the buffer @a data accordingly.
+ **
+ ** The ownership of the buffer @a data is transfered to the caller.
+ ** @a data should be freed by means of ::vl_free().
+ **
+ ** @bug Only PGM files with 1 BPP are supported.
+ **/
+
+VL_EXPORT
+int vl_pgm_read_new (char const *name, VlPgmImage *im, vl_uint8** data)
+{
+  int err = 0 ;
+  FILE *f = fopen (name, "rb") ;
+
+  if (! f) {
+    return vl_set_last_error(VL_ERR_PGM_IO, "Error opening PGM file `%s' for reading", name) ;
+  }
+
+  err = vl_pgm_extract_head(f, im) ;
+  if (err) {
+    fclose (f) ;
+    return err ;
+  }
+
+  if (vl_pgm_get_bpp(im) > 1) {
+    return vl_set_last_error(VL_ERR_BAD_ARG, "PGM with BPP > 1 not supported") ;
+  }
+
+  *data = vl_malloc (vl_pgm_get_npixels(im) * sizeof(vl_uint8)) ;
+  err = vl_pgm_extract_data(f, im, *data) ;
+
+  if (err) {
+    vl_free (data) ;
+    fclose (f) ;
+  }
+
+  fclose (f) ;
+  return err ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Read floats from a PGM file.
+ ** @param name file name.
+ ** @param im a pointer to the PGM image structure to fill.
+ ** @param data a pointer to the pointer to the allocated buffer.
+ ** @return error code.
+ **
+ ** The function reads a PGM image from file @a name and initializes
+ ** the structure @a im and the buffer @a data accordingly. The buffer
+ ** @a data is an array of floats in the range [0, 1].
+ **
+ ** The ownership of the buffer @a data is transfered to the caller.
+ ** @a data should be freed by means of ::vl_free().
+ **
+ ** @bug Only PGM files with 1 BPP are supported.
+ **/
+
+VL_EXPORT
+int vl_pgm_read_new_f (char const *name,  VlPgmImage *im, float** data)
+{
+  int err = 0 ;
+  size_t npixels ;
+  vl_uint8 *idata ;
+
+  err = vl_pgm_read_new (name, im, &idata) ;
+  if (err) {
+    return err ;
+  }
+
+  npixels = vl_pgm_get_npixels(im) ;
+  *data = vl_malloc (sizeof(float) * npixels) ;
+  {
+    size_t k ;
+    float scale = 1.0f / (float)im->max_value ;
+    for (k = 0 ; k < npixels ; ++ k) (*data)[k] = scale * idata[k] ;
+  }
+
+  vl_free (idata) ;
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Write bytes to a PGM file.
+ ** @param name file name.
+ ** @param data data to write.
+ ** @param width width of the image.
+ ** @param height height of the image.
+ ** @return error code.
+ **
+ ** The function dumps the image @a data to the PGM file of the specified
+ ** name. This is an helper function simplifying the usage of
+ ** vl_pgm_insert().
+ **/
+
+VL_EXPORT
+int vl_pgm_write (char const *name, vl_uint8 const* data, int width, int height)
+{
+  int err = 0 ;
+  VlPgmImage pgm ;
+  FILE *f = fopen (name, "wb") ;
+
+  if (! f) {
+    return vl_set_last_error(VL_ERR_PGM_IO,
+             "Error opening PGM file '%s' for writing", name) ;
+  }
+
+  pgm.width = width ;
+  pgm.height = height ;
+  pgm.is_raw = 1 ;
+  pgm.max_value = 255 ;
+
+  err = vl_pgm_insert (f, &pgm, data) ;
+  fclose (f) ;
+
+  return err ;
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Write floats to PGM file
+ ** @param name file name.
+ ** @param data data to write.
+ ** @param width width of the image.
+ ** @param height height of the image.
+ ** @return error code.
+ **
+ ** The function dumps the image @a data to the PGM file of the
+ ** specified name. The data is re-scaled to fit in the range 0-255.
+ ** This is an helper function simplifying the usage of
+ ** vl_pgm_insert().
+ **/
+
+VL_EXPORT
+int vl_pgm_write_f (char const *name, float const* data, int width, int height)
+{
+  int err = 0 ;
+  int k ;
+  float min = + VL_INFINITY_F ;
+  float max = - VL_INFINITY_F ;
+  float scale ;
+
+  vl_uint8 * buffer = vl_malloc (sizeof(float) * width * height) ;
+
+  for (k = 0 ; k < width * height ; ++k) {
+    min = VL_MIN(min, data [k]) ;
+    max = VL_MAX(max, data [k]) ;
+  }
+
+  scale = 255 / (max - min + VL_EPSILON_F) ;
+
+  for (k = 0 ; k < width * height ; ++k) {
+    buffer [k] = (vl_uint8) ((data [k] - min) * scale) ;
+  }
+
+  err = vl_pgm_write (name, buffer, width, height) ;
+
+  vl_free (buffer) ;
+  return err ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/pgm.h b/opensfm/src/third_party/vlfeat/vl/pgm.h
new file mode 100644
index 000000000..80b0ef0f1
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/pgm.h
@@ -0,0 +1,73 @@
+/** @file pgm.h
+ ** @brief Portable graymap format (PGM) parser
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_PGM_H
+#define VL_PGM_H
+
+#include "generic.h"
+#include "mathop.h"
+#include <stdio.h>
+
+/** @name PGM parser error codes
+ ** @{ */
+#define VL_ERR_PGM_INV_HEAD  101 /**< Invalid PGM header section. */
+#define VL_ERR_PGM_INV_META  102 /**< Invalid PGM meta section. */
+#define VL_ERR_PGM_INV_DATA  103 /**< Invalid PGM data section.*/
+#define VL_ERR_PGM_IO        104 /**< Generic I/O error. */
+/** @} */
+
+/** @brief PGM image meta data
+ **
+ ** A PGM image is a 2-D array of pixels of width #width and height
+ ** #height. Each pixel is an integer one or two bytes wide, depending
+ ** whether #max_value is smaller than 256.
+ **/
+
+typedef struct _VlPgmImage
+{
+  vl_size width ;      /**< image width.                     */
+  vl_size height ;     /**< image height.                    */
+  vl_size max_value ;  /**< pixel maximum value (<= 2^16-1). */
+  vl_bool is_raw ;     /**< is RAW format?                   */
+} VlPgmImage ;
+
+/** @name Core operations
+ ** @{ */
+VL_EXPORT int vl_pgm_extract_head (FILE *f, VlPgmImage *im) ;
+VL_EXPORT int vl_pgm_extract_data (FILE *f, VlPgmImage const *im, void *data) ;
+VL_EXPORT int vl_pgm_insert (FILE *f,
+                             VlPgmImage const *im,
+                             void const*data ) ;
+VL_EXPORT vl_size vl_pgm_get_npixels (VlPgmImage const *im) ;
+VL_EXPORT vl_size vl_pgm_get_bpp (VlPgmImage const *im) ;
+/** @} */
+
+/** @name Helper functions
+ ** @{ */
+VL_EXPORT int vl_pgm_write (char const *name,
+                            vl_uint8 const *data,
+                            int width, int height) ;
+VL_EXPORT int vl_pgm_write_f (char const *name,
+                              float const *data,
+                              int width, int height) ;
+VL_EXPORT int vl_pgm_read_new (char const *name,
+                               VlPgmImage *im,
+                               vl_uint8 **data) ;
+VL_EXPORT int vl_pgm_read_new_f (char const *name,
+                                 VlPgmImage *im,
+                                 float **data) ;
+
+/** @} */
+
+/* VL_PGM_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/qsort-def.h b/opensfm/src/third_party/vlfeat/vl/qsort-def.h
new file mode 100644
index 000000000..63b61c837
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/qsort-def.h
@@ -0,0 +1,200 @@
+/** @file   qsort-def.h
+ ** @brief  QSort preprocessor metaprogram
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file qsort-def.h
+
+@section qsort-def-overview Overview
+
+@ref qsort-def.h is a metaprogram to define specialized instances
+of the quick-sort algorithm.
+
+@section qsort-def-usage Usage
+
+@ref qsort-def.h is used to define a specialization of the
+::VL_QSORT_sort function that operates
+on a given type of array. For instance the code
+
+@code
+#define VL_QSORT_type float
+#define VL_QSORT_prefix my_qsort
+#include <vl/qsort-def.h>
+@endcode
+
+defines a function @c my_qsort_sort that operates on an array of floats.
+
+@todo large array compatibility.
+**/
+
+#include "host.h"
+#include <assert.h>
+
+#ifndef VL_QSORT_prefix
+#error "VL_QSORT_prefix must be defined"
+#endif
+
+#ifndef VL_QSORT_array
+#ifndef VL_QSORT_type
+#error "VL_QSORT_type must be defined if VL_QSORT_array is not"
+#endif
+#define VL_QSORT_array VL_QSORT_type*
+#define VL_QSORT_array_const VL_QSORT_type const*
+#endif
+
+#ifdef __DOXYGEN__
+#define VL_QSORT_prefix  QSortPrefix       /**< Prefix of the qsort functions */
+#define VL_QSORT_type    QSortType         /**< Data type of the qsort elements */
+#define VL_QSORT_array   QSortType*        /**< Data type of the qsort container */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_QSORT_cmp) || defined(__DOXYGEN__)
+#define VL_QSORT_cmp VL_XCAT(VL_QSORT_prefix, _cmp)
+
+/** @brief Compare two array elements
+ ** @param array qsort array.
+ ** @param indexA index of the first element @c A to compare.
+ ** @param indexB index of the second element @c B to comapre.
+ ** @return a negative number if @c A<B, 0 if @c A==B, and
+ ** a positive number if if @c A>B.
+ **/
+
+VL_INLINE VL_QSORT_type
+VL_QSORT_cmp
+(VL_QSORT_array_const array,
+ vl_uindex indexA,
+ vl_uindex indexB)
+{
+  return array[indexA] - array[indexB] ;
+}
+
+/* VL_QSORT_cmp */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_QSORT_swap) || defined(__DOXYGEN__)
+#define VL_QSORT_swap VL_XCAT(VL_QSORT_prefix, _swap)
+
+/** @brief Swap two array elements
+ ** @param array qsort array.
+ ** @param indexA index of the first element to swap.
+ ** @param indexB index of the second element to swap.
+ **
+ ** The function swaps the two elements @a a and @ b. The function
+ ** uses a temporary element of type ::VL_QSORT_type
+ ** and the copy operator @c =.
+ **/
+
+VL_INLINE void
+VL_QSORT_swap
+(VL_QSORT_array array,
+ vl_uindex indexA,
+ vl_uindex indexB)
+{
+  VL_QSORT_type t = array [indexA] ;
+  array [indexA] = array [indexB] ;
+  array [indexB] = t ;
+}
+
+/* VL_QSORT_swap */
+#endif
+
+/* ---------------------------------------------------------------- */
+#if ! defined(VL_QSORT_sort_recursive) || defined(__DOXYGEN__)
+#define VL_QSORT_sort_recursive VL_XCAT(VL_QSORT_prefix, _sort_recursive)
+
+/** @brief Sort portion of an array using quicksort
+ ** @param array (in/out) pointer to the array.
+ ** @param begin first element of the array portion.
+ ** @param end last element of the array portion.
+ **
+ ** The function sorts the array using quick-sort. Note that
+ ** @c begin must be not larger than @c end.
+ **/
+
+VL_INLINE void
+VL_QSORT_sort_recursive
+(VL_QSORT_array array, vl_uindex begin, vl_uindex end)
+{
+  vl_uindex pivot = (end + begin) / 2 ;
+  vl_uindex lowPart, i ;
+
+  assert (begin <= end) ;
+
+  /* swap pivot with last */
+  VL_QSORT_swap (array, pivot, end) ;
+  pivot = end ;
+
+  /*
+   Now scan from left to right, moving all element smaller
+   or equal than the pivot to the low part
+   array[0], array[1], ..., array[lowPart - 1].
+   */
+  lowPart = begin ;
+  for (i = begin; i < end ; ++i) { /* one less */
+    if (VL_QSORT_cmp (array, i, pivot) <= 0) {
+      /* array[i] must be moved into the low part */
+      VL_QSORT_swap (array, lowPart, i) ;
+      lowPart ++ ;
+    }
+  }
+
+  /* the pivot should also go into the low part */
+  VL_QSORT_swap (array, lowPart, pivot) ;
+  pivot = lowPart ;
+
+  /* do recursion */
+  if (pivot > begin) {
+    /* note that pivot-1 stays non-negative */
+    VL_QSORT_sort_recursive (array, begin, pivot - 1) ;
+  }
+  if (pivot < end) {
+    VL_QSORT_sort_recursive (array, pivot + 1, end) ;
+  }
+}
+
+/* VL_QSORT_sort_recursive */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_QSORT_sort) || defined(__DOXYGEN__)
+#define VL_QSORT_sort VL_XCAT(VL_QSORT_prefix, _sort)
+
+/** @brief Sort array using quicksort
+ ** @param array (in/out) pointer to the array.
+ ** @param size size of the array.
+ **
+ ** The function sorts the array using quick-sort.
+ **/
+
+VL_INLINE void
+VL_QSORT_sort
+(VL_QSORT_array array, vl_size size)
+{
+  assert (size >= 1) ;
+  VL_QSORT_sort_recursive (array, 0, size - 1) ;
+}
+
+/* VL_QSORT_qsort */
+#endif
+
+#undef VL_QSORT_prefix
+#undef VL_QSORT_swap
+#undef VL_QSORT_sort
+#undef VL_QSORT_sort_recursive
+#undef VL_QSORT_type
+#undef VL_QSORT_array
+#undef VL_QSORT_cmp
+
diff --git a/opensfm/src/third_party/vlfeat/vl/quickshift.c b/opensfm/src/third_party/vlfeat/vl/quickshift.c
new file mode 100644
index 000000000..802dbf25c
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/quickshift.c
@@ -0,0 +1,465 @@
+/** @file quickshift.c
+ ** @brief Quick shift - Definition
+ ** @author Brian Fulkerson
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page quickshift Quick shift image segmentation
+@author Brian Fulkerson
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref quickshift.h implements an image segmentation algorithm based on
+the quick shift clustering algorithm @cite{vedaldi08quick}.
+
+- @ref quickshift-intro
+- @ref quickshift-usage
+- @ref quickshift-tech
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section quickshift-intro Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Quick shift @cite{vedaldi08quick} is a fast mode seeking algorithm,
+similar to mean shift. The algorithm segments an RGB image (or any
+image with more than one channel) by identifying clusters of pixels in
+the joint spatial and color dimensions. Segments are local
+(superpixels) and can be used as a basis for further processing.
+
+Given an image, the algorithm calculates a forest of pixels whose
+branches are labeled with a distance value
+(::vl_quickshift_get_parents, ::vl_quickshift_get_dists). This
+specifies a hierarchical segmentation of the image, with segments
+corresponding to subtrees. Useful superpixels can be identified by
+cutting the branches whose distance label is above a given threshold
+(the threshold can be either fixed by hand, or determined by cross
+validation).
+
+Parameter influencing the algorithm are:
+
+- <b>Kernel size.</b> The pixel density and its modes are estimated by
+using a Parzen window estimator with a Gaussian kernel of the
+specified size (::vl_quickshift_set_kernel_size). The larger the size,
+the larger the neighborhoods of pixels considered.
+- <b>Maximum distance.</b> This (::vl_quickshift_set_max_dist) is the
+maximum distance between two pixels that the algorithm considers when
+building the forest. In principle, it can be infinity (so that a tree
+is returned), but in practice it is much faster to consider only
+relatively small distances (the maximum distance can be set to a small
+multiple of the kernel size).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section quickshift-usage Usage
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+- Create a new quick shift object (::vl_quickshift_new). The object
+  can be reused for multiple images of the same size.
+- Configure quick shift by setting the kernel size
+  (::vl_quickshift_set_kernel_size) and the maximum gap
+  (::vl_quickshift_set_max_dist). The latter is in principle not
+  necessary, but useful to speedup processing.
+- Process an image (::vl_quickshift_process).
+- Retrieve the parents (::vl_quickshift_get_parents) and the distances
+  (::vl_quickshift_get_dists). These can be used to segment
+  the image in superpixels.
+- Delete the quick shift object (::vl_quickshift_delete).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section quickshift-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+For each pixel <em>(x,y)</em>, quick shift regards @f$ (x,y,I(x,y))
+@f$ as a sample from a <em>d + 2</em> dimensional vector space. It
+then calculates the Parzen density estimate (with a Gaussian kernel of
+standard deviation @f$ \sigma @f$)
+
+@f[
+E(x,y) = P(x,y,I(x,y)) = \sum_{x'y'}
+\frac{1}{(2\pi\sigma)^{d+2}}
+\exp
+\left(
+-\frac{1}{2\sigma^2}
+\left[
+\begin{array}{c}
+x - x' \\
+y - y' \\
+I(x,y) - I(x',y') \\
+\end{array}
+\right]
+\right)
+@f]
+
+Then quick shift construct a tree connecting each image pixel to its
+nearest neighbor which has greater density value. Formally, write @f$
+(x',y') >_P (x,y) @f$ if, and only if,
+
+@f[
+  P(x',y',I(x',y')) > P(x,y,I(x,y))}.
+@f]
+
+Each pixel <em>(x, y)</em> is connected to the closest higher density
+pixel <em>parent(x, y)</em> that achieves the minimum distance in
+
+@f[
+ \mathrm{dist}(x,y) =
+ \mathrm{min}_{(x',y') > P(x,y)}
+\left(
+(x - x')^2 +
+(y - y')^2 +
+\| I(x,y) - I(x',y') \|_2^2
+\right).
+@f]
+
+**/
+
+#include "quickshift.h"
+#include "mathop.h"
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+
+/** -----------------------------------------------------------------
+ ** @internal
+ ** @brief Computes the accumulated channel L2 distance between
+ **        i,j + the distance between i,j
+ **
+ ** @param I    input image buffer
+ ** @param N1   size of the first dimension of the image
+ ** @param N2   size of the second dimension of the image
+ ** @param K    number of channels
+ ** @param i1   first dimension index of the first pixel to compare
+ ** @param i2   second dimension of the first pixel
+ ** @param j1   index of the second pixel to compare
+ ** @param j2   second dimension of the second pixel
+ **
+ ** Takes the L2 distance between the values in I at pixel i and j,
+ ** accumulating along K channels and adding in the distance
+ ** between i,j in the image.
+ **
+ ** @return the distance as described above
+ **/
+
+VL_INLINE
+vl_qs_type
+vl_quickshift_distance(vl_qs_type const * I,
+         int N1, int N2, int K,
+         int i1, int i2,
+         int j1, int j2)
+{
+  vl_qs_type dist = 0 ;
+  int d1 = j1 - i1 ;
+  int d2 = j2 - i2 ;
+  int k ;
+  dist += d1*d1 + d2*d2 ;
+  /* For k = 0...K-1, d+= L2 distance between I(i1,i2,k) and
+   * I(j1,j2,k) */
+  for (k = 0 ; k < K ; ++k) {
+    vl_qs_type d =
+      I [i1 + N1 * i2 + (N1*N2) * k] -
+      I [j1 + N1 * j2 + (N1*N2) * k] ;
+    dist += d*d ;
+  }
+  return dist ;
+}
+
+/** -----------------------------------------------------------------
+ ** @internal
+ ** @brief Computes the accumulated channel inner product between i,j + the
+ **        distance between i,j
+ **
+ ** @param I    input image buffer
+ ** @param N1   size of the first dimension of the image
+ ** @param N2   size of the second dimension of the image
+ ** @param K    number of channels
+ ** @param i1   first dimension index of the first pixel to compare
+ ** @param i2   second dimension of the first pixel
+ ** @param j1   index of the second pixel to compare
+ ** @param j2   second dimension of the second pixel
+ **
+ ** Takes the channel-wise inner product between the values in I at
+ ** pixel i and j, accumulating along K channels and adding in the
+ ** inner product between i,j in the image.
+ **
+ ** @return the inner product as described above
+ **/
+
+VL_INLINE
+vl_qs_type
+vl_quickshift_inner(vl_qs_type const * I,
+      int N1, int N2, int K,
+      int i1, int i2,
+      int j1, int j2)
+{
+  vl_qs_type ker = 0 ;
+  int k ;
+  ker += i1*j1 + i2*j2 ;
+  for (k = 0 ; k < K ; ++k) {
+    ker +=
+      I [i1 + N1 * i2 + (N1*N2) * k] *
+      I [j1 + N1 * j2 + (N1*N2) * k] ;
+  }
+  return ker ;
+}
+
+/** -----------------------------------------------------------------
+ ** @brief Create a quick shift object
+ ** @param image the image.
+ ** @param height the height (number of rows) of the image.
+ ** @param width the width (number of columns) of the image.
+ ** @param channels the number of channels of the image.
+ ** @return new quick shift object.
+ **
+ ** The @c image is an array of ::vl_qs_type values with three
+ ** dimensions (respectively @c widht, @c height, and @c
+ ** channels). Typically, a color (e.g, RGB) image has three
+ ** channels. The linear index of a pixel is computed with:
+ ** @c channels * @c width* @c height + @c row + @c height * @c col.
+ **/
+
+VL_EXPORT
+VlQS *
+vl_quickshift_new(vl_qs_type const * image, int height, int width,
+                       int channels)
+{
+  VlQS * q = vl_malloc(sizeof(VlQS));
+
+  q->image    = (vl_qs_type *)image;
+  q->height   = height;
+  q->width    = width;
+  q->channels = channels;
+
+  q->medoid   = VL_FALSE;
+  q->tau      = VL_MAX(height,width)/50;
+  q->sigma    = VL_MAX(2, q->tau/3);
+
+  q->dists    = vl_calloc(height*width, sizeof(vl_qs_type));
+  q->parents  = vl_calloc(height*width, sizeof(int));
+  q->density  = vl_calloc(height*width, sizeof(vl_qs_type)) ;
+
+  return q;
+}
+
+/** -----------------------------------------------------------------
+ ** @brief Create a quick shift objet
+ ** @param q quick shift object.
+ **/
+
+VL_EXPORT
+void vl_quickshift_process(VlQS * q)
+{
+  vl_qs_type const *I = q->image;
+  int        *parents = q->parents;
+  vl_qs_type *E = q->density;
+  vl_qs_type *dists = q->dists;
+  vl_qs_type *M = 0, *n = 0 ;
+  vl_qs_type sigma = q->sigma ;
+  vl_qs_type tau = q->tau;
+  vl_qs_type tau2 = tau*tau;
+
+  int K = q->channels, d;
+  int N1 = q->height, N2 = q->width;
+  int i1,i2, j1,j2, R, tR;
+
+  d = 2 + K ; /* Total dimensions include spatial component (x,y) */
+
+  if (q->medoid) { /* n and M are only used in mediod shift */
+    M = (vl_qs_type *) vl_calloc(N1*N2*d, sizeof(vl_qs_type)) ;
+    n = (vl_qs_type *) vl_calloc(N1*N2,   sizeof(vl_qs_type)) ;
+  }
+
+  R = (int) ceil (3 * sigma) ;
+  tR = (int) ceil (tau) ;
+
+  /* -----------------------------------------------------------------
+   *                                                                 n
+   * -------------------------------------------------------------- */
+
+  /* If we are doing medoid shift, initialize n to the inner product of the
+   * image with itself
+   */
+  if (n) {
+    for (i2 = 0 ; i2 < N2 ; ++ i2) {
+      for (i1 = 0 ; i1 < N1 ; ++ i1) {
+        n [i1 + N1 * i2] = vl_quickshift_inner(I,N1,N2,K,
+                                               i1,i2,
+                                               i1,i2) ;
+      }
+    }
+  }
+
+  /* -----------------------------------------------------------------
+   *                                                 E = - [oN'*F]', M
+   * -------------------------------------------------------------- */
+
+  /*
+     D_ij = d(x_i,x_j)
+     E_ij = exp(- .5 * D_ij / sigma^2) ;
+     F_ij = - E_ij
+     E_i  = sum_j E_ij
+     M_di = sum_j X_j F_ij
+
+     E is the parzen window estimate of the density
+     0 = dissimilar to everything, windowsize = identical
+  */
+
+  for (i2 = 0 ; i2 < N2 ; ++ i2) {
+    for (i1 = 0 ; i1 < N1 ; ++ i1) {
+
+      int j1min = VL_MAX(i1 - R, 0   ) ;
+      int j1max = VL_MIN(i1 + R, N1-1) ;
+      int j2min = VL_MAX(i2 - R, 0   ) ;
+      int j2max = VL_MIN(i2 + R, N2-1) ;
+
+      /* For each pixel in the window compute the distance between it and the
+       * source pixel */
+      for (j2 = j2min ; j2 <= j2max ; ++ j2) {
+        for (j1 = j1min ; j1 <= j1max ; ++ j1) {
+          vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
+          /* Make distance a similarity */
+          vl_qs_type Fij = - exp(- Dij / (2*sigma*sigma)) ;
+
+          /* E is E_i above */
+          E [i1 + N1 * i2] -= Fij ;
+
+          if (M) {
+            /* Accumulate votes for the median */
+            int k ;
+            M [i1 + N1*i2 + (N1*N2) * 0] += j1 * Fij ;
+            M [i1 + N1*i2 + (N1*N2) * 1] += j2 * Fij ;
+            for (k = 0 ; k < K ; ++k) {
+              M [i1 + N1*i2 + (N1*N2) * (k+2)] +=
+                I [j1 + N1*j2 + (N1*N2) * k] * Fij ;
+            }
+          }
+
+        } /* j1 */
+      } /* j2 */
+
+    }  /* i1 */
+  } /* i2 */
+
+  /* -----------------------------------------------------------------
+   *                                               Find best neighbors
+   * -------------------------------------------------------------- */
+
+  if (q->medoid) {
+
+    /*
+       Qij = - nj Ei - 2 sum_k Gjk Mik
+       n is I.^2
+    */
+
+    /* medoid shift */
+    for (i2 = 0 ; i2 < N2 ; ++i2) {
+      for (i1 = 0 ; i1 < N1 ; ++i1) {
+
+        vl_qs_type sc_best = 0  ;
+        /* j1/j2 best are the best indicies for each i */
+        vl_qs_type j1_best = i1 ;
+        vl_qs_type j2_best = i2 ;
+
+        int j1min = VL_MAX(i1 - R, 0   ) ;
+        int j1max = VL_MIN(i1 + R, N1-1) ;
+        int j2min = VL_MAX(i2 - R, 0   ) ;
+        int j2max = VL_MIN(i2 + R, N2-1) ;
+
+        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
+          for (j1 = j1min ; j1 <= j1max ; ++ j1) {
+
+            vl_qs_type Qij = - n [j1 + j2 * N1] * E [i1 + i2 * N1] ;
+            int k ;
+
+            Qij -= 2 * j1 * M [i1 + i2 * N1 + (N1*N2) * 0] ;
+            Qij -= 2 * j2 * M [i1 + i2 * N1 + (N1*N2) * 1] ;
+            for (k = 0 ; k < K ; ++k) {
+              Qij -= 2 *
+                I [j1 + j2 * N1 + (N1*N2) * k] *
+                M [i1 + i2 * N1 + (N1*N2) * (k + 2)] ;
+            }
+
+            if (Qij > sc_best) {
+              sc_best = Qij ;
+              j1_best = j1 ;
+              j2_best = j2 ;
+            }
+          }
+        }
+
+        /* parents_i is the linear index of j which is the best pair
+         * dists_i is the score of the best match
+         */
+        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
+        dists[i1 + N1 * i2] = sc_best ;
+      }
+    }
+
+  } else {
+
+    /* Quickshift assigns each i to the closest j which has an increase in the
+     * density (E). If there is no j s.t. Ej > Ei, then dists_i == inf (a root
+     * node in one of the trees of merges).
+     */
+    for (i2 = 0 ; i2 < N2 ; ++i2) {
+      for (i1 = 0 ; i1 < N1 ; ++i1) {
+
+        vl_qs_type E0 = E [i1 + N1 * i2] ;
+        vl_qs_type d_best = VL_QS_INF ;
+        vl_qs_type j1_best = i1   ;
+        vl_qs_type j2_best = i2   ;
+
+        int j1min = VL_MAX(i1 - tR, 0   ) ;
+        int j1max = VL_MIN(i1 + tR, N1-1) ;
+        int j2min = VL_MAX(i2 - tR, 0   ) ;
+        int j2max = VL_MIN(i2 + tR, N2-1) ;
+
+        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
+          for (j1 = j1min ; j1 <= j1max ; ++ j1) {
+            if (E [j1 + N1 * j2] > E0) {
+              vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
+              if (Dij <= tau2 && Dij < d_best) {
+                d_best = Dij ;
+                j1_best = j1 ;
+                j2_best = j2 ;
+              }
+            }
+          }
+        }
+
+        /* parents is the index of the best pair */
+        /* dists_i is the minimal distance, inf implies no Ej > Ei within
+         * distance tau from the point */
+        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
+        dists[i1 + N1 * i2] = sqrt(d_best) ;
+      }
+    }
+  }
+
+  if (M) vl_free(M) ;
+  if (n) vl_free(n) ;
+}
+
+/** -----------------------------------------------------------------
+ ** @brief Delete quick shift object
+ ** @param q quick shift object.
+ **/
+
+void vl_quickshift_delete(VlQS * q)
+{
+  if (q) {
+    if (q->parents) vl_free(q->parents);
+    if (q->dists)   vl_free(q->dists);
+    if (q->density) vl_free(q->density);
+
+    vl_free(q);
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/quickshift.h b/opensfm/src/third_party/vlfeat/vl/quickshift.h
new file mode 100644
index 000000000..d7bec8bf6
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/quickshift.h
@@ -0,0 +1,211 @@
+/** @file quickshift.h
+ ** @brief Quick shift (@ref quickshift)
+ ** @author Andrea Vedaldi
+ ** @author Brian Fulkerson
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_QUICKSHIFT_H
+#define VL_QUICKSHIFT_H
+
+#include "generic.h"
+#include "mathop.h"
+
+/** @brief quick shift datatype */
+typedef double vl_qs_type ;
+
+/** @brief quick shift infinity constant */
+#define VL_QS_INF VL_INFINITY_D /* Change to _F for float math */
+
+/** ------------------------------------------------------------------
+ ** @brief quick shift results
+ **
+ ** This implements quick shift mode seeking.
+ **/
+
+typedef struct _VlQS
+{
+  vl_qs_type *image ;   /**< height x width x channels feature image */
+  int height;           /**< height of the image */
+  int width;            /**< width of the image */
+  int channels;         /**< number of channels in the image */
+
+  vl_bool medoid;
+  vl_qs_type sigma;
+  vl_qs_type tau;
+
+  int *parents ;
+  vl_qs_type *dists ;
+  vl_qs_type *density ;
+} VlQS ;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT
+VlQS*  vl_quickshift_new (vl_qs_type const * im, int height, int width,
+                          int channels);
+
+VL_EXPORT
+void   vl_quickshift_delete (VlQS *q) ;
+/** @} */
+
+/** @name Process data
+ ** @{
+ **/
+
+VL_EXPORT
+void   vl_quickshift_process (VlQS *q) ;
+
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{
+ **/
+VL_INLINE vl_qs_type    vl_quickshift_get_max_dist      (VlQS const *q) ;
+VL_INLINE vl_qs_type    vl_quickshift_get_kernel_size    (VlQS const *q) ;
+VL_INLINE vl_bool       vl_quickshift_get_medoid   (VlQS const *q) ;
+
+VL_INLINE int *        vl_quickshift_get_parents  (VlQS const *q) ;
+VL_INLINE vl_qs_type * vl_quickshift_get_dists    (VlQS const *q) ;
+VL_INLINE vl_qs_type * vl_quickshift_get_density  (VlQS const *q) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_INLINE void vl_quickshift_set_max_dist    (VlQS *f, vl_qs_type tau) ;
+VL_INLINE void vl_quickshift_set_kernel_size  (VlQS *f, vl_qs_type sigma) ;
+VL_INLINE void vl_quickshift_set_medoid (VlQS *f, vl_bool medoid) ;
+/** @} */
+
+/* -------------------------------------------------------------------
+ *                                     Inline functions implementation
+ * ---------------------------------------------------------------- */
+
+/** ------------------------------------------------------------------
+ ** @brief Get tau.
+ ** @param q quick shift object.
+ ** @return the maximum distance in the feature space between nodes in the
+ **         quick shift tree.
+ **/
+
+VL_INLINE vl_qs_type
+vl_quickshift_get_max_dist (VlQS const *q)
+{
+  return q->tau ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get sigma.
+ ** @param q quick shift object.
+ ** @return the standard deviation of the kernel used in the Parzen density
+ **         estimate.
+ **/
+
+VL_INLINE vl_qs_type
+vl_quickshift_get_kernel_size (VlQS const *q)
+{
+  return q->sigma ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get medoid.
+ ** @param q quick Shift object.
+ ** @return @c true if medoid shift is used instead of quick shift.
+ **/
+
+VL_INLINE vl_bool
+vl_quickshift_get_medoid (VlQS const *q)
+{
+  return q->medoid ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get parents.
+ ** @param q quick shift object.
+ ** @return a @c height x @c width matrix where each element contains the
+ **         linear index of its parent node. The node is a root if its
+ **         value is its own linear index.
+ **/
+
+VL_INLINE int *
+vl_quickshift_get_parents (VlQS const *q)
+{
+  return q->parents ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get dists.
+ ** @param q quick shift object.
+ ** @return for each pixel, the distance in feature space to the pixel
+ **         that is its parent in the quick shift tree. The distance is
+ **         set to 'inf' if the pixel is a root node.
+ **/
+
+VL_INLINE vl_qs_type *
+vl_quickshift_get_dists (VlQS const *q)
+{
+  return q->dists ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get density.
+ ** @param q quick shift object.
+ ** @return the estimate of the density at each pixel.
+ **/
+
+VL_INLINE vl_qs_type *
+vl_quickshift_get_density (VlQS const *q)
+{
+  return q->density ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set sigma
+ ** @param q quick shift object.
+ ** @param sigma standard deviation of the kernel used in the Parzen density
+ **        estimate.
+ **/
+
+VL_INLINE void
+vl_quickshift_set_kernel_size (VlQS *q, vl_qs_type sigma)
+{
+  q -> sigma = sigma ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set max distance
+ ** @param q quick shift object.
+ ** @param tau the maximum distance in the feature space between nodes in the
+ **            quick shift tree.
+ **/
+
+VL_INLINE void
+vl_quickshift_set_max_dist (VlQS *q, vl_qs_type tau)
+{
+  q -> tau = tau ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set medoid
+ ** @param q quick shift object.
+ ** @param medoid @c true to use kernelized medoid shift, @c false (default) uses
+ **        quick shift.
+ **/
+
+VL_INLINE void
+vl_quickshift_set_medoid (VlQS *q, vl_bool medoid)
+{
+  q -> medoid = medoid ;
+}
+
+
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/random.c b/opensfm/src/third_party/vlfeat/vl/random.c
new file mode 100644
index 000000000..107ee1fb7
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/random.c
@@ -0,0 +1,266 @@
+/** @file random.c
+ ** @brief Random number generator - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ------------------------------------------------------------- -->
+@page random Random number generator
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+The module @ref random.h implements random number generation in
+VLFeat.  The generator is based on the popular Mersenne Twister
+algorithm @cite{matsumoto98mersenne} (which is the same as MATLAB
+random generator from MATLAB version 7.4 onwards).
+
+<!-- ------------------------------------------------------------- -->
+@section random-starting Getting started
+<!-- ------------------------------------------------------------- -->
+
+In VLFeat, a random number generator is implemented by an object of
+type ::VlRand. The simplest way to obtain such an object is to get the
+default random generator by
+
+@code
+VlRand * rand = vl_get_rand() ;
+vl_int32 signedRandomInteger = vl_rand_int31(rand) ;
+@code
+
+Note that there is one such generator per thread (see
+::vl_get_rand). If more control is desired, a new ::VlRand object can
+be easily created.  The object is lightweight, designed to be
+allocated on the stack:
+
+@code
+VlRand rand ;
+vl_rand_init (&rand) ;
+@endcode
+
+The generator can be seeded by ::vl_rand_seed and ::vl_rand_seed_by_array.
+For instance:
+
+@code
+vl_rand_seed (&rand, clock()) ;
+@endcode
+
+The generator can be used to obtain random quantities of
+various types:
+
+- ::vl_rand_int31, ::vl_rand_uint32 for 32-bit random integers;
+- ::vl_rand_real1 for a double in [0,1];
+- ::vl_rand_real2 for a double in [0,1);
+- ::vl_rand_real3 for a double in (0,1);
+- ::vl_rand_res53 for a double in [0,1) with high resolution.
+
+There is no need to explicitly destroy a ::VlRand instance.
+
+**/
+
+#include "random.h"
+
+/*
+A C-program for MT19937, with initialization improved 2002/1/26.
+Coded by Takuji Nishimura and Makoto Matsumoto.
+
+Before using, initialize the state by using init_genrand(seed)
+or init_by_array(init_key, keySize).
+
+Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. The names of its contributors may not be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+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.
+
+
+Any feedback is very welcome.
+http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+/* Period parameters */
+#define N 624
+#define M 397
+#define MATRIX_A VL_UINT32_C(0x9908b0df)   /* constant vector a */
+#define UPPER_MASK VL_UINT32_C(0x80000000) /* most asignificant w-r bits */
+#define LOWER_MASK VL_UINT32_C(0x7fffffff) /* least significant r bits */
+
+/* initializes mt[N] with a seed */
+
+/** @brief Initialise random number generator
+ ** @param self number generator.
+ **/
+
+void
+vl_rand_init (VlRand * self)
+{
+  memset (self->mt, 0, sizeof(self->mt[0]) * N) ;
+  self->mti = N + 1 ;
+}
+
+/** @brief Seed the state of the random number generator
+ ** @param self random number generator.
+ ** @param s seed.
+ **/
+
+void
+vl_rand_seed (VlRand * self, vl_uint32 s)
+{
+#define mti self->mti
+#define mt self->mt
+  mt[0]= s & VL_UINT32_C(0xffffffff);
+  for (mti=1; mti<N; mti++) {
+    mt[mti] =
+      (VL_UINT32_C(1812433253) * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
+    /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+    /* In the previous versions, MSBs of the seed affect   */
+    /* only MSBs of the array mt[].                        */
+    /* 2002/01/09 modified by Makoto Matsumoto             */
+    mt[mti] &= VL_UINT32_C(0xffffffff);
+    /* for >32 bit machines */
+  }
+#undef mti
+#undef mt
+}
+
+/** @brief Seed the state of the random number generator by an array
+ ** @param self     random number generator.
+ ** @param key      array of numbers.
+ ** @param keySize  length of the array.
+ **/
+
+void
+vl_rand_seed_by_array (VlRand * self, vl_uint32 const key [], vl_size keySize)
+{
+#define mti self->mti
+#define mt self->mt
+  int i, j, k;
+  vl_rand_seed (self, VL_UINT32_C(19650218));
+  i=1; j=0;
+  k = (N > keySize ? N : (int)keySize);
+  for (; k; k--) {
+    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1664525)))
+      + key[j] + j; /* non linear */
+    mt[i] &= VL_UINT32_C(0xffffffff); /* for WORDSIZE > 32 machines */
+    i++; j++;
+    if (i>=N) { mt[0] = mt[N-1]; i=1; }
+    if (j>=(signed)keySize) j=0;
+  }
+  for (k=N-1; k; k--) {
+    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1566083941)))
+      - i; /* non linear */
+    mt[i] &= VL_UINT32_C(0xffffffff) ; /* for WORDSIZE > 32 machines */
+    i++;
+    if (i>=N) { mt[0] = mt[N-1]; i=1; }
+  }
+
+  mt[0] = VL_UINT32_C(0x80000000); /* MSB is 1; assuring non-zero initial array */
+#undef mti
+#undef mt
+}
+
+/** @brief Randomly permute and array of indexes.
+ ** @param self random number generator.
+ ** @param array array of indexes.
+ ** @param size number of element in the array.
+ **
+ ** The function uses *Algorithm P*, also known as *Knuth shuffle*.
+ **/
+
+void
+vl_rand_permute_indexes (VlRand *self, vl_index *array, vl_size size)
+{
+  vl_index i, j, tmp;
+  for (i = size - 1 ; i > 0; i--) {
+    /* Pick a random index j in the range 0, i + 1 and swap it with i */
+    j = (vl_int) vl_rand_uindex (self, i + 1) ;
+    tmp = array[i] ; array[i] = array[j] ; array[j] = tmp ;
+  }
+}
+
+
+/** @brief Generate a random UINT32
+ ** @param self random number generator.
+ ** @return a random number in [0, 0xffffffff].
+ **/
+
+vl_uint32
+vl_rand_uint32 (VlRand * self)
+{
+  vl_uint32 y;
+  static vl_uint32 mag01[2]={VL_UINT32_C(0x0), MATRIX_A};
+  /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+#define mti self->mti
+#define mt self->mt
+
+  if (mti >= N) { /* generate N words at one time */
+    int kk;
+
+    if (mti == N+1)   /* if init_genrand() has not been called, */
+      vl_rand_seed (self, VL_UINT32_C(5489)); /* a default initial seed is used */
+
+    for (kk=0;kk<N-M;kk++) {
+      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+      mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
+    }
+    for (;kk<N-1;kk++) {
+      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+      mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
+    }
+    y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
+    mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
+
+    mti = 0;
+  }
+
+  y = mt[mti++];
+
+  /* Tempering */
+  y ^= (y >> 11);
+  y ^= (y << 7) & VL_UINT32_C(0x9d2c5680);
+  y ^= (y << 15) & VL_UINT32_C(0xefc60000);
+  y ^= (y >> 18);
+
+  return (vl_uint32)y;
+
+#undef mti
+#undef mt
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/random.h b/opensfm/src/third_party/vlfeat/vl/random.h
new file mode 100644
index 000000000..f464fc47b
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/random.h
@@ -0,0 +1,162 @@
+/** @file random.h
+ ** @brief Random number generator (@ref random)
+ ** @author Andrea Vedaldi
+ ** @see @ref random
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_RANDOM_H
+#define VL_RANDOM_H
+
+#include "host.h"
+
+/** @brief Random numbber generator state */
+typedef struct _VlRand {
+  vl_uint32 mt [624] ;
+  vl_uint32 mti ;
+} VlRand ;
+
+/** @name Setting and reading the state
+ **
+ ** @{ */
+VL_EXPORT void vl_rand_init (VlRand * self) ;
+VL_EXPORT void vl_rand_seed (VlRand * self, vl_uint32 s) ;
+VL_EXPORT void vl_rand_seed_by_array (VlRand * self,
+                                      vl_uint32 const key [],
+                                      vl_size keySize) ;
+/** @} */
+
+/** @name Generate random numbers
+ **
+ ** @{ */
+VL_INLINE vl_uint64 vl_rand_uint64 (VlRand * self) ;
+VL_INLINE vl_int64  vl_rand_int63  (VlRand * self) ;
+VL_EXPORT vl_uint32 vl_rand_uint32 (VlRand * self) ;
+VL_INLINE vl_int32  vl_rand_int31  (VlRand * self) ;
+VL_INLINE double    vl_rand_real1  (VlRand * self) ;
+VL_INLINE double    vl_rand_real2  (VlRand * self) ;
+VL_INLINE double    vl_rand_real3  (VlRand * self) ;
+VL_INLINE double    vl_rand_res53  (VlRand * self) ;
+VL_INLINE vl_uindex vl_rand_uindex (VlRand * self, vl_uindex range) ;
+/** @} */
+
+VL_EXPORT void vl_rand_permute_indexes (VlRand * self, vl_index* array, vl_size size) ;
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Generate a random index in a given range
+ ** @param self random number generator.
+ ** @param range range.
+ ** @return an index sampled uniformly at random in the interval [0, @c range - 1]
+ **
+ ** @remark Currently, this function uses a simple algorithm that
+ ** may yield slightly biased samples if @c range is not a power of
+ ** two.
+ **/
+
+VL_INLINE vl_uindex
+vl_rand_uindex (VlRand * self, vl_uindex range)
+{
+  if (range <= 0xffffffff) {
+    /* 32-bit version */
+    return (vl_rand_uint32 (self) % (vl_uint32)range) ;
+  } else {
+    /* 64-bit version */
+    return (vl_rand_uint64 (self) % range) ;
+  }
+}
+
+/** @brief Generate a random UINT64
+ ** @param self random number generator.
+ ** @return a random number in [0, 0xffffffffffffffff].
+ **/
+
+VL_INLINE vl_uint64
+vl_rand_uint64 (VlRand * self)
+{
+  vl_uint64 a = vl_rand_uint32 (self) ;
+  vl_uint64 b = vl_rand_uint32 (self) ;
+  return (a << 32) | b ;
+}
+
+/** @brief Generate a random INT63
+ ** @param self random number generator.
+ ** @return a random number in [0, 0x7fffffffffffffff].
+ **/
+
+VL_INLINE vl_int64
+vl_rand_int63 (VlRand * self)
+{
+  return (vl_int64)(vl_rand_uint64 (self) >> 1) ;
+}
+
+/** @brief Generate a random INT31
+ ** @param self random number generator.
+ ** @return a random number in [0, 0x7fffffff].
+ **/
+
+VL_INLINE vl_int32
+vl_rand_int31 (VlRand * self)
+{
+  return (vl_int32)(vl_rand_uint32 (self) >> 1) ;
+}
+
+/** @brief Generate a random number in [0,1]
+ ** @param self random number generator.
+ ** @return a random number.
+ **/
+
+VL_INLINE double
+vl_rand_real1 (VlRand * self)
+{
+  return vl_rand_uint32(self)*(1.0/4294967295.0);
+  /* divided by 2^32-1 */
+}
+
+/** @brief Generate a random number in [0,1)
+ ** @param self random number generator.
+ ** @return a random number.
+ **/
+
+VL_INLINE double
+vl_rand_real2 (VlRand * self)
+{
+  return vl_rand_uint32(self)*(1.0/4294967296.0);
+  /* divided by 2^32 */
+}
+
+/** @brief Generate a random number in (0,1)
+ ** @param self random number generator.
+ ** @return a random number.
+ **/
+
+VL_INLINE double
+vl_rand_real3 (VlRand * self)
+{
+  return (((double)vl_rand_uint32(self)) + 0.5)*(1.0/4294967296.0);
+  /* divided by 2^32 */
+}
+
+/** @brief Generate a random number in [0,1) with 53-bit resolution
+ ** @param self random number generator.
+ ** @return a random number.
+ **/
+
+VL_INLINE double
+vl_rand_res53 (VlRand * self)
+{
+  vl_uint32
+  a = vl_rand_uint32(self) >> 5,
+  b = vl_rand_uint32(self) >> 6 ;
+  return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0) ;
+}
+
+/* VL_RANDOM_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/rodrigues.c b/opensfm/src/third_party/vlfeat/vl/rodrigues.c
new file mode 100644
index 000000000..14958c9df
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/rodrigues.c
@@ -0,0 +1,329 @@
+/** @file rodrigues.c
+ ** @brief Rodrigues formulas - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#include "generic.h"
+#include "mathop.h"
+#include "rodrigues.h"
+
+#include <math.h>
+
+/** @brief Rodrigues' formula
+ ** @param R_pt  3x3 matrix - array of 9 double (in) .
+ ** @param dR_pt 9x3 matrix - array of 27 double (in).
+ ** @param om_pt 3 vector - array of 3 dobule (out).
+ **/
+
+void
+vl_rodrigues(double* R_pt, double* dR_pt, const double* om_pt)
+{
+  /*
+    Let
+
+       th = |om|,  r=w/th,
+       sth=sin(th),  cth=cos(th),
+       ^om = hat(om)
+
+    Then the rodrigues formula is an expansion of the exponential
+    function:
+
+     rodrigues(om) = exp ^om = I + ^r sth + ^r^2 (1 - cth).
+
+    The derivative can be computed by elementary means and
+    results:
+
+    d(vec rodrigues(om))    sth  d ^r    1 - cth  d (^r)^2
+    -------------------- =  ---- ----- + -------  -------- +
+          d om^T             th  d r^T     th      d r^T
+
+                          sth                     1 - cth
+          + vec^r (cth - -----) + vec^r^2 (sth - 2-------)r^T
+                          th                         th
+  */
+
+#define OM(i)   om_pt[(i)]
+#define R(i,j)  R_pt[(i)+3*(j)]
+#define DR(i,j) dR_pt[(i)+9*(j)]
+#undef small
+
+  const double small = 1e-6 ;
+
+  double th = sqrt( OM(0)*OM(0) +
+                    OM(1)*OM(1) +
+                    OM(2)*OM(2) ) ;
+
+  if( th < small ) {
+    R(0,0) = 1.0 ; R(0,1) = 0.0 ; R(0,2) = 0.0 ;
+    R(1,0) = 0.0 ; R(1,1) = 1.0 ; R(1,2) = 0.0 ;
+    R(2,0) = 0.0 ; R(2,1) = 0.0 ; R(2,2) = 1.0 ;
+
+    if(dR_pt) {
+      DR(0,0) = 0  ; DR(0,1) = 0   ; DR(0,2) = 0 ;
+      DR(1,0) = 0  ; DR(1,1) = 0   ; DR(1,2) = 1 ;
+      DR(2,0) = 0  ; DR(2,1) = -1  ; DR(2,2) = 0 ;
+
+      DR(3,0) = 0  ; DR(3,1) = 0   ; DR(3,2) = -1 ;
+      DR(4,0) = 0  ; DR(4,1) = 0   ; DR(4,2) = 0 ;
+      DR(5,0) = 1  ; DR(5,1) = 0   ; DR(5,2) = 0 ;
+
+      DR(6,0) = 0  ; DR(6,1) = 1   ; DR(6,2) = 0 ;
+      DR(7,0) = -1 ; DR(7,1) = 0   ; DR(7,2) = 0 ;
+      DR(8,0) = 0  ; DR(8,1) = 0   ; DR(8,2) = 0 ;
+    }
+    return ;
+  }
+
+  {
+    double x = OM(0) / th ;
+    double y = OM(1) / th ;
+    double z = OM(2) / th ;
+
+    double xx = x*x ;
+    double xy = x*y ;
+    double xz = x*z ;
+    double yy = y*y ;
+    double yz = y*z ;
+    double zz = z*z ;
+
+    const double yx = xy ;
+    const double zx = xz ;
+    const double zy = yz ;
+
+    double sth  = sin(th) ;
+    double cth  = cos(th) ;
+    double mcth = 1.0 - cth ;
+
+    R(0,0) = 1          - mcth * (yy+zz) ;
+    R(1,0) =     sth*z  + mcth * xy ;
+    R(2,0) =   - sth*y  + mcth * xz ;
+
+    R(0,1) =   - sth*z  + mcth * yx ;
+    R(1,1) = 1          - mcth * (zz+xx) ;
+    R(2,1) =     sth*x  + mcth * yz ;
+
+    R(0,2) =     sth*y  + mcth * xz ;
+    R(1,2) =   - sth*x  + mcth * yz ;
+    R(2,2) = 1          - mcth * (xx+yy) ;
+
+    if(dR_pt) {
+      double a =  sth / th ;
+      double b = mcth / th ;
+      double c = cth - a ;
+      double d = sth - 2*b ;
+
+      DR(0,0) =                         - d * (yy+zz) * x ;
+      DR(1,0) =        b*y   + c * zx   + d * xy      * x ;
+      DR(2,0) =        b*z   - c * yx   + d * xz      * x ;
+
+      DR(3,0) =        b*y   - c * zx   + d * xy      * x ;
+      DR(4,0) =     -2*b*x              - d * (zz+xx) * x ;
+      DR(5,0) =  a           + c * xx   + d * yz      * x ;
+
+      DR(6,0) =        b*z   + c * yx   + d * zx      * x ;
+      DR(7,0) = -a           - c * xx   + d * zy      * x ;
+      DR(8,0) =     -2*b*x              - d * (yy+xx) * x ;
+
+      DR(0,1) =     -2*b*y              - d * (yy+zz) * y ;
+      DR(1,1) =        b*x   + c * zy   + d * xy      * y ;
+      DR(2,1) = -a           - c * yy   + d * xz      * y ;
+
+      DR(3,1) =        b*x   - c * zy   + d * xy      * y ;
+      DR(4,1) =                         - d * (zz+xx) * y ;
+      DR(5,1) =        b*z   + c * xy   + d * yz      * y ;
+
+      DR(6,1) = a            + c * yy   + d * zx      * y ;
+      DR(7,1) =        b*z   - c * xy   + d * zy      * y ;
+      DR(8,1) =     -2*b*y              - d * (yy+xx) * y ;
+
+      DR(0,2) =     -2*b*z              - d * (yy+zz) * z ;
+      DR(1,2) =  a           + c * zz   + d * xy      * z ;
+      DR(2,2) =        b*x   - c * yz   + d * xz      * z ;
+
+      DR(3,2) =  -a          - c * zz   + d * xy      * z ;
+      DR(4,2) =     -2*b*z              - d * (zz+xx) * z ;
+      DR(5,2) =        b*y   + c * xz   + d * yz      * z ;
+
+      DR(6,2) =        b*x   + c * yz   + d * zx      * z ;
+      DR(7,2) =        b*y   - c * xz   + d * zy      * z ;
+      DR(8,2) =                         - d * (yy+xx) * z ;
+    }
+  }
+
+#undef OM
+#undef R
+#undef DR
+
+}
+
+/** @brief Inverse Rodrigues formula
+ ** @param om_pt  3    vector - array of 3   dobule (out).
+ ** @param dom_pt 3x9  matrix - array of 3x9 dobule (out).
+ ** @param R_pt   3x3  matrix - array of 9   double (in).
+ **
+ ** This function computes the Rodrigues formula of the argument @a
+ ** om_pt. The result is stored int the matrix @a R_pt. If @a dR_pt is
+ ** non null, then the derivative of the Rodrigues formula is computed
+ ** and stored into the matrix @a dR_pt.
+ **/
+
+VL_EXPORT
+void vl_irodrigues(double* om_pt, double* dom_pt, const double* R_pt)
+{
+  /*
+                    tr R - 1          1    [ R32 - R23 ]
+      th = cos^{-1} --------,  r =  ------ [ R13 - R31 ], w = th r.
+                        2           2 sth  [ R12 - R21 ]
+
+      sth = sin(th)
+
+       dw    th*cth-sth      dw     th   [di3 dj2 - di2 dj3]
+      ---- = ---------- r,  ---- = ----- [di1 dj3 - di3 dj1].
+      dRii     2 sth^2      dRij   2 sth [di1 dj2 - di2 dj1]
+
+      trace(A) < -1 only for small num. errors.
+  */
+
+#define OM(i)    om_pt[(i)]
+#define DOM(i,j) dom_pt[(i)+3*(j)]
+#define R(i,j)   R_pt[(i)+3*(j)]
+#define W(i,j)   W_pt[(i)+3*(j)]
+
+  const double small = 1e-6 ;
+
+  double th = acos
+    (0.5*(VL_MAX(R(0,0)+R(1,1)+R(2,2),-1.0) - 1.0)) ;
+
+  double sth = sin(th) ;
+  double cth = cos(th) ;
+
+  if(fabs(sth) < small && cth < 0) {
+    /*
+      we have this singularity when the rotation  is about pi (or -pi)
+      we use the fact that in this case
+
+      hat( sqrt(1-cth) * r )^2 = W = (0.5*(R+R') - eye(3))
+
+      which gives
+
+      (1-cth) rx^2 = 0.5 * (W(1,1)-W(2,2)-W(3,3))
+      (1-cth) ry^2 = 0.5 * (W(2,2)-W(3,3)-W(1,1))
+      (1-cth) rz^2 = 0.5 * (W(3,3)-W(1,1)-W(2,2))
+    */
+
+    double W_pt [9], x, y, z ;
+    W_pt[0] = 0.5*( R(0,0) + R(0,0) ) - 1.0 ;
+    W_pt[1] = 0.5*( R(1,0) + R(0,1) ) ;
+    W_pt[2] = 0.5*( R(2,0) + R(0,2) );
+
+    W_pt[3] = 0.5*( R(0,1) + R(1,0) );
+    W_pt[4] = 0.5*( R(1,1) + R(1,1) ) - 1.0;
+    W_pt[5] = 0.5*( R(2,1) + R(1,2) );
+
+    W_pt[6] =  0.5*( R(0,2) + R(2,0) ) ;
+    W_pt[7] =  0.5*( R(1,2) + R(2,1) ) ;
+    W_pt[8] =  0.5*( R(2,2) + R(2,2) ) - 1.0 ;
+
+    /* these are only absolute values */
+    x = sqrt( 0.5 * (W(0,0)-W(1,1)-W(2,2)) ) ;
+    y = sqrt( 0.5 * (W(1,1)-W(2,2)-W(0,0)) ) ;
+    z = sqrt( 0.5 * (W(2,2)-W(0,0)-W(1,1)) ) ;
+
+    /* set the biggest component to + and use the element of the
+    ** matrix W to determine the sign of the other components
+    ** then the solution is either (x,y,z) or its opposite */
+    if( x >= y && x >= z ) {
+      y = (W(1,0) >=0) ? y : -y ;
+      z = (W(2,0) >=0) ? z : -z ;
+    } else if( y >= x && y >= z ) {
+      z = (W(2,1) >=0) ? z : -z ;
+      x = (W(1,0) >=0) ? x : -x ;
+    } else {
+      x = (W(2,0) >=0) ? x : -x ;
+      y = (W(2,1) >=0) ? y : -y ;
+    }
+
+    /* we are left to chose between (x,y,z) and (-x,-y,-z)
+    ** unfortunately we cannot (as the rotation is too close to pi) and
+    ** we just keep what we have. */
+    {
+      double scale = th / sqrt( 1 - cth ) ;
+      OM(0) = scale * x ;
+      OM(1) = scale * y ;
+      OM(2) = scale * z ;
+
+      if( dom_pt ) {
+        int k ;
+        for(k=0; k<3*9; ++k)
+          dom_pt [k] = VL_NAN_D ;
+      }
+      return ;
+    }
+
+  } else {
+    double a = (fabs(sth) < small) ? 1 : th/sin(th) ;
+    double b ;
+    OM(0) = 0.5*a*(R(2,1) - R(1,2)) ;
+    OM(1) = 0.5*a*(R(0,2) - R(2,0)) ;
+    OM(2) = 0.5*a*(R(1,0) - R(0,1)) ;
+
+    if( dom_pt ) {
+      if( fabs(sth) < small ) {
+        a = 0.5 ;
+        b = 0 ;
+      } else {
+        a = th/(2*sth) ;
+        b = (th*cth - sth)/(2*sth*sth)/th ;
+      }
+
+      DOM(0,0) = b*OM(0) ;
+      DOM(1,0) = b*OM(1) ;
+      DOM(2,0) = b*OM(2) ;
+
+      DOM(0,1) = 0 ;
+      DOM(1,1) = 0 ;
+      DOM(2,1) = a ;
+
+      DOM(0,2) = 0 ;
+      DOM(1,2) = -a ;
+      DOM(2,2) = 0 ;
+
+      DOM(0,3) = 0 ;
+      DOM(1,3) = 0 ;
+      DOM(2,3) = -a ;
+
+      DOM(0,4) = b*OM(0) ;
+      DOM(1,4) = b*OM(1) ;
+      DOM(2,4) = b*OM(2) ;
+
+      DOM(0,5) = a ;
+      DOM(1,5) = 0 ;
+      DOM(2,5) = 0 ;
+
+      DOM(0,6) = 0 ;
+      DOM(1,6) = a ;
+      DOM(2,6) = 0 ;
+
+      DOM(0,7) = -a ;
+      DOM(1,7) = 0 ;
+      DOM(2,7) = 0 ;
+
+      DOM(0,8) = b*OM(0) ;
+      DOM(1,8) = b*OM(1) ;
+      DOM(2,8) = b*OM(2) ;
+    }
+  }
+
+#undef OM
+#undef DOM
+#undef R
+#undef W
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/rodrigues.h b/opensfm/src/third_party/vlfeat/vl/rodrigues.h
new file mode 100644
index 000000000..d752725ba
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/rodrigues.h
@@ -0,0 +1,33 @@
+/** @file rodrigues.h
+ ** @brief Rodrigues formulas
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-13 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file rodrigues.h
+
+@section rodrigues Rodrigues formulas
+
+- Use ::vl_rodrigues to compute the Rodrigues formula and its derivative.
+- Use ::vl_irodrigues to compute the inverse Rodrigues formula and
+  its derivative.
+
+**/
+
+#ifndef VL_RODRIGUES
+#define VL_RODRIGUES
+
+#include "generic.h"
+
+VL_EXPORT void vl_rodrigues  (double* R_pt,  double* dR_pt, const double* om_pt) ;
+VL_EXPORT void vl_irodrigues (double* om_pt, double* dom_pt, const double* R_pt) ;
+
+/* VL_RODRIGUES */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/scalespace.c b/opensfm/src/third_party/vlfeat/vl/scalespace.c
new file mode 100644
index 000000000..962f28526
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/scalespace.c
@@ -0,0 +1,821 @@
+/** @file scalespace.c
+ ** @brief Scale Space - Definition
+ ** @author Karel Lenc
+ ** @author Andrea Vedaldi
+ ** @author Michal Perdoch
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page scalespace Gaussian Scale Space (GSS)
+@author Karel Lenc
+@author Andrea Vedaldi
+@author Michal Perdoch
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref scalespace.h implements a Gaussian scale space, a data structure
+representing an image at multiple resolutions
+@cite{witkin83scale-space} @cite{koenderink84the-structure}
+@cite{lindeberg94scale-space}. Scale spaces have many use, including
+the detection of co-variant local features
+@cite{lindeberg98principles} such as SIFT, Hessian-Affine,
+Harris-Affine, Harris-Laplace, etc. @ref scalespace-starting
+demonstreates how to use the C API to compute the scalespace of an
+image. For further details refer to:
+
+- @subpage scalespace-fundamentals
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+@section scalespace-starting Getting started
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+Given an input image `image`, the following example uses the
+::VlScaleSpace object to compute its Gaussian scale space and return
+the image `level` at scale `(o,s)`, where `o` is the octave and `s` is
+the octave subdivision or sublevel:
+
+@code
+float* level ;
+VlScaleSpace ss = vl_scalespace_new(imageWidth, imageHeight) ;
+vl_scalespace_put_image(ss, image) ;
+level = vl_scalespace_get_level(ss, o, s) ;
+@endcode
+
+The image `level` is obtained by convolving `image` by a Gaussian
+filter of isotropic standard deviation given by
+
+@code
+double sigma = vl_scalespace_get_sigma(ss, o, s) ;
+@endcode
+
+The resolution of `level` is in general different from the resolution
+of `image` and is determined by the octave `o`. It can be obtained as
+follows:
+
+@code
+VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(ss, o) ;
+ogeom.width // width of level (in number of pixels)
+ogeom.height // height of level (in number of pixels)
+ogeom.step // spatial sampling step
+@endcode
+
+The parameter `ogeom.step` is the sampling step relatively to the
+sampling of the input image `image`. The ranges of valid octaves and
+scale sublevels can be obtained as
+
+@code
+VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(ss) ;
+geom.firstOctave // Index of the fisrt octave
+geom.lastOctave // Index of the last octave
+geom.octaveResolution ; // Number of octave subdivisions
+geom.octaveFirstSubdivision // Index of the first octave subdivision
+geom.octaveLastSubdivision  // Index of the last octave subdivision
+@endcode
+
+So for example `o` minimum value is `geom.firstOctave` and maximum
+value is `geom.lastOctave`. The subdivision index `s` naturally spans
+the range 0 to `geom.octaveResolution-1`. However, the scale space
+object is flexible in that it allows different ranges of subdivisions
+to be computed and `s` varies in the range
+`geom.octaveFirstSubdivision` to `geom.octaveLastSubdivision`. See
+@ref scalespace-fundamentals for further details.
+
+The geometry of the scale space can be customized upon creation, as
+follows:
+
+@code
+VlScaleSpaceGeometry geom = vl_scalespace_get_default_geometry(imageWidth, imageHeight) ;
+geom.firstOctave = -1 ;
+geom.octaveFirstSubdivision = -1 ;
+geom.octaveLastSubdivision = geom.octaveResolution ;
+VlScaleSpacae ss = vl_scalespace_new_with_geometry (geom) ;
+@endcode
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page scalespace-fundamentals Gaussian scale space fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page discusses the notion of *Gaussian scale space* and the
+relative data structure. For the C API see @ref scalespace.h and @ref
+scalespace-starting.
+
+A *scale space* is representation of an image at multiple resolution
+levels. An image is a function $\ell(x,y)$ of two coordinates $x$,
+$y$; the scale space $\ell(x,y,\sigma)$ adds a third coordinate
+$\sigma$ indexing the *scale*. Here the focus is the Gaussian scale
+space, where the image $\ell(x,y,\sigma)$ is obtained by smoothing
+$\ell(x,y)$ by a Gaussian kernel of isotropic standard deviation
+$\sigma$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section scalespace-definition Scale space definition
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Formally, the *Gaussian scale space* of an image $\ell(x,y)$ is
+defined as
+
+\[
+   \ell(x,y,\sigma) =
+   [g_{\sigma} * \ell](x,y,\sigma)
+\]
+
+where $g_\sigma$ denotes a 2D Gaussian kernel of isotropic standard
+deviation $\sigma$:
+
+\[
+  g_{\sigma}(x,y) = \frac{1}{2\pi\sigma^2}
+  \exp\left(
+  - \frac{x^2 + y^2}{2\sigma^2}
+  \right).
+\]
+
+An important detail is that the algorithm computing the scale space
+assumes that the input image $\ell(x,y)$ is pre-smoothed, roughly
+capturing the effect of the finite pixel size in a CCD. This is
+modelled by assuming that the input is not $\ell(x,y)$, but
+$\ell(x,y,\sigma_n)$, where $\sigma_n$ is a *nominal smoothing*,
+usually taken to be 0.5 (half a pixel standard deviation). This also
+means that $\sigma = \sigma_n = 0.5$ is the *finest scale* that can
+actually be computed.
+
+The scale space structure stores samples of the function
+$\ell(x,y,\sigma)$. The density of the sampling of the spatial
+coordinates $x$ and $y$ is adjusted as a function of the scale
+$\sigma$, corresponding to the intuition that images at a coarse
+resolution can be sampled more coarsely without loss of
+information. Thus, the scale space has the structure of a *pyramid*: a
+collection of digital images sampled at progressively coarser spatial
+resolution and hence of progressively smaller size (in pixels).
+
+The following figure illustrates the scale space pyramid structure:
+
+@image html scalespace-basic.png "A scalespace structure with 2 octaves and S=3 subdivisions per octave"
+
+The pyramid is organised in a number of *octaves*, indexed by a
+parameter `o`. Each octave is further subdivided into *sublevels*,
+indexed by a parameter `s`. These are related to the scale $\sigma$ by
+the equation
+
+\[
+  \sigma(s,o) = \sigma_o 2^{\displaystyle o + \frac{s}{\mathtt{octaveResolution}}}
+\]
+
+where `octaveResolution` is the resolution of the octave subsampling
+$\sigma_0$ is the *base smoothing*.
+
+At each octave the spatial resolution is doubled, in the sense that
+samples are take with a step of
+\[
+\mathtt{step} = 2^o.
+\]
+Hence, denoting as `level[i,j]` the corresponding samples, one has
+$\ell(x,y,\sigma) = \mathtt{level}[i,j]$, where
+\[
+ (x,y) = (i,j) \times \mathtt{step},
+\quad
+\sigma = \sigma(o,s),
+ \quad
+ 0 \leq i < \mathtt{lwidth},
+\quad
+ 0 \leq j < \mathtt{lheight},
+\]
+where
+\[
+  \mathtt{lwidth} = \lfloor \frac{\mathtt{width}}{2^\mathtt{o}}\rfloor, \quad
+  \mathtt{lheight} = \lfloor \frac{\mathtt{height}}{2^\mathtt{o}}\rfloor.
+\]
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section scalespace-geometry Scale space geometry
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In addition to the parameters discussed above, the geometry of the
+data stored in a scale space structure depends on the range of
+allowable octaves `o` and scale sublevels `s`.
+
+While `o` may range in any reasonable value given the size of the
+input image `image`, usually its minimum value is either 0 or -1. The
+latter corresponds to doubling the resolution of the image in the
+first octave of the scale space and it is often used in feature
+extraction. While there is no information added to the image by
+upsampling in this manner, fine scale filters, including derivative
+filters, are much easier to compute by upsalmpling first. The maximum
+practical value is dictated by the image resolution, as it should be
+$2^o\leq\min\{\mathtt{width},\mathtt{height}\}$. VLFeat has the
+flexibility of specifying the range of `o` using the `firstOctave` and
+`lastOctave` parameters of the ::VlScaleSpaceGeometry structure.
+
+The sublevel `s` varies naturally in the range
+$\{0,\dots,\mathtt{octaveResolution}-1\}$. However, it is often
+convenient to store a few extra levels per octave (e.g. to compute the
+local maxima of a function in scale or the Difference of Gaussian
+cornerness measure). Thus VLFeat scale space structure allows this
+parameter to vary in an arbitrary range, specified by the parameters
+`octaveFirstSubdivision` and `octaveLastSubdivision` of
+::VlScaleSpaceGeometry.
+
+Overall the possible values of the indexes `o` and `s` are:
+
+\[
+\mathtt{firstOctave} \leq o \leq \mathtt{lastOctave},
+\qquad
+\mathtt{octaveFirstSubdivision} \leq s \leq \mathtt{octaveLastSubdivision}.
+\]
+
+Note that, depending on these ranges, there could be *redundant pairs*
+of indexes `o` and `s` that represent the *same* pyramid level at more
+than one sampling resolution. In practice, the ability to generate
+such redundant information is very useful in algorithms using
+scalespaces, as coding multiscale operations using a fixed sampling
+resolution is far easier. For example, the DoG feature detector
+computes the scalespace with three redundant levels per octave, as
+follows:
+
+@image html scalespace.png "A scalespace containing redundant representation of certain scale levels."
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section scalespace-algorithm Algorithm and limitations
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Given $\ell(x,y,\sigma_n)$, any of a vast number digitial filtering
+techniques can be used to compute the scale levels. Presently, VLFeat
+uses a basic FIR implementation of the Gaussian filters.
+
+The FIR implementation is obtained by sampling the Gaussian function
+and re-normalizing it to have unit norm. This simple construction does
+not account properly for sampling effect, which may be a problem for
+very small Gausisan kernels. As a rule of thumb, such filters work
+sufficiently well for, say, standard deviation $\sigma$ at least 1.6
+times the sampling step. A work around to apply this basic FIR
+implementation to very small Gaussian filters is to upsample the image
+first.
+
+The limitations on the FIR filters have relatively important for the
+pyramid construction, as the latter is obtained by *incremental
+smoothing*: each successive level is obtained from the previous one by
+adding the needed amount of smoothing. In this manner, the size of the
+FIR filters remains small, which makes them efficient; at the same
+time, for what discussed, excessively small filters are not
+represented properly.
+
+*/
+
+#include "scalespace.h"
+#include "mathop.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+
+/** @file scalespace.h
+ ** @struct VlScaleSpace
+ ** @brief Scale space class
+ **
+ ** This is an opaque class used to compute the scale space of an
+ ** image.
+ **/
+
+struct _VlScaleSpace
+{
+  VlScaleSpaceGeometry geom ; /**< Geometry of the scale space */
+  float **octaves ; /**< Data */
+} ;
+
+/* ---------------------------------------------------------------- */
+/** @brief Get the default geometry for a given image size.
+ ** @param width image width.
+ ** @param height image height.
+ ** @return the default scale space geometry.
+ **
+ ** Both @a width and @a height must be at least one pixel wide.
+ **/
+
+VlScaleSpaceGeometry
+vl_scalespace_get_default_geometry (vl_size width, vl_size height)
+{
+  VlScaleSpaceGeometry geom ;
+  assert(width >= 1) ;
+  assert(height >= 1) ;
+  geom.width = width ;
+  geom.height = height ;
+  geom.firstOctave = 0 ;
+  geom.lastOctave = VL_MAX(floor(vl_log2_d(VL_MIN(width, height))) - 3, 0) ;
+  geom.octaveResolution= 3 ;
+  geom.octaveFirstSubdivision = 0 ;
+  geom.octaveLastSubdivision = geom.octaveResolution - 1 ;
+  geom.baseScale = 1.6 * pow(2.0, 1.0 / geom.octaveResolution) ;
+  geom.nominalScale = 0.5 ;
+  return geom ;
+}
+
+#define is_valid_geometry(geom) (\
+geom.firstOctave <= geom.lastOctave && \
+geom.octaveResolution >= 1 && \
+geom.octaveFirstSubdivision <= geom.octaveLastSubdivision && \
+geom.baseScale >= 0.0 && \
+geom.nominalScale >= 0.0)
+
+/** @brief Check scale space geometries for equality
+ ** @param a first geometry.
+ ** @param b second geometry.
+ ** @return true if equal.
+ **/
+
+vl_bool
+vl_scalespacegeometry_is_equal (VlScaleSpaceGeometry a,
+                                VlScaleSpaceGeometry b)
+{
+  return
+  a.width == b.width &&
+  a.height == b.height &&
+  a.firstOctave == b.firstOctave &&
+  a.lastOctave == b.lastOctave &&
+  a.octaveResolution == b.octaveResolution &&
+  a.octaveFirstSubdivision == b.octaveLastSubdivision &&
+  a.baseScale == b.baseScale &&
+  a.nominalScale == b.nominalScale ;
+}
+
+/** @brief Get the geometry of the scale space.
+ ** @param self object.
+ ** @return the scale space geometry.
+ **/
+
+VlScaleSpaceGeometry
+vl_scalespace_get_geometry (VlScaleSpace const * self)
+{
+  return self->geom ;
+}
+
+/** @brief Get the geometry of an octave of the scalespace.
+ ** @param self object.
+ ** @param o octave index.
+ ** @return the geometry of octave @a o.
+ **/
+
+VlScaleSpaceOctaveGeometry
+vl_scalespace_get_octave_geometry (VlScaleSpace const * self, vl_index o)
+{
+  VlScaleSpaceOctaveGeometry ogeom ;
+  ogeom.width = VL_SHIFT_LEFT(self->geom.width, -o) ;
+  ogeom.height = VL_SHIFT_LEFT(self->geom.height, -o) ;
+  ogeom.step = pow(2.0, o) ;
+  return ogeom ;
+}
+
+/** @brief Get the data of a scale space level
+ ** @param self object.
+ ** @param o octave index.
+ ** @param s level index.
+ ** @return pointer to the data for octave @a o, level @a s.
+ **
+ ** The octave index @a o must be in the range @c firstOctave
+ ** to @c lastOctave and the scale index @a s must be in the
+ ** range @c octaveFirstSubdivision to @c octaveLastSubdivision.
+ **/
+
+float *
+vl_scalespace_get_level (VlScaleSpace *self, vl_index o, vl_index s)
+{
+  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
+  float * octave ;
+  assert(self) ;
+  assert(o >= self->geom.firstOctave) ;
+  assert(o <= self->geom.lastOctave) ;
+  assert(s >= self->geom.octaveFirstSubdivision) ;
+  assert(s <= self->geom.octaveLastSubdivision) ;
+
+  octave = self->octaves[o - self->geom.firstOctave] ;
+  return octave + ogeom.width * ogeom.height * (s - self->geom.octaveFirstSubdivision) ;
+}
+
+/** @brief Get the data of a scale space level (const)
+ ** @param self object.
+ ** @param o octave index.
+ ** @param s level index.
+ ** @return pointer to the data for octave @a o, level @a s.
+ **
+ ** This function is the same as ::vl_scalespace_get_level but reutrns
+ ** a @c const pointer to the data.
+ **/
+
+float const *
+vl_scalespace_get_level_const (VlScaleSpace const * self, vl_index o, vl_index s)
+{
+  return vl_scalespace_get_level((VlScaleSpace*)self, o, s) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the scale of a given octave and sublevel
+ ** @param self object.
+ ** @param o octave index.
+ ** @param s sublevel index.
+ **
+ ** The function returns the scale $\sigma(o,s)$ as a function of the
+ ** octave index @a o and sublevel @a s.
+ **/
+
+double
+vl_scalespace_get_level_sigma (VlScaleSpace const *self, vl_index o, vl_index s)
+{
+  return self->geom.baseScale * pow(2.0, o + (double) s / self->geom.octaveResolution) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Upsample the rows and take the transpose
+ ** @param destination output image.
+ ** @param source input image.
+ ** @param width input image width.
+ ** @param height input image height.
+ **
+ ** The output image has dimensions @a height by 2 @a width (so the
+ ** destination buffer must be at least as big as two times the
+ ** input buffer).
+ **
+ ** Upsampling is performed by linear interpolation.
+ **/
+
+static void
+copy_and_upsample
+(float *destination,
+ float const *source, vl_size width, vl_size height)
+{
+  vl_index x, y, ox, oy ;
+  float v00, v10, v01, v11 ;
+
+  assert(destination) ;
+  assert(source) ;
+
+  for(y = 0 ; y < (signed)height ; ++y) {
+    oy = (y < ((signed)height - 1)) * width ;
+    v10 = source[0] ;
+    v11 = source[oy] ;
+    for(x = 0 ; x < (signed)width ; ++x) {
+      ox = x < ((signed)width - 1) ;
+      v00 = v10 ;
+      v01 = v11 ;
+      v10 = source[ox] ;
+      v11 = source[ox + oy] ;
+      destination[0] = v00 ;
+      destination[1] = 0.5f * (v00 + v10) ;
+      destination[2*width] = 0.5f * (v00 + v01) ;
+      destination[2*width+1] = 0.25f * (v00 + v01 + v10 + v11) ;
+      destination += 2 ;
+      source ++;
+    }
+    destination += 2*width ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Downsample
+ ** @param destination output imgae buffer.
+ ** @param source input image buffer.
+ ** @param width input image width.
+ ** @param height input image height.
+ ** @param numOctaves octaves (non negative).
+ **
+ ** The function downsamples the image @a d times, reducing it to @c
+ ** 1/2^d of its original size. The parameters @a width and @a height
+ ** are the size of the input image. The destination image @a dst is
+ ** assumed to be <code>floor(width/2^d)</code> pixels wide and
+ ** <code>floor(height/2^d)</code> pixels high.
+ **/
+
+static void
+copy_and_downsample
+(float *destination,
+ float const *source,
+ vl_size width, vl_size height, vl_size numOctaves)
+{
+  vl_index x, y ;
+  vl_size step = 1 << numOctaves ; /* step = 2^numOctaves */
+
+  assert(destination) ;
+  assert(source) ;
+
+  if (numOctaves == 0) {
+    memcpy(destination, source, sizeof(float) * width * height) ;
+  } else {
+    for(y = 0 ; y < (signed)height ; y += step) {
+      float const *p = source + y * width ;
+      for(x = 0 ; x < (signed)width - ((signed)step - 1) ; x += step) {
+        *destination++ = *p ;
+        p += step ;
+      }
+    }
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Create a new scale space object
+ ** @param width image width.
+ ** @param height image height.
+ ** @return new scale space object.
+ **
+ ** This function is the same as ::vl_scalespace_new_with_geometry()
+ ** but it uses ::vl_scalespace_get_default_geometry to initialise
+ ** the geometry of the scale space from the image size.
+ **
+ ** @sa ::vl_scalespace_new_with_geometry(), ::vl_scalespace_delete().
+ **/
+
+VlScaleSpace *
+vl_scalespace_new (vl_size width, vl_size height)
+{
+  VlScaleSpaceGeometry geom ;
+  geom = vl_scalespace_get_default_geometry(width, height) ;
+  return vl_scalespace_new_with_geometry(geom) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new scale space with the specified geometry
+ ** @param geom scale space geomerty.
+ ** @return new scale space object.
+ **
+ ** If the geometry is not valid (see ::VlScaleSpaceGeometry), the
+ ** result is unpredictable.
+ **
+ ** The function returns `NULL` if it was not possible to allocate the
+ ** object because of an out-of-memory condition.
+ **
+ ** @sa ::VlScaleSpaceGeometry, ::vl_scalespace_delete().
+ **/
+
+VlScaleSpace *
+vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom)
+{
+
+  vl_index o ;
+  vl_size numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
+  vl_size numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
+  VlScaleSpace *self ;
+
+  assert(is_valid_geometry(geom)) ;
+  numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
+  numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
+
+  self = vl_calloc(1, sizeof(VlScaleSpace)) ;
+  if (self == NULL) goto err_alloc_self ;
+  self->geom = geom ;
+  self->octaves = vl_calloc(numOctaves, sizeof(float*)) ;
+  if (self->octaves == NULL) goto err_alloc_octave_list ;
+  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
+    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
+    vl_size octaveSize = ogeom.width * ogeom.height * numSublevels ;
+    self->octaves[o - self->geom.firstOctave] = vl_malloc(octaveSize * sizeof(float)) ;
+    if (self->octaves[o - self->geom.firstOctave] == NULL) goto err_alloc_octaves;
+  }
+  return self ;
+
+err_alloc_octaves:
+  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
+    if (self->octaves[o - self->geom.firstOctave]) {
+      vl_free(self->octaves[o - self->geom.firstOctave]) ;
+    }
+  }
+err_alloc_octave_list:
+  vl_free(self) ;
+err_alloc_self:
+  return NULL ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Create a new copy of the object
+ ** @param self object to copy from.
+ **
+ ** The function returns `NULL` if the copy cannot be made due to an
+ ** out-of-memory condition.
+ **/
+
+VlScaleSpace *
+vl_scalespace_new_copy (VlScaleSpace* self)
+{
+  vl_index o  ;
+  VlScaleSpace * copy = vl_scalespace_new_shallow_copy(self) ;
+  if (copy == NULL) return NULL ;
+
+  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
+    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
+    vl_size numSubevels = self->geom.octaveLastSubdivision - self->geom.octaveFirstSubdivision + 1;
+    memcpy(copy->octaves[o - self->geom.firstOctave],
+           self->octaves[o - self->geom.firstOctave],
+           ogeom.width * ogeom.height * numSubevels * sizeof(float)) ;
+  }
+  return copy ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Create a new shallow copy of the object
+ ** @param self object to copy from.
+ **
+ ** The function works like ::vl_scalespace_new_copy() but only allocates
+ ** the scale space, without actually copying the data.
+ **/
+
+VlScaleSpace *
+vl_scalespace_new_shallow_copy (VlScaleSpace* self)
+{
+  return vl_scalespace_new_with_geometry (self->geom) ;
+}
+
+/* ---------------------------------------------------------------- */
+/** @brief Delete object
+ ** @param self object to delete.
+ ** @sa ::vl_scalespace_new()
+ **/
+
+void
+vl_scalespace_delete (VlScaleSpace * self)
+{
+  if (self) {
+    if (self->octaves) {
+      vl_index o ;
+      for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
+        if (self->octaves[o - self->geom.firstOctave]) {
+          vl_free(self->octaves[o - self->geom.firstOctave]) ;
+        }
+      }
+      vl_free(self->octaves) ;
+    }
+    vl_free(self) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @internal @brief Fill octave starting from the first level
+ ** @param self object instance.
+ ** @param o octave to process.
+ **
+ ** The function takes the first sublevel of octave @a o (the one at
+ ** sublevel `octaveFirstLevel` and iteratively
+ ** smoothes it to obtain the other octave levels.
+ **/
+
+void
+_vl_scalespace_fill_octave (VlScaleSpace *self, vl_index o)
+{
+  vl_index s ;
+  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
+
+  for(s = self->geom.octaveFirstSubdivision + 1 ;
+      s <= self->geom.octaveLastSubdivision ; ++s) {
+    double sigma = vl_scalespace_get_level_sigma(self, o, s) ;
+    double previousSigma = vl_scalespace_get_level_sigma(self, o, s - 1) ;
+    double deltaSigma = sqrtf(sigma*sigma - previousSigma*previousSigma) ;
+
+    float* level = vl_scalespace_get_level (self, o, s) ;
+    float* previous = vl_scalespace_get_level (self, o, s-1) ;
+    vl_imsmooth_f (level, ogeom.width,
+                   previous, ogeom.width, ogeom.height, ogeom.width,
+                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal @brief Initialize the first level of an octave from an image
+ ** @param self ::VlScaleSpace object instance.
+ ** @param image image data.
+ ** @param o octave to start.
+ **
+ ** The function initializes the first level of octave @a o from
+ ** image @a image. The dimensions of the image are the ones set
+ ** during the creation of the ::VlScaleSpace object instance.
+ **/
+
+static void
+_vl_scalespace_start_octave_from_image (VlScaleSpace *self,
+                                        float const *image,
+                                        vl_index o)
+{
+  float *level ;
+  double sigma, imageSigma ;
+  vl_index op ;
+
+  assert(self) ;
+  assert(image) ;
+  assert(o >= self->geom.firstOctave) ;
+  assert(o <= self->geom.lastOctave) ;
+
+  /*
+   * Copy the image to self->geom.octaveFirstSubdivision of octave o, upscaling or
+   * downscaling as needed.
+   */
+
+  level = vl_scalespace_get_level(self, VL_MAX(0, o), self->geom.octaveFirstSubdivision) ;
+  copy_and_downsample(level, image, self->geom.width, self->geom.height, VL_MAX(0, o)) ;
+
+  for (op = -1 ; op >= o ; --op) {
+    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, op + 1) ;
+    float *succLevel = vl_scalespace_get_level(self, op + 1, self->geom.octaveFirstSubdivision) ;
+    level = vl_scalespace_get_level(self, op, self->geom.octaveFirstSubdivision) ;
+    copy_and_upsample(level, succLevel, ogeom.width, ogeom.height) ;
+  }
+
+  /*
+   * Adjust the smoothing of the first level just initialised, accounting
+   * for the fact that the input image is assumed to be a nominal scale
+   * level.
+   */
+
+  sigma = vl_scalespace_get_level_sigma(self, o, self->geom.octaveFirstSubdivision) ;
+  imageSigma = self->geom.nominalScale ;
+
+  if (sigma > imageSigma) {
+    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
+    double deltaSigma = sqrt (sigma*sigma - imageSigma*imageSigma) ;
+    level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
+    vl_imsmooth_f (level, ogeom.width,
+                   level, ogeom.width, ogeom.height, ogeom.width,
+                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
+  }
+}
+
+/** @internal @brief Initialize the first level of an octave from the previous octave
+ ** @param self object.
+ ** @param o octave to initialize.
+ **
+ ** The function initializes the first level of octave @a o from the
+ ** content of octave <code>o - 1</code>.
+ **/
+
+static void
+_vl_scalespace_start_octave_from_previous_octave (VlScaleSpace *self, vl_index o)
+{
+  double sigma, prevSigma ;
+  float *level, *prevLevel ;
+  vl_index prevLevelIndex ;
+  VlScaleSpaceOctaveGeometry ogeom ;
+
+  assert(self) ;
+  assert(o > self->geom.firstOctave) ; /* must not be the first octave */
+  assert(o <= self->geom.lastOctave) ;
+
+  /*
+   * From the previous octave pick the level which is closer to
+   * self->geom.octaveFirstSubdivision in this octave.
+   * The is self->geom.octaveFirstSubdivision + self->numLevels since there are
+   * self->geom.octaveResolution levels in an octave, provided that
+   * this value does not exceed self->geom.octaveLastSubdivision.
+   */
+
+  prevLevelIndex = VL_MIN(self->geom.octaveFirstSubdivision
+                          + (signed)self->geom.octaveResolution,
+                          self->geom.octaveLastSubdivision) ;
+  prevLevel = vl_scalespace_get_level (self, o - 1, prevLevelIndex) ;
+  level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
+  ogeom = vl_scalespace_get_octave_geometry(self, o - 1) ;
+
+  copy_and_downsample (level, prevLevel, ogeom.width, ogeom.height, 1) ;
+
+  /*
+   * Add remaining smoothing, if any.
+   */
+
+  sigma = vl_scalespace_get_level_sigma(self, o, self->geom.octaveFirstSubdivision) ;
+  prevSigma = vl_scalespace_get_level_sigma(self, o - 1, prevLevelIndex) ;
+
+  if (sigma > prevSigma) {
+    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;
+    double deltaSigma = sqrt (sigma*sigma - prevSigma*prevSigma) ;
+    level = vl_scalespace_get_level (self, o, self->geom.octaveFirstSubdivision) ;
+
+    /* todo: this may fail due to an out-of-memory condition */
+    vl_imsmooth_f (level, ogeom.width,
+                   level, ogeom.width, ogeom.height, ogeom.width,
+                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
+  }
+}
+
+/** @brief Initialise Scale space with new image
+ ** @param self ::VlScaleSpace object instance.
+ ** @param image image to process.
+ **
+ ** Compute the data of all the defined octaves and scales of the scale
+ ** space @a self.
+ **/
+
+void
+vl_scalespace_put_image (VlScaleSpace *self, float const *image)
+{
+  vl_index o ;
+  _vl_scalespace_start_octave_from_image(self, image, self->geom.firstOctave) ;
+  _vl_scalespace_fill_octave(self, self->geom.firstOctave) ;
+  for (o = self->geom.firstOctave + 1 ; o <= self->geom.lastOctave ; ++o) {
+    _vl_scalespace_start_octave_from_previous_octave(self, o) ;
+    _vl_scalespace_fill_octave(self, o) ;
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/scalespace.h b/opensfm/src/third_party/vlfeat/vl/scalespace.h
new file mode 100644
index 000000000..3f7af38d8
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/scalespace.h
@@ -0,0 +1,99 @@
+/** @file scalespace.h
+ ** @brief Scale Space (@ref scalespace)
+ ** @author Andrea Vedaldi
+ ** @author Karel Lenc
+ ** @author Michal Perdoch
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_SCALESPACE_H
+#define VL_SCALESPACE_H
+
+#include "generic.h"
+#include "imopv.h"
+#include "mathop.h"
+
+/* ---------------------------------------------------------------- */
+/*                                             VlScaleSpaceGeometry */
+/* ---------------------------------------------------------------- */
+
+/** @brief Geometry of a scale space
+ **
+ ** There are a few restrictions on the valid geometrties.
+ */
+typedef struct _VlScaleSpaceGeometry
+{
+  vl_size width ; /**< Image width */
+  vl_size height ; /**< Image height */
+  vl_index firstOctave ; /**< Index of the fisrt octave */
+  vl_index lastOctave ; /**< Index of the last octave */
+  vl_size octaveResolution ; /**< Number of octave subdivisions */
+  vl_index octaveFirstSubdivision ; /**< Index of the first octave subdivision */
+  vl_index octaveLastSubdivision ; /**< Index of the last octave subdivision */
+  double baseScale ; /**< Base smoothing (smoothing of octave 0, level 0) */
+  double nominalScale ; /**< Nominal smoothing of the original image */
+} VlScaleSpaceGeometry ;
+
+VL_EXPORT
+vl_bool vl_scalespacegeometry_is_equal (VlScaleSpaceGeometry a,
+                                        VlScaleSpaceGeometry b) ;
+
+/* ---------------------------------------------------------------- */
+/*                                       VlScaleSpaceOctaveGeometry */
+/* ---------------------------------------------------------------- */
+
+/** @brief Geometry of one octave of a scale space */
+typedef struct _VlScaleSpaceOctaveGeometry
+{
+  vl_size width ; /**< Width (number of pixels) */
+  vl_size height ; /**< Height (number of pixels) */
+  double step ; /**< Sampling step (size of a pixel) */
+} VlScaleSpaceOctaveGeometry ;
+
+/* ---------------------------------------------------------------- */
+/*                                                     VlScaleSpace */
+/* ---------------------------------------------------------------- */
+
+typedef struct _VlScaleSpace VlScaleSpace ;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT VlScaleSpaceGeometry vl_scalespace_get_default_geometry(vl_size width, vl_size height) ;
+VL_EXPORT VlScaleSpace * vl_scalespace_new (vl_size width, vl_size height) ;
+VL_EXPORT VlScaleSpace * vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom) ;
+VL_EXPORT VlScaleSpace * vl_scalespace_new_copy (VlScaleSpace* src);
+VL_EXPORT VlScaleSpace * vl_scalespace_new_shallow_copy (VlScaleSpace* src);
+VL_EXPORT void vl_scalespace_delete (VlScaleSpace *self) ;
+/** @} */
+
+/** @name Process data
+ ** @{
+ **/
+VL_EXPORT void
+vl_scalespace_put_image (VlScaleSpace *self, float const* image);
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{
+ **/
+VL_EXPORT VlScaleSpaceGeometry vl_scalespace_get_geometry (VlScaleSpace const * self) ;
+VL_EXPORT VlScaleSpaceOctaveGeometry vl_scalespace_get_octave_geometry (VlScaleSpace const * self, vl_index o) ;
+VL_EXPORT float *
+vl_scalespace_get_level (VlScaleSpace * self, vl_index o, vl_index s) ;
+VL_EXPORT float const *
+vl_scalespace_get_level_const (VlScaleSpace const * self, vl_index o, vl_index s) ;
+VL_EXPORT double
+vl_scalespace_get_level_sigma (VlScaleSpace const *self, vl_index o, vl_index s) ;
+/** @} */
+
+/* VL_SCALESPACE_H */
+#endif
+
diff --git a/opensfm/src/third_party/vlfeat/vl/shuffle-def.h b/opensfm/src/third_party/vlfeat/vl/shuffle-def.h
new file mode 100644
index 000000000..4b74ea6bd
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/shuffle-def.h
@@ -0,0 +1,101 @@
+/** @file   shuffle-def.h
+ ** @brief  Shuffle preprocessor metaprogram
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file shuffle-def.h
+
+ @todo large array compatibility.
+ **/
+
+#include "host.h"
+#include "random.h"
+#include <assert.h>
+
+#ifndef VL_SHUFFLE_prefix
+#error "VL_SHUFFLE_prefix must be defined"
+#endif
+
+#ifndef VL_SHUFFLE_array
+#ifndef VL_SHUFFLE_type
+#error "VL_SHUFFLE_type must be defined if VL_SHUFFLE_array is not"
+#endif
+#define VL_SHUFFLE_array VL_SHUFFLE_type*
+#endif
+
+#ifdef __DOXYGEN__
+#define VL_SHUFFLE_prefix  ShufflePrefix       /**< Prefix of the shuffle functions */
+#define VL_SHUFFLE_type    ShuffleType         /**< Data type of the shuffle elements */
+#define VL_SHUFFLE_array   ShuffleType*        /**< Data type of the shuffle container */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_SHUFFLE_swap) || defined(__DOXYGEN__)
+#define VL_SHUFFLE_swap VL_XCAT(VL_SHUFFLE_prefix, _swap)
+
+/** @brief Swap two array elements
+ ** @param array shuffle array.
+ ** @param indexA index of the first element to swap.
+ ** @param indexB index of the second element to swap.
+ **
+ ** The function swaps the two elements @a a and @ b. The function
+ ** uses a temporary element of type ::VL_SHUFFLE_type
+ ** and the copy operator @c =.
+ **/
+
+VL_INLINE void
+VL_SHUFFLE_swap
+(VL_SHUFFLE_array array,
+ vl_uindex indexA,
+ vl_uindex indexB)
+{
+  VL_SHUFFLE_type t = array [indexA] ;
+  array [indexA] = array [indexB] ;
+  array [indexB] = t ;
+}
+
+/* VL_SHUFFLE_swap */
+#endif
+
+/* ---------------------------------------------------------------- */
+
+#if ! defined(VL_SHUFFLE_shuffle) || defined(__DOXYGEN__)
+#define VL_SHUFFLE_shuffle VL_XCAT(VL_SHUFFLE_prefix, _shuffle)
+
+/** @brief Shuffle
+ ** @param array (in/out) pointer to the array.
+ ** @param size size of the array.
+ ** @param rand random number generator to use.
+ **
+ ** The function randomly permutes the array.
+ **/
+
+VL_INLINE void
+VL_SHUFFLE_shuffle
+(VL_SHUFFLE_array array, vl_size size, VlRand * rand)
+{
+  vl_uindex n = size ;
+  while (n > 1) {
+    vl_uindex k = vl_rand_uindex (rand, n) ;
+    n -- ;
+    VL_SHUFFLE_swap (array, n, k) ;
+  }
+}
+
+/* VL_SHUFFLE_shuffle */
+#endif
+
+#undef VL_SHUFFLE_prefix
+#undef VL_SHUFFLE_swap
+#undef VL_SHUFFLE_shuffle
+#undef VL_SHUFFLE_type
+#undef VL_SHUFFLE_array
diff --git a/opensfm/src/third_party/vlfeat/vl/sift.c b/opensfm/src/third_party/vlfeat/vl/sift.c
new file mode 100644
index 000000000..03963fe6f
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/sift.c
@@ -0,0 +1,2197 @@
+/** @file sift.c
+ ** @brief SIFT - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page sift Scale Invariant Feature Transform (SIFT)
+@author Andrea Vedaldi
+@par "Credits:" May people have contributed with suggestions and bug
+reports. Although the following list is certainly incomplete, we would
+like to thank: Wei Dong, Loic, Giuseppe, Liu, Erwin, P. Ivanov, and
+Q. S. Luo.
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref sift.h implements a @ref sift-usage "SIFT filter object", a
+reusable object to extract SIFT features @cite{lowe99object} from one
+or multiple images.
+
+This is the original VLFeat implementation of SIFT, designed to be
+compatible with Lowe's original SIFT. See @ref covdet for a different
+version of SIFT integrated in the more general covariant feature
+detector engine.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section sift-intro Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A SIFT feature is a selected image region (also called keypoint) with
+an associated descriptor. Keypoints are extracted by the <b>@ref
+sift-intro-detector "SIFT detector"</b> and their descriptors are
+computed by the <b>@ref sift-intro-descriptor "SIFT descriptor"</b>.  It is
+also common to use independently the SIFT detector (i.e. computing the
+keypoints without descriptors) or the SIFT descriptor (i.e.  computing
+descriptors of custom keypoints).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-intro-detector SIFT detector
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A SIFT <em>keypoint</em> is a circular image region with an
+orientation. It is described by a geometric <em>frame</em> of four
+parameters: the keypoint center coordinates @e x and @e y, its @e
+scale (the radius of the region), and its @e orientation (an angle
+expressed in radians). The SIFT detector uses as keypoints image
+structures which resemble &ldquo;blobs&rdquo;. By searching for blobs
+at multiple scales and positions, the SIFT detector is invariant (or,
+more accurately, covariant) to translation, rotations, and re scaling
+of the image.
+
+The keypoint orientation is also determined from the local image
+appearance and is covariant to image rotations. Depending on the
+symmetry of the keypoint appearance, determining the orientation can
+be ambiguous. In this case, the SIFT detectors returns a list of up to
+four possible orientations, constructing up to four frames (differing
+only by their orientation) for each detected image blob.
+
+@image html sift-frame.png "SIFT keypoints are circular image regions with an orientation."
+
+There are several parameters that influence the detection of SIFT
+keypoints. First, searching keypoints at multiple scales is obtained
+by constructing a so-called &ldquo;Gaussian scale space&rdquo;. The
+scale space is just a collection of images obtained by progressively
+smoothing the input image, which is analogous to gradually reducing
+the image resolution. Conventionally, the smoothing level is called
+<em>scale</em> of the image. The construction of the scale space is
+influenced by the following parameters, set when creating the SIFT
+filter object by ::vl_sift_new():
+
+- <b>Number of octaves</b>. Increasing the scale by an octave means
+  doubling the size of the smoothing kernel, whose effect is roughly
+  equivalent to halving the image resolution. By default, the scale
+  space spans as many octaves as possible (i.e. roughly <code>
+  log2(min(width,height)</code>), which has the effect of searching
+  keypoints of all possible sizes.
+- <b>First octave index</b>. By convention, the octave of index 0
+  starts with the image full resolution. Specifying an index greater
+  than 0 starts the scale space at a lower resolution (e.g. 1 halves
+  the resolution). Similarly, specifying a negative index starts the
+  scale space at an higher resolution image, and can be useful to
+  extract very small features (since this is obtained by interpolating
+  the input image, it does not make much sense to go past -1).
+- <b>Number of levels per octave</b>. Each octave is sampled at this
+  given number of intermediate scales (by default 3). Increasing this
+  number might in principle return more refined keypoints, but in
+  practice can make their selection unstable due to noise (see [1]).
+
+Keypoints are further refined by eliminating those that are likely to
+be unstable, either because they are selected nearby an image edge,
+rather than an image blob, or are found on image structures with low
+contrast. Filtering is controlled by the follow:
+
+- <b>Peak threshold.</b> This is the minimum amount of contrast to
+  accept a keypoint. It is set by configuring the SIFT filter object
+  by ::vl_sift_set_peak_thresh().
+- <b>Edge threshold.</b> This is the edge rejection threshold. It is
+  set by configuring the SIFT filter object by
+  ::vl_sift_set_edge_thresh().
+
+<table>
+ <caption>Summary of the parameters influencing the SIFT detector.</caption>
+ <tr style="font-weight:bold;">
+ <td>Parameter</td>
+ <td>See also</td>
+ <td>Controlled by</td>
+ <td>Comment</td>
+ </tr>
+ <tr>
+ <td>number of octaves</td>
+ <td> @ref sift-intro-detector </td>
+ <td>::vl_sift_new</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td>first octave index</td>
+ <td> @ref sift-intro-detector </td>
+ <td>::vl_sift_new</td>
+ <td>set to -1 to extract very small features</td>
+ </tr>
+ <tr>
+ <td>number of scale levels per octave</td>
+ <td> @ref sift-intro-detector </td>
+ <td>::vl_sift_new</td>
+ <td>can affect the number of extracted keypoints</td>
+ </tr>
+ <tr>
+ <td>edge threshold</td>
+ <td> @ref sift-intro-detector </td>
+ <td>::vl_sift_set_edge_thresh</td>
+ <td>decrease to eliminate more keypoints</td>
+ </tr>
+ <tr>
+ <td>peak threshold</td>
+ <td> @ref sift-intro-detector </td>
+ <td>::vl_sift_set_peak_thresh</td>
+ <td>increase to eliminate more keypoints</td>
+ </tr>
+</table>
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-intro-descriptor SIFT Descriptor
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@sa @ref sift-tech-descriptor "Descriptor technical details"
+
+A SIFT descriptor is a 3-D spatial histogram of the image gradients in
+characterizing the appearance of a keypoint. The gradient at each
+pixel is regarded as a sample of a three-dimensional elementary
+feature vector, formed by the pixel location and the gradient
+orientation. Samples are weighed by the gradient norm and accumulated
+in a 3-D histogram @em h, which (up to normalization and clamping)
+forms the SIFT descriptor of the region. An additional Gaussian
+weighting function is applied to give less importance to gradients
+farther away from the keypoint center. Orientations are quantized into
+eight bins and the spatial coordinates into four each, as follows:
+
+@image html sift-descr-easy.png "The SIFT descriptor is a spatial histogram of the image gradient."
+
+SIFT descriptors are computed by either calling
+::vl_sift_calc_keypoint_descriptor or
+::vl_sift_calc_raw_descriptor. They accept as input a keypoint
+frame, which specifies the descriptor center, its size, and its
+orientation on the image plane. The following parameters influence the
+descriptor calculation:
+
+- <b>magnification factor</b>. The descriptor size is determined by
+multiplying the keypoint scale by this factor. It is set by
+::vl_sift_set_magnif.
+- <b>Gaussian window size</b>. The descriptor support is determined by
+a Gaussian window, which discounts gradient contributions farther away
+from the descriptor center. The standard deviation of this window is
+set by ::vl_sift_set_window_size and expressed in unit of bins.
+
+VLFeat SIFT descriptor uses the following convention. The @em y axis
+points downwards and angles are measured clockwise (to be consistent
+with the standard image convention). The 3-D histogram (consisting of
+@f$ 8 \times 4 \times 4 = 128 @f$ bins) is stacked as a single
+128-dimensional vector, where the fastest varying dimension is the
+orientation and the slowest the @em y spatial coordinate. This is
+illustrated by the following figure.
+
+@image html sift-conv-vlfeat.png "VLFeat conventions"
+
+@note Keypoints (frames) D. Lowe's SIFT implementation convention is
+slightly different: The @em y axis points upwards and the angles are
+measured counter-clockwise.
+
+@image html sift-conv.png "D. Lowes' SIFT implementation conventions"
+
+<table>
+ <caption>Summary of the parameters influencing the SIFT descriptor.</caption>
+ <tr style="font-weight:bold;">
+ <td>Parameter</td>
+ <td>See also</td>
+ <td>Controlled by</td>
+ <td>Comment</td>
+ </tr>
+ <tr>
+ <td>magnification factor</td>
+ <td> @ref sift-intro-descriptor </td>
+ <td>::vl_sift_set_magnif</td>
+ <td>increase this value to enlarge the image region described</td>
+ </tr>
+ <tr>
+ <td>Gaussian window size</td>
+ <td> @ref sift-intro-descriptor </td>
+ <td>::vl_sift_set_window_size</td>
+ <td>smaller values let the center of the descriptor count more</td>
+ </tr>
+</table>
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section sift-intro-extensions Extensions
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<b>Eliminating low-contrast descriptors.</b> Near-uniform patches do
+not yield stable keypoints or descriptors. ::vl_sift_set_norm_thresh()
+can be used to set a threshold on the average norm of the local
+gradient to zero-out descriptors that correspond to very low contrast
+regions. By default, the threshold is equal to zero, which means that
+no descriptor is zeroed. Normally this option is useful only with
+custom keypoints, as detected keypoints are implicitly selected at
+high contrast image regions.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section sift-usage Using the SIFT filter object
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The code provided in this module can be used in different ways.  You
+can instantiate and use a <b>SIFT filter</b> to extract both SIFT
+keypoints and descriptors from one or multiple images. Alternatively,
+you can use one of the low level functions to run only a part of the
+SIFT algorithm (for instance, to compute the SIFT descriptors of
+custom keypoints).
+
+To use a <b>SIFT filter</b> object:
+
+- Initialize a SIFT filter object with ::vl_sift_new(). The filter can
+  be reused for multiple images of the same size (e.g. for an entire
+  video sequence).
+- For each octave in the scale space:
+  - Compute the next octave of the DOG scale space using either
+   ::vl_sift_process_first_octave() or ::vl_sift_process_next_octave()
+   (stop processing if ::VL_ERR_EOF is returned).
+  - Run the SIFT detector with ::vl_sift_detect() to get the keypoints.
+  - For each keypoint:
+    - Use ::vl_sift_calc_keypoint_orientations() to get the keypoint orientation(s).
+    - For each orientation:
+      - Use ::vl_sift_calc_keypoint_descriptor() to get the keypoint descriptor.
+- Delete the SIFT filter by ::vl_sift_delete().
+
+To compute SIFT descriptors of custom keypoints, use
+::vl_sift_calc_raw_descriptor().
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section sift-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-tech-ss Scale space
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+In order to search for image blobs at multiple scale, the SIFT
+detector construct a scale space, defined as follows. Let
+@f$I_0(\mathbf{x})@f$ denote an idealized <em>infinite resolution</em>
+image. Consider the  <em>Gaussian kernel</em>
+
+@f[
+ g_{\sigma}(\mathbf{x})
+ =
+ \frac{1}{2\pi\sigma^2}
+ \exp
+ \left(
+ -\frac{1}{2}
+ \frac{\mathbf{x}^\top\mathbf{x}}{\sigma^2}
+ \right)
+@f]
+
+The <b>Gaussian scale space</b> is the collection of smoothed images
+
+@f[
+ I_\sigma = g_\sigma * I,  \quad \sigma \geq 0.
+@f]
+
+The image at infinite resolution @f$ I_0 @f$ is useful conceptually,
+but is not available to us; instead, the input image @f$ I_{\sigma_n}
+@f$ is assumed to be pre-smoothed at a nominal level @f$ \sigma_n =
+0.5 @f$ to account for the finite resolution of the pixels. Thus in
+practice the scale space is computed by
+
+@f[
+I_\sigma = g_{\sqrt{\sigma^2 - \sigma_n^2}} * I_{\sigma_n},
+\quad \sigma \geq \sigma_n.
+@f]
+
+Scales are sampled at logarithmic steps given by
+
+@f[
+\sigma = \sigma_0 2^{o+s/S},
+\quad s = 0,\dots,S-1,
+\quad o = o_{\min}, \dots, o_{\min}+O-1,
+@f]
+
+where @f$ \sigma_0 = 1.6 @f$ is the <em>base scale</em>, @f$ o_{\min}
+@f$ is the <em>first octave index</em>, @em O the <em>number of
+octaves</em> and @em S the <em>number of scales per octave</em>.
+
+Blobs are detected as local extrema of the <b>Difference of
+Gaussians</b> (DoG) scale space, obtained by subtracting successive
+scales of the Gaussian scale space:
+
+@f[
+\mathrm{DoG}_{\sigma(o,s)} = I_{\sigma(o,s+1)} - I_{\sigma(o,s)}
+@f]
+
+At each next octave, the resolution of the images is halved to save
+computations. The images composing the Gaussian and DoG scale space
+can then be arranged as in the following figure:
+
+@image html sift-ss.png  "GSS and DoG scale space  structures."
+
+The black vertical segments represent images of the Gaussian Scale
+Space (GSS), arranged by increasing scale @f$\sigma@f$.  Notice that
+the scale level index @e s varies in a slightly redundant set
+
+@f[
+s = -1, \dots, S+2
+@f]
+
+This simplifies glueing together different octaves and extracting DoG
+maxima (required by the SIFT detector).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-tech-detector Detector
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The SIFT frames (keypoints) are extracted based on local extrema
+(peaks) of the DoG scale space. Numerically, local extrema are
+elements whose @f$ 3 \times 3 \times 3 @f$ neighbors (in space and
+scale) have all smaller (or larger) value.  Once extracted, local
+extrema are quadratically interpolated (this is very important
+especially at the lower resolution scales in order to have accurate
+keypoint localization at the full resolution).  Finally, they are
+filtered to eliminate low-contrast responses or responses close to
+edges and the orientation(s) are assigned, as explained next.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsubsection sift-tech-detector-peak Eliminating low contrast responses
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Peaks which are too short may have been generated by noise and are
+discarded.  This is done by comparing the absolute value of the DoG
+scale space at the peak with the <b>peak threshold</b> @f$t_p@f$ and
+discarding the peak its value is below the threshold.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsubsection sift-tech-detector-edge Eliminating edge responses
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Peaks which are too flat are often generated by edges and do not yield
+stable features. These peaks are detected and removed as follows.
+Given a peak @f$x,y,\sigma@f$, the algorithm evaluates the @em x,@em y
+Hessian of of the DoG scale space at the scale @f$\sigma@f$.  Then the
+following score (similar to the Harris function) is computed:
+
+@f[
+\frac{(\mathrm{tr}\,D(x,y,\sigma))^2}{\det D(x,y,\sigma)},
+\quad
+D =
+\left[
+\begin{array}{cc}
+\frac{\partial^2 \mathrm{DoG}}{\partial x^2} &
+\frac{\partial^2 \mathrm{DoG}}{\partial x\partial y} \\
+\frac{\partial^2 \mathrm{DoG}}{\partial x\partial y} &
+\frac{\partial^2 \mathrm{DoG}}{\partial y^2}
+\end{array}
+\right].
+ @f]
+
+This score has a minimum (equal to 4) when both eigenvalues of the
+Jacobian are equal (curved peak) and increases as one of the
+eigenvalues grows and the other stays small. Peaks are retained if the
+score is below the quantity @f$(t_e+1)(t_e+1)/t_e@f$, where @f$t_e@f$
+is the <b>edge threshold</b>. Notice that this quantity has a minimum
+equal to 4 when @f$t_e=1@f$ and grows thereafter. Therefore the range
+of the edge threshold is @f$[1,\infty)@f$.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-tech-detector-orientation Orientation assignment
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A peak in the DoG scale space fixes 2 parameters of the keypoint: the
+position and scale. It remains to choose an orientation. In order to
+do this, SIFT computes an histogram of the gradient orientations in a
+Gaussian window with a standard deviation which is 1.5 times bigger
+than the scale @f$\sigma@f$ of the keypoint.
+
+@image html sift-orient.png
+
+This histogram is then smoothed and the maximum is selected.  In
+addition to the biggest mode, up to other three modes whose amplitude
+is within the 80% of the biggest mode are retained and returned as
+additional orientations.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsection sift-tech-descriptor Descriptor
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+A SIFT descriptor of a local region (keypoint) is a 3-D spatial
+histogram of the image gradients.  The gradient at each pixel is
+regarded as a sample of a three-dimensional elementary feature vector,
+formed by the pixel location and the gradient orientation. Samples are
+weighed by the gradient norm and accumulated in a 3-D histogram @em h,
+which (up to normalization and clamping) forms the SIFT descriptor of
+the region. An additional Gaussian weighting function is applied to
+give less importance to gradients farther away from the keypoint
+center.
+
+<!-- @image html sift-bins.png -->
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsubsection sift-tech-descriptor-can Construction in the canonical frame
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Denote the gradient vector field computed at the scale @f$ \sigma @f$ by
+@f[
+  J(x,y) = \nabla I_\sigma(x,y)
+  =
+  \left[\begin{array}{cc}
+  \frac{\partial I_\sigma}{\partial x} &
+  \frac{\partial I_\sigma}{\partial y} &
+  \end{array}\right]
+@f]
+
+The descriptor is a 3-D spatial histogram capturing the distribution
+of @f$ J(x,y) @f$. It is convenient to describe its construction in
+the <em>canonical frame</em>. In this frame, the image and descriptor
+axes coincide and each spatial bin has side 1. The histogram has @f$
+N_\theta \times N_x \times N_y @f$ bins (usually @f$ 8 \times 4 \times
+4 @f$), as in the following figure:
+
+@image html sift-can.png Canonical SIFT descriptor and spatial binning functions
+
+Bins are indexed by a triplet of indexes <em>t, i, j</em> and their
+centers are given by
+
+@f{eqnarray*}
+ \theta_t &=& \frac{2\pi}{N_\theta} t, \quad t = 0,\dots,N_{\theta}-1, \\
+ x_i &=& i - \frac{N_x -1}{2}, \quad i = 0,\dots,N_x-1, \\
+ y_j &=& j - \frac{N_x -1}{2}, \quad j = 0,\dots,N_y-1. \\
+@f}
+
+The histogram is computed by using trilinear interpolation, i.e.  by
+weighing contributions by the <em>binning functions</em>
+
+@f{eqnarray*}
+  \displaystyle
+  w(z) &=& \mathrm{max}(0, 1 - |z|),
+  \\
+  \displaystyle
+  w_\mathrm{ang}(z) &=& \sum_{k=-\infty}^{+\infty}
+  w\left(
+  \frac{N_\theta}{2\pi} z + N_\theta k
+  \right).
+@f}
+
+The gradient vector field is transformed in a three-dimensional
+density map of weighed contributions
+
+@f[
+   f(\theta, x, y) = |J(x,y)| \delta(\theta - \angle J(x,y))
+@f]
+
+The historam is localized in the keypoint support by a Gaussian window
+of standard deviation @f$ \sigma_{\mathrm{win}} @f$. The histogram is
+then given by
+
+@f{eqnarray*}
+ h(t,i,j) &=& \int
+ g_{\sigma_\mathrm{win}}(x,y)
+ w_\mathrm{ang}(\theta - \theta_t) w(x-x_i) w(y-y_j)
+ f(\theta,x,y)
+ d\theta\,dx\,dy
+\\
+&=& \int
+ g_{\sigma_\mathrm{win}}(x,y)
+ w_\mathrm{ang}(\angle J(x,y) - \theta_t) w(x-x_i) w(y-y_j)
+ |J(x,y)|\,dx\,dy
+@f}
+
+In post processing, the histogram is @f$ l^2 @f$ normalized, then
+clamped at 0.2, and @f$ l^2 @f$ normalized again.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsubsection sift-tech-descriptor-image Calculation in the image frame
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+Invariance to similarity transformation is attained by attaching
+descriptors to SIFT keypoints (or other similarity-covariant frames).
+Then projecting the image in the canonical descriptor frames has the
+effect of undoing the image deformation.
+
+In practice, however, it is convenient to compute the descriptor
+directly in the image frame. To do this, denote with a hat quantities
+relative to the canonical frame and without a hat quantities relative
+to the image frame (so for instance @f$ \hat x @f$ is the @e
+x-coordinate in the canonical frame and @f$ x @f$ the x-coordinate in
+the image frame). Assume that canonical and image frame are
+related by an affinity:
+
+@f[
+  \mathbf{x} = A \hat{\mathbf{x}} + T,
+  \qquad
+  \mathbf{x} =
+  \begin{bmatrix}{c}
+    x \\
+    y
+  \end{bmatrix},
+  \quad
+  \mathbf{x} =
+  \begin{bmatrix}{c}
+    \hat x \\
+    \hat y
+  \end{bmatrix}.
+@f]
+
+@image html sift-image-frame.png
+
+Then all quantities can be computed in the image frame directly. For instance,
+the image at infinite resolution in the two frames are related by
+
+@f[
+ \hat I_0(\hat{\mathbf{x}})  = I_0(\mathbf{x}),
+ \qquad
+ \mathbf{x} = A \hat{\mathbf{x}} + T.
+@f]
+
+The canonized image at scale @f$ \hat \sigma @f$ is in relation with the scaled image
+
+@f[
+ \hat I_{\hat{\sigma}}(\hat{\mathbf{x}})  = I_{A\hat{\sigma}}(\mathbf{x}),
+ \qquad \mathbf{x} = A \hat{\mathbf{x}} + T
+@f]
+
+where, by generalizing the previous definitions, we have
+
+@f[
+ I_{A\hat \sigma}(\mathbf{x}) = (g_{A\hat\sigma} * I_0)(\mathbf{x}),
+\quad
+ g_{A\hat\sigma}(\mathbf{x})
+ =
+ \frac{1}{2\pi|A|\hat \sigma^2}
+ \exp
+ \left(
+ -\frac{1}{2}
+ \frac{\mathbf{x}^\top A^{-\top}A^{-1}\mathbf{x}}{\hat \sigma^2}
+ \right)
+@f]
+
+Deriving shows that the gradient fields are in relation
+
+@f[
+  \hat J(\hat{\mathbf{x}}) = J(\mathbf{x}) A,
+ \quad J(\mathbf{x}) = (\nabla I_{A\hat\sigma})(\mathbf{x}),
+ \qquad \mathbf{x} = A \hat{\mathbf{x}} + T.
+@f]
+
+Therefore we can compute the descriptor either in the image or canonical frame as:
+
+@f{eqnarray*}
+ h(t,i,j)
+ &=&
+ \int
+ g_{\hat \sigma_\mathrm{win}}(\hat{\mathbf{x}})\,
+ w_\mathrm{ang}(\angle \hat J(\hat{\mathbf{x}}) - \theta_t)\,
+ w_{ij}(\hat{\mathbf{x}})\,
+ |\hat J(\hat{\mathbf{x}})|\,
+ d\hat{\mathbf{x}}
+ \\
+ &=& \int
+ g_{A \hat \sigma_\mathrm{win}}(\mathbf{x} - T)\,
+ w_\mathrm{ang}(\angle J(\mathbf{x})A - \theta_t)\,
+ w_{ij}(A^{-1}(\mathbf{x} - T))\,
+ |J(\mathbf{x})A|\,
+ d\mathbf{x}.
+@f}
+
+where we defined the product of the two spatial binning functions
+
+@f[
+ w_{ij}(\hat{\mathbf{x}}) = w(\hat x - \hat x_i) w(\hat y - \hat y_j)
+@f]
+
+
+In the actual implementation, this integral is computed by visiting a
+rectangular area of the image that fully contains the keypoint grid
+(along with half a bin border to fully include the bin windowing
+function). Since the descriptor can be rotated, this area is a
+rectangle of sides @f$m/2\sqrt{2} (N_x+1,N_y+1)@f$ (see also the
+illustration).
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@subsubsection sift-tech-descriptor-std Standard SIFT descriptor
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+For a SIFT-detected keypoint of center @f$ T @f$, scale @f$ \sigma @f$
+and orientation @f$ \theta @f$, the affine transformation @f$ (A,T)
+@f$ reduces to the similarity transformation
+
+@f[
+     \mathbf{x} = m \sigma R(\theta) \hat{\mathbf{x}} + T
+@f]
+
+where @f$ R(\theta) @f$ is a counter-clockwise rotation of @f$ \theta
+@f$ radians, @f$ m \mathcal{\sigma} @f$ is the size of a descriptor
+bin in pixels, and @e m is the <b>descriptor magnification factor</b>
+which expresses how much larger a descriptor bin is compared to
+the scale of the keypoint @f$ \sigma @f$
+(the default value is @e m = 3). Moreover, the
+standard SIFT descriptor computes the image gradient at the scale of
+the keypoints, which in the canonical frame is equivalent to a
+smoothing of @f$ \hat \sigma = 1/m @f$. Finally, the default
+Gaussian window size is set to have standard deviation
+ @f$ \hat \sigma_\mathrm{win} = 2 @f$. This yields the formula
+
+@f{eqnarray*}
+ h(t,i,j)
+ &=&
+ m \sigma \int
+ g_{\sigma_\mathrm{win}}(\mathbf{x} - T)\,
+ w_\mathrm{ang}(\angle J(\mathbf{x}) - \theta  - \theta_t)\,
+ w_{ij}\left(\frac{R(\theta)^\top \mathbf{x} - T}{m\sigma}\right)\,
+ |J(\mathbf{x})|\,
+ d\mathbf{x},
+\\
+\sigma_{\mathrm{win}} &=& m\sigma\hat \sigma_{\mathrm{win}},
+\\
+ J(\mathbf{x})
+ &=& \nabla (g_{m \sigma \hat \sigma} * I)(\mathbf{x})
+ = \nabla (g_{\sigma} * I)(\mathbf{x})
+ = \nabla I_{\sigma} (\mathbf{x}).
+@f}
+
+
+
+**/
+
+#include "sift.h"
+#include "imopv.h"
+#include "mathop.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdio.h>
+
+/** @internal @brief Use bilinear interpolation to compute orientations */
+#define VL_SIFT_BILINEAR_ORIENTATIONS 1
+
+#define EXPN_SZ  256          /**< ::fast_expn table size @internal */
+#define EXPN_MAX 25.0         /**< ::fast_expn table max  @internal */
+double expn_tab [EXPN_SZ+1] ; /**< ::fast_expn table      @internal */
+
+#define NBO 8
+#define NBP 4
+
+#define log2(x) (log(x)/VL_LOG_OF_2)
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Fast @f$exp(-x)@f$ approximation
+ **
+ ** @param x argument.
+ **
+ ** The argument must be in the range [0, ::EXPN_MAX] .
+ **
+ ** @return approximation of @f$exp(-x)@f$.
+ **/
+
+VL_INLINE double
+fast_expn (double x)
+{
+  double a,b,r ;
+  int i ;
+  /*assert(0 <= x && x <= EXPN_MAX) ;*/
+
+  if (x > EXPN_MAX) return 0.0 ;
+
+  x *= EXPN_SZ / EXPN_MAX ;
+  i = (int)vl_floor_d (x) ;
+  r = x - i ;
+  a = expn_tab [i    ] ;
+  b = expn_tab [i + 1] ;
+  return a + r * (b - a) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Initialize tables for ::fast_expn
+ **/
+
+VL_INLINE void
+fast_expn_init ()
+{
+  int k  ;
+  for(k = 0 ; k < EXPN_SZ + 1 ; ++ k) {
+    expn_tab [k] = exp (- (double) k * (EXPN_MAX / EXPN_SZ)) ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Copy image, upsample rows and take transpose
+ **
+ ** @param dst     output image buffer.
+ ** @param src     input image buffer.
+ ** @param width   input image width.
+ ** @param height  input image height.
+ **
+ ** The output image has dimensions @a height by 2 @a width (so the
+ ** destination buffer must be at least as big as two times the
+ ** input buffer).
+ **
+ ** Upsampling is performed by linear interpolation.
+ **/
+
+static void
+copy_and_upsample_rows
+(vl_sift_pix       *dst,
+ vl_sift_pix const *src, int width, int height)
+{
+  int x, y ;
+  vl_sift_pix a, b ;
+
+  for(y = 0 ; y < height ; ++y) {
+    b = a = *src++ ;
+    for(x = 0 ; x < width - 1 ; ++x) {
+      b = *src++ ;
+      *dst = a ;             dst += height ;
+      *dst = 0.5 * (a + b) ; dst += height ;
+      a = b ;
+    }
+    *dst = b ; dst += height ;
+    *dst = b ; dst += height ;
+    dst += 1 - width * 2 * height ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Smooth an image
+ ** @param self        SIFT filter.
+ ** @param outputImage output imgae buffer.
+ ** @param tempImage   temporary image buffer.
+ ** @param inputImage  input image buffer.
+ ** @param width       input image width.
+ ** @param height      input image height.
+ ** @param sigma       smoothing.
+ **/
+
+static void
+_vl_sift_smooth (VlSiftFilt * self,
+                 vl_sift_pix * outputImage,
+                 vl_sift_pix * tempImage,
+                 vl_sift_pix const * inputImage,
+                 vl_size width,
+                 vl_size height,
+                 double sigma)
+{
+  /* prepare Gaussian filter */
+  if (self->gaussFilterSigma != sigma) {
+    vl_uindex j ;
+    vl_sift_pix acc = 0 ;
+    if (self->gaussFilter) vl_free (self->gaussFilter) ;
+    self->gaussFilterWidth = VL_MAX(ceil(4.0 * sigma), 1) ;
+    self->gaussFilterSigma = sigma ;
+    self->gaussFilter = vl_malloc (sizeof(vl_sift_pix) * (2 * self->gaussFilterWidth + 1)) ;
+
+    for (j = 0 ; j < 2 * self->gaussFilterWidth + 1 ; ++j) {
+      vl_sift_pix d = ((vl_sift_pix)((signed)j - (signed)self->gaussFilterWidth)) / ((vl_sift_pix)sigma) ;
+      self->gaussFilter[j] = (vl_sift_pix) exp (- 0.5 * (d*d)) ;
+      acc += self->gaussFilter[j] ;
+    }
+    for (j = 0 ; j < 2 * self->gaussFilterWidth + 1 ; ++j) {
+      self->gaussFilter[j] /= acc ;
+    }
+  }
+
+  if (self->gaussFilterWidth == 0) {
+    memcpy (outputImage, inputImage, sizeof(vl_sift_pix) * width * height) ;
+    return ;
+  }
+
+  vl_imconvcol_vf (tempImage, height,
+                   inputImage, width, height, width,
+                   self->gaussFilter,
+                   - self->gaussFilterWidth, self->gaussFilterWidth,
+                   1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
+
+  vl_imconvcol_vf (outputImage, width,
+                   tempImage, height, width, height,
+                   self->gaussFilter,
+                   - self->gaussFilterWidth, self->gaussFilterWidth,
+                   1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Copy and downsample an image
+ **
+ ** @param dst    output imgae buffer.
+ ** @param src    input  image buffer.
+ ** @param width  input  image width.
+ ** @param height input  image height.
+ ** @param d      octaves (non negative).
+ **
+ ** The function downsamples the image @a d times, reducing it to @c
+ ** 1/2^d of its original size. The parameters @a width and @a height
+ ** are the size of the input image. The destination image @a dst is
+ ** assumed to be <code>floor(width/2^d)</code> pixels wide and
+ ** <code>floor(height/2^d)</code> pixels high.
+ **/
+
+static void
+copy_and_downsample
+(vl_sift_pix       *dst,
+ vl_sift_pix const *src,
+ int width, int height, int d)
+{
+  int x, y ;
+
+  d = 1 << d ; /* d = 2^d */
+  for(y = 0 ; y < height ; y+=d) {
+    vl_sift_pix const * srcrowp = src + y * width ;
+    for(x = 0 ; x < width - (d-1) ; x+=d) {
+      *dst++ = *srcrowp ;
+      srcrowp += d ;
+    }
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Create a new SIFT filter
+ **
+ ** @param width    image width.
+ ** @param height   image height.
+ ** @param noctaves number of octaves.
+ ** @param nlevels  number of levels per octave.
+ ** @param o_min    first octave index.
+ **
+ ** The function allocates and returns a new SIFT filter for the
+ ** specified image and scale space geometry.
+ **
+ ** Setting @a O to a negative value sets the number of octaves to the
+ ** maximum possible value depending on the size of the image.
+ **
+ ** @return the new SIFT filter.
+ ** @sa ::vl_sift_delete().
+ **/
+
+VL_EXPORT
+VlSiftFilt *
+vl_sift_new (int width, int height,
+             int noctaves, int nlevels,
+             int o_min)
+{
+  VlSiftFilt *f = vl_malloc (sizeof(VlSiftFilt)) ;
+
+  int w   = VL_SHIFT_LEFT (width,  -o_min) ;
+  int h   = VL_SHIFT_LEFT (height, -o_min) ;
+  int nel = w * h ;
+
+  /* negative value O => calculate max. value */
+  if (noctaves < 0) {
+    noctaves = VL_MAX (floor (log2 (VL_MIN(width, height))) - o_min - 3, 1) ;
+  }
+
+  f-> width   = width ;
+  f-> height  = height ;
+  f-> O       = noctaves ;
+  f-> S       = nlevels ;
+  f-> o_min   = o_min ;
+  f-> s_min   = -1 ;
+  f-> s_max   = nlevels + 1 ;
+  f-> o_cur   = o_min ;
+
+  f-> temp    = vl_malloc (sizeof(vl_sift_pix) * nel    ) ;
+  f-> octave  = vl_malloc (sizeof(vl_sift_pix) * nel
+                        * (f->s_max - f->s_min + 1)  ) ;
+  f-> dog     = vl_malloc (sizeof(vl_sift_pix) * nel
+                        * (f->s_max - f->s_min    )  ) ;
+  f-> grad    = vl_malloc (sizeof(vl_sift_pix) * nel * 2
+                        * (f->s_max - f->s_min    )  ) ;
+
+  f-> sigman  = 0.5 ;
+  f-> sigmak  = pow (2.0, 1.0 / nlevels) ;
+  f-> sigma0  = 1.6 * f->sigmak ;
+  f-> dsigma0 = f->sigma0 * sqrt (1.0 - 1.0 / (f->sigmak*f->sigmak)) ;
+
+  f-> gaussFilter = NULL ;
+  f-> gaussFilterSigma = 0 ;
+  f-> gaussFilterWidth = 0 ;
+
+  f-> octave_width  = 0 ;
+  f-> octave_height = 0 ;
+
+  f-> keys     = 0 ;
+  f-> nkeys    = 0 ;
+  f-> keys_res = 0 ;
+
+  f-> peak_thresh = 0.0 ;
+  f-> edge_thresh = 10.0 ;
+  f-> norm_thresh = 0.0 ;
+  f-> magnif      = 3.0 ;
+  f-> windowSize  = NBP / 2 ;
+
+  f-> grad_o  = o_min - 1 ;
+
+  /* initialize fast_expn stuff */
+  fast_expn_init () ;
+
+  return f ;
+}
+
+/** -------------------------------------------------------------------
+ ** @brief Delete SIFT filter
+ **
+ ** @param f SIFT filter to delete.
+ **
+ ** The function frees the resources allocated by ::vl_sift_new().
+ **/
+
+VL_EXPORT
+void
+vl_sift_delete (VlSiftFilt* f)
+{
+  if (f) {
+    if (f->keys) vl_free (f->keys) ;
+    if (f->grad) vl_free (f->grad) ;
+    if (f->dog) vl_free (f->dog) ;
+    if (f->octave) vl_free (f->octave) ;
+    if (f->temp) vl_free (f->temp) ;
+    if (f->gaussFilter) vl_free (f->gaussFilter) ;
+    vl_free (f) ;
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Start processing a new image
+ **
+ ** @param f  SIFT filter.
+ ** @param im image data.
+ **
+ ** The function starts processing a new image by computing its
+ ** Gaussian scale space at the lower octave. It also empties the
+ ** internal keypoint buffer.
+ **
+ ** @return error code. The function returns ::VL_ERR_EOF if there are
+ ** no more octaves to process.
+ **
+ ** @sa ::vl_sift_process_next_octave().
+ **/
+
+VL_EXPORT
+int
+vl_sift_process_first_octave (VlSiftFilt *f, vl_sift_pix const *im)
+{
+  int o, s, h, w ;
+  double sa, sb ;
+  vl_sift_pix *octave ;
+
+  /* shortcuts */
+  vl_sift_pix *temp   = f-> temp ;
+  int width           = f-> width ;
+  int height          = f-> height ;
+  int o_min           = f-> o_min ;
+  int s_min           = f-> s_min ;
+  int s_max           = f-> s_max ;
+  double sigma0       = f-> sigma0 ;
+  double sigmak       = f-> sigmak ;
+  double sigman       = f-> sigman ;
+  double dsigma0      = f-> dsigma0 ;
+
+  /* restart from the first */
+  f->o_cur = o_min ;
+  f->nkeys = 0 ;
+  w = f-> octave_width  = VL_SHIFT_LEFT(f->width,  - f->o_cur) ;
+  h = f-> octave_height = VL_SHIFT_LEFT(f->height, - f->o_cur) ;
+
+  /* is there at least one octave? */
+  if (f->O == 0)
+    return VL_ERR_EOF ;
+
+  /* ------------------------------------------------------------------
+   *                     Compute the first sublevel of the first octave
+   * --------------------------------------------------------------- */
+
+  /*
+   * If the first octave has negative index, we upscale the image; if
+   * the first octave has positive index, we downscale the image; if
+   * the first octave has index zero, we just copy the image.
+   */
+
+  octave = vl_sift_get_octave (f, s_min) ;
+
+  if (o_min < 0) {
+    /* double once */
+    copy_and_upsample_rows (temp,   im,   width,      height) ;
+    copy_and_upsample_rows (octave, temp, height, 2 * width ) ;
+
+    /* double more */
+    for(o = -1 ; o > o_min ; --o) {
+      copy_and_upsample_rows (temp, octave,
+                              width << -o,      height << -o ) ;
+      copy_and_upsample_rows (octave, temp,
+                              width << -o, 2 * (height << -o)) ;
+    }
+  }
+  else if (o_min > 0) {
+    /* downsample */
+    copy_and_downsample (octave, im, width, height, o_min) ;
+  }
+  else {
+    /* direct copy */
+    memcpy(octave, im, sizeof(vl_sift_pix) * width * height) ;
+  }
+
+  /*
+   * Here we adjust the smoothing of the first level of the octave.
+   * The input image is assumed to have nominal smoothing equal to
+   * f->simgan.
+   */
+
+  sa = sigma0 * pow (sigmak,   s_min) ;
+  sb = sigman * pow (2.0,    - o_min) ;
+
+  if (sa > sb) {
+    double sd = sqrt (sa*sa - sb*sb) ;
+    _vl_sift_smooth (f, octave, temp, octave, w, h, sd) ;
+  }
+
+  /* -----------------------------------------------------------------
+   *                                          Compute the first octave
+   * -------------------------------------------------------------- */
+
+  for(s = s_min + 1 ; s <= s_max ; ++s) {
+    double sd = dsigma0 * pow (sigmak, s) ;
+    _vl_sift_smooth (f, vl_sift_get_octave(f, s), temp,
+                     vl_sift_get_octave(f, s - 1), w, h, sd) ;
+  }
+
+  return VL_ERR_OK ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Process next octave
+ **
+ ** @param f SIFT filter.
+ **
+ ** The function computes the next octave of the Gaussian scale space.
+ ** Notice that this clears the record of any feature detected in the
+ ** previous octave.
+ **
+ ** @return error code. The function returns the error
+ ** ::VL_ERR_EOF when there are no more octaves to process.
+ **
+ ** @sa ::vl_sift_process_first_octave().
+ **/
+
+VL_EXPORT
+int
+vl_sift_process_next_octave (VlSiftFilt *f)
+{
+
+  int s, h, w, s_best ;
+  double sa, sb ;
+  vl_sift_pix *octave, *pt ;
+
+  /* shortcuts */
+  vl_sift_pix *temp   = f-> temp ;
+  int O               = f-> O ;
+  int S               = f-> S ;
+  int o_min           = f-> o_min ;
+  int s_min           = f-> s_min ;
+  int s_max           = f-> s_max ;
+  double sigma0       = f-> sigma0 ;
+  double sigmak       = f-> sigmak ;
+  double dsigma0      = f-> dsigma0 ;
+
+  /* is there another octave ? */
+  if (f->o_cur == o_min + O - 1)
+    return VL_ERR_EOF ;
+
+  /* retrieve base */
+  s_best = VL_MIN(s_min + S, s_max) ;
+  w      = vl_sift_get_octave_width  (f) ;
+  h      = vl_sift_get_octave_height (f) ;
+  pt     = vl_sift_get_octave        (f, s_best) ;
+  octave = vl_sift_get_octave        (f, s_min) ;
+
+  /* next octave */
+  copy_and_downsample (octave, pt, w, h, 1) ;
+
+  f-> o_cur            += 1 ;
+  f-> nkeys             = 0 ;
+  w = f-> octave_width  = VL_SHIFT_LEFT(f->width,  - f->o_cur) ;
+  h = f-> octave_height = VL_SHIFT_LEFT(f->height, - f->o_cur) ;
+
+  sa = sigma0 * powf (sigmak, s_min     ) ;
+  sb = sigma0 * powf (sigmak, s_best - S) ;
+
+  if (sa > sb) {
+    double sd = sqrt (sa*sa - sb*sb) ;
+    _vl_sift_smooth (f, octave, temp, octave, w, h, sd) ;
+  }
+
+  /* ------------------------------------------------------------------
+   *                                                        Fill octave
+   * --------------------------------------------------------------- */
+
+  for(s = s_min + 1 ; s <= s_max ; ++s) {
+    double sd = dsigma0 * pow (sigmak, s) ;
+    _vl_sift_smooth (f, vl_sift_get_octave(f, s), temp,
+                     vl_sift_get_octave(f, s - 1), w, h, sd) ;
+  }
+
+  return VL_ERR_OK ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Detect keypoints
+ **
+ ** The function detect keypoints in the current octave filling the
+ ** internal keypoint buffer. Keypoints can be retrieved by
+ ** ::vl_sift_get_keypoints().
+ **
+ ** @param f SIFT filter.
+ **/
+
+VL_EXPORT
+void
+vl_sift_detect (VlSiftFilt * f)
+{
+  vl_sift_pix* dog   = f-> dog ;
+  int          s_min = f-> s_min ;
+  int          s_max = f-> s_max ;
+  int          w     = f-> octave_width ;
+  int          h     = f-> octave_height ;
+  double       te    = f-> edge_thresh ;
+  double       tp    = f-> peak_thresh ;
+
+  int const    xo    = 1 ;      /* x-stride */
+  int const    yo    = w ;      /* y-stride */
+  int const    so    = w * h ;  /* s-stride */
+
+  double       xper  = pow (2.0, f->o_cur) ;
+
+  int x, y, s, i, ii, jj ;
+  vl_sift_pix *pt, v ;
+  VlSiftKeypoint *k ;
+
+  /* clear current list */
+  f-> nkeys = 0 ;
+
+  /* compute difference of gaussian (DoG) */
+  pt = f-> dog ;
+  for (s = s_min ; s <= s_max - 1 ; ++s) {
+    vl_sift_pix* src_a = vl_sift_get_octave (f, s    ) ;
+    vl_sift_pix* src_b = vl_sift_get_octave (f, s + 1) ;
+    vl_sift_pix* end_a = src_a + w * h ;
+    while (src_a != end_a) {
+      *pt++ = *src_b++ - *src_a++ ;
+    }
+  }
+
+  /* -----------------------------------------------------------------
+   *                                          Find local maxima of DoG
+   * -------------------------------------------------------------- */
+
+  /* start from dog [1,1,s_min+1] */
+  pt  = dog + xo + yo + so ;
+
+  for(s = s_min + 1 ; s <= s_max - 2 ; ++s) {
+    for(y = 1 ; y < h - 1 ; ++y) {
+      for(x = 1 ; x < w - 1 ; ++x) {
+        v = *pt ;
+
+#define CHECK_NEIGHBORS(CMP,SGN)                    \
+        ( v CMP ## = SGN 0.8 * tp &&                \
+          v CMP *(pt + xo) &&                       \
+          v CMP *(pt - xo) &&                       \
+          v CMP *(pt + so) &&                       \
+          v CMP *(pt - so) &&                       \
+          v CMP *(pt + yo) &&                       \
+          v CMP *(pt - yo) &&                       \
+                                                    \
+          v CMP *(pt + yo + xo) &&                  \
+          v CMP *(pt + yo - xo) &&                  \
+          v CMP *(pt - yo + xo) &&                  \
+          v CMP *(pt - yo - xo) &&                  \
+                                                    \
+          v CMP *(pt + xo      + so) &&             \
+          v CMP *(pt - xo      + so) &&             \
+          v CMP *(pt + yo      + so) &&             \
+          v CMP *(pt - yo      + so) &&             \
+          v CMP *(pt + yo + xo + so) &&             \
+          v CMP *(pt + yo - xo + so) &&             \
+          v CMP *(pt - yo + xo + so) &&             \
+          v CMP *(pt - yo - xo + so) &&             \
+                                                    \
+          v CMP *(pt + xo      - so) &&             \
+          v CMP *(pt - xo      - so) &&             \
+          v CMP *(pt + yo      - so) &&             \
+          v CMP *(pt - yo      - so) &&             \
+          v CMP *(pt + yo + xo - so) &&             \
+          v CMP *(pt + yo - xo - so) &&             \
+          v CMP *(pt - yo + xo - so) &&             \
+          v CMP *(pt - yo - xo - so) )
+
+        if (CHECK_NEIGHBORS(>,+) ||
+            CHECK_NEIGHBORS(<,-) ) {
+
+          /* make room for more keypoints */
+          if (f->nkeys >= f->keys_res) {
+            f->keys_res += 500 ;
+            if (f->keys) {
+              f->keys = vl_realloc (f->keys,
+                                    f->keys_res *
+                                    sizeof(VlSiftKeypoint)) ;
+            } else {
+              f->keys = vl_malloc (f->keys_res *
+                                   sizeof(VlSiftKeypoint)) ;
+            }
+          }
+
+          k = f->keys + (f->nkeys ++) ;
+
+          k-> ix = x ;
+          k-> iy = y ;
+          k-> is = s ;
+        }
+        pt += 1 ;
+      }
+      pt += 2 ;
+    }
+    pt += 2 * yo ;
+  }
+
+  /* -----------------------------------------------------------------
+   *                                               Refine local maxima
+   * -------------------------------------------------------------- */
+
+  /* this pointer is used to write the keypoints back */
+  k = f->keys ;
+
+  for (i = 0 ; i < f->nkeys ; ++i) {
+
+    int x = f-> keys [i] .ix ;
+    int y = f-> keys [i] .iy ;
+    int s = f-> keys [i]. is ;
+
+    double Dx=0,Dy=0,Ds=0,Dxx=0,Dyy=0,Dss=0,Dxy=0,Dxs=0,Dys=0 ;
+    double A [3*3], b [3] ;
+
+    int dx = 0 ;
+    int dy = 0 ;
+
+    int iter, i, j ;
+
+    for (iter = 0 ; iter < 5 ; ++iter) {
+
+      x += dx ;
+      y += dy ;
+
+      pt = dog
+        + xo * x
+        + yo * y
+        + so * (s - s_min) ;
+
+      /** @brief Index GSS @internal */
+#define at(dx,dy,ds) (*( pt + (dx)*xo + (dy)*yo + (ds)*so))
+
+      /** @brief Index matrix A @internal */
+#define Aat(i,j)     (A[(i)+(j)*3])
+
+      /* compute the gradient */
+      Dx = 0.5 * (at(+1,0,0) - at(-1,0,0)) ;
+      Dy = 0.5 * (at(0,+1,0) - at(0,-1,0));
+      Ds = 0.5 * (at(0,0,+1) - at(0,0,-1)) ;
+
+      /* compute the Hessian */
+      Dxx = (at(+1,0,0) + at(-1,0,0) - 2.0 * at(0,0,0)) ;
+      Dyy = (at(0,+1,0) + at(0,-1,0) - 2.0 * at(0,0,0)) ;
+      Dss = (at(0,0,+1) + at(0,0,-1) - 2.0 * at(0,0,0)) ;
+
+      Dxy = 0.25 * ( at(+1,+1,0) + at(-1,-1,0) - at(-1,+1,0) - at(+1,-1,0) ) ;
+      Dxs = 0.25 * ( at(+1,0,+1) + at(-1,0,-1) - at(-1,0,+1) - at(+1,0,-1) ) ;
+      Dys = 0.25 * ( at(0,+1,+1) + at(0,-1,-1) - at(0,-1,+1) - at(0,+1,-1) ) ;
+
+      /* solve linear system ....................................... */
+      Aat(0,0) = Dxx ;
+      Aat(1,1) = Dyy ;
+      Aat(2,2) = Dss ;
+      Aat(0,1) = Aat(1,0) = Dxy ;
+      Aat(0,2) = Aat(2,0) = Dxs ;
+      Aat(1,2) = Aat(2,1) = Dys ;
+
+      b[0] = - Dx ;
+      b[1] = - Dy ;
+      b[2] = - Ds ;
+
+      /* Gauss elimination */
+      for(j = 0 ; j < 3 ; ++j) {
+        double maxa    = 0 ;
+        double maxabsa = 0 ;
+        int    maxi    = -1 ;
+        double tmp ;
+
+        /* look for the maximally stable pivot */
+        for (i = j ; i < 3 ; ++i) {
+          double a    = Aat (i,j) ;
+          double absa = vl_abs_d (a) ;
+          if (absa > maxabsa) {
+            maxa    = a ;
+            maxabsa = absa ;
+            maxi    = i ;
+          }
+        }
+
+        /* if singular give up */
+        if (maxabsa < 1e-10f) {
+          b[0] = 0 ;
+          b[1] = 0 ;
+          b[2] = 0 ;
+          break ;
+        }
+
+        i = maxi ;
+
+        /* swap j-th row with i-th row and normalize j-th row */
+        for(jj = j ; jj < 3 ; ++jj) {
+          tmp = Aat(i,jj) ; Aat(i,jj) = Aat(j,jj) ; Aat(j,jj) = tmp ;
+          Aat(j,jj) /= maxa ;
+        }
+        tmp = b[j] ; b[j] = b[i] ; b[i] = tmp ;
+        b[j] /= maxa ;
+
+        /* elimination */
+        for (ii = j+1 ; ii < 3 ; ++ii) {
+          double x = Aat(ii,j) ;
+          for (jj = j ; jj < 3 ; ++jj) {
+            Aat(ii,jj) -= x * Aat(j,jj) ;
+          }
+          b[ii] -= x * b[j] ;
+        }
+      }
+
+      /* backward substitution */
+      for (i = 2 ; i > 0 ; --i) {
+        double x = b[i] ;
+        for (ii = i-1 ; ii >= 0 ; --ii) {
+          b[ii] -= x * Aat(ii,i) ;
+        }
+      }
+
+      /* .......................................................... */
+      /* If the translation of the keypoint is big, move the keypoint
+       * and re-iterate the computation. Otherwise we are all set.
+       */
+
+      dx= ((b[0] >  0.6 && x < w - 2) ?  1 : 0)
+        + ((b[0] < -0.6 && x > 1    ) ? -1 : 0) ;
+
+      dy= ((b[1] >  0.6 && y < h - 2) ?  1 : 0)
+        + ((b[1] < -0.6 && y > 1    ) ? -1 : 0) ;
+
+      if (dx == 0 && dy == 0) break ;
+    }
+
+    /* check threshold and other conditions */
+    {
+      double val   = at(0,0,0)
+        + 0.5 * (Dx * b[0] + Dy * b[1] + Ds * b[2]) ;
+      double score = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ;
+      double xn = x + b[0] ;
+      double yn = y + b[1] ;
+      double sn = s + b[2] ;
+
+      vl_bool good =
+        vl_abs_d (val)  > tp                  &&
+        score           < (te+1)*(te+1)/te    &&
+        score           >= 0                  &&
+        vl_abs_d (b[0]) <  1.5                &&
+        vl_abs_d (b[1]) <  1.5                &&
+        vl_abs_d (b[2]) <  1.5                &&
+        xn              >= 0                  &&
+        xn              <= w - 1              &&
+        yn              >= 0                  &&
+        yn              <= h - 1              &&
+        sn              >= s_min              &&
+        sn              <= s_max ;
+
+      if (good) {
+        k-> o     = f->o_cur ;
+        k-> ix    = x ;
+        k-> iy    = y ;
+        k-> is    = s ;
+        k-> s     = sn ;
+        k-> x     = xn * xper ;
+        k-> y     = yn * xper ;
+        k-> sigma = f->sigma0 * pow (2.0, sn/f->S) * xper ;
+        ++ k ;
+      }
+
+    } /* done checking */
+  } /* next keypoint to refine */
+
+  /* update keypoint count */
+  f-> nkeys = (int)(k - f->keys) ;
+}
+
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Update gradients to current GSS octave
+ **
+ ** @param f SIFT filter.
+ **
+ ** The function makes sure that the gradient buffer is up-to-date
+ ** with the current GSS data.
+ **
+ ** @remark The minimum octave size is 2x2xS.
+ **/
+
+static void
+update_gradient (VlSiftFilt *f)
+{
+  int       s_min = f->s_min ;
+  int       s_max = f->s_max ;
+  int       w     = vl_sift_get_octave_width  (f) ;
+  int       h     = vl_sift_get_octave_height (f) ;
+  int const xo    = 1 ;
+  int const yo    = w ;
+  int const so    = h * w ;
+  int y, s ;
+
+  if (f->grad_o == f->o_cur) return ;
+
+  for (s  = s_min + 1 ;
+       s <= s_max - 2 ; ++ s) {
+
+    vl_sift_pix *src, *end, *grad, gx, gy ;
+
+#define SAVE_BACK                                                       \
+    *grad++ = vl_fast_sqrt_f (gx*gx + gy*gy) ;                          \
+    *grad++ = vl_mod_2pi_f   (vl_fast_atan2_f (gy, gx) + 2*VL_PI) ;     \
+    ++src ;                                                             \
+
+    src  = vl_sift_get_octave (f,s) ;
+    grad = f->grad + 2 * so * (s - s_min -1) ;
+
+    /* first pixel of the first row */
+    gx = src[+xo] - src[0] ;
+    gy = src[+yo] - src[0] ;
+    SAVE_BACK ;
+
+    /* middle pixels of the  first row */
+    end = (src - 1) + w - 1 ;
+    while (src < end) {
+      gx = 0.5 * (src[+xo] - src[-xo]) ;
+      gy =        src[+yo] - src[0] ;
+      SAVE_BACK ;
+    }
+
+    /* last pixel of the first row */
+    gx = src[0]   - src[-xo] ;
+    gy = src[+yo] - src[0] ;
+    SAVE_BACK ;
+
+    for (y = 1 ; y < h -1 ; ++y) {
+
+      /* first pixel of the middle rows */
+      gx =        src[+xo] - src[0] ;
+      gy = 0.5 * (src[+yo] - src[-yo]) ;
+      SAVE_BACK ;
+
+      /* middle pixels of the middle rows */
+      end = (src - 1) + w - 1 ;
+      while (src < end) {
+        gx = 0.5 * (src[+xo] - src[-xo]) ;
+        gy = 0.5 * (src[+yo] - src[-yo]) ;
+        SAVE_BACK ;
+      }
+
+      /* last pixel of the middle row */
+      gx =        src[0]   - src[-xo] ;
+      gy = 0.5 * (src[+yo] - src[-yo]) ;
+      SAVE_BACK ;
+    }
+
+    /* first pixel of the last row */
+    gx = src[+xo] - src[0] ;
+    gy = src[  0] - src[-yo] ;
+    SAVE_BACK ;
+
+    /* middle pixels of the last row */
+    end = (src - 1) + w - 1 ;
+    while (src < end) {
+      gx = 0.5 * (src[+xo] - src[-xo]) ;
+      gy =        src[0]   - src[-yo] ;
+      SAVE_BACK ;
+    }
+
+    /* last pixel of the last row */
+    gx = src[0]   - src[-xo] ;
+    gy = src[0]   - src[-yo] ;
+    SAVE_BACK ;
+  }
+  f->grad_o = f->o_cur ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Calculate the keypoint orientation(s)
+ **
+ ** @param f        SIFT filter.
+ ** @param angles   orientations (output).
+ ** @param k        keypoint.
+ **
+ ** The function computes the orientation(s) of the keypoint @a k.
+ ** The function returns the number of orientations found (up to
+ ** four). The orientations themselves are written to the vector @a
+ ** angles.
+ **
+ ** @remark The function requires the keypoint octave @a k->o to be
+ ** equal to the filter current octave ::vl_sift_get_octave. If this
+ ** is not the case, the function returns zero orientations.
+ **
+ ** @remark The function requires the keypoint scale level @c k->s to
+ ** be in the range @c s_min+1 and @c s_max-2 (where usually @c
+ ** s_min=0 and @c s_max=S+2). If this is not the case, the function
+ ** returns zero orientations.
+ **
+ ** @return number of orientations found.
+ **/
+
+VL_EXPORT
+int
+vl_sift_calc_keypoint_orientations (VlSiftFilt *f,
+                                    double angles [4],
+                                    VlSiftKeypoint const *k)
+{
+  double const winf   = 1.5 ;
+  double       xper   = pow (2.0, f->o_cur) ;
+
+  int          w      = f-> octave_width ;
+  int          h      = f-> octave_height ;
+  int const    xo     = 2 ;         /* x-stride */
+  int const    yo     = 2 * w ;     /* y-stride */
+  int const    so     = 2 * w * h ; /* s-stride */
+  double       x      = k-> x     / xper ;
+  double       y      = k-> y     / xper ;
+  double       sigma  = k-> sigma / xper ;
+
+  int          xi     = (int) (x + 0.5) ;
+  int          yi     = (int) (y + 0.5) ;
+  int          si     = k-> is ;
+
+  double const sigmaw = winf * sigma ;
+  int          W      = VL_MAX(floor (3.0 * sigmaw), 1) ;
+
+  int          nangles= 0 ;
+
+  enum {nbins = 36} ;
+
+  double hist [nbins], maxh ;
+  vl_sift_pix const * pt ;
+  int xs, ys, iter, i ;
+
+  /* skip if the keypoint octave is not current */
+  if(k->o != f->o_cur)
+    return 0 ;
+
+  /* skip the keypoint if it is out of bounds */
+  if(xi < 0            ||
+     xi > w - 1        ||
+     yi < 0            ||
+     yi > h - 1        ||
+     si < f->s_min + 1 ||
+     si > f->s_max - 2  ) {
+    return 0 ;
+  }
+
+  /* make gradient up to date */
+  update_gradient (f) ;
+
+  /* clear histogram */
+  memset (hist, 0, sizeof(double) * nbins) ;
+
+  /* compute orientation histogram */
+  pt = f-> grad + xo*xi + yo*yi + so*(si - f->s_min - 1) ;
+
+#undef  at
+#define at(dx,dy) (*(pt + xo * (dx) + yo * (dy)))
+
+  for(ys  =  VL_MAX (- W,       - yi) ;
+      ys <=  VL_MIN (+ W, h - 1 - yi) ; ++ys) {
+
+    for(xs  = VL_MAX (- W,       - xi) ;
+        xs <= VL_MIN (+ W, w - 1 - xi) ; ++xs) {
+
+
+      double dx = (double)(xi + xs) - x;
+      double dy = (double)(yi + ys) - y;
+      double r2 = dx*dx + dy*dy ;
+      double wgt, mod, ang, fbin ;
+
+      /* limit to a circular window */
+      if (r2 >= W*W + 0.6) continue ;
+
+      wgt  = fast_expn (r2 / (2*sigmaw*sigmaw)) ;
+      mod  = *(pt + xs*xo + ys*yo    ) ;
+      ang  = *(pt + xs*xo + ys*yo + 1) ;
+      fbin = nbins * ang / (2 * VL_PI) ;
+
+#if defined(VL_SIFT_BILINEAR_ORIENTATIONS)
+      {
+        int bin = (int) vl_floor_d (fbin - 0.5) ;
+        double rbin = fbin - bin - 0.5 ;
+        hist [(bin + nbins) % nbins] += (1 - rbin) * mod * wgt ;
+        hist [(bin + 1    ) % nbins] += (    rbin) * mod * wgt ;
+      }
+#else
+      {
+        int    bin  = vl_floor_d (fbin) ;
+        bin = vl_floor_d (nbins * ang / (2*VL_PI)) ;
+        hist [(bin) % nbins] += mod * wgt ;
+      }
+#endif
+
+    } /* for xs */
+  } /* for ys */
+
+  /* smooth histogram */
+  for (iter = 0; iter < 6; iter ++) {
+    double prev  = hist [nbins - 1] ;
+    double first = hist [0] ;
+    int i ;
+    for (i = 0; i < nbins - 1; i++) {
+      double newh = (prev + hist[i] + hist[(i+1) % nbins]) / 3.0;
+      prev = hist[i] ;
+      hist[i] = newh ;
+    }
+    hist[i] = (prev + hist[i] + first) / 3.0 ;
+  }
+
+  /* find the histogram maximum */
+  maxh = 0 ;
+  for (i = 0 ; i < nbins ; ++i)
+    maxh = VL_MAX (maxh, hist [i]) ;
+
+  /* find peaks within 80% from max */
+  nangles = 0 ;
+  for(i = 0 ; i < nbins ; ++i) {
+    double h0 = hist [i] ;
+    double hm = hist [(i - 1 + nbins) % nbins] ;
+    double hp = hist [(i + 1 + nbins) % nbins] ;
+
+    /* is this a peak? */
+    if (h0 > 0.8*maxh && h0 > hm && h0 > hp) {
+
+      /* quadratic interpolation */
+      double di = - 0.5 * (hp - hm) / (hp + hm - 2 * h0) ;
+      double th = 2 * VL_PI * (i + di + 0.5) / nbins ;
+      angles [ nangles++ ] = th ;
+      if( nangles == 4 )
+        goto enough_angles ;
+    }
+  }
+ enough_angles:
+  return nangles ;
+}
+
+
+/** ------------------------------------------------------------------
+ ** @internal
+ ** @brief Normalizes in norm L_2 a descriptor
+ ** @param begin begin of histogram.
+ ** @param end   end of histogram.
+ **/
+
+VL_INLINE vl_sift_pix
+normalize_histogram
+(vl_sift_pix *begin, vl_sift_pix *end)
+{
+  vl_sift_pix* iter ;
+  vl_sift_pix  norm = 0.0 ;
+
+  for (iter = begin ; iter != end ; ++ iter)
+    norm += (*iter) * (*iter) ;
+
+  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;
+
+  for (iter = begin; iter != end ; ++ iter)
+    *iter /= norm ;
+
+  return norm;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Run the SIFT descriptor on raw data
+ **
+ ** @param f        SIFT filter.
+ ** @param grad     image gradients.
+ ** @param descr    SIFT descriptor (output).
+ ** @param width    image width.
+ ** @param height   image height.
+ ** @param x        keypoint x coordinate.
+ ** @param y        keypoint y coordinate.
+ ** @param sigma    keypoint scale.
+ ** @param angle0   keypoint orientation.
+ **
+ ** The function runs the SIFT descriptor on raw data. Here @a image
+ ** is a 2 x @a width x @a height array (by convention, the memory
+ ** layout is a s such the first index is the fastest varying
+ ** one). The first @a width x @a height layer of the array contains
+ ** the gradient magnitude and the second the gradient angle (in
+ ** radians, between 0 and @f$ 2\pi @f$). @a x, @a y and @a sigma give
+ ** the keypoint center and scale respectively.
+ **
+ ** In order to be equivalent to a standard SIFT descriptor the image
+ ** gradient must be computed at a smoothing level equal to the scale
+ ** of the keypoint. In practice, the actual SIFT algorithm makes the
+ ** following additional approximation, which influence the result:
+ **
+ ** - Scale is discretized in @c S levels.
+ ** - The image is downsampled once for each octave (if you do this,
+ **   the parameters @a x, @a y and @a sigma must be
+ **   scaled too).
+ **/
+
+VL_EXPORT
+void
+vl_sift_calc_raw_descriptor (VlSiftFilt const *f,
+                             vl_sift_pix const* grad,
+                             vl_sift_pix *descr,
+                             int width, int height,
+                             double x, double y,
+                             double sigma,
+                             double angle0)
+{
+  double const magnif = f-> magnif ;
+
+  int          w      = width ;
+  int          h      = height ;
+  int const    xo     = 2 ;         /* x-stride */
+  int const    yo     = 2 * w ;     /* y-stride */
+
+  int          xi     = (int) (x + 0.5) ;
+  int          yi     = (int) (y + 0.5) ;
+
+  double const st0    = sin (angle0) ;
+  double const ct0    = cos (angle0) ;
+  double const SBP    = magnif * sigma + VL_EPSILON_D ;
+  int    const W      = floor
+    (sqrt(2.0) * SBP * (NBP + 1) / 2.0 + 0.5) ;
+
+  int const binto = 1 ;          /* bin theta-stride */
+  int const binyo = NBO * NBP ;  /* bin y-stride */
+  int const binxo = NBO ;        /* bin x-stride */
+
+  int bin, dxi, dyi ;
+  vl_sift_pix const *pt ;
+  vl_sift_pix       *dpt ;
+
+  /* check bounds */
+  if(xi    <  0               ||
+     xi    >= w               ||
+     yi    <  0               ||
+     yi    >= h -    1        )
+    return ;
+
+  /* clear descriptor */
+  memset (descr, 0, sizeof(vl_sift_pix) * NBO*NBP*NBP) ;
+
+  /* Center the scale space and the descriptor on the current keypoint.
+   * Note that dpt is pointing to the bin of center (SBP/2,SBP/2,0).
+   */
+  pt  = grad + xi*xo + yi*yo ;
+  dpt = descr + (NBP/2) * binyo + (NBP/2) * binxo ;
+
+#undef atd
+#define atd(dbinx,dbiny,dbint) *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
+
+  /*
+   * Process pixels in the intersection of the image rectangle
+   * (1,1)-(M-1,N-1) and the keypoint bounding box.
+   */
+  for(dyi =  VL_MAX(- W,   - yi   ) ;
+      dyi <= VL_MIN(+ W, h - yi -1) ; ++ dyi) {
+
+    for(dxi =  VL_MAX(- W,   - xi   ) ;
+        dxi <= VL_MIN(+ W, w - xi -1) ; ++ dxi) {
+
+      /* retrieve */
+      vl_sift_pix mod   = *( pt + dxi*xo + dyi*yo + 0 ) ;
+      vl_sift_pix angle = *( pt + dxi*xo + dyi*yo + 1 ) ;
+      vl_sift_pix theta = vl_mod_2pi_f (angle - angle0) ;
+
+      /* fractional displacement */
+      vl_sift_pix dx = xi + dxi - x;
+      vl_sift_pix dy = yi + dyi - y;
+
+      /* get the displacement normalized w.r.t. the keypoint
+         orientation and extension */
+      vl_sift_pix nx = ( ct0 * dx + st0 * dy) / SBP ;
+      vl_sift_pix ny = (-st0 * dx + ct0 * dy) / SBP ;
+      vl_sift_pix nt = NBO * theta / (2 * VL_PI) ;
+
+      /* Get the Gaussian weight of the sample. The Gaussian window
+       * has a standard deviation equal to NBP/2. Note that dx and dy
+       * are in the normalized frame, so that -NBP/2 <= dx <=
+       * NBP/2. */
+      vl_sift_pix const wsigma = f->windowSize ;
+      vl_sift_pix win = fast_expn
+        ((nx*nx + ny*ny)/(2.0 * wsigma * wsigma)) ;
+
+      /* The sample will be distributed in 8 adjacent bins.
+         We start from the ``lower-left'' bin. */
+      int         binx = (int)vl_floor_f (nx - 0.5) ;
+      int         biny = (int)vl_floor_f (ny - 0.5) ;
+      int         bint = (int)vl_floor_f (nt) ;
+      vl_sift_pix rbinx = nx - (binx + 0.5) ;
+      vl_sift_pix rbiny = ny - (biny + 0.5) ;
+      vl_sift_pix rbint = nt - bint ;
+      int         dbinx ;
+      int         dbiny ;
+      int         dbint ;
+
+      /* Distribute the current sample into the 8 adjacent bins*/
+      for(dbinx = 0 ; dbinx < 2 ; ++dbinx) {
+        for(dbiny = 0 ; dbiny < 2 ; ++dbiny) {
+          for(dbint = 0 ; dbint < 2 ; ++dbint) {
+
+            if (binx + dbinx >= - (NBP/2) &&
+                binx + dbinx <    (NBP/2) &&
+                biny + dbiny >= - (NBP/2) &&
+                biny + dbiny <    (NBP/2) ) {
+              vl_sift_pix weight = win
+                * mod
+                * vl_abs_f (1 - dbinx - rbinx)
+                * vl_abs_f (1 - dbiny - rbiny)
+                * vl_abs_f (1 - dbint - rbint) ;
+
+              atd(binx+dbinx, biny+dbiny, (bint+dbint) % NBO) += weight ;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /* Standard SIFT descriptors are normalized, truncated and normalized again */
+  if(1) {
+
+    /* normalize L2 norm */
+    vl_sift_pix norm = normalize_histogram (descr, descr + NBO*NBP*NBP) ;
+
+    /*
+       Set the descriptor to zero if it is lower than our
+       norm_threshold.  We divide by the number of samples in the
+       descriptor region because the Gaussian window used in the
+       calculation of the descriptor is not normalized.
+     */
+    int numSamples =
+      (VL_MIN(W, w - xi -1) - VL_MAX(-W, - xi) + 1) *
+      (VL_MIN(W, h - yi -1) - VL_MAX(-W, - yi) + 1) ;
+
+    if(f-> norm_thresh && norm < f-> norm_thresh * numSamples) {
+        for(bin = 0; bin < NBO*NBP*NBP ; ++ bin)
+            descr [bin] = 0;
+    }
+    else {
+      /* truncate at 0.2. */
+      for(bin = 0; bin < NBO*NBP*NBP ; ++ bin) {
+        if (descr [bin] > 0.2) descr [bin] = 0.2;
+      }
+
+      /* normalize again. */
+      normalize_histogram (descr, descr + NBO*NBP*NBP) ;
+    }
+  }
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Compute the descriptor of a keypoint
+ **
+ ** @param f        SIFT filter.
+ ** @param descr    SIFT descriptor (output)
+ ** @param k        keypoint.
+ ** @param angle0   keypoint direction.
+ **
+ ** The function computes the SIFT descriptor of the keypoint @a k of
+ ** orientation @a angle0. The function fills the buffer @a descr
+ ** which must be large enough to hold the descriptor.
+ **
+ ** The function assumes that the keypoint is on the current octave.
+ ** If not, it does not do anything.
+ **/
+
+VL_EXPORT
+void
+vl_sift_calc_keypoint_descriptor (VlSiftFilt *f,
+                                  vl_sift_pix *descr,
+                                  VlSiftKeypoint const* k,
+                                  double angle0)
+{
+  /*
+     The SIFT descriptor is a three dimensional histogram of the
+     position and orientation of the gradient.  There are NBP bins for
+     each spatial dimension and NBO bins for the orientation dimension,
+     for a total of NBP x NBP x NBO bins.
+
+     The support of each spatial bin has an extension of SBP = 3sigma
+     pixels, where sigma is the scale of the keypoint.  Thus all the
+     bins together have a support SBP x NBP pixels wide. Since
+     weighting and interpolation of pixel is used, the support extends
+     by another half bin. Therefore, the support is a square window of
+     SBP x (NBP + 1) pixels. Finally, since the patch can be
+     arbitrarily rotated, we need to consider a window 2W += sqrt(2) x
+     SBP x (NBP + 1) pixels wide.
+  */
+
+  double const magnif      = f-> magnif ;
+
+  double       xper        = pow (2.0, f->o_cur) ;
+
+  int          w           = f-> octave_width ;
+  int          h           = f-> octave_height ;
+  int const    xo          = 2 ;         /* x-stride */
+  int const    yo          = 2 * w ;     /* y-stride */
+  int const    so          = 2 * w * h ; /* s-stride */
+  double       x           = k-> x     / xper ;
+  double       y           = k-> y     / xper ;
+  double       sigma       = k-> sigma / xper ;
+
+  int          xi          = (int) (x + 0.5) ;
+  int          yi          = (int) (y + 0.5) ;
+  int          si          = k-> is ;
+
+  double const st0         = sin (angle0) ;
+  double const ct0         = cos (angle0) ;
+  double const SBP         = magnif * sigma + VL_EPSILON_D ;
+  int    const W           = floor
+    (sqrt(2.0) * SBP * (NBP + 1) / 2.0 + 0.5) ;
+
+  int const binto = 1 ;          /* bin theta-stride */
+  int const binyo = NBO * NBP ;  /* bin y-stride */
+  int const binxo = NBO ;        /* bin x-stride */
+
+  int bin, dxi, dyi ;
+  vl_sift_pix const *pt ;
+  vl_sift_pix       *dpt ;
+
+  /* check bounds */
+  if(k->o  != f->o_cur        ||
+     xi    <  0               ||
+     xi    >= w               ||
+     yi    <  0               ||
+     yi    >= h -    1        ||
+     si    <  f->s_min + 1    ||
+     si    >  f->s_max - 2     )
+    return ;
+
+  /* synchronize gradient buffer */
+  update_gradient (f) ;
+
+  /* VL_PRINTF("W = %d ; magnif = %g ; SBP = %g\n", W,magnif,SBP) ; */
+
+  /* clear descriptor */
+  memset (descr, 0, sizeof(vl_sift_pix) * NBO*NBP*NBP) ;
+
+  /* Center the scale space and the descriptor on the current keypoint.
+   * Note that dpt is pointing to the bin of center (SBP/2,SBP/2,0).
+   */
+  pt  = f->grad + xi*xo + yi*yo + (si - f->s_min - 1)*so ;
+  dpt = descr + (NBP/2) * binyo + (NBP/2) * binxo ;
+
+#undef atd
+#define atd(dbinx,dbiny,dbint) *(dpt + (dbint)*binto + (dbiny)*binyo + (dbinx)*binxo)
+
+  /*
+   * Process pixels in the intersection of the image rectangle
+   * (1,1)-(M-1,N-1) and the keypoint bounding box.
+   */
+  for(dyi =  VL_MAX (- W, 1 - yi    ) ;
+      dyi <= VL_MIN (+ W, h - yi - 2) ; ++ dyi) {
+
+    for(dxi =  VL_MAX (- W, 1 - xi    ) ;
+        dxi <= VL_MIN (+ W, w - xi - 2) ; ++ dxi) {
+
+      /* retrieve */
+      vl_sift_pix mod   = *( pt + dxi*xo + dyi*yo + 0 ) ;
+      vl_sift_pix angle = *( pt + dxi*xo + dyi*yo + 1 ) ;
+      vl_sift_pix theta = vl_mod_2pi_f (angle - angle0) ;
+
+      /* fractional displacement */
+      vl_sift_pix dx = xi + dxi - x;
+      vl_sift_pix dy = yi + dyi - y;
+
+      /* get the displacement normalized w.r.t. the keypoint
+         orientation and extension */
+      vl_sift_pix nx = ( ct0 * dx + st0 * dy) / SBP ;
+      vl_sift_pix ny = (-st0 * dx + ct0 * dy) / SBP ;
+      vl_sift_pix nt = NBO * theta / (2 * VL_PI) ;
+
+      /* Get the Gaussian weight of the sample. The Gaussian window
+       * has a standard deviation equal to NBP/2. Note that dx and dy
+       * are in the normalized frame, so that -NBP/2 <= dx <=
+       * NBP/2. */
+      vl_sift_pix const wsigma = f->windowSize ;
+      vl_sift_pix win = fast_expn
+        ((nx*nx + ny*ny)/(2.0 * wsigma * wsigma)) ;
+
+      /* The sample will be distributed in 8 adjacent bins.
+         We start from the ``lower-left'' bin. */
+      int         binx = (int)vl_floor_f (nx - 0.5) ;
+      int         biny = (int)vl_floor_f (ny - 0.5) ;
+      int         bint = (int)vl_floor_f (nt) ;
+      vl_sift_pix rbinx = nx - (binx + 0.5) ;
+      vl_sift_pix rbiny = ny - (biny + 0.5) ;
+      vl_sift_pix rbint = nt - bint ;
+      int         dbinx ;
+      int         dbiny ;
+      int         dbint ;
+
+      /* Distribute the current sample into the 8 adjacent bins*/
+      for(dbinx = 0 ; dbinx < 2 ; ++dbinx) {
+        for(dbiny = 0 ; dbiny < 2 ; ++dbiny) {
+          for(dbint = 0 ; dbint < 2 ; ++dbint) {
+
+            if (binx + dbinx >= - (NBP/2) &&
+                binx + dbinx <    (NBP/2) &&
+                biny + dbiny >= - (NBP/2) &&
+                biny + dbiny <    (NBP/2) ) {
+              vl_sift_pix weight = win
+                * mod
+                * vl_abs_f (1 - dbinx - rbinx)
+                * vl_abs_f (1 - dbiny - rbiny)
+                * vl_abs_f (1 - dbint - rbint) ;
+
+              atd(binx+dbinx, biny+dbiny, (bint+dbint) % NBO) += weight ;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /* Standard SIFT descriptors are normalized, truncated and normalized again */
+  if(1) {
+
+    /* Normalize the histogram to L2 unit length. */
+    vl_sift_pix norm = normalize_histogram (descr, descr + NBO*NBP*NBP) ;
+
+    /* Set the descriptor to zero if it is lower than our norm_threshold */
+    if(f-> norm_thresh && norm < f-> norm_thresh) {
+        for(bin = 0; bin < NBO*NBP*NBP ; ++ bin)
+            descr [bin] = 0;
+    }
+    else {
+
+      /* Truncate at 0.2. */
+      for(bin = 0; bin < NBO*NBP*NBP ; ++ bin) {
+        if (descr [bin] > 0.2) descr [bin] = 0.2;
+      }
+
+      /* Normalize again. */
+      normalize_histogram (descr, descr + NBO*NBP*NBP) ;
+    }
+  }
+
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Initialize a keypoint from its position and scale
+ **
+ ** @param f     SIFT filter.
+ ** @param k     SIFT keypoint (output).
+ ** @param x     x coordinate of the keypoint center.
+ ** @param y     y coordinate of the keypoint center.
+ ** @param sigma keypoint scale.
+ **
+ ** The function initializes a keypoint structure @a k from
+ ** the location @a x
+ ** and @a y and the scale @a sigma of the keypoint. The keypoint structure
+ ** maps the keypoint to an octave and scale level of the discretized
+ ** Gaussian scale space, which is required for instance to compute the
+ ** keypoint SIFT descriptor.
+ **
+ ** @par Algorithm
+ **
+ ** The formula linking the keypoint scale sigma to the octave and
+ ** scale indexes is
+ **
+ ** @f[ \sigma(o,s) = \sigma_0 2^{o+s/S} @f]
+ **
+ ** In addition to the scale index @e s (which can be fractional due
+ ** to scale interpolation) a keypoint has an integer scale index @e
+ ** is too (which is the index of the scale level where it was
+ ** detected in the DoG scale space). We have the constraints (@ref
+ ** sift-tech-detector see also the "SIFT detector"):
+ **
+ ** - @e o is integer in the range @f$ [o_\mathrm{min},
+ **   o_{\mathrm{min}}+O-1] @f$.
+ ** - @e is is integer in the range @f$ [s_\mathrm{min}+1,
+ **   s_\mathrm{max}-2] @f$.  This depends on how the scale is
+ **   determined during detection, and must be so here because
+ **   gradients are computed only for this range of scale levels
+ **   and are required for the calculation of the SIFT descriptor.
+ ** - @f$ |s - is| < 0.5 @f$ for detected keypoints in most cases due
+ **   to the interpolation technique used during detection. However
+ **   this is not necessary.
+ **
+ ** Thus octave o represents scales @f$ \{ \sigma(o, s) : s \in
+ ** [s_\mathrm{min}+1-.5, s_\mathrm{max}-2+.5] \} @f$. Note that some
+ ** scales may be represented more than once. For each scale, we
+ ** select the largest possible octave that contains it, i.e.
+ **
+ ** @f[
+ **  o(\sigma)
+ **  = \max \{ o \in \mathbb{Z} :
+ **    \sigma_0 2^{\frac{s_\mathrm{min}+1-.5}{S}} \leq \sigma \}
+ **  = \mathrm{floor}\,\left[
+ **    \log_2(\sigma / \sigma_0) - \frac{s_\mathrm{min}+1-.5}{S}\right]
+ ** @f]
+ **
+ ** and then
+ **
+ ** @f[
+ ** s(\sigma) = S  \left[\log_2(\sigma / \sigma_0) - o(\sigma)\right],
+ ** \quad
+ ** is(\sigma) = \mathrm{round}\,(s(\sigma))
+ ** @f]
+ **
+ ** In practice, both @f$ o(\sigma) @f$ and @f$ is(\sigma) @f$ are
+ ** clamped to their feasible range as determined by the SIFT filter
+ ** parameters.
+ **/
+
+VL_EXPORT
+void
+vl_sift_keypoint_init (VlSiftFilt const *f,
+                       VlSiftKeypoint *k,
+                       double x,
+                       double y,
+                       double sigma)
+{
+  int    o, ix, iy, is ;
+  double s, phi, xper ;
+
+  phi = log2 ((sigma + VL_EPSILON_D) / f->sigma0) ;
+  o   = (int)vl_floor_d (phi -  ((double) f->s_min + 0.5) / f->S) ;
+  o   = VL_MIN (o, f->o_min + f->O - 1) ;
+  o   = VL_MAX (o, f->o_min           ) ;
+  s   = f->S * (phi - o) ;
+
+  is  = (int)(s + 0.5) ;
+  is  = VL_MIN(is, f->s_max - 2) ;
+  is  = VL_MAX(is, f->s_min + 1) ;
+
+  xper = pow (2.0, o) ;
+  ix   = (int)(x / xper + 0.5) ;
+  iy   = (int)(y / xper + 0.5) ;
+
+  k -> o  = o ;
+
+  k -> ix = ix ;
+  k -> iy = iy ;
+  k -> is = is ;
+
+  k -> x = x ;
+  k -> y = y ;
+  k -> s = s ;
+
+  k->sigma = sigma ;
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/sift.h b/opensfm/src/third_party/vlfeat/vl/sift.h
new file mode 100644
index 000000000..50e03f434
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/sift.h
@@ -0,0 +1,418 @@
+/** @file sift.h
+ ** @brief SIFT (@ref sift)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_SIFT_H
+#define VL_SIFT_H
+
+#include <stdio.h>
+#include "generic.h"
+
+/** @brief SIFT filter pixel type */
+typedef float vl_sift_pix ;
+
+/** ------------------------------------------------------------------
+ ** @brief SIFT filter keypoint
+ **
+ ** This structure represent a keypoint as extracted by the SIFT
+ ** filter ::VlSiftFilt.
+ **/
+
+typedef struct _VlSiftKeypoint
+{
+  int o ;           /**< o coordinate (octave). */
+
+  int ix ;          /**< Integer unnormalized x coordinate. */
+  int iy ;          /**< Integer unnormalized y coordinate. */
+  int is ;          /**< Integer s coordinate. */
+
+  float x ;     /**< x coordinate. */
+  float y ;     /**< y coordinate. */
+  float s ;     /**< s coordinate. */
+  float sigma ; /**< scale. */
+} VlSiftKeypoint ;
+
+/** ------------------------------------------------------------------
+ ** @brief SIFT filter
+ **
+ ** This filter implements the SIFT detector and descriptor.
+ **/
+
+typedef struct _VlSiftFilt
+{
+  double sigman ;       /**< nominal image smoothing. */
+  double sigma0 ;       /**< smoothing of pyramid base. */
+  double sigmak ;       /**< k-smoothing */
+  double dsigma0 ;      /**< delta-smoothing. */
+
+  int width ;           /**< image width. */
+  int height ;          /**< image height. */
+  int O ;               /**< number of octaves. */
+  int S ;               /**< number of levels per octave. */
+  int o_min ;           /**< minimum octave index. */
+  int s_min ;           /**< minimum level index. */
+  int s_max ;           /**< maximum level index. */
+  int o_cur ;           /**< current octave. */
+
+  vl_sift_pix *temp ;   /**< temporary pixel buffer. */
+  vl_sift_pix *octave ; /**< current GSS data. */
+  vl_sift_pix *dog ;    /**< current DoG data. */
+  int octave_width ;    /**< current octave width. */
+  int octave_height ;   /**< current octave height. */
+
+  vl_sift_pix *gaussFilter ;  /**< current Gaussian filter */
+  double gaussFilterSigma ;   /**< current Gaussian filter std */
+  vl_size gaussFilterWidth ;  /**< current Gaussian filter width */
+
+  VlSiftKeypoint* keys ;/**< detected keypoints. */
+  int nkeys ;           /**< number of detected keypoints. */
+  int keys_res ;        /**< size of the keys buffer. */
+
+  double peak_thresh ;  /**< peak threshold. */
+  double edge_thresh ;  /**< edge threshold. */
+  double norm_thresh ;  /**< norm threshold. */
+  double magnif ;       /**< magnification factor. */
+  double windowSize ;   /**< size of Gaussian window (in spatial bins) */
+
+  vl_sift_pix *grad ;   /**< GSS gradient data. */
+  int grad_o ;          /**< GSS gradient data octave. */
+
+} VlSiftFilt ;
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT
+VlSiftFilt*  vl_sift_new    (int width, int height,
+                             int noctaves, int nlevels,
+                             int o_min) ;
+VL_EXPORT
+void         vl_sift_delete (VlSiftFilt *f) ;
+/** @} */
+
+/** @name Process data
+ ** @{
+ **/
+
+VL_EXPORT
+int   vl_sift_process_first_octave       (VlSiftFilt *f,
+                                          vl_sift_pix const *im) ;
+
+VL_EXPORT
+int   vl_sift_process_next_octave        (VlSiftFilt *f) ;
+
+VL_EXPORT
+void  vl_sift_detect                     (VlSiftFilt *f) ;
+
+VL_EXPORT
+int   vl_sift_calc_keypoint_orientations (VlSiftFilt *f,
+                                          double angles [4],
+                                          VlSiftKeypoint const*k);
+VL_EXPORT
+void  vl_sift_calc_keypoint_descriptor   (VlSiftFilt *f,
+                                          vl_sift_pix *descr,
+                                          VlSiftKeypoint const* k,
+                                          double angle) ;
+
+VL_EXPORT
+void  vl_sift_calc_raw_descriptor        (VlSiftFilt const *f,
+                                          vl_sift_pix const* image,
+                                          vl_sift_pix *descr,
+                                          int widht, int height,
+                                          double x, double y,
+                                          double s, double angle0) ;
+
+VL_EXPORT
+void  vl_sift_keypoint_init              (VlSiftFilt const *f,
+                                          VlSiftKeypoint *k,
+                                          double x,
+                                          double y,
+                                          double sigma) ;
+/** @} */
+
+/** @name Retrieve data and parameters
+ ** @{
+ **/
+VL_INLINE int    vl_sift_get_octave_index   (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_noctaves       (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_octave_first   (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_octave_width   (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_octave_height  (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_nlevels        (VlSiftFilt const *f) ;
+VL_INLINE int    vl_sift_get_nkeypoints     (VlSiftFilt const *f) ;
+VL_INLINE double vl_sift_get_peak_thresh    (VlSiftFilt const *f) ;
+VL_INLINE double vl_sift_get_edge_thresh    (VlSiftFilt const *f) ;
+VL_INLINE double vl_sift_get_norm_thresh    (VlSiftFilt const *f) ;
+VL_INLINE double vl_sift_get_magnif         (VlSiftFilt const *f) ;
+VL_INLINE double vl_sift_get_window_size    (VlSiftFilt const *f) ;
+
+VL_INLINE vl_sift_pix *vl_sift_get_octave  (VlSiftFilt const *f, int s) ;
+VL_INLINE VlSiftKeypoint const *vl_sift_get_keypoints (VlSiftFilt const *f) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_INLINE void vl_sift_set_peak_thresh (VlSiftFilt *f, double t) ;
+VL_INLINE void vl_sift_set_edge_thresh (VlSiftFilt *f, double t) ;
+VL_INLINE void vl_sift_set_norm_thresh (VlSiftFilt *f, double t) ;
+VL_INLINE void vl_sift_set_magnif      (VlSiftFilt *f, double m) ;
+VL_INLINE void vl_sift_set_window_size (VlSiftFilt *f, double m) ;
+/** @} */
+
+/* -------------------------------------------------------------------
+ *                                     Inline functions implementation
+ * ---------------------------------------------------------------- */
+
+/** ------------------------------------------------------------------
+ ** @brief Get current octave index.
+ ** @param f SIFT filter.
+ ** @return index of the current octave.
+ **/
+
+VL_INLINE int
+vl_sift_get_octave_index (VlSiftFilt const *f)
+{
+  return f-> o_cur ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get number of octaves.
+ ** @param f SIFT filter.
+ ** @return number of octaves.
+ **/
+
+VL_INLINE int
+vl_sift_get_noctaves (VlSiftFilt const *f)
+{
+  return f-> O ;
+}
+
+/**-------------------------------------------------------------------
+ ** @brief Get first octave.
+ ** @param f SIFT filter.
+ ** @return index of the first octave.
+ **/
+
+VL_INLINE int
+vl_sift_get_octave_first (VlSiftFilt const *f)
+{
+  return f-> o_min ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get current octave width
+ ** @param f SIFT filter.
+ ** @return current octave width.
+ **/
+
+VL_INLINE int
+vl_sift_get_octave_width (VlSiftFilt const *f)
+{
+  return f-> octave_width ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get current octave height
+ ** @param f SIFT filter.
+ ** @return current octave height.
+ **/
+
+VL_INLINE int
+vl_sift_get_octave_height (VlSiftFilt const *f)
+{
+  return f-> octave_height ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get current octave data
+ ** @param f SIFT filter.
+ ** @param s level index.
+ **
+ ** The level index @a s ranges in the interval <tt>s_min = -1</tt>
+ ** and <tt> s_max = S + 2</tt>, where @c S is the number of levels
+ ** per octave.
+ **
+ ** @return pointer to the octave data for level @a s.
+ **/
+
+VL_INLINE vl_sift_pix *
+vl_sift_get_octave (VlSiftFilt const *f, int s)
+{
+  int w = vl_sift_get_octave_width  (f) ;
+  int h = vl_sift_get_octave_height (f) ;
+  return f->octave + w * h * (s - f->s_min) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get number of levels per octave
+ ** @param f SIFT filter.
+ ** @return number of leves per octave.
+ **/
+
+VL_INLINE int
+vl_sift_get_nlevels (VlSiftFilt const *f)
+{
+  return f-> S ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get number of keypoints.
+ ** @param f SIFT filter.
+ ** @return number of keypoints.
+ **/
+
+VL_INLINE int
+vl_sift_get_nkeypoints (VlSiftFilt const *f)
+{
+  return f-> nkeys ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get keypoints.
+ ** @param f SIFT filter.
+ ** @return pointer to the keypoints list.
+ **/
+
+VL_INLINE VlSiftKeypoint const *
+vl_sift_get_keypoints (VlSiftFilt const *f)
+{
+  return f-> keys ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get peaks treashold
+ ** @param f SIFT filter.
+ ** @return threshold ;
+ **/
+
+VL_INLINE double
+vl_sift_get_peak_thresh (VlSiftFilt const *f)
+{
+  return f -> peak_thresh ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get edges threshold
+ ** @param f SIFT filter.
+ ** @return threshold.
+ **/
+
+VL_INLINE double
+vl_sift_get_edge_thresh (VlSiftFilt const *f)
+{
+  return f -> edge_thresh ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get norm threshold
+ ** @param f SIFT filter.
+ ** @return threshold.
+ **/
+
+VL_INLINE double
+vl_sift_get_norm_thresh (VlSiftFilt const *f)
+{
+  return f -> norm_thresh ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the magnification factor
+ ** @param f SIFT filter.
+ ** @return magnification factor.
+ **/
+
+VL_INLINE double
+vl_sift_get_magnif (VlSiftFilt const *f)
+{
+  return f -> magnif ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get the Gaussian window size.
+ ** @param f SIFT filter.
+ ** @return standard deviation of the Gaussian window (in spatial bin units).
+ **/
+
+VL_INLINE double
+vl_sift_get_window_size (VlSiftFilt const *f)
+{
+  return f -> windowSize ;
+}
+
+
+
+/** ------------------------------------------------------------------
+ ** @brief Set peaks threshold
+ ** @param f SIFT filter.
+ ** @param t threshold.
+ **/
+
+VL_INLINE void
+vl_sift_set_peak_thresh (VlSiftFilt *f, double t)
+{
+  f -> peak_thresh = t ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set edges threshold
+ ** @param f SIFT filter.
+ ** @param t threshold.
+ **/
+
+VL_INLINE void
+vl_sift_set_edge_thresh (VlSiftFilt *f, double t)
+{
+  f -> edge_thresh = t ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set norm threshold
+ ** @param f SIFT filter.
+ ** @param t threshold.
+ **/
+
+VL_INLINE void
+vl_sift_set_norm_thresh (VlSiftFilt *f, double t)
+{
+  f -> norm_thresh = t ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set the magnification factor
+ ** @param f SIFT filter.
+ ** @param m magnification factor.
+ **/
+
+VL_INLINE void
+vl_sift_set_magnif (VlSiftFilt *f, double m)
+{
+  f -> magnif = m ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Set the Gaussian window size
+ ** @param f SIFT filter.
+ ** @param x Gaussian window size (in units of spatial bin).
+ **
+ ** This is the parameter @f$ \hat \sigma_{\text{win}} @f$ of
+ ** the standard SIFT descriptor @ref sift-tech-descriptor-std.
+ **/
+
+VL_INLINE void
+vl_sift_set_window_size (VlSiftFilt *f, double x)
+{
+  f -> windowSize = x ;
+}
+
+/* VL_SIFT_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/slic.c b/opensfm/src/third_party/vlfeat/vl/slic.c
new file mode 100644
index 000000000..f6043e0b5
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/slic.c
@@ -0,0 +1,411 @@
+/** @file slic.c
+ ** @brief SLIC superpixels - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page slic Simple Linear Iterative Clustering (SLIC)
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref slic.h implements the *Simple Linear Iterative Clustering* (SLIC)
+algorithm, an image segmentation method described in @cite{achanta10slic}.
+
+- @ref slic-overview
+- @ref slic-usage
+- @ref slic-tech
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section slic-overview Overview
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+SLIC @cite{achanta10slic} is a simple and efficient method to decompose
+an image in visually homogeneous regions. It is based on a spatially
+localized version of k-means clustering. Similar to mean shift or
+quick shift (@ref quickshift.h), each pixel is associated to a feature
+vector
+
+@f[
+\Psi(x,y) =
+\left[
+\begin{array}{c}
+\lambda x \\
+\lambda y \\
+I(x,y)
+\end{array}
+\right]
+@f]
+
+and then k-means clustering is run on those. As discussed below, the
+coefficient @f$ \lambda @f$ balances the spatial and appearance
+components of the feature vectors, imposing a degree of spatial
+regularization to the extracted regions.
+
+SLIC takes two parameters: the nominal size of the regions
+(superpixels) @c regionSize and the strength of the spatial
+regularization @c regularizer. The image is first divided into a grid
+with step @c regionSize. The center of each grid tile is then used to
+initialize a corresponding k-means (up to a small shift to avoid
+image edges). Finally, the k-means centers and clusters are refined by
+using the Lloyd algorithm, yielding segmenting the image. As a
+further restriction and simplification, during the k-means iterations
+each pixel can be assigned to only the <em>2 x 2</em> centers
+corresponding to grid tiles adjacent to the pixel.
+
+The parameter @c regularizer sets the trade-off between clustering
+appearance and spatial regularization. This is obtained by setting
+
+@f[
+ \lambda = \frac{\mathtt{regularizer}}{\mathtt{regionSize}}
+@f]
+
+in the definition of the feature @f$ \psi(x,y) @f$.
+
+After the k-means step, SLIC optionally
+removes any segment whose area is smaller than a threshld @c minRegionSize
+by merging them into larger ones.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section slic-usage Usage from the C library
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+To compute the SLIC superpixels of an image use the function
+::vl_slic_segment.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section slic-tech Technical details
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+SLIC starts by dividing the image domain into a regular grid with @f$
+M \times N @f$ tiles, where
+
+@f[
+   M = \lceil \frac{\mathtt{imageWidth}}{\mathtt{regionSize}} \rceil,
+   \quad
+   N = \lceil \frac{\mathtt{imageHeight}}{\mathtt{regionSize}} \rceil.
+@f]
+
+A region (superpixel or k-means cluster) is initialized from each grid
+center
+
+@f[
+  x_i = \operatorname{round} i \frac{\mathtt{imageWidth}}{\mathtt{regionSize}}
+  \quad
+  y_j = \operatorname{round} j \frac{\mathtt{imageWidth}}{\mathtt{regionSize}}.
+@f]
+
+In order to avoid placing these centers on top of image
+discontinuities, the centers are then moved in a 3 x 3
+neighbourohood to minimize the edge strength
+
+@f[
+   \operatorname{edge}(x,y) =
+   \| I(x+1,y) - I(x-1,y) \|_2^2 +
+   \| I(x,y+1) - I(x,y-1) \|_2^2.
+@f]
+
+Then the regions are obtained by running k-means clustering, started
+from the centers
+
+@f[
+  C = \{ \Psi(x_i,y_j), i=0,1,\dots,M-1\ j=0,1,\dots,N-1 \}
+@f]
+
+thus obtained. K-means uses the standard LLoyd algorithm alternating
+assigning pixels to the clostest centers a re-estiamting the centers
+as the average of the corresponding feature vectors of the pixel
+assigned to them. The only difference compared to standard k-means is
+that each pixel can be assigned only to the center originated from the
+neighbour tiles. This guarantees that there are exactly four
+pixel-to-center comparisons at each round of minimization, which
+threfore cost @f$ O(n) @f$, where @f$ n @f$ is the number of
+superpixels.
+
+After k-means has converged, SLIC eliminates any connected region whose
+area is less than @c minRegionSize pixels. This is done by greedily
+merging regions to neighbour ones: the pixels @f$ p @f$ are scanned in
+lexicographical order and the corresponding connected components
+are visited. If a region has already been visited, it is skipped; if not,
+its area is computed and if this is less than  @c minRegionSize its label
+is changed to the one of a neighbour
+region at @f$ p @f$ that has already been vistied (there is always one
+except for the very first pixel).
+
+*/
+
+#include "slic.h"
+#include "mathop.h"
+#include <math.h>
+#include <string.h>
+
+/** @brief SLIC superpixel segmentation
+ ** @param segmentation segmentation.
+ ** @param image image to segment.
+ ** @param width image width.
+ ** @param height image height.
+ ** @param numChannels number of image channels (depth).
+ ** @param regionSize nominal size of the regions.
+ ** @param regularization trade-off between appearance and spatial terms.
+ ** @param minRegionSize minimum size of a segment.
+ **
+ ** The function computes the SLIC superpixels of the specified image @a image.
+ ** @a image is a pointer to an @c width by @c height by @c by numChannles array of @c float.
+ ** @a segmentation is a pointer to a @c width by @c height array of @c vl_uint32.
+ ** @a segmentation contain the labels of each image pixels, from 0 to
+ ** the number of regions minus one.
+ **
+ ** @sa @ref slic-overview, @ref slic-tech
+ **/
+
+void
+vl_slic_segment (vl_uint32 * segmentation,
+                 float const * image,
+                 vl_size width,
+                 vl_size height,
+                 vl_size numChannels,
+                 vl_size regionSize,
+                 float regularization,
+                 vl_size minRegionSize)
+{
+  vl_index i, x, y, u, v, k, region ;
+  vl_uindex iter ;
+  vl_size const numRegionsX = (vl_size) ceil((double) width / regionSize) ;
+  vl_size const numRegionsY = (vl_size) ceil((double) height / regionSize) ;
+  vl_size const numRegions = numRegionsX * numRegionsY ;
+  vl_size const numPixels = width * height ;
+  float * centers ;
+  float * edgeMap ;
+  float previousEnergy = VL_INFINITY_F ;
+  float startingEnergy ;
+  vl_uint32 * masses ;
+  vl_size const maxNumIterations = 100 ;
+
+  assert(segmentation) ;
+  assert(image) ;
+  assert(width >= 1) ;
+  assert(height >= 1) ;
+  assert(numChannels >= 1) ;
+  assert(regionSize >= 1) ;
+  assert(regularization >= 0) ;
+
+#define atimage(x,y,k) image[(x)+(y)*width+(k)*width*height]
+#define atEdgeMap(x,y) edgeMap[(x)+(y)*width]
+
+  edgeMap = vl_calloc(numPixels, sizeof(float)) ;
+  masses = vl_malloc(sizeof(vl_uint32) * numPixels) ;
+  centers = vl_malloc(sizeof(float) * (2 + numChannels) * numRegions) ;
+
+  /* compute edge map (gradient strength) */
+  for (k = 0 ; k < (signed)numChannels ; ++k) {
+    for (y = 1 ; y < (signed)height-1 ; ++y) {
+      for (x = 1 ; x < (signed)width-1 ; ++x) {
+        float a = atimage(x-1,y,k) ;
+        float b = atimage(x+1,y,k) ;
+        float c = atimage(x,y+1,k) ;
+        float d = atimage(x,y-1,k) ;
+        atEdgeMap(x,y) += (a - b)  * (a - b) + (c - d) * (c - d) ;
+      }
+    }
+  }
+
+  /* initialize K-means centers */
+  i = 0 ;
+  for (v = 0 ; v < (signed)numRegionsY ; ++v) {
+    for (u = 0 ; u < (signed)numRegionsX ; ++u) {
+      vl_index xp ;
+      vl_index yp ;
+      vl_index centerx = 0 ;
+      vl_index centery = 0 ;
+      float minEdgeValue = VL_INFINITY_F ;
+
+      x = (vl_index) vl_round_d(regionSize * (u + 0.5)) ;
+      y = (vl_index) vl_round_d(regionSize * (v + 0.5)) ;
+
+      x = VL_MAX(VL_MIN(x, (signed)width-1),0) ;
+      y = VL_MAX(VL_MIN(y, (signed)height-1),0) ;
+
+      /* search in a 3x3 neighbourhood the smallest edge response */
+      for (yp = VL_MAX(0, y-1) ; yp <= VL_MIN((signed)height-1, y+1) ; ++ yp) {
+        for (xp = VL_MAX(0, x-1) ; xp <= VL_MIN((signed)width-1, x+1) ; ++ xp) {
+          float thisEdgeValue = atEdgeMap(xp,yp) ;
+          if (thisEdgeValue < minEdgeValue) {
+            minEdgeValue = thisEdgeValue ;
+            centerx = xp ;
+            centery = yp ;
+          }
+        }
+      }
+
+      /* initialize the new center at this location */
+      centers[i++] = (float) centerx ;
+      centers[i++] = (float) centery ;
+      for (k  = 0 ; k < (signed)numChannels ; ++k) {
+        centers[i++] = atimage(centerx,centery,k) ;
+      }
+    }
+  }
+
+  /* run k-means iterations */
+  for (iter = 0 ; iter < maxNumIterations ; ++iter) {
+    float factor = regularization / (regionSize * regionSize) ;
+    float energy = 0 ;
+
+    /* assign pixels to centers */
+    for (y = 0 ; y < (signed)height ; ++y) {
+      for (x = 0 ; x < (signed)width ; ++x) {
+        vl_index u = floor((double)x / regionSize - 0.5) ;
+        vl_index v = floor((double)y / regionSize - 0.5) ;
+        vl_index up, vp ;
+        float minDistance = VL_INFINITY_F ;
+
+        for (vp = VL_MAX(0, v) ; vp <= VL_MIN((signed)numRegionsY-1, v+1) ; ++vp) {
+          for (up = VL_MAX(0, u) ; up <= VL_MIN((signed)numRegionsX-1, u+1) ; ++up) {
+            vl_index region = up  + vp * numRegionsX ;
+            float centerx = centers[(2 + numChannels) * region + 0]  ;
+            float centery = centers[(2 + numChannels) * region + 1] ;
+            float spatial = (x - centerx) * (x - centerx) + (y - centery) * (y - centery) ;
+            float appearance = 0 ;
+            float distance ;
+            for (k = 0 ; k < (signed)numChannels ; ++k) {
+              float centerz = centers[(2 + numChannels) * region + k + 2]  ;
+              float z = atimage(x,y,k) ;
+              appearance += (z - centerz) * (z - centerz) ;
+            }
+            distance = appearance + factor * spatial ;
+            if (minDistance > distance) {
+              minDistance = distance ;
+              segmentation[x + y * width] = (vl_uint32)region ;
+            }
+          }
+        }
+        energy += minDistance ;
+      }
+    }
+
+    /*
+     VL_PRINTF("vl:slic: iter %d: energy: %g\n", iter, energy) ;
+    */
+
+    /* check energy termination conditions */
+    if (iter == 0) {
+      startingEnergy = energy ;
+    } else {
+      if ((previousEnergy - energy) < 1e-5 * (startingEnergy - energy)) {
+        break ;
+      }
+    }
+    previousEnergy = energy ;
+
+    /* recompute centers */
+    memset(masses, 0, sizeof(vl_uint32) * width * height) ;
+    memset(centers, 0, sizeof(float) * (2 + numChannels) * numRegions) ;
+
+    for (y = 0 ; y < (signed)height ; ++y) {
+      for (x = 0 ; x < (signed)width ; ++x) {
+        vl_index pixel = x + y * width ;
+        vl_index region = segmentation[pixel] ;
+        masses[region] ++ ;
+        centers[region * (2 + numChannels) + 0] += x ;
+        centers[region * (2 + numChannels) + 1] += y ;
+        for (k = 0 ; k < (signed)numChannels ; ++k) {
+          centers[region * (2 + numChannels) + k + 2] += atimage(x,y,k) ;
+        }
+      }
+    }
+
+    for (region = 0 ; region < (signed)numRegions ; ++region) {
+      float mass = VL_MAX(masses[region], 1e-8) ;
+      for (i = (2 + numChannels) * region ;
+           i < (signed)(2 + numChannels) * (region + 1) ;
+           ++i) {
+        centers[i] /= mass ;
+      }
+    }
+  }
+
+  vl_free(masses) ;
+  vl_free(centers) ;
+  vl_free(edgeMap) ;
+
+  /* elimiate small regions */
+  {
+    vl_uint32 * cleaned = vl_calloc(numPixels, sizeof(vl_uint32)) ;
+    vl_uindex * segment = vl_malloc(sizeof(vl_uindex) * numPixels) ;
+    vl_size segmentSize ;
+    vl_uint32 label ;
+    vl_uint32 cleanedLabel ;
+    vl_size numExpanded ;
+    vl_index const dx [] = {+1, -1,  0,  0} ;
+    vl_index const dy [] = { 0,  0, +1, -1} ;
+    vl_index direction ;
+    vl_index pixel ;
+
+    for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) {
+      if (cleaned[pixel]) continue ;
+      label = segmentation[pixel] ;
+      numExpanded = 0 ;
+      segmentSize = 0 ;
+      segment[segmentSize++] = pixel ;
+
+      /*
+       find cleanedLabel as the label of an already cleaned
+       region neihbour of this pixel
+       */
+      cleanedLabel = label + 1 ;
+      cleaned[pixel] = label + 1 ;
+      x = pixel % width ;
+      y = pixel / width ;
+      for (direction = 0 ; direction < 4 ; ++direction) {
+        vl_index xp = x + dx[direction] ;
+        vl_index yp = y + dy[direction] ;
+        vl_index neighbor = xp + yp * width ;
+        if (0 <= xp && xp < (signed)width &&
+            0 <= yp && yp < (signed)height &&
+            cleaned[neighbor]) {
+          cleanedLabel = cleaned[neighbor] ;
+        }
+      }
+
+      /* expand the segment */
+      while (numExpanded < segmentSize) {
+        vl_index open = segment[numExpanded++] ;
+        x = open % width ;
+        y = open / width ;
+        for (direction = 0 ; direction < 4 ; ++direction) {
+          vl_index xp = x + dx[direction] ;
+          vl_index yp = y + dy[direction] ;
+          vl_index neighbor = xp + yp * width ;
+          if (0 <= xp && xp < (signed)width &&
+              0 <= yp && yp < (signed)height &&
+              cleaned[neighbor] == 0 &&
+              segmentation[neighbor] == label) {
+            cleaned[neighbor] = label + 1 ;
+            segment[segmentSize++] = neighbor ;
+          }
+        }
+      }
+
+      /* change label to cleanedLabel if the semgent is too small */
+      if (segmentSize < minRegionSize) {
+        while (segmentSize > 0) {
+          cleaned[segment[--segmentSize]] = cleanedLabel ;
+        }
+      }
+    }
+    /* restore base 0 indexing of the regions */
+    for (pixel = 0 ; pixel < (signed)numPixels ; ++pixel) cleaned[pixel] -- ;
+
+    memcpy(segmentation, cleaned, numPixels * sizeof(vl_uint32)) ;
+    vl_free(cleaned) ;
+    vl_free(segment) ;
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/slic.h b/opensfm/src/third_party/vlfeat/vl/slic.h
new file mode 100644
index 000000000..1bffcdecf
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/slic.h
@@ -0,0 +1,30 @@
+/** @file slic.h
+ ** @brief SLIC superpixels (@ref slic)
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_SLIC_H
+#define VL_SLIC_H
+
+#include "generic.h"
+
+VL_EXPORT void
+vl_slic_segment (vl_uint32 * segmentation,
+                 float const * image,
+                 vl_size width,
+                 vl_size height,
+                 vl_size numChannels,
+                 vl_size regionSize,
+                 float regularization,
+                 vl_size minRegionSize) ;
+
+/* VL_SLIC_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/stringop.c b/opensfm/src/third_party/vlfeat/vl/stringop.c
new file mode 100644
index 000000000..5f92df340
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/stringop.c
@@ -0,0 +1,462 @@
+/** @file stringop.c
+ ** @brief String operations - Definition
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+@file stringop.h
+@brief String operations
+@author Andrea Vedaldi
+@tableofcontents
+
+@ref stringop.h implements basic string operations. All functions that
+write to strings use range checking, which makes them safer than some
+standard POSIX equivalent (see @ref vl-stringop-err).
+
+@section vl-stringop-enumeration Enumerations
+
+@ref stringop.h defines a simple enumeration data type. This is given
+by an array of enumeration members, represented by
+instances of the ::VlEnumerator strucutre, each storing a
+name-value pair. The enumeration must end by a member whose
+name is set to @c NULL.
+
+Use ::vl_enumeration_get and ::vl_enumeration_get_casei
+to retrieve an enumeration member by name.
+
+@section vl-stringop-file-protocols File protocols
+
+@ref stringop.h defines a few file "protocols" and helps parsing them
+from URL-like formatted strings. The supported protocols are:
+
+<table>
+<caption>File protocols</caption>
+<tr><td>Protocol</td><td>Code</td><td>URL prefix</td></tr>
+<tr><td>ASCII</td><td>::VL_PROT_ASCII</td><td><code>ascii://</code></td></tr>
+<tr><td>BINARY</td><td>::VL_PROT_BINARY</td><td><code>binary://</code></td></tr>
+</table>
+
+@section vl-stringop-err Detecting overflow
+
+@ref stringop.h functions that write a string to a character buffer take
+both the buffer and its size @c n as input. If @c n is not large
+enough, the output may be truncated but it is always a null terminated
+string (provided that @c n &gt;= 1). Such functions also return the
+length of the string that would have been written @c r (which does not
+include the terminating null character) had the buffer been large
+enough.  Hence an <em>overflow</em> can be detected by testing if @c r
+&gt;= @c n, @c r can be used to re-allocate a buffer large enough to
+contain the result, and the operation can be repeated.
+**/
+
+#include "stringop.h"
+
+#include <string.h>
+#include <ctype.h>
+
+/** ------------------------------------------------------------------
+ ** @brief Extract the protocol prefix from a string
+ ** @param string string.
+ ** @param protocol protocol code (output).
+ ** @return pointer to the first character after the protocol prefix.
+ **
+ ** The function extracts the prefix of the string @a string
+ ** terminated by the first occurrence of the @c :// substring (if
+ ** any). It then matches the suffix terminated by @c :// to the
+ ** supported @ref vl-stringop-file-protocols protocols. If @c protocol is not
+ ** @c NULL, the corresponding protocol code is written to @a protocol
+ **
+ ** The function writes to @a protocol the value ::VL_PROT_NONE if no
+ ** suffix is detected and ::VL_PROT_UNKNOWN if there is a suffix but
+ ** it cannot be matched to any of the supported protocols.
+ **/
+
+VL_EXPORT char *
+vl_string_parse_protocol (char const *string, int *protocol)
+{
+  char const * cpt ;
+  int dummy ;
+
+  /* handle the case prot = 0 */
+  if (protocol == 0)
+    protocol = &dummy ;
+
+  /* look for :// */
+  cpt = strstr(string, "://") ;
+
+  if (cpt == 0) {
+    *protocol = VL_PROT_NONE ;
+    cpt = string ;
+  }
+  else {
+    if (strncmp(string, "ascii", cpt - string) == 0) {
+      *protocol = VL_PROT_ASCII ;
+    }
+    else if (strncmp(string, "bin",   cpt - string) == 0) {
+      *protocol = VL_PROT_BINARY ;
+    }
+    else {
+      *protocol = VL_PROT_UNKNOWN ;
+    }
+    cpt += 3 ;
+  }
+  return (char*) cpt ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Get protocol name
+ ** @param protocol protocol code.
+ ** @return pointer protocol name string.
+ **
+ ** The function returns a pointer to a string containing the name of
+ ** the protocol @a protocol (see the @a vl-file-protocols protocols
+ ** list).  If the protocol is unknown the function returns the empty
+ ** string.
+ **/
+
+VL_EXPORT char const *
+vl_string_protocol_name (int protocol)
+{
+  switch (protocol) {
+  case VL_PROT_ASCII:
+    return "ascii" ;
+  case VL_PROT_BINARY:
+    return "bin" ;
+  case VL_PROT_NONE :
+    return "" ;
+  default:
+    return 0 ;
+  }
+}
+
+
+/** ------------------------------------------------------------------
+ ** @brief Extract base of file name
+ ** @param destination destination buffer.
+ ** @param destinationSize size of destination buffer.
+ ** @param source input string.
+ ** @param maxNumStrippedExtensions maximum number of extensions to strip.
+ ** @return length of the destination string.
+ **
+ ** The function removes the leading path and up to @c
+ ** maxNumStrippedExtensions trailing extensions from the string @a
+ ** source and writes the result to the buffer @a destination.
+ **
+ ** The leading path is the longest suffix that ends with either the
+ ** @c \ or @c / characters. An extension is a string starting with
+ ** the <code>.</code> character not containing it. For instance, the string @c
+ ** file.png contains the extension <code>.png</code> and the string @c
+ ** file.tar.gz contains two extensions (<code>.tar</code> and @c <code>.gz</code>).
+ **
+ ** @sa @ref vl-stringop-err.
+ **/
+
+VL_EXPORT vl_size
+vl_string_basename (char * destination,
+                    vl_size destinationSize,
+                    char const * source,
+                    vl_size maxNumStrippedExtensions)
+{
+  char c ;
+  vl_uindex k = 0, beg, end ;
+
+  /* find beginning */
+  beg = 0 ;
+  for (k = 0 ; (c = source[k]) ; ++ k) {
+    if (c == '\\' || c == '/') beg = k + 1 ;
+  }
+
+  /* find ending */
+  end = strlen (source) ;
+  for (k = end ; k > beg ; --k) {
+    if (source[k - 1] == '.' && maxNumStrippedExtensions > 0) {
+      -- maxNumStrippedExtensions ;
+      end = k - 1 ;
+    }
+  }
+
+  return vl_string_copy_sub (destination, destinationSize,
+                             source + beg, source + end) ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Replace wildcard characters by a string
+ ** @param destination output buffer.
+ ** @param destinationSize size of the output buffer.
+ ** @param source input string.
+ ** @param wildcardChar wildcard character.
+ ** @param escapeChar escape character.
+ ** @param replacement replacement string.
+ **
+ ** The function replaces the occurrence of the specified wildcard
+ ** character @a wildcardChar by the string @a replacement. The result
+ ** is written to the buffer @a destination of size @a
+ ** destinationSize.
+ **
+ ** Wildcard characters may be escaped by preceding them by the @a esc
+ ** character. More in general, anything following an occurrence of @a
+ ** esc character is copied verbatim. To disable the escape characters
+ ** simply set @a esc to 0.
+ **
+ ** @return length of the result.
+ ** @sa @ref vl-stringop-err.
+ **/
+
+VL_EXPORT vl_size
+vl_string_replace_wildcard (char * destination,
+                            vl_size destinationSize,
+                            char const * source,
+                            char wildcardChar,
+                            char escapeChar,
+                            char const * replacement)
+{
+  char c ;
+  vl_uindex k = 0 ;
+  vl_bool escape = 0 ;
+
+  while ((c = *source++)) {
+
+    /* enter escape mode ? */
+    if (! escape && c == escapeChar) {
+      escape = 1 ;
+      continue ;
+    }
+
+    /* wildcard or regular? */
+    if (! escape && c == wildcardChar) {
+      char const * repl = replacement ;
+      while ((c = *repl++)) {
+        if (destination && k + 1 < destinationSize) {
+          destination[k] = c ;
+        }
+        ++ k ;
+      }
+    }
+    /* regular character */
+    else {
+      if (destination && k + 1 < destinationSize) {
+        destination[k] = c ;
+      }
+      ++ k ;
+    }
+    escape = 0 ;
+  }
+
+  /* add trailing 0 */
+  if (destinationSize > 0) {
+    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
+  }
+  return  k ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Copy string
+ ** @param destination output buffer.
+ ** @param destinationSize size of the output buffer.
+ ** @param source string to copy.
+ ** @return length of the source string.
+ **
+ ** The function copies the string @a source to the buffer @a
+ ** destination of size @a destinationSize.
+ **
+ ** @sa @ref vl-stringop-err.
+ **/
+
+VL_EXPORT vl_size
+vl_string_copy (char * destination, vl_size destinationSize,
+                char const * source)
+{
+  char c ;
+  vl_uindex k = 0 ;
+
+  while ((c = *source++)) {
+    if (destination && k + 1 < destinationSize) {
+      destination[k] = c ;
+    }
+    ++ k ;
+  }
+
+  /* finalize */
+  if (destinationSize > 0) {
+    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
+  }
+  return  k ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Copy substring
+ ** @param destination output buffer.
+ ** @param destinationSize  size of output buffer.
+ ** @param beginning start of the substring.
+ ** @param end end of the substring.
+ ** @return length of the destination string.
+ **
+ ** The function copies the substring from at @a beginning to @a end
+ ** (not included) to the buffer @a destination of size @a
+ ** destinationSize. If, however, the null character is found before
+ ** @a end, the substring terminates there.
+ **
+ ** @sa @ref vl-stringop-err.
+ **/
+
+VL_EXPORT vl_size
+vl_string_copy_sub (char * destination,
+                    vl_size destinationSize,
+                    char const * beginning,
+                    char const * end)
+{
+  char c ;
+  vl_uindex k = 0 ;
+
+  while (beginning < end && (c = *beginning++)) {
+    if (destination && k + 1 < destinationSize) {
+      destination[k] = c ;
+    }
+    ++ k ;
+  }
+
+  /* finalize */
+  if (destinationSize > 0) {
+    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
+  }
+  return  k ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Search character in reversed order
+ ** @param beginning pointer to the substring beginning.
+ ** @param end pointer to the substring end.
+ ** @param c character to search for.
+ ** @return pointer to last occurrence of @a c, or 0 if none.
+ **
+ ** The function searches for the last occurrence of the character @a c
+ ** in the substring from @a beg to @a end (the latter not being included).
+ **/
+
+VL_EXPORT char *
+vl_string_find_char_rev (char const *beginning, char const* end, char c)
+{
+  while (end -- != beginning) {
+    if (*end == c) {
+      return (char*) end ;
+    }
+  }
+  return 0 ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Calculate string length
+ ** @param string string.
+ ** @return string length.
+ **/
+
+VL_EXPORT vl_size
+vl_string_length (char const *string)
+{
+  vl_uindex i ;
+  for (i = 0 ; string[i] ; ++i) ;
+  return i ;
+}
+
+/** ------------------------------------------------------------------
+ ** @brief Compare strings case-insensitive
+ ** @param string1 fisrt string.
+ ** @param string2 second string.
+ ** @return an integer =,<,> 0 if @c string1 =,<,> @c string2
+ **/
+
+VL_EXPORT int
+vl_string_casei_cmp (const char * string1, const char * string2)
+{
+  while (tolower((char unsigned)*string1) ==
+         tolower((char unsigned)*string2))
+  {
+    if (*string1 == 0) {
+      return 0 ;
+    }
+    string1 ++ ;
+    string2 ++ ;
+  }
+  return
+    (int)tolower((char unsigned)*string1) -
+    (int)tolower((char unsigned)*string2) ;
+}
+
+/* -------------------------------------------------------------------
+ *                                                       VlEnumeration
+ * ---------------------------------------------------------------- */
+
+/** @brief Get a member of an enumeration by name
+ ** @param enumeration array of ::VlEnumerator objects.
+ ** @param name the name of the desired member.
+ ** @return enumerator matching @a name.
+ **
+ ** If @a name is not found in the enumeration, then the value
+ ** @c NULL is returned.
+ **
+ ** @sa vl-stringop-enumeration
+ **/
+
+VL_EXPORT VlEnumerator *
+vl_enumeration_get (VlEnumerator const *enumeration, char const *name)
+{
+  assert(enumeration) ;
+  while (enumeration->name) {
+    if (strcmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
+    enumeration ++ ;
+  }
+  return NULL ;
+}
+
+/** @brief Get a member of an enumeration by name (case insensitive)
+ ** @param enumeration array of ::VlEnumerator objects.
+ ** @param name the name of the desired member.
+ ** @return enumerator matching @a name.
+ **
+ ** If @a name is not found in the enumeration, then the value
+ ** @c NULL is returned. @a string is matched case insensitive.
+ **
+ **  @sa vl-stringop-enumeration
+ **/
+
+VL_EXPORT VlEnumerator *
+vl_enumeration_get_casei (VlEnumerator const *enumeration, char const *name)
+{
+  assert(enumeration) ;
+  while (enumeration->name) {
+    if (vl_string_casei_cmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
+    enumeration ++ ;
+  }
+  return NULL ;
+}
+
+/** @brief Get a member of an enumeration by value
+ ** @param enumeration array of ::VlEnumerator objects.
+ ** @param value value of the desired member.
+ ** @return enumerator matching @a value.
+ **
+ ** If @a value is not found in the enumeration, then the value
+ ** @c NULL is returned.
+ **
+ ** @sa vl-stringop-enumeration
+ **/
+
+VL_EXPORT VlEnumerator *
+vl_enumeration_get_by_value (VlEnumerator const *enumeration, vl_index value)
+{
+  assert(enumeration) ;
+  while (enumeration->name) {
+    if (enumeration->value == value) return (VlEnumerator*)enumeration ;
+    enumeration ++ ;
+  }
+  return NULL ;
+}
+
diff --git a/opensfm/src/third_party/vlfeat/vl/stringop.h b/opensfm/src/third_party/vlfeat/vl/stringop.h
new file mode 100644
index 000000000..f5f6a524f
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/stringop.h
@@ -0,0 +1,58 @@
+/** @file stringop.h
+ ** @brief String operations
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_STRINGOP_H
+#define VL_STRINGOP_H
+
+#include "generic.h"
+
+/** @brief File protocols */
+enum {
+  VL_PROT_UNKNOWN = -1, /**< unknown protocol */
+  VL_PROT_NONE    =  0, /**< no protocol      */
+  VL_PROT_ASCII,        /**< ASCII protocol   */
+  VL_PROT_BINARY        /**< Binary protocol  */
+} ;
+
+
+VL_EXPORT vl_size vl_string_copy (char *destination, vl_size destinationSize, char const *source) ;
+VL_EXPORT vl_size vl_string_copy_sub (char *destination, vl_size destinationSize,
+                                      char const *beginning, char const *end) ;
+VL_EXPORT char *vl_string_parse_protocol (char const *string, int *protocol) ;
+VL_EXPORT char const *vl_string_protocol_name (int prot) ;
+VL_EXPORT vl_size vl_string_basename (char *destination, vl_size destinationSize,
+                                      char const *source, vl_size maxNumStrippedExtension) ;
+VL_EXPORT vl_size vl_string_replace_wildcard (char * destination, vl_size destinationSize,
+                                              char const *src, char wildcardChar, char escapeChar,
+                                              char const *replacement) ;
+VL_EXPORT char *vl_string_find_char_rev (char const *beginning, char const *end, char c) ;
+VL_EXPORT vl_size vl_string_length (char const *string) ;
+VL_EXPORT int vl_string_casei_cmp (const char *string1, const char *string2) ;
+
+/** @name String enumerations
+ ** @{ */
+
+/** @brief Member of an enumeration */
+typedef struct _VlEnumerator
+{
+  char const *name ; /**< enumeration member name. */
+  vl_index value ;   /**< enumeration member value. */
+} VlEnumerator ;
+
+VL_EXPORT VlEnumerator *vl_enumeration_get (VlEnumerator const *enumeration, char const *name) ;
+VL_EXPORT VlEnumerator *vl_enumeration_get_casei (VlEnumerator const *enumeration, char const *name) ;
+VL_EXPORT VlEnumerator *vl_enumeration_get_by_value (VlEnumerator const *enumeration, vl_index value) ;
+/** @} */
+
+/* VL_STRINGOP_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svm.c b/opensfm/src/third_party/vlfeat/vl/svm.c
new file mode 100644
index 000000000..49af2ebe3
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/svm.c
@@ -0,0 +1,2172 @@
+/** @file svm.c
+ ** @brief Support Vector Machines (SVM) - Implementation
+ ** @author Milan Sulc
+ ** @author Daniele Perrone
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 Milan Sulc.
+Copyright (C) 2012 Daniele Perrone.
+Copyright (C) 2011-13 Andrea Vedaldi.
+
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/** @file svm.h
+ ** @see @ref svm.
+ **/
+
+/**
+<!-- ------------------------------------------------------------- -->
+@page svm Support Vector Machines (SVM)
+@author Milan Sulc
+@author Daniele Perrone
+@author Andrea Vedaldi
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+*Support Vector Machines* (SVMs) are one of the most popular types of
+discriminate classifiers. VLFeat implements two solvers, SGD and SDCA,
+capable of learning linear SVMs on a large scale. These linear solvers
+can be combined with explicit feature maps to learn non-linear models
+as well. The solver supports a few variants of the standard
+SVM formulation, including using loss functions other than the hinge
+loss.
+
+@ref svm-starting demonstrates how to use VLFeat to learn an SVM.
+Information on SVMs and the corresponding optimization algorithms as
+implemented by VLFeat are given in:
+
+- @subpage svm-fundamentals - Linear SVMs and their learning.
+- @subpage svm-advanced - Loss functions, dual objective, and other details.
+- @subpage svm-sgd - The SGD algorithm.
+- @subpage svm-sdca - The SDCA algorithm.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-starting Getting started
+<!-- ------------------------------------------------------------- -->
+
+This section demonstrates how to learn an SVM by using VLFeat. SVM
+learning is implemented by the ::VlSvm object type. Let's
+start by a complete example:
+
+@code
+#include <stdio.h>
+#include <vl/svm.h>
+
+int main()
+{
+  vl_size const numData = 4 ;
+  vl_size const dimension = 2 ;
+  double x [dimension * numData] = {
+    0.0, -0.5,
+    0.6, -0.3,
+    0.0,  0.5
+    0.6,  0.0} ;
+  double y [numData] = {1, 1, -1, 1} ;
+  double lambda = 0.01;
+  double * const model ;
+  double bias ;
+
+  VlSvm * svm = vl_svm_new(VlSvmSolverSgd,
+                           x, dimension, numData,
+                           y,
+                           lambda) ;
+  vl_svm_train(svm) ;
+
+  model = vl_svm_get_model(svm) ;
+  bias = vl_svm_get_bias(svm) ;
+
+  printf("model w = [ %f , %f ] , bias b = %f \n",
+         model[0],
+         model[1],
+         bias);
+
+  vl_svm_delete(svm) ;
+  return 0;
+}
+@endcode
+
+This code learns a binary linear SVM using the SGD algorithm on
+four two-dimensional points using 0.01 as regularization parameter.
+
+::VlSvmSolverSdca can be specified in place of ::VlSvmSolverSdca
+in orer to use the SDCA algorithm instead.
+
+Convergence and other diagnostic information can be obtained after
+training by using the ::vl_svm_get_statistics function. Algorithms
+regularly check for convergence (usally after each pass over the data).
+The ::vl_svm_set_diagnostic_function can be used to specify a callback
+to be invoked when diagnostic is run. This can be used, for example,
+to dump information on the screen as the algorithm progresses.
+
+Convergence is reached after a maximum number of iterations
+(::vl_svm_set_max_num_iterations) or after a given criterion falls
+below a threshold (::vl_svm_set_epsilon). The meaning of these
+may depend on the specific algorithm (see @ref svm for further details).
+
+::VlSvm is a quite powerful object. Algorithms only need to perform
+inner product and accumulation operation on the data (see @ref svm-advanced).
+This is used to abstract from the data type and support almost anything
+by speciying just two functions (::vl_svm_set_data_functions).
+
+A simple interface to this advanced functionality is provided by the
+::VlSvmDataset object. This supports natively @c float and @c double
+data types, as well as applying on the fly the homogeneous kernel map
+(@ref homkermap). This is exemplified in @ref svmdataset-starting.
+
+*/
+
+/**
+<!-- ------------------------------------------------------------- -->
+@page svm-fundamentals SVM fundamentals
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+This page introduces the SVM formulation used in VLFeat. See @ref svm
+for more information on VLFeat SVM support.
+
+Let $ \bx \in \real^d $ be a vector representing, for example, an
+image, an audio track, or a fragment of text. Our goal is to design a
+*classifier*, i.e. a function that associates to each vector $\bx$ a
+positive or negative label based on a desired criterion, for example
+the fact that the image contains or not a cat, that the audio track
+contains or not English speech, or that the text is or not a
+scientific paper.
+
+The vector $\bx$ is classified by looking at the sign of a *linear
+scoring function* $\langle \bx, \bw \rangle$. The goal of learning is
+to estimate the parameter $\bw \in \real^d$ in such a way that the
+score is positive if the vector $\bx$ belongs to the positive class
+and negative otherwise. In fact, in the standard SVM formulation the
+the goal is to have a score of *at least 1* in the first case, and of
+*at most -1* in the second one, imposing a *margin*.
+
+The parameter $\bw$ is estimated or *learned* by fitting the scoring
+function to a training set of $n$ example pairs $(\bx_i,y_i),
+i=1,\dots,n$. Here $y_i \in \{-1,1\}$ are the *ground truth labels* of
+the corresponding example vectors. The fit quality is measured by a
+*loss function* which, in standard SVMs, is the *hinge loss*:
+
+\[
+\ell_i(\langle \bw,\bx\rangle) = \max\{0, 1 - y_i \langle \bw,\bx\rangle\}.
+\]
+
+Note that the hinge loss is zero only if the score $\langle
+\bw,\bx\rangle$ is at least 1 or at most -1, depending on the label
+$y_i$.
+
+Fitting the training data is usually insufficient. In order for the
+scoring function *generalize to future data* as well, it is usually
+preferable to trade off the fitting accuracy with the *regularity* of
+the learned scoring function $\langle \bx, \bw \rangle$. Regularity in
+the standard formulation is measured by the norm of the parameter
+vector $\|\bw\|^2$ (see @ref svm-advanced). Averaging the loss on all
+training samples and adding to it the regularizer weighed by a
+parameter $\lambda$ yields the *regularized loss objective*
+
+@f{equation}{
+\boxed{\displaystyle
+E(\bw) =  \frac{\lambda}{2} \left\| \bw \right\|^2
++ \frac{1}{n} \sum_{i=1}^n \max\{0, 1 - y_i \langle \bw,\bx\rangle\}.
+\label{e:svm-primal-hinge}
+}
+@f}
+
+Note that this objective function is *convex*, so that there exists a
+single global optimum.
+
+The scoring function $\langle \bx, \bw \rangle$ considered so far has
+been linear and unbiased. @ref svm-bias discusses how a bias term can
+be added to the SVM and @ref svm-feature-maps shows how non-linear
+SVMs can be reduced to the linear case by computing suitable feature
+maps.
+
+@ref svm-learning shows how VLFeat can be used to learn an SVM by
+minimizing $E(\bw)$.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-learning Learning
+<!-- ------------------------------------------------------------- -->
+
+Learning an SVM amounts to finding the minimizer $\bw^*$ of the cost
+function $E(\bw)$. While there are dozens of methods that can be used
+to do so, VLFeat implements two large scale methods, designed to work
+with linear SVMs (see @ref svm-feature-maps to go beyond linear):
+
+- @ref svm-sgd
+- @ref svm-sdca
+
+Using these solvers is exemplified in @ref svm-starting.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-bias Adding a bias
+<!-- ------------------------------------------------------------- -->
+
+It is common to add to the SVM scoring function a *bias term* $b$, and
+to consider the score $\langle \bx,\bw \rangle + b$. In practice the
+bias term can be crucial to fit the training data optimally, as there
+is no reason why the inner products $\langle \bx,\bw \rangle$ should
+be naturally centered at zero.
+
+Some SVM learning algorithms can estimate both $\bw$ and $b$
+directly. However, other algorithms such as SGD and SDCA cannot. In
+this case, a simple workaround is to add a constant component $B > 0$
+(we call this constant the *bias multiplier*) to the data,
+i.e. consider the extended data vectors:
+\[
+\bar \bx = \begin{bmatrix} \bx \\ B \end{bmatrix},
+\quad
+\bar \bw = \begin{bmatrix} \bw \\ w_b \end{bmatrix}.
+\]
+In this manner the scoring function incorporates implicitly a bias $b = B w_b$:
+\[
+\langle \bar\bx, \bar\bw \rangle =
+\langle \bx, \bw \rangle + B w_b.
+\]
+
+The disadvantage of this reduction is that the term $w_b^2$ becomes
+part of the SVM regularizer, which shrinks the bias $b$ towards
+zero. This effect can be alleviated by making $B$ sufficiently large,
+because in this case $\|\bw\|^2 \gg w_b^2$ and the shrinking effect is
+negligible.
+
+Unfortunately, making $B$ too large makes the problem numerically
+unbalanced, so a reasonable trade-off between shrinkage and stability
+is generally sought. Typically, a good trade-off is obtained by
+normalizing the data to have unitary Euclidean norm and then choosing
+$B \in [1, 10]$.
+
+Specific implementations of SGD and SDCA may provide explicit support
+to learn the bias in this manner, but it is important to understand
+the implications on speed and accuracy of the learning if this is
+done.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-feature-maps Non-linear SVMs and feature maps
+<!-- ------------------------------------------------------------- -->
+
+So far only linear scoring function $\langle \bx,\bw \rangle$ have
+been considered. Implicitly, however, this assumes that the objects to
+be classified (e.g. images) have been encoded as vectors $\bx$ in a
+way that makes linear classification possible. This encoding step can
+be made explicit by introducing the *feature map* $\Phi(\bx) \in
+\real^d$. Including the feature map yields a scoring function
+*non-linear* in $\bx$:
+\[
+\bx\in\mathcal{X} \quad\longrightarrow\quad \langle \Phi(\bx), \bw \rangle.
+\]
+The nature of the input space $\mathcal{X}$ can be arbitrary and might
+not have a vector space structure at all.
+
+The representation or encoding captures a notion of *similarity*
+between objects: if two vectors $\Phi(\bx_1)$ and $\Phi(\bx_2)$ are
+similar, then their scores will also be similar. Note that choosing a
+feature map amounts to incorporating this information in the model
+*prior* to learning.
+
+The relation of feature maps to similarity functions is formalized by
+the notion of a *kernel*, a positive definite function $K(\bx,\bx')$
+measuring the similarity of a pair of objects. A feature map defines a
+kernel by
+
+\[
+K(\bx,\bx') = \langle \Phi(\bx),\Phi(\bx') \rangle.
+\]
+
+Viceversa, any kernel function can be represented by a feature map in
+this manner, establishing an equivalence.
+
+So far, all solvers in VLFeat assume that the feature map $\Psi(\bx)$
+can be explicitly computed. Although classically kernels were
+introduced to generalize solvers to non-linear SVMs for which a
+feature map *cannot* be computed (e.g. for a Gaussian kernel the
+feature map is infinite dimensional), in practice using explicit
+feature representations allow to use much faster solvers, so it makes
+sense to *reverse* this process.
+*/
+
+/**
+<!-- ------------------------------------------------------------- -->
+@page svm-advanced Advanced SVM topics
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+This page discusses advanced SVM topics. For an introduction to SVMs,
+please refer to @ref svm and @ref svm-fundamentals.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-loss-functions Loss functions
+<!-- ------------------------------------------------------------- -->
+
+The SVM formulation given in @ref svm-fundamentals uses the
+hinge loss, which is only one of a variety of loss functions that
+are often used for SVMs. More in general, one
+can consider the objective
+
+@f{equation}{
+E(\bw) =  \frac{\lambda}{2} \left\| \bw \right\|^2 + \frac{1}{n} \sum_{i=1}^n \ell_i(\langle \bw,\bx\rangle).
+\label{e:svm-primal}
+@f}
+
+where the loss $\ell_i(z)$ is a convex function of the scalar variable
+$z$. Losses differ by: (i) their purpose (some are suitable for
+classification, other for regression), (ii) their smoothness (which
+usually affects how quickly the SVM objective function can be
+minimized), and (iii) their statistical interpretation (for example
+the logistic loss can be used to learn logistic models).
+
+Concrete examples are the:
+
+<table>
+<tr>
+<td>Name</td>
+<td>Loss $\ell_i(z)$</td>
+<td>Description</td>
+</tr>
+<tr>
+<td>Hinge</td>
+<td>$\max\{0, 1-y_i z\}$</td>
+<td>The standard SVM loss function.</td>
+</tr>
+<tr>
+<td>Square hinge</td>
+<td>$\max\{0, 1-y_i z\}^2$</td>
+<td>The standard SVM loss function, but squared. This version is
+smoother and may yield numerically easier problems.</td>
+</tr>
+<tr>
+<td>Square or l2</td>
+<td>$(y_i - z)^2$</td>
+<td>This loss yields the ridge regression model (l2 regularised least
+square).</td>
+</tr>
+<tr>
+<td>Linear or l1</td>
+<td>$|y_i - z|$</td>
+<td>Another loss suitable for regression, usually more robust but
+harder to optimize than the squared one.</td>
+</tr>
+<tr>
+<td>Insensitive l1</td>
+<td>$\max\{0, |y_i - z| - \epsilon\}$.</td>
+<td>This is a variant of the previous loss, proposed in the original
+Support Vector Regression formulation. Differently from the previous
+two losses, the insensitivity may yield to a sparse selection of
+support vectors.</td>
+</tr>
+<tr>
+<td>Logistic</td>
+<td>$\log(1 + e^{-y_i z})$</td>
+<td>This corresponds to regularized logisitc regression. The loss can
+be seen as a negative log-likelihood: $\ell_i(z) = -\log P[y_i | z] =
+- \log \sigma(y_iz/2)$, where $\sigma(z) = e^z/(1 + e^z)$ is the
+sigmoid function, mapping a score $z$ to a probability. The $1/2$
+factor in the sigmoid is due to the fact that labels are in $\{-1,1\}$
+rather than $\{0,1\}$ as more common for the standard sigmoid
+model.</td>
+</tr>
+</table>
+
+<!-- ------------------------------------------------------------- -->
+@section svm-data-abstraction Data abstraction: working with compressed data
+<!-- ------------------------------------------------------------- -->
+
+VLFeat learning algorithms (SGD and SDCA) access the data by means of
+only two operations:
+
+- *inner product*: computing the inner product between the model and
+a data vector, i.e. $\langle \bw, \bx \rangle$.
+- *accumulation*: summing a data vector to the model, i.e. $\bw
+\leftarrow \bw + \beta \bx$.
+
+VLFeat learning algorithms are *parameterized* in these two
+operations. As a consequence, the data can be stored in any format
+suitable to the user (e.g. dense matrices, sparse matrices,
+block-sparse matrices, disk caches, and so on) provided that these two
+operations can be implemented efficiently. Differently from the data,
+however, the model vector $\bw$ is represented simply as a dense array
+of doubles. This choice is adequate in almost any case.
+
+A particularly useful aspect of this design choice is that the
+training data can be store in *compressed format* (for example by
+using product quantization (PQ)). Furthermore, higher-dimensional
+encodings such as the homogeneous kernel map (@ref homkermap) and the
+intersection kernel map can be *computed on the fly*. Such techniques
+are very important when dealing with GBs of data.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-dual-problem Dual problem
+<!-- ------------------------------------------------------------- -->
+
+In optimization, the *dual objective* $D(\balpha)$ of the SVM
+objective $E(\bw)$ is of great interest. To obtain the dual objective,
+one starts by approximating each loss term from below by a family of planes:
+\[
+\ell_i(z) = \sup_{u} (u z - \ell_i^*(u) ),
+\qquad
+\ell_i^*(u) = \sup_{z} (z u - \ell_i(z) )
+\]
+where $\ell_i^*(u)$ is the *dual conjugate* of the loss and gives the
+intercept of each approximating plane as a function of the slope. When
+the loss function is convex, the approximation is in fact exact. Examples
+include:
+
+<table>
+<tr>
+<td>Name</td>
+<td>Loss $\ell_i(z)$</td>
+<td>Conjugate loss $\ell_i^*(u)$</td>
+</tr>
+<tr>
+<td>Hinge</td>
+<td>$\max\{0, 1-y_i z\}$</td>
+<td>\[
+\ell_i^*(u) =
+\begin{cases}
+y_i u, & -1 \leq y_i u \leq 0, \\
++\infty, & \text{otherwise}
+\end{cases}
+\]</td>
+</tr>
+<tr>
+<td>Square hinge</td>
+<td>$\max\{0, 1-y_i z\}^2$</td>
+<td>\[\ell_i^*(u) =
+\begin{cases}
+y_i u + \frac{u^2}{4}, & y_i u \leq 0, \\
++\infty, & \text{otherwise} \\
+\end{cases}\]</td>
+</tr>
+<tr>
+<td>Linear or l1</td>
+<td>$|y_i - z|$</td>
+<td>\[\ell_i^*(u) =
+\begin{cases}
+y_i u, & -1 \leq y_i u \leq 1, \\
++\infty, & \text{otherwise} \\
+\end{cases}\]</td>
+</tr>
+<tr>
+<td>Square or l2</td>
+<td>$(y_i - z)^2$</td>
+<td>\[\ell_i^*(u)=y_iu + \frac{u^2}{4}\]</td>
+</tr>
+<tr>
+<td>Insensitive l1</td>
+<td>$\max\{0, |y_i - z| - \epsilon\}$.</td>
+<td></td>
+</tr>
+<tr>
+<td>Logistic</td>
+<td>$\log(1 + e^{-y_i z})$</td>
+<td>\[\ell_i^*(u) =
+ \begin{cases}
+ (1+u) \log(1+u) - u \log(-u), & -1 \leq y_i u \leq 0, \\
+ +\infty, & \text{otherwise} \\
+ \end{cases}\]
+</td>
+</tr>
+</table>
+
+Since each plane $- z \alpha_i - \ell^*_i(-\alpha_i) \leq \ell_i(z)$
+bounds the loss from below, by substituting in $E(\bw)$ one can write
+a lower bound for the SVM objective
+\[
+F(\bw,\balpha) = \frac{\lambda}{2} \|\bw\|^2 -
+\frac{1}{n}\sum_{i=1}^n (\bw^\top \bx_i\alpha_i + \ell_i^*(-\alpha_i))
+\leq E(\bw).
+\]
+for each setting of the *dual variables* $\alpha_i$. The dual
+objective function $D(\balpha)$ is obtained by minimizing the lower
+bound $F(\bw,\balpha)$ w.r.t. to $\bw$:
+\[
+D(\balpha) = \inf_{\bw} F(\bw,\balpha) \leq E(\bw).
+\]
+The minimizer and the dual objective are now easy to find:
+\[
+\boxed{\displaystyle
+\bw(\balpha) =
+\frac{1}{\lambda n}
+\sum_{i=1}^n \bx_i \alpha_i = \frac{1}{\lambda n} X\balpha,
+\quad
+D(\balpha) = - \frac{1}{2\lambda n^2} \balpha^\top X^\top X \balpha +
+\frac{1}{n} \sum_{i=1}^n - \ell_i^*(-\alpha_i)
+}
+\]
+where $X = [\bx_1, \dots, \bx_n]$ is the data matrix. Since the dual
+is uniformly smaller than the primal, one has the *duality gap* bound:
+\[
+D(\balpha) \leq P(\bw^*) \leq P(\bw(\balpha))
+\]
+This bound can be used to evaluate how far off $\bw(\balpha)$ is from
+the primal minimizer $\bw^*$. In fact, due to convexity, this bound
+can be shown to be zero when $\balpha^*$ is the dual maximizer (strong
+duality):
+\[
+D(\balpha^*) = P(\bw^*) = P(\bw(\balpha^*)),
+\quad \bw^* = \bw(\balpha^*).
+\]
+
+<!-- ------------------------------------------------------------- -->
+@section svm-C Parametrization in C
+<!-- ------------------------------------------------------------- -->
+
+Often a slightly different form of the SVM objective is considered,
+where a parameter $C$ is used to scale the loss instead of the regularizer:
+
+\[
+E_C(\bw) = \frac{1}{2} \|\bw\|^2 + C \sum_{i=1}^n \ell_i(\langle \bx_i, \bw\rangle)
+\]
+
+This and the objective function $E(\bw)$ in $\lambda$ are equivalent
+(proportional) if
+
+\[
+\lambda = \frac{1}{nC},
+\qquad C = \frac{1}{n\lambda}.
+\] up to an overall scaling factor to the problem.
+
+**/
+
+/**
+
+<!-- ------------------------------------------------------------- -->
+@page svm-sdca Stochastic Dual Coordinate Ascent
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+This page describes the *Stochastic Dual Coordinate Ascent* (SDCA)
+linear SVM solver. Please see @ref svm for an overview of VLFeat SVM
+support.
+
+SDCA maximizes the dual SVM objective (see @ref svm-dual-problem
+for a derivation of this expression):
+
+\[
+D(\balpha) = - \frac{1}{2\lambda n^2} \balpha^\top X^\top X \balpha +
+\frac{1}{n} \sum_{i=1}^n - \ell_i^*(-\alpha_i)
+\]
+
+where $X$ is the data matrix. Recall that the primal parameter
+corresponding to a given setting of the dual variables is:
+
+\[
+\bw(\balpha) = \frac{1}{\lambda n} \sum_{i=1}^n \bx_i \alpha_i = \frac{1}{\lambda n} X\balpha
+\]
+
+In its most basic form, the *SDCA algorithm* can be summarized as follows:
+
+- Let $\balpha_0 = 0$.
+- Until the duality gap $P(\bw(\balpha_t)) -  D(\balpha_t) < \epsilon$
+  - Pick a dual variable $q$ uniformly at random in $1, \dots, n$.
+  - Maximize the dual with respect to this variable: $\Delta\alpha_q = \max_{\Delta\alpha_q} D(\balpha_t + \Delta\alpha_q \be_q )$
+  - Update $\balpha_{t+1} = \balpha_{t} + \be_q \Delta\alpha_q$.
+
+In VLFeat, we partially use the nomenclature from @cite{shwartz13a-dual} and @cite{hsieh08a-dual}.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-sdca-dual-max Dual coordinate maximization
+<!-- ------------------------------------------------------------- -->
+
+The updated dual objective can be expanded as:
+\[
+D(\balpha_t + \be_q \Delta\alpha_q) =
+\text{const.}
+- \frac{1}{2\lambda n^2} \bx_q^\top \bx_q (\Delta\alpha_q)^2
+- \frac{1}{n} \bx_q^\top \frac{X\alpha_t}{\lambda n} \Delta\alpha_q
+- \frac{1}{n} \ell^*_q(- \alpha_q - \Delta\alpha_q)
+\]
+This can also be written as
+@f{align*}
+D(\balpha_t + \be_q \Delta\alpha_q) &\propto
+- \frac{A}{2} (\Delta\alpha_q)^2
+- B \Delta\alpha_q
+- \ell^*_q(- \alpha_q - \Delta\alpha_q),
+\\
+A &= \frac{1}{\lambda n} \bx_q^\top \bx_q = \frac{1}{\lambda n} \| \bx_q \|^2,
+\\
+B &= \bx_q^\top \frac{X\balpha_t}{\lambda n} = \bx_q^\top \bw_t.
+@f}
+Maximizing this quantity in the scalar variable $\Delta\balpha$ is usually
+not difficult. It is convenient to store and incrementally
+update the model $\bw_t$ after the optimal step $\Delta\balpha$ has been
+determined:
+\[
+\bw_t = \frac{X \balpha_t}{\lambda n},
+\quad \bw_{t+1} = \bw_t + \frac{1}{\lambda n }\bx_q \be_q \Delta\alpha_q.
+\]
+
+For example, consider the hinge loss as given in @ref svm-advanced :
+\[
+\ell_q^*(u) =
+\begin{cases}
+y_q u, & -1 \leq y_q u \leq 0, \\
++\infty, & \text{otherwise}.
+\end{cases}
+\]
+The maximizer $\Delta\alpha_q$ of the update objective must be in the
+range where the conjugate loss is not infinite. Ignoring such bounds,
+the update can be obtained by setting the derivative of the objective
+to zero, obtaining
+\[
+\tilde {\Delta \alpha_q}= \frac{y_q - B}{A}.
+\]
+Note that $B$ is simply current score associated by the SVM to
+the sample $\bx_q$. Incorporating the constraint $-1 \leq - y_q
+(\alpha_q + \Delta \alpha_q) \leq 0$,
+i.e. $0 \leq y_q (\alpha_q + \Delta \alpha_q) \leq 1$, one obtains the update
+\[
+\Delta\alpha_q =  y_q \max\{0, \min\{1, y_q (\tilde {\Delta\alpha_q } + \alpha_q)\}\} - \alpha_q.
+\]
+
+<!-- ------------------------------------------------------------ --->
+@section svm-sdca-details Implementation details
+<!-- ------------------------------------------------------------ --->
+
+Rather than visiting points completely at random, VLFeat SDCA follows
+the best practice of visiting all the points at every epoch (pass
+through the data), changing the order of the visit randomly by picking
+every time a new random permutation.
+**/
+
+/**
+<!-- ------------------------------------------------------------- -->
+@page svm-sgd Stochastic Gradient Descent
+@tableofcontents
+<!-- ------------------------------------------------------------- -->
+
+This page describes the *Stochastic Gradient Descent* (SGD) linear SVM
+solver. SGD minimizes directly the primal SVM objective (see @ref svm):
+
+\[
+E(\bw) = \frac{\lambda}{2} \left\| \bw \right\|^2 + \frac{1}{n} \sum_{i=1}^n
+\ell_i(\langle \bw,\bx\rangle)
+\]
+
+Firts, rewrite the objective as the average
+
+\[
+E(\bw) = \frac{1}{n} \sum_{i=1}^n E_i(\bw),
+\quad
+E_i(\bw) = \frac{\lambda}{2}  \left\| \bw \right\|^2 + \ell_i(\langle \bw,\bx\rangle).
+\]
+
+Then SGD performs gradient steps by considering at each iteration
+one term $E_i(\bw)$ selected at random from this average.
+In its most basic form, the algorithm is:
+
+- Start with $\bw_0 = 0$.
+- For $t=1,2,\dots T$:
+  - Sample one index $i$ in $1,\dots,n$ uniformly at random.
+  - Compute a subgradient $\bg_t$ of $E_i(\bw)$ at $\bw_t$.
+  - Compute the learning rate $\eta_t$.
+  - Update $\bw_{t+1} = \bw_t - \eta_t \bg_t$.
+
+Provided that the learning rate $\eta_t$ is chosen correctly, this
+simple algorithm is guaranteed to converge to the minimizer $\bw^*$ of
+$E$.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-sgd-convergence Convergence and speed
+<!-- ------------------------------------------------------------- -->
+
+The goal of the SGD algorithm is to bring the *primal suboptimality*
+below a threshold $\epsilon_P$:
+\[
+E(\bw_t) - E(\bw^*) \leq \epsilon_P.
+\]
+
+If the learning rate $\eta_t$ is selected appropriately, SGD can be
+shown to converge properly. For example,
+@cite{shalev-shwartz07pegasos} show that, since $E(\bw)$ is
+$\lambda$-strongly convex, then using the learning rate
+\[
+\boxed{\eta_t = \frac{1}{\lambda t}}
+\]
+guarantees that the algorithm reaches primal-suboptimality $\epsilon_P$ in
+\[
+\tilde O\left( \frac{1}{\lambda \epsilon_P} \right).
+\]
+iterations. This particular SGD variant is sometimes known as PEGASOS
+@cite{shalev-shwartz07pegasos} and is the version implemented in
+VLFeat.
+
+The *convergence speed* is not sufficient to tell the *learning speed*,
+i.e. how quickly an algorithm can learn an SVM that performs optimally
+on the test set. The following two observations
+can be used to link convergence speed to learning speed:
+
+- The regularizer strength is often heuristically selected to be
+  inversely proportional to the number of training samples: $\lambda =
+  \lambda_0 /n$. This reflects the fact that with more training data
+  the prior should count less.
+- The primal suboptimality $\epsilon_P$ should be about the same as
+  the estimation error of the SVM primal. This estimation error is due
+  to the finite training set size and can be shown to be of the order
+  of $1/\lambda n = 1 / \lambda_0$.
+
+Under these two assumptions, PEGASOS can learn a linear SVM in time
+$\tilde O(n)$, which is *linear in the number of training
+examples*. This fares much better with $O(n^2)$ or worse of non-linear
+SVM solvers.
+
+<!-- ------------------------------------------------------------- -->
+@section svm-sgd-bias The bias term
+<!-- ------------------------------------------------------------- -->
+
+Adding a bias $b$ to the SVM scoring function $\langle \bw, \bx
+\rangle +b$ is done, as explained in @ref svm-bias, by appending a
+constant feature $B$ (the *bias multiplier*) to the data vectors $\bx$
+and a corresponding weight element $w_b$ to the weight vector $\bw$,
+so that $b = B w_b$ As noted, the bias multiplier should be
+relatively large in order to avoid shrinking the bias towards zero,
+but small to make the optimization stable. In particular, setting $B$
+to zero learns an unbiased SVM (::vl_svm_set_bias_multiplier).
+
+To counter instability caused by a large bias multiplier, the learning
+rate of the bias is slowed down by multiplying the overall learning
+rate $\eta_t$ by a bias-specific rate coefficient
+(::vl_svm_set_bias_learning_rate).
+
+As a rule of thumb, if the data vectors $\bx$ are $l^2$ normalized (as
+they typically should for optimal performance), then a reasonable bias
+multiplier is in the range 1 to 10 and a reasonable bias learning rate
+is somewhere in the range of the inverse of that (in this manner the
+two parts of the extended feature vector $(\bx, B)$ are balanced).
+
+<!-- ------------------------------------------------------------- -->
+@section svm-sgd-starting-iteration Adjusting the learning rate
+<!-- ------------------------------------------------------------- -->
+
+Initially, the learning rate $\eta_t = 1/\lambda t$ is usually too
+fast: as usually $\lambda \ll 1$, $\eta_1 \gg 1$. But this is clearly
+excessive (for example, without a loss term, the best learning rate at
+the first iteration is simply $\eta_1=1$, as this nails the optimum in
+one step). Thus, the learning rate formula is modified to be $\eta_t =
+1 / \lambda (t + t_0)$, where $t_0 \approx 2/\lambda$, which is
+equivalent to start $t_0$ iterations later. In this manner $\eta_1
+\approx 1/2$.
+
+<!-- ------------------------------------------------------------ --->
+@subsection svm-sgd-warm-start Warm start
+<!-- ------------------------------------------------------------ --->
+
+Starting from a given model $\bw$ is easy in SGD as the optimization
+runs in the primal. However, the starting iteration index $t$ should
+also be advanced for a warm start, as otherwise the initial setting of
+$\bw$ is rapidly forgot (::vl_svm_set_model, ::vl_svm_set_bias,
+::vl_svm_set_iteration_number).
+
+<!-- ------------------------------------------------------------- -->
+@section svm-sgd-details Implementation details
+<!-- ------------------------------------------------------------- -->
+
+@par "Random sampling of points"
+
+Rather than visiting points completely at random, VLFeat SDCA follows
+the best practice of visiting all the points at every epoch (pass
+through the data), changing the order of the visit randomly by picking
+every time a new random permutation.
+
+@par "Factored representation"
+
+At each iteration, the SGD algorithm updates the vector $\bw$
+(including the additional bias component $w_b$) as $\bw_{t+1}
+\leftarrow \bw_t - \lambda \eta_t \bw_t - \eta_t \bg_t$, where
+$\eta_t$ is the learning rate. If the subgradient of the loss function
+$\bg_t$ is zero at a given iteration, this amounts to simply shrink
+$\bw$ towards the origin by multiplying it by the factor $1 - \lambda
+\eta_t$. Thus such an iteration can be accelerated significantly by
+representing internally $\bw_t = f_t \bu_t$, where $f_t$ is a scaling
+factor. Then, the update becomes
+\[
+   f_{t+1} \bu_{t+1}
+   = f_{t} \bu_{t} - \lambda \eta_t f_{t} \bu_{t} - \eta_t \bg_t
+   = (1-\lambda \eta_t) f_{t} \bu_{t} - \eta_t \bg_t.
+\]
+Setting $f_{t+1} = (1-\lambda \eta_t) f_{t}$, this gives the update
+equation for $\bu_t$
+\[
+\bu_{t+1} = \bu_{t} - \frac{\eta_t}{f_{t+1}} \bg_t.
+\]
+but this step can be skipped whenever $\bg_t$ is equal to zero.
+
+When the bias component has a different learning rate, this scheme
+must be adjusted slightly by adding a separated factor for the bias,
+but it is otherwise identical.
+
+
+**/
+
+/*
+
+<!-- ------------------------------------------------------------ --->
+@section svm-pegasos PEGASOS
+<!-- ------------------------------------------------------------ --->
+
+<!-- ------------------------------------------------------------ --->
+@subsection svm-pegasos-algorithm Algorithm
+<!-- ------------------------------------------------------------ --->
+
+PEGASOS @cite{shalev-shwartz07pegasos} is a stochastic subgradient
+optimizer. At the <em>t</em>-th iteration the algorithm:
+
+- Samples uniformly at random as subset @f$ A_t @f$ of <em>k</em> of
+training pairs @f$(x,y)@f$ from the <em>m</em> pairs provided for
+training (this subset is called mini batch).
+- Computes a subgradient @f$ \nabla_t @f$ of the function @f$ E_t(w) =
+\frac{1}{2}\|w\|^2 + \frac{1}{k} \sum_{(x,y) \in A_t} \ell(w;(x,y))
+@f$ (this is the SVM objective function restricted to the
+minibatch).
+- Compute an intermediate weight vector @f$ w_{t+1/2} @f$ by doing a
+step @f$ w_{t+1/2} = w_t - \alpha_t \nabla_t @f$ with learning rate
+@f$ \alpha_t = 1/(\eta t) @f$ along the subgradient. Note that the
+learning rate is inversely proportional to the iteration number.
+- Back projects the weight vector @f$ w_{t+1/2} @f$ on the
+hypersphere of radius @f$ \sqrt{\lambda} @f$ to obtain the next
+model estimate @f$ w_{t+1} @f$:
+@f[
+w_t = \min\{1, \sqrt{\lambda}/\|w\|\} w_{t+1/2}.
+@f]
+The hypersphere is guaranteed to contain the optimal weight vector
+@f$ w^* @f$.
+
+VLFeat implementation fixes to one the size of the mini batches @f$ k
+@f$.
+
+
+<!-- ------------------------------------------------------------ --->
+@subsection svm-pegasos-permutation Permutation
+<!-- ------------------------------------------------------------ --->
+
+VLFeat PEGASOS can use a user-defined permutation to decide the order
+in which data points are visited (instead of using random
+sampling). By specifying a permutation the algorithm is guaranteed to
+visit each data point exactly once in each loop. The permutation needs
+not to be bijective. This can be used to visit certain data samples
+more or less often than others, implicitly reweighting their relative
+importance in the SVM objective function. This can be used to balance
+the data.
+
+<!-- ------------------------------------------------------------ --->
+@subsection svm-pegasos-kernels Non-linear kernels
+<!-- ------------------------------------------------------------ --->
+
+PEGASOS can be extended to non-linear kernels, but the algorithm is
+not particularly efficient in this setting [1]. When possible, it may
+be preferable to work with explicit feature maps.
+
+Let @f$ k(x,y) @f$ be a positive definite kernel. A <em>feature
+map</em> is a function @f$ \Psi(x) @f$ such that @f$ k(x,y) = \langle
+\Psi(x), \Psi(y) \rangle @f$. Using this representation the non-linear
+SVM learning objective function writes:
+
+@f[
+\min_{w} \frac{\lambda}{2} \|w\|^2 + \frac{1}{m} \sum_{i=1}^n
+\ell(w; (\Psi(x)_i,y_i)).
+@f]
+
+Thus the only difference with the linear case is that the feature @f$
+\Psi(x) @f$ is used in place of the data @f$ x @f$.
+
+@f$ \Psi(x) @f$ can be learned off-line, for instance by using the
+incomplete Cholesky decomposition @f$ V^\top V @f$ of the Gram matrix
+@f$ K = [k(x_i,x_j)] @f$ (in this case @f$ \Psi(x_i) @f$ is the
+<em>i</em>-th columns of <em>V</em>). Alternatively, for additive
+kernels (e.g. intersection, Chi2) the explicit feature map computed by
+@ref homkermap.h can be used.
+
+For additive kernels it is also possible to perform the feature
+expansion online inside the solver, setting the specific feature map
+via ::vl_svmdataset_set_map. This is particular useful to keep the
+size of the training data small, when the number of the samples is big
+or the memory is limited.
+*/
+
+#include "svm.h"
+#include "mathop.h"
+#include <string.h>
+
+struct VlSvm_ {
+  VlSvmSolverType solver ;      /**< SVM solver type. */
+
+  vl_size dimension ;           /**< Model dimension. */
+  double * model ;              /**< Model ($\bw$ vector). */
+  double bias ;                 /**< Bias. */
+  double biasMultiplier ;       /**< Bias feature multiplier. */
+
+  /* valid during a run */
+  double lambda ;               /**< Regularizer multiplier. */
+  void const * data ;
+  vl_size numData ;
+  double const * labels ;       /**< Data labels. */
+  double const * weights ;      /**< Data weights. */
+
+  VlSvmDataset * ownDataset ;   /**< Optional owned dataset. */
+
+  VlSvmDiagnosticFunction diagnosticFn ;
+  void * diagnosticFnData ;
+  vl_size diagnosticFrequency ; /**< Frequency of diagnostic. */
+
+  VlSvmLossFunction lossFn ;
+  VlSvmLossFunction conjugateLossFn ;
+  VlSvmLossFunction lossDerivativeFn ;
+  VlSvmDcaUpdateFunction dcaUpdateFn ;
+  VlSvmInnerProductFunction innerProductFn ;
+  VlSvmAccumulateFunction accumulateFn ;
+
+  vl_size iteration ;           /**< Current iterations number. */
+  vl_size maxNumIterations ;    /**< Maximum number of iterations. */
+  double epsilon ;              /**< Stopping threshold. */
+
+  /* Book keeping */
+  VlSvmStatistics statistics ;  /**< Statistcs. */
+  double * scores ;
+
+  /* SGD specific */
+  double  biasLearningRate ;    /**< Bias learning rate. */
+
+  /* SDCA specific */
+  double * alpha ;              /**< Dual variables. */
+} ;
+
+/* ---------------------------------------------------------------- */
+
+/** @brief Create a new object with plain data.
+ ** @param type type of SMV solver.
+ ** @param data a pointer to a matrix of data.
+ ** @param dimension dimension of the SVM model.
+ ** @param numData number of training samples.
+ ** @param labels training labels.
+ ** @param lambda regularizer parameter.
+ ** @return the new object.
+ **
+ ** @a data has one column per sample, in @c double format.
+ ** More advanced inputs can be used with ::vl_svm_new_with_dataset
+ ** and ::vl_svm_new_with_abstract_data.
+ **
+ ** @sa ::vl_svm_delete
+ **/
+
+VlSvm *
+vl_svm_new (VlSvmSolverType type,
+            double const * data,
+            vl_size dimension,
+            vl_size numData,
+            double const * labels,
+            double lambda)
+{
+  VlSvmDataset * dataset = vl_svmdataset_new(VL_TYPE_DOUBLE, (void*)data, dimension, numData) ;
+  VlSvm * self = vl_svm_new_with_dataset (type, dataset, labels, lambda) ;
+  self->ownDataset = dataset ;
+  return self ;
+}
+
+/** @brief Create a new object with a dataset.
+ ** @param solver type of SMV solver.
+ ** @param dataset SVM dataset object
+ ** @param labels training samples labels.
+ ** @param lambda regularizer parameter.
+ ** @return the new object.
+ ** @sa ::vl_svm_delete
+ **/
+
+VlSvm *
+vl_svm_new_with_dataset (VlSvmSolverType solver,
+                         VlSvmDataset * dataset,
+                         double const * labels,
+                         double lambda)
+{
+  VlSvm * self = vl_svm_new_with_abstract_data (solver,
+                                             dataset,
+                                             vl_svmdataset_get_dimension(dataset),
+                                             vl_svmdataset_get_num_data(dataset),
+                                             labels,
+                                             lambda) ;
+  vl_svm_set_data_functions (self,
+                             vl_svmdataset_get_inner_product_function(dataset),
+                             vl_svmdataset_get_accumulate_function(dataset)) ;
+  return self ;
+}
+
+/** @brief Create a new object with abstract data.
+ ** @param solver type of SMV solver.
+ ** @param data pointer to the data.
+ ** @param dimension dimension of the SVM model.
+ ** @param numData num training samples.
+ ** @param labels training samples labels.
+ ** @param lambda regularizer parameter.
+ ** @return the new object.
+ **
+ ** After calling this function, ::vl_svm_set_data_functions *must*
+ ** be used to setup suitable callbacks for the inner product
+ ** and accumulation operations (@see svm-data-abstraction).
+ **
+ ** @sa ::vl_svm_delete
+ **/
+
+VlSvm *
+vl_svm_new_with_abstract_data (VlSvmSolverType solver,
+                               void * data,
+                               vl_size dimension,
+                               vl_size numData,
+                               double const * labels,
+                               double lambda)
+{
+  VlSvm * self = vl_calloc(1,sizeof(VlSvm)) ;
+
+  assert(dimension >= 1) ;
+  assert(numData >= 1) ;
+  assert(labels) ;
+
+  self->solver = solver ;
+
+  self->dimension = dimension ;
+  self->model = 0 ;
+  self->bias = 0 ;
+  self->biasMultiplier = 1.0 ;
+
+  self->lambda = lambda ;
+  self->data = data ;
+  self->numData = numData ;
+  self->labels = labels ;
+
+  self->diagnosticFrequency = numData ;
+  self->diagnosticFn = 0 ;
+  self->diagnosticFnData = 0 ;
+
+  self->lossFn = vl_svm_hinge_loss ;
+  self->conjugateLossFn = vl_svm_hinge_conjugate_loss ;
+  self->lossDerivativeFn = vl_svm_hinge_loss_derivative ;
+  self->dcaUpdateFn = vl_svm_hinge_dca_update ;
+
+  self->innerProductFn = 0 ;
+  self->accumulateFn = 0 ;
+
+  self->iteration = 0 ;
+  self->maxNumIterations = VL_MAX((double)numData, vl_ceil_f(10.0 / lambda)) ;
+  self->epsilon = 1e-2 ;
+
+  /* SGD */
+  self->biasLearningRate = 0.01 ;
+
+  /* SDCA */
+  self->alpha = 0 ;
+
+  /* allocations */
+  self->model = vl_calloc(dimension, sizeof(double)) ;
+  if (self->model == NULL) goto err_alloc ;
+
+  if (self->solver == VlSvmSolverSdca) {
+    self->alpha = vl_calloc(self->numData, sizeof(double)) ;
+    if (self->alpha == NULL) goto err_alloc ;
+  }
+
+  self->scores = vl_calloc(numData, sizeof(double)) ;
+  if (self->scores == NULL) goto err_alloc ;
+
+  return self ;
+
+err_alloc:
+  if (self->scores) {
+    vl_free (self->scores) ;
+    self->scores = 0 ;
+  }
+  if (self->model) {
+    vl_free (self->model) ;
+    self->model = 0 ;
+  }
+  if (self->alpha) {
+    vl_free (self->alpha) ;
+    self->alpha = 0 ;
+  }
+  return 0 ;
+}
+
+/** @brief Delete object.
+ ** @param self object.
+ ** @sa ::vl_svm_new
+ **/
+
+void
+vl_svm_delete (VlSvm * self)
+{
+  if (self->model) {
+    vl_free (self->model) ;
+    self->model = 0 ;
+  }
+  if (self->alpha) {
+    vl_free (self->alpha) ;
+    self->alpha = 0 ;
+  }
+  if (self->ownDataset) {
+    vl_svmdataset_delete(self->ownDataset) ;
+    self->ownDataset = 0 ;
+  }
+  vl_free (self) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                              Setters and getters */
+/* ---------------------------------------------------------------- */
+
+/** @brief Set the convergence threshold
+ ** @param self object
+ ** @param epsilon threshold (non-negative).
+ **/
+
+void vl_svm_set_epsilon (VlSvm *self, double epsilon)
+{
+  assert(self) ;
+  assert(epsilon >= 0) ;
+  self->epsilon = epsilon ;
+}
+
+/** @brief Get the convergence threshold
+ ** @param self object
+ ** @return epsilon threshold.
+ **/
+
+double vl_svm_get_epsilon (VlSvm const *self)
+{
+  assert(self) ;
+  return self->epsilon ;
+}
+
+/** @brief Set the bias learning rate
+ ** @param self object
+ ** @param rate bias learning rate (positive).
+ **
+ ** This parameter applies only to the SGD solver.
+ **/
+
+void vl_svm_set_bias_learning_rate (VlSvm *self, double rate)
+{
+  assert(self) ;
+  assert(rate > 0) ;
+  self->biasLearningRate = rate ;
+}
+
+/** @brief Get the bias leraning rate.
+ ** @param self object
+ ** @return bias learning rate.
+ **/
+
+double vl_svm_get_bias_learning_rate (VlSvm const *self)
+{
+  assert(self) ;
+  return self->biasLearningRate ;
+}
+
+/** @brief Set the bias multiplier.
+ ** @param self object
+ ** @param b bias multiplier.
+ **
+ ** The *bias multiplier* is the value of the constant feature
+ ** appended to the data vectors to implement the bias (@ref svm-bias).
+ **/
+
+void vl_svm_set_bias_multiplier (VlSvm * self, double b)
+{
+  assert(self) ;
+  assert(b >= 0) ;
+  self->biasMultiplier = b ;
+}
+
+/** @brief Get the bias multiplier.
+ ** @param self object.
+ ** @return bias multiplier.
+ **/
+
+double vl_svm_get_bias_multiplier (VlSvm const * self)
+{
+  assert(self) ;
+  return self->biasMultiplier ;
+}
+
+/** @brief Set the current iteratio number.
+ ** @param self object.
+ ** @param n iteration number.
+ **
+ ** If called before training,
+ ** this can be used with SGD for a warm start, as the net
+ ** effect is to slow down the learning rate.
+ **/
+
+void vl_svm_set_iteration_number (VlSvm *self, vl_uindex n)
+{
+  assert(self) ;
+  self->iteration = n ;
+}
+
+/** @brief Get the current iteration number.
+ ** @param self object.
+ ** @return current iteration number.
+ **/
+
+vl_size vl_svm_get_iteration_number (VlSvm const *self)
+{
+  assert(self) ;
+  return self->iteration ;
+}
+
+/** @brief Set the maximum number of iterations.
+ ** @param self object.
+ ** @param n maximum number of iterations.
+ **/
+
+void vl_svm_set_max_num_iterations (VlSvm *self, vl_size n)
+{
+  assert(self) ;
+  self->maxNumIterations = n ;
+}
+
+/** @brief Get the maximum number of iterations.
+ ** @param self object.
+ ** @return maximum number of iterations.
+ **/
+
+vl_size vl_svm_get_max_num_iterations (VlSvm const *self)
+{
+  assert(self) ;
+  return self->maxNumIterations ;
+}
+
+/** @brief Set the diagnostic frequency.
+ ** @param self object.
+ ** @param f diagnostic frequency (@c >= 1).
+ **
+ ** A diagnostic round (to test for convergence and to printout
+ ** information) is performed every @a f iterations.
+ **/
+
+void vl_svm_set_diagnostic_frequency (VlSvm *self, vl_size f)
+{
+  assert(self) ;
+  assert(f > 0) ;
+  self->diagnosticFrequency = f ;
+}
+
+/** @brief Get the diagnostic frequency.
+ ** @param self object.
+ ** @return diagnostic frequency.
+ **/
+
+vl_size vl_svm_get_diagnostic_frequency (VlSvm const *self)
+{
+  assert(self) ;
+  return self->diagnosticFrequency ;
+}
+
+/** @brief Get the SVM solver type.
+ ** @param self object.
+ ** @return SVM solver type.
+ **/
+
+VlSvmSolverType vl_svm_get_solver (VlSvm const * self)
+{
+  assert(self) ;
+  return self->solver ;
+}
+
+/** @brief Set the regularizer parameter lambda.
+ ** @param self object.
+ ** @param lambda regularizer parameter.
+ **
+ ** Note that @a lambda is usually set when calling a
+ ** constructor for ::VlSvm as certain parameters, such
+ ** as the maximum number of iterations, are tuned accordingly.
+ ** This tuning is not performed when @a lambda is changed
+ ** using this function.
+ **/
+
+void vl_svm_set_lambda (VlSvm * self, double lambda)
+{
+  assert(self) ;
+  assert(lambda >= 0) ;
+  self->lambda = lambda ;
+}
+
+/** @brief Get the regularizer parameter lambda.
+ ** @param self object.
+ ** @return diagnostic frequency.
+ **/
+
+double vl_svm_get_lambda (VlSvm const * self)
+{
+  assert(self) ;
+  return self->lambda ;
+}
+
+/** @brief Set the data weights.
+ ** @param self object.
+ ** @param weights data weights.
+ **
+ ** @a weights must be an array of non-negative weights.
+ ** The loss of each data point is multiplied by the corresponding
+ ** weight.
+ **
+ ** Set @a weights to @c NULL to weight the data uniformly by 1 (default).
+ **
+ ** Note that the @a weights array is *not* copied and must be valid
+ ** througout the object lifetime (unless it is replaced).
+ **/
+
+void vl_svm_set_weights (VlSvm * self, double const *weights)
+{
+  assert(self) ;
+  self->weights = weights ;
+}
+
+/** @brief Get the data weights.
+ ** @param self object.
+ ** @return data weights.
+ **/
+
+double const *vl_svm_get_weights (VlSvm const * self)
+{
+  assert(self) ;
+  return self->weights ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                         Get data */
+/* ---------------------------------------------------------------- */
+
+/** @brief Get the model dimenison.
+ ** @param self object.
+ ** @return model dimension.
+ **
+ ** This is the dimensionality of the weight vector $\bw$.
+ **/
+
+vl_size vl_svm_get_dimension (VlSvm *self)
+{
+  assert(self) ;
+  return self->dimension ;
+}
+
+/** @brief Get the number of data samples.
+ ** @param self object.
+ ** @return model number of data samples
+ **
+ ** This is the dimensionality of the weight vector $\bw$.
+ **/
+
+vl_size vl_svm_get_num_data (VlSvm *self)
+{
+  assert(self) ;
+  return self->numData ;
+}
+
+/** @brief Get the SVM model.
+ ** @param self object.
+ ** @return model.
+ **
+ ** This is the weight vector $\bw$.
+ **/
+
+double const * vl_svm_get_model (VlSvm const *self)
+{
+  assert(self) ;
+  return self->model ;
+}
+
+/** @brief Set the SVM model.
+ ** @param self object.
+ ** @param model model.
+ **
+ ** The function *copies* the content of the vector @a model to the
+ ** internal model buffer. This operation can be used for warm start
+ ** with the SGD algorithm, but has undefined effect with the SDCA algorithm.
+ **/
+
+void vl_svm_set_model (VlSvm *self, double const *model)
+{
+  assert(self) ;
+  assert(model) ;
+  memcpy(self->model, model, sizeof(double) * vl_svm_get_dimension(self)) ;
+}
+
+/** @brief Set the SVM bias.
+ ** @param self object.
+ ** @param b bias.
+ **
+ ** The function set the internal representation of the SVM bias to
+ ** be equal to @a b (the bias multiplier
+ ** is applied). The same remark
+ ** that applies to ::vl_svm_set_model applies here too.
+ **/
+
+void vl_svm_set_bias (VlSvm *self, double b)
+{
+  assert(self);
+  if (self->biasMultiplier) {
+    self->bias = b / self->biasMultiplier ;
+  }
+}
+
+/** @brief Get the value of the bias.
+ ** @param self object.
+ ** @return bias $b$.
+ **
+ ** The value of the bias returned already include the effect of
+ ** bias mutliplier.
+ **/
+
+double vl_svm_get_bias (VlSvm const *self)
+{
+  assert(self) ;
+  return self->bias * self->biasMultiplier ;
+}
+
+/** @brief Get the solver statistics.
+ ** @param self object.
+ ** @return statistics.
+ **/
+
+VlSvmStatistics const * vl_svm_get_statistics (VlSvm const *self)
+{
+  assert(self) ;
+  return &self->statistics ;
+}
+
+/** @brief Get the scores of the data points.
+ ** @param self object.
+ ** @return vector of scores.
+ **
+ ** After training or during the diagnostic callback,
+ ** this function can be used to retrieve the scores
+ ** of the points, i.e. $\langle \bx_i, \bw \rangle + b$.
+ **/
+
+double const * vl_svm_get_scores (VlSvm const *self)
+{
+  return self->scores ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                        Callbacks */
+/* ---------------------------------------------------------------- */
+
+/** @typedef VlSvmDiagnosticFunction
+ ** @brief SVM diagnostic function pointer.
+ ** @param svm is an instance of ::VlSvm .
+ **/
+
+/** @typedef VlSvmAccumulateFunction
+ ** @brief Pointer to a function that adds to @a model the data point at
+ ** position @a element multiplied by the constant @a multiplier.
+ **/
+
+/** @typedef VlSvmInnerProductFunction
+ ** @brief Pointer to a function that defines the inner product
+ ** between the data point at position @a element and the SVM model
+ **/
+
+/** @brief Set the diagnostic function callback
+ ** @param self object.
+ ** @param f diagnostic function pointer.
+ ** @param data pointer to data used by the diagnostic function.
+ **/
+
+void
+vl_svm_set_diagnostic_function (VlSvm *self, VlSvmDiagnosticFunction f, void *data) {
+  self->diagnosticFn = f ;
+  self->diagnosticFnData = data ;
+}
+
+/** @brief Set the data functions.
+ ** @param self object.
+ ** @param inner inner product function.
+ ** @param acc accumulate function.
+ **
+ ** See @ref svm-data-abstraction.
+ **/
+
+void vl_svm_set_data_functions (VlSvm *self, VlSvmInnerProductFunction inner, VlSvmAccumulateFunction acc)
+{
+  assert(self) ;
+  assert(inner) ;
+  assert(acc) ;
+  self->innerProductFn = inner ;
+  self->accumulateFn = acc ;
+}
+
+/** @brief Set the loss function callback.
+ ** @param self object.
+ ** @param f loss function callback.
+ **
+ ** Note that setting up a loss requires specifying more than just one
+ ** callback. See @ref svm-loss-functions for details.
+ **/
+
+void vl_svm_set_loss_function (VlSvm *self, VlSvmLossFunction f)
+{
+  assert(self) ;
+  self->lossFn = f ;
+}
+
+/** @brief Set the loss derivative function callback.
+ ** @copydetails vl_svm_set_loss_function.
+ **/
+
+void vl_svm_set_loss_derivative_function (VlSvm *self, VlSvmLossFunction f)
+{
+  assert(self) ;
+  self->lossDerivativeFn = f ;
+}
+
+/** @brief Set the conjugate loss function callback.
+ ** @copydetails vl_svm_set_loss_function.
+ **/
+
+void vl_svm_set_conjugate_loss_function (VlSvm *self, VlSvmLossFunction f)
+{
+  assert(self) ;
+  self->conjugateLossFn = f ;
+}
+
+/** @brief Set the DCA update function callback.
+ ** @copydetails vl_svm_set_loss_function.
+ **/
+
+void vl_svm_set_dca_update_function (VlSvm *self, VlSvmDcaUpdateFunction f)
+{
+  assert(self) ;
+  self->dcaUpdateFn = f ;
+}
+
+/** @brief Set the loss function to one of the default types.
+ ** @param self object.
+ ** @param loss type of loss function.
+ ** @sa @ref svm-loss-functions.
+ **/
+
+void
+vl_svm_set_loss (VlSvm *self, VlSvmLossType loss)
+{
+#define SETLOSS(x,y) \
+case VlSvmLoss ## x: \
+  vl_svm_set_loss_function(self, vl_svm_ ## y ## _loss) ; \
+  vl_svm_set_loss_derivative_function(self, vl_svm_ ## y ## _loss_derivative) ; \
+  vl_svm_set_conjugate_loss_function(self, vl_svm_ ## y ## _conjugate_loss) ; \
+  vl_svm_set_dca_update_function(self, vl_svm_ ## y ## _dca_update) ; \
+  break;
+
+  switch (loss) {
+      SETLOSS(Hinge, hinge) ;
+      SETLOSS(Hinge2, hinge2) ;
+      SETLOSS(L1, l1) ;
+      SETLOSS(L2, l2) ;
+      SETLOSS(Logistic, logistic) ;
+    default:
+      assert(0) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                               Pre-defined losses */
+/* ---------------------------------------------------------------- */
+
+/** @typedef VlSvmLossFunction
+ ** @brief SVM loss function pointer.
+ ** @param inner inner product between sample and model $\bw^\top \bx$.
+ ** @param label sample label $y$.
+ ** @return value of the loss.
+ **
+ ** The interface is the same for a loss function, its derivative,
+ ** or the conjugate loss.
+ **
+ ** @sa @ref svm-fundamentals
+ **/
+
+/** @typedef VlSvmDcaUpdateFunction
+ ** @brief SVM SDCA update function pointer.
+ ** @param alpha current value of the dual variable.
+ ** @param inner inner product $\bw^\top \bx$ of the sample with the SVM model.
+ ** @param norm2 normalization factor $\|\bx\|^2/\lambda n$.
+ ** @param label label $y$ of the sample.
+ ** @return incremental update $\Delta\alpha$ of the dual variable.
+ **
+ ** @sa @ref svm-sdca
+ **/
+
+/** @brief SVM hinge loss
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_hinge_loss (double inner, double label)
+{
+  return VL_MAX(1 - label * inner, 0.0);
+}
+
+/** @brief SVM hinge loss derivative
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_hinge_loss_derivative (double inner, double label)
+{
+  if (label * inner < 1.0) {
+    return - label ;
+  } else {
+    return 0.0 ;
+  }
+}
+
+/** @brief SVM hinge loss conjugate
+ ** @param u dual variable.
+ ** @param label label value.
+ ** @return conjugate loss.
+ **/
+double
+vl_svm_hinge_conjugate_loss (double u, double label) {
+  double z = label * u ;
+  if (-1 <= z && z <= 0) {
+    return label * u ;
+  } else {
+    return VL_INFINITY_D ;
+  }
+}
+
+/** @brief SVM hinge loss DCA update
+ ** @copydetails VlSvmDcaUpdateFunction */
+double
+vl_svm_hinge_dca_update (double alpha, double inner, double norm2, double label) {
+  double palpha = (label - inner) / norm2 + alpha ;
+  return label * VL_MAX(0, VL_MIN(1, label * palpha)) - alpha ;
+}
+
+/** @brief SVM square hinge loss
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_hinge2_loss (double inner,double label)
+{
+  double z = VL_MAX(1 - label * inner, 0.0) ;
+  return z*z ;
+}
+
+/** @brief SVM square hinge loss derivative
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_hinge2_loss_derivative (double inner, double label)
+{
+  if (label * inner < 1.0) {
+    return 2 * (inner - label) ;
+  } else {
+    return 0 ;
+  }
+}
+
+/** @brief SVM square hinge loss conjugate
+ ** @copydetails vl_svm_hinge_conjugate_loss */
+double
+vl_svm_hinge2_conjugate_loss (double u, double label) {
+  if (label * u <= 0) {
+    return (label + u/4) * u ;
+  } else {
+    return VL_INFINITY_D ;
+  }
+}
+
+/** @brief SVM square hinge loss DCA update
+ ** @copydetails VlSvmDcaUpdateFunction */
+double
+vl_svm_hinge2_dca_update (double alpha, double inner, double norm2, double label) {
+  double palpha = (label - inner - 0.5*alpha) / (norm2 + 0.5) + alpha ;
+  return label * VL_MAX(0, label * palpha) - alpha ;
+}
+
+/** @brief SVM l1 loss
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_l1_loss (double inner,double label)
+{
+  return vl_abs_d(label - inner) ;
+}
+
+/** @brief SVM l1 loss derivative
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_l1_loss_derivative (double inner, double label)
+{
+  if (label > inner) {
+    return - 1.0 ;
+  } else {
+    return + 1.0 ;
+  }
+}
+
+/** @brief SVM l1 loss conjugate
+ ** @copydetails vl_svm_hinge_conjugate_loss */
+double
+vl_svm_l1_conjugate_loss (double u, double label) {
+  if (vl_abs_d(u) <= 1) {
+    return label*u ;
+  } else {
+    return VL_INFINITY_D ;
+  }
+}
+
+/** @brief SVM l1 loss DCA update
+ ** @copydetails VlSvmDcaUpdateFunction */
+double
+vl_svm_l1_dca_update (double alpha, double inner, double norm2, double label) {
+  if (vl_abs_d(alpha) <= 1) {
+    double palpha = (label - inner) / norm2 + alpha ;
+    return VL_MAX(-1.0, VL_MIN(1.0, palpha)) - alpha ;
+  } else {
+    return VL_INFINITY_D ;
+  }
+}
+
+/** @brief SVM l2 loss
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_l2_loss (double inner,double label)
+{
+  double z = label - inner ;
+  return z*z ;
+}
+
+/** @brief SVM l2 loss derivative
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_l2_loss_derivative (double inner, double label)
+{
+  return - 2 * (label - inner) ;
+}
+
+/** @brief SVM l2 loss conjugate
+ ** @copydetails vl_svm_hinge_conjugate_loss */
+double
+vl_svm_l2_conjugate_loss (double u, double label) {
+  return (label + u/4) * u ;
+}
+
+/** @brief SVM l2 loss DCA update
+ ** @copydetails VlSvmDcaUpdateFunction */
+double
+vl_svm_l2_dca_update (double alpha, double inner, double norm2, double label) {
+  return (label - inner - 0.5*alpha) / (norm2 + 0.5) ;
+}
+
+/** @brief SVM l2 loss
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_logistic_loss (double inner,double label)
+{
+  double z = label * inner ;
+  if (z >= 0) {
+    return log(1.0 + exp(-z)) ;
+  } else {
+    return -z + log(exp(z) + 1.0) ;
+  }
+}
+
+/** @brief SVM l2 loss derivative
+ ** @copydetails VlSvmLossFunction */
+double
+vl_svm_logistic_loss_derivative (double inner, double label)
+{
+  double z = label * inner ;
+  double t = 1 / (1 + exp(-z)) ; /* this is stable for z << 0 too */
+  return label * (t - 1) ; /*  = -label exp(-z) / (1 + exp(-z)) */
+}
+
+VL_INLINE double xlogx(double x)
+{
+  if (x <= 1e-10) return 0 ;
+  return x*log(x) ;
+}
+
+/** @brief SVM l2 loss conjugate
+ ** @copydetails vl_svm_hinge_conjugate_loss */
+double
+vl_svm_logistic_conjugate_loss (double u, double label) {
+  double z = label * u ;
+  if (-1 <= z && z <= 0) {
+    return xlogx(-z) + xlogx(1+z) ;
+  } else {
+    return VL_INFINITY_D ;
+  }
+}
+
+/** @brief SVM l2 loss DCA update
+ ** @copydetails VlSvmDcaUpdateFunction */
+double
+vl_svm_logistic_dca_update (double alpha, double inner, double norm2, double label) {
+  /*
+   The goal is to solve the problem
+
+   min_delta A/2 delta^2 + B delta + l*(-alpha - delta|y),  -1 <= - y (alpha+delta) <= 0
+
+   where A = norm2, B = inner, and y = label. To simplify the notation, we set
+
+     f(beta) = beta * log(beta) + (1 - beta) * log(1 - beta)
+
+   where beta = y(alpha + delta) such that
+
+     l*(-alpha - delta |y) = f(beta).
+
+   Hence 0 <= beta <= 1, delta = + y beta - alpha. Substituting
+
+     min_beta A/2 beta^2 + y (B - A alpha) beta + f(beta) + const
+
+   The Newton step is then given by
+
+     beta = beta - (A beta + y(B - A alpha) + df) / (A + ddf).
+
+   However, the function is singluar for beta=0 and beta=1 (infinite
+   first and second order derivatives). Since the function is monotonic
+   (second derivarive always strictly greater than zero) and smooth,
+   we canuse bisection to find the zero crossing of the first derivative.
+   Once one is sufficiently close to the optimum, a one or two Newton
+   steps are sufficien to land on it with excellent accuracy.
+   */
+
+  double  df, ddf, der, dder ;
+  vl_index t ;
+
+  /* bisection */
+  double beta1 = 0 ;
+  double beta2 = 1 ;
+  double beta = 0.5 ;
+
+  for (t = 0 ; t < 5 ; ++t) {
+    df = log(beta) - log(1-beta) ;
+    der = norm2 * beta + label * (inner - norm2*alpha) + df ;
+    if (der >= 0) {
+      beta2 = beta ;
+    } else {
+      beta1 = beta ;
+    }
+    beta = 0.5 * (beta1 + beta2) ;
+  }
+
+#if 1
+  /* a final Newton step, but not too close to the singularities */
+  for (t = 0 ; (t < 2) & (beta > VL_EPSILON_D) & (beta < 1-VL_EPSILON_D) ; ++t) {
+    df = log(beta) - log(1-beta) ;
+    ddf = 1 / (beta * (1-beta)) ;
+    der = norm2 * beta + label * (inner - norm2*alpha) + df ;
+    dder = norm2 + ddf ;
+    beta -= der / dder ;
+    beta = VL_MAX(0, VL_MIN(1, beta)) ;
+  }
+#endif
+
+  return label * beta - alpha ;
+}
+
+/* ---------------------------------------------------------------- */
+
+/** @internal @brief Update SVM statistics
+ ** @param self object.
+ **/
+
+void _vl_svm_update_statistics (VlSvm *self)
+{
+  vl_size i, k ;
+  double inner, p ;
+
+  memset(&self->statistics, 0, sizeof(VlSvmStatistics)) ;
+
+  self->statistics.regularizer = self->bias * self->bias ;
+  for (i = 0; i < self->dimension; i++) {
+    self->statistics.regularizer += self->model[i] * self->model[i] ;
+  }
+  self->statistics.regularizer *= self->lambda * 0.5 ;
+
+  for (k = 0; k < self->numData ; k++) {
+    p = (self->weights) ? self->weights[k] : 1.0 ;
+    if (p <= 0) continue ;
+    inner = self->innerProductFn(self->data, k, self->model) ;
+    inner += self->bias * self->biasMultiplier ;
+    self->scores[k] = inner ;
+    self->statistics.loss += p * self->lossFn(inner, self->labels[k]) ;
+    if (self->solver == VlSvmSolverSdca) {
+
+      self->statistics.dualLoss -= p * self->conjugateLossFn(- self->alpha[k] / p, self->labels[k]) ;
+    }
+  }
+
+  self->statistics.loss /= self->numData ;
+  self->statistics.objective = self->statistics.regularizer + self->statistics.loss ;
+
+  if (self->solver == VlSvmSolverSdca) {
+    self->statistics.dualLoss /= self->numData ;
+    self->statistics.dualObjective = - self->statistics.regularizer + self->statistics.dualLoss ;
+    self->statistics.dualityGap = self->statistics.objective - self->statistics.dualObjective ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                                       Evaluate rather than solve */
+/* ---------------------------------------------------------------- */
+
+void _vl_svm_evaluate (VlSvm *self)
+{
+  double startTime = vl_get_cpu_time () ;
+
+  _vl_svm_update_statistics (self) ;
+
+  self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
+  self->statistics.iteration = 0 ;
+  self->statistics.epoch = 0 ;
+  self->statistics.status = VlSvmStatusConverged ;
+
+  if (self->diagnosticFn) {
+    self->diagnosticFn(self, self->diagnosticFnData) ;
+  }
+}
+
+/* ---------------------------------------------------------------- */
+/*                         Stochastic Dual Coordinate Ascent Solver */
+/* ---------------------------------------------------------------- */
+
+void _vl_svm_sdca_train (VlSvm *self)
+{
+  double * norm2 ;
+  vl_index * permutation ;
+  vl_uindex i, t  ;
+  double inner, delta, multiplier, p ;
+
+  double startTime = vl_get_cpu_time () ;
+  VlRand * rand = vl_get_rand() ;
+
+  norm2 = (double*) vl_calloc(self->numData, sizeof(double));
+  permutation = vl_calloc(self->numData, sizeof(vl_index)) ;
+
+  {
+    double * buffer = vl_calloc(self->dimension, sizeof(double)) ;
+    for (i = 0 ; i < (unsigned)self->numData; i++) {
+      double n2 ;
+      permutation [i] = i ;
+      memset(buffer, 0, self->dimension * sizeof(double)) ;
+      self->accumulateFn (self->data, i, buffer, 1) ;
+      n2 = self->innerProductFn (self->data, i, buffer) ;
+      n2 += self->biasMultiplier * self->biasMultiplier ;
+      norm2[i] = n2 / (self->lambda * self->numData) ;
+    }
+    vl_free(buffer) ;
+  }
+
+  for (t = 0 ; 1 ; ++t) {
+
+    if (t % self->numData == 0) {
+      /* once a new epoch is reached (all data have been visited),
+       change permutation */
+      vl_rand_permute_indexes(rand, permutation, self->numData) ;
+    }
+
+    /* pick a sample and compute update */
+    i = permutation[t % self->numData] ;
+    p = (self->weights) ? self->weights[i] : 1.0 ;
+    if (p > 0) {
+      inner = self->innerProductFn(self->data, i, self->model) ;
+      inner += self->bias * self->biasMultiplier ;
+      delta = p * self->dcaUpdateFn(self->alpha[i] / p, inner, p * norm2[i], self->labels[i]) ;
+    } else {
+      delta = 0 ;
+    }
+
+    /* apply update */
+    if (delta != 0) {
+      self->alpha[i] += delta ;
+      multiplier = delta / (self->numData * self->lambda) ;
+      self->accumulateFn(self->data,i,self->model,multiplier) ;
+      self->bias += self->biasMultiplier * multiplier;
+    }
+
+    /* call diagnostic occasionally */
+    if ((t + 1) % self->diagnosticFrequency == 0 || t + 1 == self->maxNumIterations) {
+      _vl_svm_update_statistics (self) ;
+      self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
+      self->statistics.iteration = t ;
+      self->statistics.epoch = t / self->numData ;
+
+      self->statistics.status = VlSvmStatusTraining ;
+      if (self->statistics.dualityGap < self->epsilon) {
+        self->statistics.status = VlSvmStatusConverged ;
+      }
+      else if (t + 1 == self->maxNumIterations) {
+        self->statistics.status = VlSvmStatusMaxNumIterationsReached ;
+      }
+
+      if (self->diagnosticFn) {
+        self->diagnosticFn(self, self->diagnosticFnData) ;
+      }
+
+      if (self->statistics.status != VlSvmStatusTraining) {
+        break ;
+      }
+    }
+  } /* next iteration */
+
+  vl_free (norm2) ;
+  vl_free (permutation) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                               Stochastic Gradient Descent Solver */
+/* ---------------------------------------------------------------- */
+
+void _vl_svm_sgd_train (VlSvm *self)
+{
+  vl_index * permutation ;
+  double * scores ;
+  double * previousScores ;
+  vl_uindex i, t, k ;
+  double inner, gradient, rate, biasRate, p ;
+  double factor = 1.0 ;
+  double biasFactor = 1.0 ; /* to allow slower bias learning rate */
+  vl_index t0 = VL_MAX(2, vl_ceil_d(1.0 / self->lambda)) ;
+  //t0=2 ;
+
+  double startTime = vl_get_cpu_time () ;
+  VlRand * rand = vl_get_rand() ;
+
+  permutation = vl_calloc(self->numData, sizeof(vl_index)) ;
+  scores = vl_calloc(self->numData * 2, sizeof(double)) ;
+  previousScores = scores + self->numData ;
+
+  for (i = 0 ; i < (unsigned)self->numData; i++) {
+    permutation [i] = i ;
+    previousScores [i] = - VL_INFINITY_D ;
+  }
+
+  /*
+   We store the w vector as the product fw (factor * model).
+   We also use a different factor for the bias: biasFactor * biasMultiplier
+   to enable a slower learning rate for the bias.
+
+   Given this representation, it is easy to carry the two key operations:
+
+   * Inner product: <fw,x> = f <w,x>
+
+   * Model update: fp wp = fw - rate * lambda * w - rate * g
+                         = f(1 - rate * lambda) w - rate * g
+
+     Thus the update equations are:
+
+                   fp = f(1 - rate * lambda), and
+                   wp = w + rate / fp * g ;
+
+   * Realization of the scaling factor. Before the statistics function
+     is called, or training finishes, the factor (and biasFactor)
+     are explicitly applied to the model and the bias.
+  */
+
+  for (t = 0 ; 1 ; ++t) {
+
+    if (t % self->numData == 0) {
+      /* once a new epoch is reached (all data have been visited),
+       change permutation */
+      vl_rand_permute_indexes(rand, permutation, self->numData) ;
+    }
+
+    /* pick a sample and compute update */
+    i = permutation[t % self->numData] ;
+    p = (self->weights) ? self->weights[i] : 1.0 ;
+    p = VL_MAX(0.0, p) ; /* we assume non-negative weights, so this is just for robustness */
+    inner = factor * self->innerProductFn(self->data, i, self->model) ;
+    inner += biasFactor * (self->biasMultiplier * self->bias) ;
+    gradient = p * self->lossDerivativeFn(inner, self->labels[i]) ;
+    previousScores[i] = scores[i] ;
+    scores[i] = inner ;
+
+    /* apply update */
+    rate = 1.0 /  (self->lambda * (t + t0)) ;
+    biasRate = rate * self->biasLearningRate ;
+    factor *= (1.0 - self->lambda * rate) ;
+    biasFactor *= (1.0 - self->lambda * biasRate) ;
+
+    /* debug: realize the scaling factor all the times */
+    /*
+    for (k = 0 ; k < self->dimension ; ++k) self->model[k] *= factor ;
+    self->bias *= biasFactor;
+    factor = 1.0 ;
+    biasFactor = 1.0 ;
+    */
+
+    if (gradient != 0) {
+      self->accumulateFn(self->data, i, self->model, - gradient * rate / factor) ;
+      self->bias += self->biasMultiplier * (- gradient * biasRate / biasFactor) ;
+    }
+
+    /* call diagnostic occasionally */
+    if ((t + 1) % self->diagnosticFrequency == 0 || t + 1 == self->maxNumIterations) {
+
+      /* realize factor before computing statistics or completing training */
+      for (k = 0 ; k < self->dimension ; ++k) self->model[k] *= factor ;
+      self->bias *= biasFactor;
+      factor = 1.0 ;
+      biasFactor = 1.0 ;
+
+      _vl_svm_update_statistics (self) ;
+
+      for (k = 0 ; k < self->numData ; ++k) {
+        double delta = scores[k] - previousScores[k] ;
+        self->statistics.scoresVariation += delta * delta ;
+      }
+      self->statistics.scoresVariation = sqrt(self->statistics.scoresVariation) / self->numData ;
+
+      self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
+      self->statistics.iteration = t ;
+      self->statistics.epoch = t / self->numData ;
+
+      self->statistics.status = VlSvmStatusTraining ;
+      if (self->statistics.scoresVariation < self->epsilon) {
+        self->statistics.status = VlSvmStatusConverged ;
+      }
+      else if (t + 1 == self->maxNumIterations) {
+        self->statistics.status = VlSvmStatusMaxNumIterationsReached ;
+      }
+
+      if (self->diagnosticFn) {
+        self->diagnosticFn(self, self->diagnosticFnData) ;
+      }
+
+      if (self->statistics.status != VlSvmStatusTraining) {
+        break ;
+      }
+    }
+  } /* next iteration */
+
+  vl_free (scores) ;
+  vl_free (permutation) ;
+}
+
+/* ---------------------------------------------------------------- */
+/*                                                       Dispatcher */
+/* ---------------------------------------------------------------- */
+
+/** @brief Run the SVM solver
+ ** @param self object.
+ **
+ ** The data on which the SVM operates is passed upon the cration of
+ ** the ::VlSvm object. This function runs a solver to learn a
+ ** corresponding model. See @ref svm-starting.
+ **/
+
+void vl_svm_train (VlSvm * self)
+{
+  assert (self) ;
+  switch (self->solver) {
+    case VlSvmSolverSdca:
+      _vl_svm_sdca_train(self) ;
+      break ;
+    case VlSvmSolverSgd:
+      _vl_svm_sgd_train(self) ;
+      break ;
+    case VlSvmSolverNone:
+      _vl_svm_evaluate(self) ;
+      break ;
+    default:
+      assert(0) ;
+  }
+}
diff --git a/opensfm/src/third_party/vlfeat/vl/svm.h b/opensfm/src/third_party/vlfeat/vl/svm.h
new file mode 100644
index 000000000..1fcc6d474
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/svm.h
@@ -0,0 +1,195 @@
+/** @file svm.h
+ ** @brief Support Vector Machines (@ref svm)
+ ** @author Milan Sulc
+ ** @author Daniele Perrone
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 Milan Sulc.
+Copyright (C) 2012 Daniele Perrone.
+Copyright (C) 2011-13 Andrea Vedaldi.
+
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_SVM_H
+#define VL_SVM_H
+
+#include "generic.h"
+#include "svmdataset.h"
+
+/** @typedef VlSvm
+ ** @brief SVM solver.
+ ** This object implements VLFeat SVM solvers (see @ref svm.h).
+ **/
+
+#ifndef __DOXYGEN__
+struct VlSvm_ ;
+typedef struct VlSvm_ VlSvm ;
+#else
+typedef OPAQUE VlSvm ;
+#endif
+
+/** @brief Type of SVM solver */
+typedef enum
+{
+  VlSvmSolverNone = 0, /**< No solver (used to evaluate an SVM). */
+  VlSvmSolverSgd = 1,  /**< SGD algorithm (@ref svm-sgd). */
+  VlSvmSolverSdca      /**< SDCA algorithm (@ref svm-sdca). */
+} VlSvmSolverType ;
+
+/** @brief Type of SVM loss
+ **
+ ** Default SVM loss types. The loss can be set by using ::vl_svm_set_loss.
+ ** Note that custom losses can be used too by using ::vl_svm_set_loss_function,
+ ** ::vl_svm_set_loss_derivative_function, etc.
+ **
+ ** @sa svm-loss-functions
+ **/
+typedef enum
+{
+  VlSvmLossHinge = 0,   /**< Standard hinge loss. */
+  VlSvmLossHinge2 = 1,  /**< Hinge loss squared. */
+  VlSvmLossL1,          /**< L1 loss. */
+  VlSvmLossL2,          /**< L2 loss. */
+  VlSvmLossLogistic     /**< Logistic loss. */
+} VlSvmLossType ;
+
+/** @brief Solver status */
+typedef enum
+{
+  VlSvmStatusTraining = 1, /**< Optimization in progress. */
+  VlSvmStatusConverged, /**< Optimization finished because the convergence criterion was met. */
+  VlSvmStatusMaxNumIterationsReached /**< Optimization finished without convergence. */
+} VlSvmSolverStatus ;
+
+/** @brief SVM statistics
+ ** This structure contains statistics characterising the state of
+ ** the SVM solver, such as the current value of the objective function.
+ **
+ ** Not all fields are used by all solvers.
+ **/
+typedef struct VlSvmStatistics_ {
+  VlSvmSolverStatus status ;    /**< Solver status. */
+  vl_size iteration ;           /**< Solver iteration. */
+  vl_size epoch ;               /**< Solver epoch (iteration / num samples). */
+  double objective ;            /**< Objective function value. */
+  double regularizer ;          /**< Regularizer value. */
+  double loss ;                 /**< Loss value. */
+  double dualObjective ;        /**< Dual objective value. */
+  double dualLoss ;             /**< Dual loss value. */
+  double dualityGap ;           /**< Duality gap = objective - dualObjective. */
+  double scoresVariation ;      /**< Variance of the score updates. */
+  double elapsedTime ;          /**< Time elapsed from the start of training. */
+} VlSvmStatistics ;
+
+/** @name Create and destroy
+ ** @{ */
+VL_EXPORT VlSvm * vl_svm_new (VlSvmSolverType type,
+                              double const * data,
+                              vl_size dimension,
+                              vl_size numData,
+                              double const * labels,
+                              double lambda) ;
+
+VL_EXPORT VlSvm * vl_svm_new_with_dataset (VlSvmSolverType type,
+                                           VlSvmDataset * dataset,
+                                           double const * labels,
+                                           double lambda) ;
+
+VL_EXPORT VlSvm * vl_svm_new_with_abstract_data (VlSvmSolverType type,
+                                              void * data,
+                                              vl_size dimension,
+                                              vl_size numData,
+                                              double const * labels,
+                                              double lambda) ;
+
+VL_EXPORT void vl_svm_delete (VlSvm * self) ;
+/** @} */
+
+/** @name Retrieve parameters and data
+ ** @{ */
+VL_EXPORT VlSvmStatistics const * vl_svm_get_statistics (VlSvm const *self) ;
+VL_EXPORT double const * vl_svm_get_model (VlSvm const *self) ;
+VL_EXPORT double vl_svm_get_bias (VlSvm const *self) ;
+VL_EXPORT vl_size vl_svm_get_dimension (VlSvm *self) ;
+VL_EXPORT vl_size vl_svm_get_num_data (VlSvm *self) ;
+VL_EXPORT double vl_svm_get_epsilon (VlSvm const *self) ;
+VL_EXPORT double vl_svm_get_bias_learning_rate (VlSvm const *self) ;
+VL_EXPORT vl_size vl_svm_get_max_num_iterations (VlSvm const *self) ;
+VL_EXPORT vl_size vl_svm_get_diagnostic_frequency (VlSvm const *self) ;
+VL_EXPORT VlSvmSolverType vl_svm_get_solver (VlSvm const *self) ;
+VL_EXPORT double vl_svm_get_bias_multiplier (VlSvm const *self) ;
+VL_EXPORT double vl_svm_get_lambda (VlSvm const *self) ;
+VL_EXPORT vl_size vl_svm_get_iteration_number (VlSvm const *self) ;
+VL_EXPORT double const * vl_svm_get_scores (VlSvm const *self) ;
+VL_EXPORT double const * vl_svm_get_weights (VlSvm const *self) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{ */
+VL_EXPORT void vl_svm_set_epsilon (VlSvm *self, double epsilon) ;
+VL_EXPORT void vl_svm_set_bias_learning_rate (VlSvm *self, double rate) ;
+VL_EXPORT void vl_svm_set_max_num_iterations (VlSvm *self, vl_size maxNumIterations) ;
+VL_EXPORT void vl_svm_set_diagnostic_frequency (VlSvm *self, vl_size f) ;
+VL_EXPORT void vl_svm_set_bias_multiplier (VlSvm *self, double b) ;
+VL_EXPORT void vl_svm_set_model (VlSvm *self, double const *model) ;
+VL_EXPORT void vl_svm_set_bias (VlSvm *self, double b) ;
+VL_EXPORT void vl_svm_set_iteration_number (VlSvm *self, vl_uindex n) ;
+VL_EXPORT void vl_svm_set_weights (VlSvm *self, double const *weights) ;
+
+VL_EXPORT void vl_svm_set_diagnostic_function (VlSvm *self, VlSvmDiagnosticFunction f, void *data) ;
+VL_EXPORT void vl_svm_set_loss_function (VlSvm *self, VlSvmLossFunction f) ;
+VL_EXPORT void vl_svm_set_loss_derivative_function (VlSvm *self, VlSvmLossFunction f) ;
+VL_EXPORT void vl_svm_set_conjugate_loss_function (VlSvm *self, VlSvmLossFunction f) ;
+VL_EXPORT void vl_svm_set_dca_update_function (VlSvm *self, VlSvmDcaUpdateFunction f) ;
+VL_EXPORT void vl_svm_set_data_functions (VlSvm *self, VlSvmInnerProductFunction inner, VlSvmAccumulateFunction acc) ;
+VL_EXPORT void vl_svm_set_loss (VlSvm *self, VlSvmLossType loss) ;
+/** @} */
+
+/** @name Process data
+ ** @{ */
+VL_EXPORT void vl_svm_train (VlSvm * self) ;
+/** @} */
+
+/** @name Loss functions
+ ** @sa @ref svm-advanced
+ ** @{ */
+
+/* hinge */
+VL_EXPORT double vl_svm_hinge_loss (double label, double inner) ;
+VL_EXPORT double vl_svm_hinge_loss_derivative (double label, double inner) ;
+VL_EXPORT double vl_svm_hinge_conjugate_loss (double label, double u) ;
+VL_EXPORT double vl_svm_hinge_dca_update (double alpha, double inner, double norm2, double label) ;
+
+/* square hinge */
+VL_EXPORT double vl_svm_hinge2_loss (double label, double inner) ;
+VL_EXPORT double vl_svm_hinge2_loss_derivative (double label, double inner) ;
+VL_EXPORT double vl_svm_hinge2_conjugate_loss (double label, double u) ;
+VL_EXPORT double vl_svm_hinge2_dca_update (double alpha, double inner, double norm2, double label) ;
+
+/* l1 */
+VL_EXPORT double vl_svm_l1_loss (double label, double inner) ;
+VL_EXPORT double vl_svm_l1_loss_derivative (double label, double inner) ;
+VL_EXPORT double vl_svm_l1_conjugate_loss (double label, double u) ;
+VL_EXPORT double vl_svm_l1_dca_update (double alpha, double inner, double norm2, double label) ;
+
+/* l2 */
+VL_EXPORT double vl_svm_l2_loss (double label, double inner) ;
+VL_EXPORT double vl_svm_l2_loss_derivative (double label, double inner) ;
+VL_EXPORT double vl_svm_l2_conjugate_loss (double label, double u) ;
+VL_EXPORT double vl_svm_l2_dca_update (double alpha, double inner, double norm2, double label) ;
+
+/* logistic */
+VL_EXPORT double vl_svm_logistic_loss (double label, double inner) ;
+VL_EXPORT double vl_svm_logistic_loss_derivative (double label, double inner) ;
+VL_EXPORT double vl_svm_logistic_conjugate_loss (double label, double u) ;
+VL_EXPORT double vl_svm_logistic_dca_update (double alpha, double inner, double norm2, double label) ;
+/** } */
+
+/* VL_SVM_H */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svmdataset.c b/opensfm/src/third_party/vlfeat/vl/svmdataset.c
new file mode 100644
index 000000000..a4100d11c
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/svmdataset.c
@@ -0,0 +1,407 @@
+/** @file svmdataset.c
+ ** @brief SVM Dataset - Definition
+ ** @author Daniele Perrone
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2012 Daniele Perrone.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+@file svmdataset.h
+@tableofcontents
+@author Daniele Perrone
+@author Andrea Vedaldi
+
+The SVM solver object ::VlSvm, supporting SVM learning in VLFeat,
+uses an abstraction mechanism to work on arbitrary data types.
+This module provides an helper object, ::VlSvmDataset,
+that simplify taking advantage of this functionality, supporting for example
+different data types and the computation of feature maps out of the box.
+
+<!-- ------------------------------------------------------------- -->
+@section svmdataset-starting Getting started
+<!-- ------------------------------------------------------------- -->
+
+As discussed in @ref svm-advanced, most linear SVM solvers,
+such as the ones implemented in VLFeat in @ref svm, require only two
+operations to be defined on the data:
+
+- *Inner product* between a data point $\bx$ and the model vector $\bw$.
+  This is implemented by a function of type ::VlSvmInnerProductFunction.
+- *Accumulation* of a dataobint $\bx$ to the model vector $\bw$:
+  $\bw \leftarrow \bw + \alpha \bx$. This is implemented
+  by a function of the type ::VlSvmAccumulateFunction .
+
+The SVM solver needs to know nothing about the data once these two
+operations are defined. These functions can do any number of things,
+such as supporting different formats for the data (dense or sparse,
+float or double), computing feature maps, or expanding compressed
+representations such as Product Quantization.
+
+VLFeat provides the helper object ::VlSvmDataset to support some
+of these functionalities out of the box (it is important to remark
+that its use with the SVM solver ::VlSvm is entirely optional).
+
+Presently, ::VlSvmDataset supports:
+
+- @c float and @c double dense arrays.
+- The on-the-fly application of the homogeneous kernel map to implement
+  additive non-linear kernels (see @ref homkermap).
+
+For example, to learn a linear SVM on SINGLE data:
+
+@code
+int main()
+{
+  vl_size const numData = 4 ;
+  vl_size const dimension = 2 ;
+  single x [dimension * numData] = {
+    0.0, -0.5,
+    0.6, -0.3,
+    0.0,  0.5,
+    0.6,  0.0} ;
+  double y [numData] = {1, 1, -1, 1} ;
+  double lambda = 0.01;
+  double * const model ;
+  double bias ;
+
+  VlSvmDataset * dataset = vl_svmdataset_new (VL_TYPE_SINGLE, x, dimension, numData) ;
+  VlSvm * svm = vl_svm_new_with_dataset (VlSvmSolverSgd, dataset, y, lambda) ;
+
+  vl_svm_train(svm) ;
+
+  model = vl_svm_get_model(svm) ;
+  bias = vl_svm_get_bias(svm) ;
+
+  printf("model w = [ %f , %f ] , bias b = %f \n",
+         model[0],
+         model[1],
+         bias);
+
+  vl_svm_delete(svm) ;
+  vl_svmdataset_delete(dataset) ;
+  return 0;
+}
+@endcode
+
+**/
+
+/* ---------------------------------------------------------------- */
+#ifndef VL_SVMDATASET_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+#include "svmdataset.h"
+#include <string.h>
+#include <math.h>
+
+struct VlSvmDataset_ {
+  vl_type dataType ;                /**< Data type. */
+  void * data ;                     /**< Pointer to data. */
+  vl_size numData ;                 /**< Number of wrapped data. */
+  vl_size dimension ;               /**< Data point dimension. */
+  VlHomogeneousKernelMap * hom ;    /**< Homogeneous kernel map (optional). */
+  void * homBuffer ;                /**< Homogeneous kernel map buffer. */
+  vl_size homDimension ;            /**< Homogeneous kernel map dimension. */
+} ;
+
+/* templetized parts of the implementation */
+#define FLT VL_TYPE_FLOAT
+#define VL_SVMDATASET_INSTANTIATING
+#include "svmdataset.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define VL_SVMDATASET_INSTANTIATING
+#include "svmdataset.c"
+
+/** @brief Create a new object wrapping a dataset.
+ ** @param dataType of data (@c float and @c double supported).
+ ** @param data pointer to the data.
+ ** @param dimension the dimension of a data vector.
+ ** @param numData number of wrapped data vectors.
+ ** @return new object.
+ **
+ ** The function allocates and returns a new SVM dataset object
+ ** wrapping the data pointed by @a data. Note that no copy is made
+ ** of data, so the caller should keep the data allocated as the object exists.
+ **
+ ** @sa ::vl_svmdataset_delete
+ **/
+
+VlSvmDataset*
+vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData)
+{
+  VlSvmDataset * self ;
+  assert(dataType == VL_TYPE_DOUBLE || dataType == VL_TYPE_FLOAT) ;
+  assert(data) ;
+
+  self = vl_calloc(1, sizeof(VlSvmDataset)) ;
+  if (self == NULL) return NULL ;
+
+  self->dataType = dataType ;
+  self->data = data ;
+  self->dimension = dimension ;
+  self->numData = numData ;
+  self->hom = NULL ;
+  self->homBuffer = NULL ;
+  return self ;
+}
+
+/** @brief Delete the object.
+ ** @param self object to delete.
+ **
+ ** The function frees the resources allocated by
+ ** ::vl_svmdataset_new(). Notice that the wrapped data will *not*
+ ** be freed as it is not owned by the object.
+ **/
+
+void vl_svmdataset_delete (VlSvmDataset *self)
+{
+  if (self->homBuffer) {
+    vl_free(self->homBuffer) ;
+    self->homBuffer = 0 ;
+  }
+  vl_free (self) ;
+}
+
+/** @brief Get the wrapped data.
+ ** @param self object.
+ ** @return a pointer to the wrapped data.
+ **/
+
+void*
+vl_svmdataset_get_data (VlSvmDataset const *self)
+{
+  return self->data ;
+}
+
+/** @brief Get the number of wrapped data elements.
+ ** @param self object.
+ ** @return number of wrapped data elements.
+ **/
+
+vl_size
+vl_svmdataset_get_num_data (VlSvmDataset const *self)
+{
+  return self->numData ;
+}
+
+/** @brief Get the dimension of the wrapped data.
+ ** @param self object.
+ ** @return dimension of the wrapped data.
+ **/
+
+vl_size
+vl_svmdataset_get_dimension (VlSvmDataset const *self)
+{
+  if (self->hom) {
+    return self->dimension * vl_homogeneouskernelmap_get_dimension(self->hom) ;
+  }
+  return self->dimension ;
+}
+
+/** @brief Get the homogeneous kernel map object.
+ ** @param self object.
+ ** @return homogenoeus kernel map object (or @c NULL if any).
+ **/
+
+VlHomogeneousKernelMap *
+vl_svmdataset_get_homogeneous_kernel_map (VlSvmDataset const *self)
+{
+  assert(self) ;
+  return self->hom ;
+}
+
+/** @brief Set the homogeneous kernel map object.
+ ** @param self object.
+ ** @param hom homogeneous kernel map object to use.
+ **
+ ** After changing the kernel map, the inner product and accumulator
+ ** function should be queried again (::vl_svmdataset_get_inner_product_function
+ ** adn ::vl_svmdataset_get_accumulate_function).
+ **
+ ** Set this to @c NULL to avoid using a kernel map.
+ **
+ ** Note that this does *not* transfer the ownership of the object
+ ** to the function. Furthermore, ::VlSvmDataset holds to the
+ ** object until it is destroyed or the object is replaced or removed
+ ** by calling this function again.
+ **/
+
+void
+vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
+                                          VlHomogeneousKernelMap * hom)
+{
+  assert(self) ;
+  self->hom = hom ;
+  self->homDimension = 0 ;
+  if (self->homBuffer) {
+    vl_free (self->homBuffer) ;
+    self->homBuffer = 0 ;
+  }
+  if (self->hom) {
+    self->homDimension = vl_homogeneouskernelmap_get_dimension(self->hom) ;
+    self->homBuffer = vl_calloc(self->homDimension, vl_get_type_size(self->dataType)) ;
+  }
+}
+
+/** @brief Get the accumulate function
+ ** @param self object.
+ ** @return a pointer to the accumulate function to use with this data.
+ **/
+
+VlSvmAccumulateFunction
+vl_svmdataset_get_accumulate_function(VlSvmDataset const *self)
+{
+  if (self->hom == NULL) {
+    switch (self->dataType) {
+      case VL_TYPE_FLOAT:
+        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_f ;
+        break ;
+      case VL_TYPE_DOUBLE:
+        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_d ;
+        break ;
+    }
+  } else {
+    switch (self->dataType) {
+      case VL_TYPE_FLOAT:
+        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_f ;
+        break ;
+      case VL_TYPE_DOUBLE:
+        return (VlSvmAccumulateFunction) vl_svmdataset_accumulate_hom_d ;
+        break ;
+    }
+  }
+  assert(0) ;
+  return NULL ;
+}
+
+/** @brief Get the inner product function.
+ ** @param self object.
+ ** @return a pointer to the inner product function to use with this data.
+ **/
+
+VlSvmInnerProductFunction
+vl_svmdataset_get_inner_product_function (VlSvmDataset const *self)
+{
+  if (self->hom == NULL) {
+    switch (self->dataType) {
+      case VL_TYPE_FLOAT:
+        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_f ;
+        break ;
+      case VL_TYPE_DOUBLE:
+        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_d ;
+        break ;
+      default:
+        assert(0) ;
+    }
+  } else {
+    switch (self->dataType) {
+      case VL_TYPE_FLOAT:
+        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_f ;
+        break ;
+      case VL_TYPE_DOUBLE:
+        return (VlSvmInnerProductFunction) _vl_svmdataset_inner_product_hom_d ;
+        break ;
+      default:
+        assert(0) ;
+    }
+  }
+
+  return NULL;
+}
+
+/* VL_SVMDATASET_INSTANTIATING */
+#endif
+
+/* ---------------------------------------------------------------- */
+#ifdef VL_SVMDATASET_INSTANTIATING
+/* ---------------------------------------------------------------- */
+
+#include "float.h"
+
+double
+VL_XCAT(_vl_svmdataset_inner_product_,SFX) (VlSvmDataset const *self,
+                                            vl_uindex element,
+                                            double const *model)
+{
+  double product = 0 ;
+  T* data = ((T*)self->data) + self->dimension * element ;
+  T* end = data + self->dimension ;
+  while (data != end) {
+    product += (*data++) * (*model++) ;
+  }
+  return product ;
+}
+
+void
+VL_XCAT(vl_svmdataset_accumulate_,SFX)(VlSvmDataset const *self,
+                                       vl_uindex element,
+                                       double *model,
+                                       const double multiplier)
+{
+  T* data = ((T*)self->data) + self->dimension * element ;
+  T* end = data + self->dimension ;
+  while (data != end) {
+    *model += (*data++) * multiplier ;
+    model++ ;
+  }
+}
+
+double
+VL_XCAT(_vl_svmdataset_inner_product_hom_,SFX) (VlSvmDataset const *self,
+                                                vl_uindex element,
+                                                double const *model)
+{
+  double product = 0 ;
+  T* data = ((T*)self->data) + self->dimension * element ;
+  T* end = data + self->dimension ;
+  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
+  while (data != end) {
+    /* TODO: zeros in data could be optimized by skipping over them */
+    T* buf = self->homBuffer ;
+    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
+                                                   self->homBuffer,
+                                                   1,
+                                                   (*data++)) ;
+    while (buf != bufEnd) {
+      product += (*buf++) * (*model++) ;
+    }
+  }
+  return product ;
+}
+
+void
+VL_XCAT(vl_svmdataset_accumulate_hom_,SFX)(VlSvmDataset const *self,
+                                           vl_uindex element,
+                                           double *model,
+                                           const double multiplier)
+{
+  T* data = ((T*)self->data) + self->dimension * element ;
+  T* end = data + self->dimension ;
+  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
+  while (data != end) {
+    /* TODO: zeros in data could be optimized by skipping over them */
+    T* buf = self->homBuffer ;
+    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
+                                                   self->homBuffer,
+                                                   1,
+                                                   (*data++)) ;
+    while (buf != bufEnd) {
+      *model += (*buf++) * multiplier ;
+      model++ ;
+    }
+  }
+}
+
+#undef FLT
+#undef VL_SVMDATASET_INSTANTIATING
+
+/* VL_SVMDATASET_INSTANTIATING */
+#endif
diff --git a/opensfm/src/third_party/vlfeat/vl/svmdataset.h b/opensfm/src/third_party/vlfeat/vl/svmdataset.h
new file mode 100644
index 000000000..c2e1c6204
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/svmdataset.h
@@ -0,0 +1,82 @@
+/** @file svmdataset.h
+ ** @brief SVM Dataset
+ ** @author Daniele Perrone
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2012 Daniele Perrone.
+Copyright (C) 2013 Andrea Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_SVMDATASET_H
+#define VL_SVMDATASET_H
+
+#include "generic.h"
+#include "homkermap.h"
+
+struct VlSvm_ ;
+
+/** @typedef VlSvmDataset
+ ** @brief SVM dataset object
+ **
+ ** This objects contain a training set to be used in combination with
+ ** the SVM solver object ::VlSvm. Its main purpose is to implement
+ ** the two basic operations inner product (::VlSvmInnerProductFunction)
+ ** and accumulation (::VlSvmAccumulateFunction).
+ **
+ ** See @ref svm and @ref svm-advanced for further information.
+ **/
+
+#ifndef __DOXYGEN__
+struct VlSvmDataset_ ;
+typedef struct VlSvmDataset_ VlSvmDataset ;
+#else
+typedef OPAQUE VlSvmDataset ;
+#endif
+
+/** @name SVM callbacks
+ ** @{ */
+typedef void (*VlSvmDiagnosticFunction) (struct VlSvm_ *svm, void *data) ;
+typedef double (*VlSvmLossFunction) (double inner, double label) ;
+typedef double (*VlSvmDcaUpdateFunction) (double alpha, double inner, double norm2, double label) ;
+typedef double (*VlSvmInnerProductFunction)(const void *data, vl_uindex element, double *model) ;
+typedef void (*VlSvmAccumulateFunction) (const void *data, vl_uindex element, double *model, double multiplier) ;
+/* typedef double (*VlSvmSquareNormFunction) (const void *data, vl_uindex element) ; */
+/** @} */
+
+/** @name Create and destroy
+ ** @{
+ **/
+VL_EXPORT VlSvmDataset* vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData) ;
+VL_EXPORT void vl_svmdataset_delete (VlSvmDataset * dataset) ;
+/** @} */
+
+/** @name Set parameters
+ ** @{
+ **/
+VL_EXPORT void vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
+                                                         VlHomogeneousKernelMap * hom) ;
+/** @} */
+
+/** @name Get data and parameters
+ ** @{
+ **/
+VL_EXPORT void* vl_svmdataset_get_data (VlSvmDataset const *self) ;
+VL_EXPORT vl_size vl_svmdataset_get_num_data (VlSvmDataset const *self) ;
+VL_EXPORT vl_size vl_svmdataset_get_dimension (VlSvmDataset const *self) ;
+VL_EXPORT void* vl_svmdataset_get_map (VlSvmDataset const *self) ;
+VL_EXPORT vl_size vl_svmdataset_get_mapDim (VlSvmDataset const *self) ;
+VL_EXPORT VlSvmAccumulateFunction vl_svmdataset_get_accumulate_function (VlSvmDataset const *self) ;
+VL_EXPORT VlSvmInnerProductFunction vl_svmdataset_get_inner_product_function (VlSvmDataset const * self) ;
+VL_EXPORT VlHomogeneousKernelMap * vl_svmdataset_get_homogeneous_kernel_map (VlSvmDataset const * self) ;
+/** @} */
+
+/* VL_SVMDATASET_H */
+#endif
+
+
diff --git a/opensfm/src/third_party/vlfeat/vl/vlad.c b/opensfm/src/third_party/vlfeat/vl/vlad.c
new file mode 100644
index 000000000..8b6bd6ac1
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/vlad.c
@@ -0,0 +1,323 @@
+/** @file vlad.c
+ ** @brief VLAD - Declaration
+ ** @author David Novotny
+ ** @author Andrea Vedaldi
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andera Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+/**
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page vlad Vector of Locally Aggregated Descriptors (VLAD) encoding
+@author David Novotny
+@author Andrea Vedaldi
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+@ref vlad.h implements the *Vector of Linearly Aggregated Descriptors*
+(VLAD) image representation @cite{jegou10aggregating}
+@cite{arandjelovic13all-about}.
+
+@ref vlad-starting demonstreates how to use the C API to compute the
+VLAD representation of an image. For further details on the VLAD image
+representation refer to:
+
+- @subpage vlad-fundamentals - VLAD definition and computation.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section vlad-starting Getting started with VLAD
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+The VLAD encoding of a set of features is obtained by using the
+function ::vl_vlad_encode.  The function can be applied to both @c
+float or @c double data types.
+
+::vl_vlad_encode requires a visual dictionary, for example obtained by
+using @ref kmeans. Furthermore, the assignments of features to
+dictionary elements must be pre-computed, for example by using @ref
+kdtree.
+
+In the following example code, the vocabulary is first created using
+the KMeans clustering, then the points, that are to be encoded are
+assigned to its corresponding nearest vocabulary words, after that the
+original vlad encoding routine without any normalization option takes place.
+At the end of the process the encoding is stored in the @c enc variable.
+
+@code
+vl_uint32 * indexes;
+float * assignments;
+float * enc
+int i;
+
+// create a KMeans object and run clustering to get vocabulary words (centers)
+kmeans = vl_kmeans_new (VLDistanceL2, VL_TYPE_FLOAT) ;
+vl_kmeans_cluster (kmeans,
+                   data,
+                   dimension,
+                   numData,
+                   numCenters) ;
+
+// find nearest cliuster centers for the data that should be encoded
+indexes = vl_malloc(sizeof(vl_uint32) * numDataToEncode);
+vl_kmeans_quantize(kmeans,indexes,dataToEncode,numDataToEncode);
+
+// convert indexes array to assignments array,
+// which can be processed by vl_vlad_encode
+assignments = vl_malloc(sizeof(float) * numDataToEncode * numCenters);
+memset(assignments, 0, sizeof(float) * numDataToEncode * numCenters);
+for(i = 0; i < numDataToEncode; i++) {
+  assignments[i * numCenters + indexes[i]] = 1.;
+}
+
+// allocate space for vlad encoding
+enc = vl_malloc(sizeof(TYPE) * dimension * numCenters);
+
+// do the encoding job
+vl_vlad_encode (enc, VL_F_TYPE,
+                vl_kmeans_get_centers(kmeans), dimension, numCenters,
+                data, numData,
+                assignments,
+                0) ;
+@endcode
+
+Various @ref vlad-normalization normalizations can be applied to the
+VLAD vectors. These are controlled by the parameter @a flag of
+::vl_vlad_encode.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@page vlad-fundamentals VLAD fundamentals
+@tableofcontents
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+This page describes the *Vector of Locally Aggregated Descriptors*
+(VLAD) image encoding of @cite{jegou10aggregating}. See @ref vlad for
+an overview of the C API.
+
+VLAD is a *feature encoding and pooling* method, similar to @ref
+fisher "Fisher vectors". VLAD encodes a set of local feature
+descriptors $I=(\bx_1,\dots,\bx_n)$ extracted from an image using a
+dictionary built using a clustering method such as @ref gmm or @ref
+kmeans. Let $q_{ik}$ be the strength of the association of data vector
+$\bx_i$ to cluster $\mu_k$, such that $q_{ik} \geq 0$ and
+$\sum_{k=1}^K q_{ik} = 1$. The association may be either soft
+(e.g. obtained as the posterior probabilities of the GMM clusters) or
+hard (e.g. obtained by vector quantization with K-means).
+
+$\mu_k$ are the cluster *means*, vectors of the same dimension as the
+data $\bx_i$. VLAD encodes feature $\bx$ by considering the *residuals*
+\[
+ \bv_k = \sum_{i=1}^{N} q_{ik} (\bx_{i} - \mu_k).
+\]
+The residulas are stacked together to obtain the vector
+\[
+\hat\Phi(I) =
+\begin{bmatrix}
+\vdots \\
+\bv_k \\
+\vdots
+\end{bmatrix}
+\]
+
+Before the VLAD encoding is used it is usually normalized, as
+explained @ref vlad-normalization next.
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+@section vlad-normalization VLAD normalization
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  -->
+
+VLFeat VLAD implementation supports a number of different
+normalization strategies. These are optionally applied in this order:
+
+- **Component-wise mass normalization.** Each vector $\bv_k$ is
+  divided by the total mass of features associated to it $\sum_{i=1}^N
+  q_{ik}$.
+
+- **Square-rooting.** The function $\sign(z)\sqrt{|z|}$ is applied to
+  all scalar components of the VLAD descriptor.
+
+- **Component-wise $l^2$ normalization.** The vectors $\bv_k$ are
+  divided by their norm $\|\bv_k\|_2$.
+
+- **Global $l^2$ normalization.** The VLAD descriptor $\hat\Phi(I)$ is
+  divided by its norm $\|\hat\Phi(I)\|_2$.
+*/
+
+#include "vlad.h"
+#include "mathop.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+
+/* ================================================================ */
+#ifdef VL_VLAD_INSTANTIATING
+
+static void
+VL_XCAT(_vl_vlad_encode_, SFX)
+(TYPE * enc,
+ TYPE const * means, vl_size dimension, vl_size numClusters,
+ TYPE const * data, vl_size numData,
+ TYPE const * assignments,
+ int flags)
+{
+  vl_uindex dim ;
+  vl_index i_cl, i_d ;
+
+  memset(enc, 0, sizeof(TYPE) * dimension * numClusters) ;
+
+#if defined(_OPENMP)
+#pragma omp parallel for default(shared) private(i_cl,i_d,dim) num_threads(vl_get_max_threads())
+#endif
+  for (i_cl = 0; i_cl < (signed)numClusters; i_cl++) {
+    double clusterMass = 0 ;
+    for (i_d = 0; i_d < (signed)numData; i_d++) {
+      if (assignments[i_d*numClusters + i_cl] > 0) {
+        double q = assignments[i_d*numClusters+i_cl] ;
+        clusterMass +=  q ;
+        for(dim = 0; dim < dimension; dim++) {
+          enc [i_cl * dimension + dim] += q * data [i_d  * dimension + dim] ;
+        }
+      }
+    }
+
+    if (clusterMass > 0) {
+      if (flags & VL_VLAD_FLAG_NORMALIZE_MASS) {
+        for(dim = 0; dim < dimension; dim++) {
+          enc[i_cl*dimension + dim] /= clusterMass ;
+          enc[i_cl*dimension + dim] -= means[i_cl*dimension+dim];
+        }
+      } else {
+        for(dim = 0; dim < dimension; dim++) {
+          enc[i_cl*dimension + dim] -= clusterMass * means[i_cl*dimension+dim];
+        }
+      }
+    }
+
+    if (flags & VL_VLAD_FLAG_SQUARE_ROOT) {
+      for(dim = 0; dim < dimension; dim++) {
+        TYPE z = enc[i_cl*dimension + dim] ;
+        if (z >= 0) {
+          enc[i_cl*dimension + dim] = VL_XCAT(vl_sqrt_, SFX)(z) ;
+        } else {
+          enc[i_cl*dimension + dim] = - VL_XCAT(vl_sqrt_, SFX)(- z) ;
+        }
+      }
+    }
+
+    if (flags & VL_VLAD_FLAG_NORMALIZE_COMPONENTS) {
+      TYPE n = 0 ;
+      dim = 0 ;
+      for(dim = 0; dim < dimension; dim++) {
+        TYPE z = enc[i_cl*dimension + dim] ;
+        n += z * z ;
+      }
+      n = VL_XCAT(vl_sqrt_, SFX)(n) ;
+      n = VL_MAX(n, 1e-12) ;
+      for(dim = 0; dim < dimension; dim++) {
+        enc[i_cl*dimension + dim] /= n ;
+      }
+    }
+  }
+
+  if (! (flags & VL_VLAD_FLAG_UNNORMALIZED)) {
+    TYPE n = 0 ;
+    for(dim = 0 ; dim < dimension * numClusters ; dim++) {
+      TYPE z = enc [dim] ;
+      n += z * z ;
+    }
+    n = VL_XCAT(vl_sqrt_, SFX)(n) ;
+    n = VL_MAX(n, 1e-12) ;
+    for(dim = 0 ; dim < dimension * numClusters ; dim++) {
+      enc[dim] /= n ;
+    }
+  }
+}
+
+/* VL_FISHER_INSTANTIATING */
+#else
+
+#ifndef __DOXYGEN__
+#define FLT VL_TYPE_FLOAT
+#define TYPE float
+#define SFX f
+#define VL_VLAD_INSTANTIATING
+#include "vlad.c"
+
+#define FLT VL_TYPE_DOUBLE
+#define TYPE double
+#define SFX d
+#define VL_VLAD_INSTANTIATING
+#include "vlad.c"
+#endif
+
+/* VL_VLAD_INSTANTIATING */
+#endif
+
+/* ================================================================ */
+#ifndef VL_VLAD_INSTANTIATING
+
+/** @brief VLAD encoding of a set of vectors.
+ ** @param enc output VLAD encoding (out).
+ ** @param dataType the type of the input data (::VL_TYPE_DOUBLE or ::VL_TYPE_FLOAT).
+ ** @param numData number of data vectors to encode.
+ ** @param means cluster means.
+ ** @param numClusters number of clusters.
+ ** @param data the data vectors to encode.
+ ** @param dimension dimensionality of the data.
+ ** @param assignments data to cluster soft assignments.
+ ** @param flags options.
+ **
+ ** @a enc is the VLAD vector of size @a numClusters by
+ ** @a dimension. @a means is a matrix with @a numClusters columns and
+ ** @a dimension rows. @a data is the matrix of vectors to be encoded,
+ ** with @a dimension rows and @a numData columns. @a assignments is a
+ ** matrix with @a numClusters rows and @a numData columns.
+ ** All the matrices should be stored in column-major order.
+ **
+ ** @a flag allows controlling further options:
+ ** ::VL_VLAD_FLAG_NORMALIZE_COMPONENTS, ::VL_VLAD_FLAG_SQUARE_ROOT,
+ ** ::VL_VLAD_FLAG_UNNORMALIZED, and ::VL_VLAD_FLAG_NORMALIZE_MASS.
+ **
+ ** @sa @ref vlad
+ **/
+
+void
+vl_vlad_encode (void * enc, vl_type dataType,
+                void const * means, vl_size dimension, vl_size numClusters,
+                void const * data, vl_size numData,
+                void const * assignments,
+                int flags)
+{
+  switch(dataType) {
+    case VL_TYPE_FLOAT:
+      _vl_vlad_encode_f ((float *) enc,
+                         (float const *) means, dimension, numClusters,
+                         (float const *) data,  numData,
+                         (float const *) assignments, flags) ;
+      break;
+    case VL_TYPE_DOUBLE:
+      _vl_vlad_encode_d ((double *) enc,
+                         (double const *) means, dimension, numClusters,
+                         (double const *) data, numData,
+                         (double const *) assignments, flags) ;
+      break;
+    default:
+      abort();
+  }
+}
+
+/* ! VL_VLAD_INSTANTIATING */
+#endif
+
+#undef SFX
+#undef TYPE
+#undef FLT
+#undef VL_VLAD_INSTANTIATING
diff --git a/opensfm/src/third_party/vlfeat/vl/vlad.h b/opensfm/src/third_party/vlfeat/vl/vlad.h
new file mode 100644
index 000000000..72ca6dc93
--- /dev/null
+++ b/opensfm/src/third_party/vlfeat/vl/vlad.h
@@ -0,0 +1,53 @@
+/** @file vlad.h
+ ** @brief VLAD encoding (@ref vlad)
+ ** @author David Novotny
+ ** @author Andrea Vedaldi
+ ** @see @ref vlad
+ **/
+
+/*
+Copyright (C) 2013 David Novotny and Andera Vedaldi.
+All rights reserved.
+
+This file is part of the VLFeat library and is made available under
+the terms of the BSD license (see the COPYING file).
+*/
+
+#ifndef VL_VLAD_H
+#define VL_VLAD_H
+
+#include "generic.h"
+
+/** @name VLAD options
+ ** @{ */
+#define VL_VLAD_FLAG_NORMALIZE_COMPONENTS (0x1 << 0)
+#define VL_VLAD_FLAG_SQUARE_ROOT          (0x1 << 1)
+#define VL_VLAD_FLAG_UNNORMALIZED         (0x1 << 2)
+#define VL_VLAD_FLAG_NORMALIZE_MASS       (0x1 << 3)
+
+/** @def VL_VLAD_FLAG_NORMALIZE_COMPONENTS
+ ** @brief Normalize each VLAD component individually.
+ **/
+
+/** @def VL_VLAD_FLAG_SQUARE_ROOT
+ ** @brief Use signed squared-root.
+ **/
+
+/** @def VL_VLAD_FLAG_UNNORMALIZED
+ ** @brief Do not globally normalize the VLAD descriptor.
+ **/
+
+/** @def VL_VLAD_FLAG_NORMALIZE_MASS
+ ** @brief Normalize each component by the number of features assigned to it.
+ **/
+/** @} */
+
+VL_EXPORT void vl_vlad_encode
+  (void * enc, vl_type dataType,
+   void const * means, vl_size dimension, vl_size numClusters,
+   void const * data, vl_size numData,
+   void const * assignments,
+   int flags) ;
+
+/* VL_VLAD_H */
+#endif

From 672db1d623cffabef1a72e3496ec5f1ed48c69b2 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Tue, 22 Apr 2025 08:37:33 -0700
Subject: [PATCH 118/235] Fixes for docker tests to build and pass (#1092)

Summary:
Revert some changes from bots and humans that were not compatible with non-meta-internal tools.

* Require C++17
* Avoid using python 3.10 features
* Avoid using ceres 2 features (ceres::isfinite)
* Avoid using meta internal global paths

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1092

Reviewed By: DodgySpaniard

Differential Revision: D73259083

Pulled By: paulinus

fbshipit-source-id: 40af597bb2e2750f826f051166a15ec84553b9aa
---
 opensfm/features.py                       | 4 ++--
 opensfm/reconstruction.py                 | 4 ++--
 opensfm/src/CMakeLists.txt                | 4 ++--
 opensfm/src/bundle/src/bundle_adjuster.cc | 2 +-
 opensfm/test/test_commands.py             | 3 +--
 opensfm/test/test_dataset.py              | 3 ++-
 opensfm/test/test_datastructures.py       | 6 +++---
 opensfm/test/test_io.py                   | 3 ++-
 opensfm/test/test_pairs_selection.py      | 3 ++-
 requirements.txt                          | 2 +-
 10 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/opensfm/features.py b/opensfm/features.py
index 173eeebc1..d877eea0b 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -51,7 +51,7 @@ class FeaturesData:
     descriptors: Optional[np.ndarray]
     colors: np.ndarray
     semantic: Optional[SemanticData]
-    depths: np.ndarray | None  # New field. This field is not serialized yet
+    depths: Optional[np.ndarray]  # New field. This field is not serialized yet
 
     FEATURES_VERSION: int = 3
     FEATURES_HEADER: str = "OPENSFM_FEATURES_VERSION"
@@ -62,7 +62,7 @@ def __init__(
         descriptors: Optional[np.ndarray],
         colors: np.ndarray,
         semantic: Optional[SemanticData],
-        depths: np.ndarray | None = None,
+        depths: Optional[np.ndarray] = None,
     ):
         self.points = points
         self.descriptors = descriptors
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index b215bb4ec..b66454126 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -2,6 +2,7 @@
 """Incremental reconstruction pipeline"""
 
 import datetime
+import enum
 import logging
 import math
 from abc import ABC, abstractmethod
@@ -28,13 +29,12 @@
 from opensfm.align import align_reconstruction, apply_similarity
 from opensfm.context import current_memory_usage, parallel_map
 from opensfm.dataset_base import DataSetBase
-from python.migrations.py310 import StrEnum310
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-class ReconstructionAlgorithm(StrEnum310):
+class ReconstructionAlgorithm(str, enum.Enum):
     INCREMENTAL = "incremental"
     TRIANGULATION = "triangulation"
 
diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index c85aa6fb4..0aa29d365 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -24,8 +24,8 @@ set(CMAKE_CXX_VISIBILITY_INLINES ON)
 # fPIC
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-# C++14
-set(CMAKE_CXX_STANDARD 14)
+# C++17
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Enable all warnings
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index f5f24795b..25f68fa0d 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -505,7 +505,7 @@ struct AddRelativeDepthError {
       return;
     }
     const auto &depth = obs.depth_prior.value();
-    if (!ceres::isfinite(depth.value)) {
+    if (!std::isfinite(depth.value)) {
       throw std::runtime_error(obs.shot->GetID() +
                                " has non-finite depth prior");
     }
diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index b2dda5770..a5890bcd9 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -2,9 +2,8 @@
 import argparse
 from os.path import join
 
-from mapillary.opensfm.opensfm.test import data_generation, utils
-
 from opensfm import commands, dataset
+from opensfm.test import data_generation, utils
 
 
 def run_command(command, args) -> None:
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 3a0500aef..83e829854 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,7 +1,8 @@
 # pyre-unsafe
 import numpy as np
-from mapillary.opensfm.opensfm.test import data_generation
+
 from opensfm import features
+from opensfm.test import data_generation
 
 
 def test_dataset_load_features_sift(tmpdir) -> None:
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index a0a7ea50a..ee4dc700c 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -6,14 +6,14 @@
 
 import numpy as np
 import pytest
-from mapillary.opensfm.opensfm.test.utils import (
+from opensfm import pygeometry, pymap, types
+from opensfm.pymap import RigCamera, RigInstance, Shot
+from opensfm.test.utils import (
     assert_cameras_equal,
     assert_maps_equal,
     assert_metadata_equal,
     assert_shots_equal,
 )
-from opensfm import pygeometry, pymap, types
-from opensfm.pymap import RigCamera, RigInstance, Shot
 from opensfm.types import Reconstruction
 
 
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 0246ed377..76feec6bf 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -4,8 +4,9 @@
 from io import StringIO
 
 import numpy as np
-from mapillary.opensfm.opensfm.test import data_generation, utils
+
 from opensfm import io, pygeometry, types
+from opensfm.test import data_generation, utils
 
 
 filename = os.path.join(
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index f2447b3fe..a91c4549e 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -5,9 +5,10 @@
 
 import numpy as np
 import pytest
-from mapillary.opensfm.opensfm.test import data_generation
+
 from opensfm import commands, dataset, feature_loader, geo, pairs_selection
 from opensfm.dataset_base import DataSetBase
+from opensfm.test import data_generation
 
 
 NEIGHBORS = 6
diff --git a/requirements.txt b/requirements.txt
index 0d50b21ef..608fcb746 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -10,7 +10,7 @@ Pillow>=8.1.1
 pyproj>=1.9.5.1
 pytest==3.0.7
 python-dateutil>=2.7
-pyyaml==5.4
+pyyaml>=5.4
 scipy>=1.10.0
 Sphinx==4.2.0
 six

From 51dad31f08926c399c96f90b04bb5f09d1afc6a8 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 22 Apr 2025 12:45:34 -0700
Subject: [PATCH 119/235] replace open method with specialized methods for text
 and binary modes

Summary: This is just for consistency, since `open_rt` and `open_wt` already existed. It also simplifies strict typing, since every method returns either text or binary io. Finally, removing `*args` and `**kwargs` avoids adding calls that are not supported by `IoFilesystemBase` sub-classes

Differential Revision: D73199675

fbshipit-source-id: 9da268d4ef69a11160163eb127cf17825503038d
---
 opensfm/actions/export_colmap.py | 18 +++-------
 opensfm/dataset.py               | 48 +++++++++++++-------------
 opensfm/io.py                    | 59 +++++++++++++++++++++++---------
 opensfm/report.py                |  8 ++---
 opensfm/stats.py                 | 18 ++++------
 5 files changed, 82 insertions(+), 69 deletions(-)

diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index 01a4cd00e..5c384fb42 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -86,8 +86,8 @@ def run_dataset(data: DataSet, binary: bool) -> None:
         db.close()
 
         data.io_handler.rm_if_exist(database_path)
-        with data.io_handler.open(tmp_database_path, "rb") as f:
-            with data.io_handler.open(database_path, "wb") as fwb:
+        with data.io_handler.open_rb(tmp_database_path) as f:
+            with data.io_handler.open_wb(database_path) as fwb:
                 fwb.write(f.read())
 
 
@@ -194,7 +194,6 @@ def blob_to_array(blob, dtype, shape: Tuple[int] = (-1,)):
         return np.frombuffer(blob, dtype=dtype).reshape(*shape)
 
 
-# pyre-fixme[11]: Annotation `Connection` is not defined as a type.
 class COLMAPDatabase(sqlite3.Connection):
     @staticmethod
     def connect(database_path) -> t.Any:
@@ -203,7 +202,6 @@ def connect(database_path) -> t.Any:
     def __init__(self, *args, **kwargs) -> None:
         super(COLMAPDatabase, self).__init__(*args, **kwargs)
 
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `executescript`.
         self.create_tables = lambda: self.executescript(CREATE_ALL)
         self.create_cameras_table = lambda: self.executescript(CREATE_CAMERAS_TABLE)
         self.create_descriptors_table = lambda: self.executescript(
@@ -221,7 +219,6 @@ def add_camera(
         self, model, width, height, params, prior_focal_length=False, camera_id=None
     ) -> t.Any:
         params = np.asarray(params, np.float64)
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         cursor = self.execute(
             "INSERT INTO cameras VALUES (?, ?, ?, ?, ?, ?)",
             (
@@ -238,7 +235,6 @@ def add_camera(
     def add_image(
         self, name, camera_id, prior_q=(0, 0, 0, 0), prior_t=(0, 0, 0), image_id=None
     ) -> t.Any:
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         cursor = self.execute(
             "INSERT INTO images VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
@@ -261,7 +257,6 @@ def add_keypoints(self, image_id, keypoints) -> None:
         assert keypoints.shape[1] in [2, 4, 6]
 
         keypoints = np.asarray(keypoints, np.float32)
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO keypoints VALUES (?, ?, ?, ?)",
             (image_id,) + keypoints.shape + (array_to_blob(keypoints),),
@@ -269,7 +264,6 @@ def add_keypoints(self, image_id, keypoints) -> None:
 
     def add_descriptors(self, image_id, descriptors) -> None:
         descriptors = np.ascontiguousarray(descriptors, np.uint8)
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO descriptors VALUES (?, ?, ?, ?)",
             (image_id,) + descriptors.shape + (array_to_blob(descriptors),),
@@ -284,7 +278,6 @@ def add_matches(self, image_id1, image_id2, matches) -> None:
 
         pair_id = image_ids_to_pair_id(image_id1, image_id2)
         matches = np.asarray(matches, np.uint32)
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO matches VALUES (?, ?, ?, ?)",
             (pair_id,) + matches.shape + (array_to_blob(matches),),
@@ -304,7 +297,6 @@ def add_two_view_geometry(
         F = np.asarray(F, dtype=np.float64)
         E = np.asarray(E, dtype=np.float64)
         H = np.asarray(H, dtype=np.float64)
-        # pyre-fixme[16]: `COLMAPDatabase` has no attribute `execute`.
         self.execute(
             "INSERT INTO two_view_geometries VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
             (pair_id,)
@@ -440,7 +432,7 @@ def export_cameras_reconstruction(data, path, camera_map, binary: bool = False)
             cameras[camera_id] = camera
 
     if binary:
-        fout = data.io_handler.open(os.path.join(path, "cameras.bin"), "wb")
+        fout = data.io_handler.open_wb(os.path.join(path, "cameras.bin"))
         fout.write(pack("<Q", len(cameras)))
     else:
         fout = data.io_handler.open_wt(os.path.join(path, "cameras.txt"))
@@ -471,7 +463,7 @@ def export_images_reconstruction(
     tracks_manager = data.load_tracks_manager()
 
     if binary:
-        fout = data.io_handler.open(os.path.join(path, "images.bin"), "wb")
+        fout = data.io_handler.open_wb(os.path.join(path, "images.bin"))
         n_ims = 0
         for reconstruction in reconstructions:
             n_ims += len(reconstruction.shots)
@@ -545,7 +537,7 @@ def export_points_reconstruction(data, path, images_map, binary: bool = False):
     points_map = {}
 
     if binary:
-        fout = data.io_handler.open(os.path.join(path, "points3D.bin"), "wb")
+        fout = data.io_handler.open_wb(os.path.join(path, "points3D.bin"))
         n_points = 0
         for reconstruction in reconstructions:
             n_points += len(reconstruction.points)
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 5d0b18fc4..f984926e5 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -49,7 +49,7 @@ def _config_file(self) -> str:
     def load_config(self) -> None:
         config_file_path = self._config_file()
         if self.io_handler.isfile(config_file_path):
-            with self.io_handler.open(config_file_path) as f:
+            with self.io_handler.open_rt(config_file_path) as f:
                 self.config = config.load_config_from_fileobject(f)
         else:
             self.config = config.default_config()
@@ -82,7 +82,7 @@ def _image_file(self, image: str) -> str:
 
     def open_image_file(self, image: str) -> IO[Any]:
         """Open image file and return file object."""
-        return self.io_handler.open(self._image_file(image), "rb")
+        return self.io_handler.open_rb(self._image_file(image))
 
     def load_image(
         self,
@@ -160,7 +160,7 @@ def load_segmentation(self, image: str) -> Optional[np.ndarray]:
         """Load image segmentation if it exists, otherwise return None."""
         segmentation_file = self._segmentation_file(image)
         if self.io_handler.isfile(segmentation_file):
-            with self.io_handler.open(segmentation_file, "rb") as fp:
+            with self.io_handler.open_rb(segmentation_file) as fp:
                 with PngImageFile(fp) as png_image:
                     # TODO: We do not write a header tag in the metadata. Might be good safety check.
                     data = np.array(png_image)
@@ -292,7 +292,7 @@ def _save_features(
         self, filepath: str, features_data: features.FeaturesData
     ) -> None:
         self.io_handler.mkdir_p(self._feature_path())
-        with self.io_handler.open(filepath, "wb") as fwb:
+        with self.io_handler.open_wb(filepath) as fwb:
             features_data.save(fwb, self.config)
 
     def features_exist(self, image: str) -> bool:
@@ -306,7 +306,7 @@ def load_features(self, image: str) -> Optional[features.FeaturesData]:
             if self.io_handler.isfile(self._feature_file_legacy(image))
             else self._feature_file(image)
         )
-        with self.io_handler.open(features_filepath, "rb") as f:
+        with self.io_handler.open_rb(features_filepath) as f:
             return features.FeaturesData.from_file(f, self.config)
 
     def save_features(self, image: str, features_data: features.FeaturesData) -> None:
@@ -319,12 +319,12 @@ def words_exist(self, image: str) -> bool:
         return self.io_handler.isfile(self._words_file(image))
 
     def load_words(self, image: str) -> np.ndarray:
-        with self.io_handler.open(self._words_file(image), "rb") as f:
+        with self.io_handler.open_rb(self._words_file(image)) as f:
             s = np.load(f)
             return s["words"].astype(np.int32)
 
     def save_words(self, image: str, words: np.ndarray) -> None:
-        with self.io_handler.open(self._words_file(image), "wb") as f:
+        with self.io_handler.open_wb(self._words_file(image)) as f:
             np.savez_compressed(f, words=words.astype(np.uint16))
 
     def _matches_path(self) -> str:
@@ -359,7 +359,7 @@ def find_class(self, module, name):
                     )
                 return getattr(self.modules_map[classname], name)
 
-        with self.io_handler.open(self._matches_file(image), "rb") as fin:
+        with self.io_handler.open_rb(self._matches_file(image)) as fin:
             matches = MatchingUnpickler(BytesIO(gzip.decompress(fin.read()))).load()
         return matches
 
@@ -369,7 +369,7 @@ def save_matches(self, image: str, matches: Dict[str, np.ndarray]) -> None:
         with BytesIO() as buffer:
             with gzip.GzipFile(fileobj=buffer, mode="w") as fzip:
                 pickle.dump(matches, fzip)
-            with self.io_handler.open(self._matches_file(image), "wb") as fw:
+            with self.io_handler.open_wb(self._matches_file(image)) as fw:
                 fw.write(buffer.getvalue())
 
     def find_matches(self, im1: str, im2: str) -> np.ndarray:
@@ -392,7 +392,7 @@ def load_tracks_manager(
         self, filename: Optional[str] = None
     ) -> pymap.TracksManager:
         """Return the tracks manager"""
-        with self.io_handler.open(self._tracks_manager_file(filename), "r") as f:
+        with self.io_handler.open_rt(self._tracks_manager_file(filename)) as f:
             return pymap.TracksManager.instanciate_from_string(f.read())
 
     def tracks_exists(self, filename: Optional[str] = None) -> bool:
@@ -401,7 +401,7 @@ def tracks_exists(self, filename: Optional[str] = None) -> bool:
     def save_tracks_manager(
         self, tracks_manager: pymap.TracksManager, filename: Optional[str] = None
     ) -> None:
-        with self.io_handler.open(self._tracks_manager_file(filename), "w") as fw:
+        with self.io_handler.open_wt(self._tracks_manager_file(filename)) as fw:
             fw.write(tracks_manager.as_string())
 
     def _reconstruction_file(self, filename: Optional[str]) -> str:
@@ -562,7 +562,7 @@ def save_rig_assignments(
     def append_to_profile_log(self, content: str) -> None:
         """Append content to the profile.log file."""
         path = os.path.join(self.data_path, "profile.log")
-        with self.io_handler.open(path, "a") as fp:
+        with self.io_handler.open_at(path) as fp:
             fp.write(content)
 
     def _report_path(self) -> str:
@@ -578,7 +578,7 @@ def save_report(self, report_str: str, path: str) -> None:
         filepath = os.path.join(self._report_path(), path)
         self.io_handler.mkdir_p(os.path.dirname(filepath))
         with self.io_handler.open_wt(filepath) as fout:
-            return fout.write(report_str)
+            fout.write(report_str)
 
     def _ply_file(self, filename: Optional[str]) -> str:
         return os.path.join(self.data_path, filename or "reconstruction.ply")
@@ -787,7 +787,7 @@ def undistorted_segmentation_exists(self, image: str) -> bool:
     def load_undistorted_segmentation(self, image: str) -> np.ndarray:
         """Load an undistorted image segmentation."""
         segmentation_file = self._undistorted_segmentation_file(image)
-        with self.io_handler.open(segmentation_file, "rb") as fp:
+        with self.io_handler.open_rb(segmentation_file) as fp:
             with PngImageFile(fp) as png_image:
                 # TODO: We do not write a header tag in the metadata. Might be good safety check.
                 data = np.array(png_image)
@@ -855,7 +855,7 @@ def point_cloud_file(self, filename: str = "merged.ply") -> str:
     def load_point_cloud(
         self, filename: str = "merged.ply"
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        with self.io_handler.open(self.point_cloud_file(filename), "r") as fp:
+        with self.io_handler.open_rt(self.point_cloud_file(filename)) as fp:
             return io.point_cloud_from_ply(fp)
 
     def save_point_cloud(
@@ -867,7 +867,7 @@ def save_point_cloud(
         filename: str = "merged.ply",
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
-        with self.io_handler.open(self.point_cloud_file(filename), "w") as fp:
+        with self.io_handler.open_wt(self.point_cloud_file(filename)) as fp:
             io.point_cloud_to_ply(points, normals, colors, labels, fp)
 
     def raw_depthmap_exists(self, image: str) -> bool:
@@ -884,7 +884,7 @@ def save_raw_depthmap(
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "raw.npz")
-        with self.io_handler.open(filepath, "wb") as f:
+        with self.io_handler.open_wb(filepath) as f:
             np.savez_compressed(
                 f, depth=depth, plane=plane, score=score, nghbr=nghbr, nghbrs=nghbrs
             )
@@ -892,7 +892,7 @@ def save_raw_depthmap(
     def load_raw_depthmap(
         self, image: str
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        with self.io_handler.open(self.depthmap_file(image, "raw.npz"), "rb") as f:
+        with self.io_handler.open_rb(self.depthmap_file(image, "raw.npz")) as f:
             o = np.load(f)
             return o["depth"], o["plane"], o["score"], o["nghbr"], o["nghbrs"]
 
@@ -904,13 +904,13 @@ def save_clean_depthmap(
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "clean.npz")
-        with self.io_handler.open(filepath, "wb") as f:
+        with self.io_handler.open_wb(filepath) as f:
             np.savez_compressed(f, depth=depth, plane=plane, score=score)
 
     def load_clean_depthmap(
         self, image: str
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-        with self.io_handler.open(self.depthmap_file(image, "clean.npz"), "rb") as f:
+        with self.io_handler.open_rb(self.depthmap_file(image, "clean.npz")) as f:
             o = np.load(f)
             return o["depth"], o["plane"], o["score"]
 
@@ -927,7 +927,7 @@ def save_pruned_depthmap(
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "pruned.npz")
-        with self.io_handler.open(filepath, "wb") as f:
+        with self.io_handler.open_wb(filepath) as f:
             np.savez_compressed(
                 f,
                 points=points,
@@ -939,7 +939,7 @@ def save_pruned_depthmap(
     def load_pruned_depthmap(
         self, image: str
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        with self.io_handler.open(self.depthmap_file(image, "pruned.npz"), "rb") as f:
+        with self.io_handler.open_rb(self.depthmap_file(image, "pruned.npz")) as f:
             o = np.load(f)
             return (
                 o["points"],
@@ -950,14 +950,14 @@ def load_pruned_depthmap(
 
     def load_undistorted_tracks_manager(self) -> pymap.TracksManager:
         filename = os.path.join(self.data_path, "tracks.csv")
-        with self.io_handler.open(filename, "r") as f:
+        with self.io_handler.open_rt(filename) as f:
             return pymap.TracksManager.instanciate_from_string(f.read())
 
     def save_undistorted_tracks_manager(
         self, tracks_manager: pymap.TracksManager
     ) -> None:
         filename = os.path.join(self.data_path, "tracks.csv")
-        with self.io_handler.open(filename, "w") as fw:
+        with self.io_handler.open_wt(filename) as fw:
             fw.write(tracks_manager.as_string())
 
     def load_undistorted_reconstruction(self) -> List[types.Reconstruction]:
diff --git a/opensfm/io.py b/opensfm/io.py
index 1ddce757c..36a1f02f1 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -5,7 +5,18 @@
 import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Dict, IO, Iterable, List, Optional, TextIO, Tuple, Union
+from typing import (
+    Any,
+    BinaryIO,
+    Dict,
+    IO,
+    Iterable,
+    List,
+    Optional,
+    TextIO,
+    Tuple,
+    Union,
+)
 
 import cv2
 import numpy as np
@@ -1291,6 +1302,7 @@ def exists(cls, path: str):
         pass
 
     @classmethod
+    @abstractmethod
     def ls(cls, path: str):
         pass
 
@@ -1305,27 +1317,34 @@ def isdir(cls, path: str):
         pass
 
     @classmethod
+    @abstractmethod
     def rm_if_exist(cls, filename: str):
         pass
 
     @classmethod
+    @abstractmethod
     def symlink(cls, src_path: str, dst_path: str, **kwargs):
         pass
 
     @classmethod
     @abstractmethod
-    def open(cls, *args, **kwargs) -> IO[Any]:
-        pass
+    def open_wb(cls, path: str) -> BinaryIO: ...
 
     @classmethod
     @abstractmethod
-    def open_wt(cls, path: str):
-        pass
+    def open_rb(cls, path: str) -> BinaryIO: ...
 
     @classmethod
     @abstractmethod
-    def open_rt(cls, path: str):
-        pass
+    def open_wt(cls, path: str) -> TextIO: ...
+
+    @classmethod
+    @abstractmethod
+    def open_rt(cls, path: str) -> TextIO: ...
+
+    @classmethod
+    @abstractmethod
+    def open_at(cls, path: str) -> TextIO: ...
 
     @classmethod
     @abstractmethod
@@ -1391,16 +1410,24 @@ def symlink(cls, src_path: str, dst_path: str, **kwargs):
         os.symlink(src_path, dst_path, **kwargs)
 
     @classmethod
-    def open(cls, *args, **kwargs) -> IO[Any]:
-        return open(*args, **kwargs)
+    def open_wb(cls, path: str) -> BinaryIO:
+        return open(path, "wb")
+
+    @classmethod
+    def open_rb(cls, path: str) -> BinaryIO:
+        return open(path, "rb")
+
+    @classmethod
+    def open_wt(cls, path: str) -> TextIO:
+        return open(path, "wt")
 
     @classmethod
-    def open_wt(cls, path: str):
-        return cls.open(path, "w", encoding="utf-8")
+    def open_rt(cls, path: str) -> TextIO:
+        return open(path, "rt")
 
     @classmethod
-    def open_rt(cls, path: str):
-        return cls.open(path, "r", encoding="utf-8")
+    def open_at(cls, path: str) -> TextIO:
+        return open(path, "at")
 
     @classmethod
     def mkdir_p(cls, path: str):
@@ -1414,17 +1441,17 @@ def imread(
         unchanged: bool = False,
         anydepth: bool = False,
     ):
-        with cls.open(path, "rb") as fb:
+        with cls.open_rb(path) as fb:
             return imread_from_fileobject(fb, grayscale, unchanged, anydepth)
 
     @classmethod
     def imwrite(cls, path: str, image) -> None:
-        with cls.open(path, "wb") as fwb:
+        with cls.open_wb(path) as fwb:
             imwrite_from_fileobject(fwb, image, path)
 
     @classmethod
     def image_size(cls, path: str) -> Tuple[int, int]:
-        with cls.open(path, "rb") as fb:
+        with cls.open_rb(path) as fb:
             return image_size_from_fileobject(fb)
 
     @classmethod
diff --git a/opensfm/report.py b/opensfm/report.py
index a726633ce..4be661f44 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -44,9 +44,7 @@ def save_report(self, filename: str) -> None:
         if isinstance(bytestring, str):
             bytestring = bytestring.encode("utf8")
 
-        with self.io_handler.open(
-            os.path.join(self.output_path, filename), "wb"
-        ) as fwb:
+        with self.io_handler.open_wb(os.path.join(self.output_path, filename)) as fwb:
             fwb.write(bytestring)
 
     def _make_table(self, columns_names, rows, row_header=False) -> None:
@@ -113,8 +111,8 @@ def _make_subsection(self, title: str) -> None:
     def _make_centered_image(self, image_path: str, desired_height: float) -> None:
         with tempfile.TemporaryDirectory() as tmp_local_dir:
             local_image_path = os.path.join(tmp_local_dir, os.path.basename(image_path))
-            with self.io_handler.open(local_image_path, "wb") as fwb:
-                with self.io_handler.open(image_path, "rb") as f:
+            with self.io_handler.open_wb(local_image_path) as fwb:
+                with self.io_handler.open_rb(image_path) as f:
                     fwb.write(f.read())
 
             width, height = PIL.Image.open(local_image_path).size
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 678a5689f..fd62af125 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -541,7 +541,7 @@ def save_matchgraph(
         pad=0.0,
     )
 
-    with io_handler.open(os.path.join(output_path, "matchgraph.png"), "wb") as fwb:
+    with io_handler.open_wb(os.path.join(output_path, "matchgraph.png")) as fwb:
         plt.savefig(
             fwb,
             dpi=300,
@@ -589,9 +589,7 @@ def save_residual_histogram(
     axs[1].set_title("Pixel Residual")
     axs[2].set_title("Angular Residual")
 
-    with io_handler.open(
-        os.path.join(output_path, "residual_histogram.png"), "wb"
-    ) as fwb:
+    with io_handler.open_wb(os.path.join(output_path, "residual_histogram.png")) as fwb:
         plt.savefig(
             fwb,
             dpi=300,
@@ -763,7 +761,7 @@ def save_topview(
         [0, f"{int(size_y / 2):.0f}", f"{size_y:.0f} meters"],
         fontsize="small",
     )
-    with io_handler.open(os.path.join(output_path, "topview.png"), "wb") as fwb:
+    with io_handler.open_wb(os.path.join(output_path, "topview.png")) as fwb:
         plt.savefig(
             fwb,
             dpi=300,
@@ -855,11 +853,10 @@ def save_heatmap(
             fontsize="x-small",
         )
 
-    with io_handler.open(
+    with io_handler.open_wb(
         os.path.join(
             output_path, "heatmap_" + str(camera_id.replace("/", "_")) + ".png"
-        ),
-        "wb",
+        )
     ) as fwb:
         plt.savefig(
             fwb,
@@ -986,11 +983,10 @@ def save_residual_grids(
             [0, buckets_y / 2, buckets_y], [0, int(h / 2), h], fontsize="x-small"
         )
 
-        with io_handler.open(
+        with io_handler.open_wb(
             os.path.join(
                 output_path, "residuals_" + str(camera_id.replace("/", "_")) + ".png"
-            ),
-            "wb",
+            )
         ) as fwb:
             plt.savefig(
                 fwb,

From 47e36078d896cc34ba4cffdbc273485c9ac44528 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 22 Apr 2025 12:45:34 -0700
Subject: [PATCH 120/235] pyre strict in dataset and io

Differential Revision: D73199680

fbshipit-source-id: 39e745f4669fe1c84fda951ec879160f80eb771c
---
 opensfm/dataset.py | 100 +++++++++++++++++++------------------
 opensfm/io.py      | 121 ++++++++++++++++++++++-----------------------
 2 files changed, 110 insertions(+), 111 deletions(-)

diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index f984926e5..939112c08 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import gzip
 import json
 import logging
@@ -8,6 +8,7 @@
 from typing import Any, Dict, IO, List, Optional, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import config, features, geo, io, masking, pygeometry, pymap, rig, types
 from opensfm.dataset_base import DataSetBase
 from PIL.PngImagePlugin import PngImageFile
@@ -30,14 +31,17 @@ class DataSet(DataSetBase):
     """
 
     io_handler: io.IoFilesystemBase = io.IoFilesystemDefault()
-    config = None
+    config: Dict[str, Any] = {}
     image_files: Dict[str, str] = {}
     mask_files: Dict[str, str] = {}
     image_list: List[str] = []
 
-    def __init__(self, data_path: str, io_handler=io.IoFilesystemDefault) -> None:
+    def __init__(
+        self, data_path: str, io_handler: Optional[io.IoFilesystemBase] = None
+    ) -> None:
         """Init dataset associated to a folder."""
-        self.io_handler = io_handler
+        if io_handler is not None:
+            self.io_handler = io_handler
         self.data_path = data_path
         self.load_config()
         self.load_image_list()
@@ -80,7 +84,7 @@ def _image_file(self, image: str) -> str:
         """Path to the image file."""
         return self.image_files[image]
 
-    def open_image_file(self, image: str) -> IO[Any]:
+    def open_image_file(self, image: str) -> IO[bytes]:
         """Open image file and return file object."""
         return self.io_handler.open_rb(self._image_file(image))
 
@@ -90,7 +94,7 @@ def load_image(
         unchanged: bool = False,
         anydepth: bool = False,
         grayscale: bool = False,
-    ) -> np.ndarray:
+    ) -> NDArray:
         """Load image pixels as numpy array.
 
         The array is 3D, indexed by y-coord, x-coord, channel.
@@ -117,7 +121,7 @@ def load_mask_list(self) -> None:
         else:
             self._set_mask_path(os.path.join(self.data_path, "masks"))
 
-    def load_mask(self, image: str) -> Optional[np.ndarray]:
+    def load_mask(self, image: str) -> Optional[NDArray]:
         """Load image mask if it exists, otherwise return None."""
         if image in self.mask_files:
             mask_path = self.mask_files[image]
@@ -138,7 +142,7 @@ def _instances_path(self) -> str:
     def _instances_file(self, image: str) -> str:
         return os.path.join(self._instances_path(), image + ".png")
 
-    def load_instances(self, image: str) -> Optional[np.ndarray]:
+    def load_instances(self, image: str) -> Optional[NDArray]:
         """Load image instances file if it exists, otherwise return None."""
         instances_file = self._instances_file(image)
         if self.io_handler.isfile(instances_file):
@@ -153,10 +157,10 @@ def _segmentation_path(self) -> str:
     def _segmentation_file(self, image: str) -> str:
         return os.path.join(self._segmentation_path(), image + ".png")
 
-    def segmentation_labels(self) -> List[Any]:
+    def segmentation_labels(self) -> List[Dict[str, Any]]:
         return []
 
-    def load_segmentation(self, image: str) -> Optional[np.ndarray]:
+    def load_segmentation(self, image: str) -> Optional[NDArray]:
         """Load image segmentation if it exists, otherwise return None."""
         segmentation_file = self._segmentation_file(image)
         if self.io_handler.isfile(segmentation_file):
@@ -318,12 +322,12 @@ def _words_file(self, image: str) -> str:
     def words_exist(self, image: str) -> bool:
         return self.io_handler.isfile(self._words_file(image))
 
-    def load_words(self, image: str) -> np.ndarray:
+    def load_words(self, image: str) -> NDArray:
         with self.io_handler.open_rb(self._words_file(image)) as f:
             s = np.load(f)
             return s["words"].astype(np.int32)
 
-    def save_words(self, image: str, words: np.ndarray) -> None:
+    def save_words(self, image: str, words: NDArray) -> None:
         with self.io_handler.open_wb(self._words_file(image)) as f:
             np.savez_compressed(f, words=words.astype(np.uint16))
 
@@ -338,7 +342,7 @@ def _matches_file(self, image: str) -> str:
     def matches_exists(self, image: str) -> bool:
         return self.io_handler.isfile(self._matches_file(image))
 
-    def load_matches(self, image: str) -> Dict[str, np.ndarray]:
+    def load_matches(self, image: str) -> Dict[str, NDArray]:
         # Prevent pickling of anything except what we strictly need
         # as 'pickle.load' is RCE-prone. Will raise on any class other
         # than the numpy ones we allow.
@@ -363,7 +367,7 @@ def find_class(self, module, name):
             matches = MatchingUnpickler(BytesIO(gzip.decompress(fin.read()))).load()
         return matches
 
-    def save_matches(self, image: str, matches: Dict[str, np.ndarray]) -> None:
+    def save_matches(self, image: str, matches: Dict[str, NDArray]) -> None:
         self.io_handler.mkdir_p(self._matches_path())
 
         with BytesIO() as buffer:
@@ -372,7 +376,7 @@ def save_matches(self, image: str, matches: Dict[str, np.ndarray]) -> None:
             with self.io_handler.open_wb(self._matches_file(image)) as fw:
                 fw.write(buffer.getvalue())
 
-    def find_matches(self, im1: str, im2: str) -> np.ndarray:
+    def find_matches(self, im1: str, im2: str) -> NDArray:
         if self.matches_exists(im1):
             im1_matches = self.load_matches(im1)
             if im2 in im1_matches:
@@ -422,7 +426,7 @@ def save_reconstruction(
         self,
         reconstruction: List[types.Reconstruction],
         filename: Optional[str] = None,
-        minify=False,
+        minify: bool = False,
     ) -> None:
         with self.io_handler.open_wt(self._reconstruction_file(filename)) as fout:
             io.json_dump(io.reconstructions_to_json(reconstruction), fout, minify)
@@ -628,11 +632,11 @@ def save_ground_control_points(
         with self.io_handler.open_wt(self._ground_control_points_file()) as fout:
             io.write_ground_control_points(points, fout)
 
-    def image_as_array(self, image: str) -> np.ndarray:
+    def image_as_array(self, image: str) -> NDArray:
         logger.warning("image_as_array() is deprecated. Use load_image() instead.")
         return self.load_image(image)
 
-    def mask_as_array(self, image: str) -> Optional[np.ndarray]:
+    def mask_as_array(self, image: str) -> Optional[NDArray]:
         logger.warning("mask_as_array() is deprecated. Use load_mask() instead.")
         return self.load_mask(image)
 
@@ -707,18 +711,20 @@ class UndistortedDataSet:
     base: DataSetBase
     config: Dict[str, Any] = {}
     data_path: str
+    io_handler: io.IoFilesystemBase = io.IoFilesystemDefault()
 
     def __init__(
         self,
         base_dataset: DataSetBase,
         undistorted_data_path: str,
-        io_handler=io.IoFilesystemDefault,
+        io_handler: Optional[io.IoFilesystemBase] = None,
     ) -> None:
         """Init dataset associated to a folder."""
         self.base = base_dataset
         self.config = self.base.config
         self.data_path = undistorted_data_path
-        self.io_handler = io_handler
+        if io_handler is not None:
+            self.io_handler = io_handler
 
     def load_undistorted_shot_ids(self) -> Dict[str, List[str]]:
         filename = os.path.join(self.data_path, "undistorted_shot_ids.json")
@@ -738,11 +744,11 @@ def _undistorted_image_file(self, image: str) -> str:
         """Path of undistorted version of an image."""
         return os.path.join(self._undistorted_image_path(), image)
 
-    def load_undistorted_image(self, image: str) -> np.ndarray:
+    def load_undistorted_image(self, image: str) -> NDArray:
         """Load undistorted image pixels as a numpy array."""
         return self.io_handler.imread(self._undistorted_image_file(image))
 
-    def save_undistorted_image(self, image: str, array: np.ndarray) -> None:
+    def save_undistorted_image(self, image: str, array: NDArray) -> None:
         """Save undistorted image pixels."""
         self.io_handler.mkdir_p(self._undistorted_image_path())
         self.io_handler.imwrite(self._undistorted_image_file(image), array)
@@ -762,13 +768,13 @@ def undistorted_mask_exists(self, image: str) -> bool:
         """Check if the undistorted mask file exists."""
         return self.io_handler.isfile(self._undistorted_mask_file(image))
 
-    def load_undistorted_mask(self, image: str) -> np.ndarray:
+    def load_undistorted_mask(self, image: str) -> NDArray:
         """Load undistorted mask pixels as a numpy array."""
         return self.io_handler.imread(
             self._undistorted_mask_file(image), grayscale=True
         )
 
-    def save_undistorted_mask(self, image: str, array: np.ndarray) -> None:
+    def save_undistorted_mask(self, image: str, array: NDArray) -> None:
         """Save the undistorted image mask."""
         self.io_handler.mkdir_p(self._undistorted_mask_path())
         self.io_handler.imwrite(self._undistorted_mask_file(image), array)
@@ -784,7 +790,7 @@ def undistorted_segmentation_exists(self, image: str) -> bool:
         """Check if the undistorted segmentation file exists."""
         return self.io_handler.isfile(self._undistorted_segmentation_file(image))
 
-    def load_undistorted_segmentation(self, image: str) -> np.ndarray:
+    def load_undistorted_segmentation(self, image: str) -> NDArray:
         """Load an undistorted image segmentation."""
         segmentation_file = self._undistorted_segmentation_file(image)
         with self.io_handler.open_rb(segmentation_file) as fp:
@@ -804,12 +810,12 @@ def load_undistorted_segmentation(self, image: str) -> np.ndarray:
                 else:
                     raise IndexError
 
-    def save_undistorted_segmentation(self, image: str, array: np.ndarray) -> None:
+    def save_undistorted_segmentation(self, image: str, array: NDArray) -> None:
         """Save the undistorted image segmentation."""
         self.io_handler.mkdir_p(self._undistorted_segmentation_path())
         self.io_handler.imwrite(self._undistorted_segmentation_file(image), array)
 
-    def load_undistorted_segmentation_mask(self, image: str) -> Optional[np.ndarray]:
+    def load_undistorted_segmentation_mask(self, image: str) -> Optional[NDArray]:
         """Build a mask from the undistorted segmentation.
 
         The mask is non-zero only for pixels with segmentation
@@ -828,7 +834,7 @@ def load_undistorted_segmentation_mask(self, image: str) -> Optional[np.ndarray]
 
         return masking.mask_from_segmentation(segmentation, ignore_values)
 
-    def load_undistorted_combined_mask(self, image: str) -> Optional[np.ndarray]:
+    def load_undistorted_combined_mask(self, image: str) -> Optional[NDArray]:
         """Combine undistorted binary mask with segmentation mask.
 
         Return a mask that is non-zero only where the binary
@@ -854,16 +860,16 @@ def point_cloud_file(self, filename: str = "merged.ply") -> str:
 
     def load_point_cloud(
         self, filename: str = "merged.ply"
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
         with self.io_handler.open_rt(self.point_cloud_file(filename)) as fp:
             return io.point_cloud_from_ply(fp)
 
     def save_point_cloud(
         self,
-        points: np.ndarray,
-        normals: np.ndarray,
-        colors: np.ndarray,
-        labels: np.ndarray,
+        points: NDArray,
+        normals: NDArray,
+        colors: NDArray,
+        labels: NDArray,
         filename: str = "merged.ply",
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
@@ -876,11 +882,11 @@ def raw_depthmap_exists(self, image: str) -> bool:
     def save_raw_depthmap(
         self,
         image: str,
-        depth: np.ndarray,
-        plane: np.ndarray,
-        score: np.ndarray,
-        nghbr: np.ndarray,
-        nghbrs: np.ndarray,
+        depth: NDArray,
+        plane: NDArray,
+        score: NDArray,
+        nghbr: NDArray,
+        nghbrs: NDArray,
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "raw.npz")
@@ -891,7 +897,7 @@ def save_raw_depthmap(
 
     def load_raw_depthmap(
         self, image: str
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray, NDArray, NDArray, NDArray, NDArray]:
         with self.io_handler.open_rb(self.depthmap_file(image, "raw.npz")) as f:
             o = np.load(f)
             return o["depth"], o["plane"], o["score"], o["nghbr"], o["nghbrs"]
@@ -900,16 +906,14 @@ def clean_depthmap_exists(self, image: str) -> bool:
         return self.io_handler.isfile(self.depthmap_file(image, "clean.npz"))
 
     def save_clean_depthmap(
-        self, image: str, depth: np.ndarray, plane: np.ndarray, score: np.ndarray
+        self, image: str, depth: NDArray, plane: NDArray, score: NDArray
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "clean.npz")
         with self.io_handler.open_wb(filepath) as f:
             np.savez_compressed(f, depth=depth, plane=plane, score=score)
 
-    def load_clean_depthmap(
-        self, image: str
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def load_clean_depthmap(self, image: str) -> Tuple[NDArray, NDArray, NDArray]:
         with self.io_handler.open_rb(self.depthmap_file(image, "clean.npz")) as f:
             o = np.load(f)
             return o["depth"], o["plane"], o["score"]
@@ -920,10 +924,10 @@ def pruned_depthmap_exists(self, image: str) -> bool:
     def save_pruned_depthmap(
         self,
         image: str,
-        points: np.ndarray,
-        normals: np.ndarray,
-        colors: np.ndarray,
-        labels: np.ndarray,
+        points: NDArray,
+        normals: NDArray,
+        colors: NDArray,
+        labels: NDArray,
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "pruned.npz")
@@ -938,7 +942,7 @@ def save_pruned_depthmap(
 
     def load_pruned_depthmap(
         self, image: str
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    ) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
         with self.io_handler.open_rb(self.depthmap_file(image, "pruned.npz")) as f:
             o = np.load(f)
             return (
diff --git a/opensfm/io.py b/opensfm/io.py
index 36a1f02f1..3f4adc7e6 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import json
 import logging
 import os
@@ -21,12 +21,14 @@
 import cv2
 import numpy as np
 import pyproj
-from numpy import ndarray
+from numpy.typing import NDArray
 from opensfm import context, features, geo, pygeometry, pymap, types
 from PIL import Image
 
 logger: logging.Logger = logging.getLogger(__name__)
 
+JSONType = Any  # pyre-ignore[33]
+
 
 def camera_from_json(key: str, obj: Dict[str, Any]) -> pygeometry.Camera:
     """
@@ -347,7 +349,7 @@ def cameras_from_json(obj: Dict[str, Any]) -> Dict[str, pygeometry.Camera]:
     return cameras
 
 
-def camera_to_json(camera) -> Dict[str, Any]:
+def camera_to_json(camera: pygeometry.Camera) -> Dict[str, Any]:
     """
     Write camera to a json object
     """
@@ -834,7 +836,7 @@ def camera_to_vector(camera: pygeometry.Camera) -> List[float]:
 
 def _read_gcp_list_lines(
     lines: Iterable[str],
-    projection,
+    projection: Optional[pyproj.Transformer],
     exifs: Dict[str, Dict[str, Any]],
 ) -> List[pymap.GroundControlPoint]:
     points = {}
@@ -925,7 +927,9 @@ def _valid_gcp_line(line: str) -> bool:
     return stripped != "" and stripped[0] != "#"
 
 
-def read_gcp_list(fileobj, exif: Dict[str, Any]) -> List[pymap.GroundControlPoint]:
+def read_gcp_list(
+    fileobj: IO[str], exif: Dict[str, Any]
+) -> List[pymap.GroundControlPoint]:
     """Read a ground control points from a gcp_list.txt file.
 
     It requires the points to be in the WGS84 lat, lon, alt format.
@@ -938,7 +942,7 @@ def read_gcp_list(fileobj, exif: Dict[str, Any]) -> List[pymap.GroundControlPoin
     return points
 
 
-def read_ground_control_points(fileobj: IO) -> List[pymap.GroundControlPoint]:
+def read_ground_control_points(fileobj: IO[str]) -> List[pymap.GroundControlPoint]:
     """Read ground control points from json file"""
     obj = json_load(fileobj)
 
@@ -973,7 +977,7 @@ def read_ground_control_points(fileobj: IO) -> List[pymap.GroundControlPoint]:
 
 def write_ground_control_points(
     gcp: List[pymap.GroundControlPoint],
-    fileobj: IO,
+    fileobj: IO[str],
 ) -> None:
     """Write ground control points to json file."""
     obj = {"points": []}
@@ -1011,21 +1015,21 @@ def json_dump_kwargs(minify: bool = False) -> Dict[str, Any]:
     return {"indent": indent, "ensure_ascii": False, "separators": separators}
 
 
-def json_dump(data, fout: IO[str], minify: bool = False) -> None:
+def json_dump(data: JSONType, fout: IO[str], minify: bool = False) -> None:
     kwargs = json_dump_kwargs(minify)
     return json.dump(data, fout, **kwargs)
 
 
-def json_dumps(data, minify: bool = False) -> str:
+def json_dumps(data: JSONType, minify: bool = False) -> str:
     kwargs = json_dump_kwargs(minify)
     return json.dumps(data, **kwargs)
 
 
-def json_load(fp: Union[IO[str], IO[bytes]]) -> Any:
+def json_load(fp: Union[IO[str], IO[bytes]]) -> JSONType:
     return json.load(fp)
 
 
-def json_loads(text: Union[str, bytes]) -> Any:
+def json_loads(text: Union[str, bytes]) -> JSONType:
     return json.loads(text)
 
 
@@ -1125,7 +1129,7 @@ def reconstruction_to_ply(
 
 def point_cloud_from_ply(
     fp: TextIO,
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
     """Load point cloud from a PLY file."""
     all_lines = fp.read().splitlines()
     start = all_lines.index("end_header") + 1
@@ -1149,10 +1153,10 @@ def point_cloud_from_ply(
 
 
 def point_cloud_to_ply(
-    points: np.ndarray,
-    normals: np.ndarray,
-    colors: np.ndarray,
-    labels: np.ndarray,
+    points: NDArray,
+    normals: NDArray,
+    colors: NDArray,
+    labels: NDArray,
     fp: TextIO,
 ) -> None:
     fp.write("ply\n")
@@ -1195,26 +1199,29 @@ def mkdir_p(path: str) -> None:
     os.makedirs(path, exist_ok=True)
 
 
-def open_wt(path: str) -> IO[Any]:
+def open_wt(path: str) -> TextIO:
     """Open a file in text mode for writing utf-8."""
     return open(path, "w", encoding="utf-8")
 
 
-def open_rt(path: str) -> IO[Any]:
+def open_rt(path: str) -> TextIO:
     """Open a file in text mode for reading utf-8."""
     return open(path, "r", encoding="utf-8")
 
 
 def imread(
     path: str, grayscale: bool = False, unchanged: bool = False, anydepth: bool = False
-) -> ndarray:
+) -> NDArray:
     with open(path, "rb") as fb:
         return imread_from_fileobject(fb, grayscale, unchanged, anydepth)
 
 
 def imread_from_fileobject(
-    fb, grayscale: bool = False, unchanged: bool = False, anydepth: bool = False
-) -> np.ndarray:
+    fb: IO[bytes],
+    grayscale: bool = False,
+    unchanged: bool = False,
+    anydepth: bool = False,
+) -> NDArray:
     """Load image as an array ignoring EXIF orientation."""
     if context.OPENCV3:
         if grayscale:
@@ -1256,18 +1263,15 @@ def imread_from_fileobject(
         image[:, :, :3] = image[:, :, [2, 1, 0]]  # Turn BGR to RGB (or BGRA to RGBA)
     return image
 
-    @classmethod
-    def imwrite(cls, path: str, image: np.ndarray) -> None:
-        with cls.open(path, "wb") as fwb:
-            imwrite(fwb, image, path)
-
 
-def imwrite(path: str, image: np.ndarray) -> None:
+def imwrite(path: str, image: NDArray) -> None:
     with open(path, "wb") as fwb:
         return imwrite_from_fileobject(fwb, image, path)
 
 
-def imwrite_from_fileobject(fwb, image: np.ndarray, ext: str) -> None:
+def imwrite_from_fileobject(
+    fwb: Union[IO[str], IO[bytes]], image: NDArray, ext: str
+) -> None:
     """Write an image to a file object"""
     if len(image.shape) == 3:
         image[:, :, :3] = image[:, :, [2, 1, 0]]  # Turn RGB to BGR (or RGBA to BGRA)
@@ -1298,33 +1302,27 @@ def image_size(path: str) -> Tuple[int, int]:
 class IoFilesystemBase(ABC):
     @classmethod
     @abstractmethod
-    def exists(cls, path: str):
-        pass
+    def exists(cls, path: str) -> bool: ...
 
     @classmethod
     @abstractmethod
-    def ls(cls, path: str):
-        pass
+    def ls(cls, path: str) -> List[str]: ...
 
     @classmethod
     @abstractmethod
-    def isfile(cls, path: str):
-        pass
+    def isfile(cls, path: str) -> bool: ...
 
     @classmethod
     @abstractmethod
-    def isdir(cls, path: str):
-        pass
+    def isdir(cls, path: str) -> bool: ...
 
     @classmethod
     @abstractmethod
-    def rm_if_exist(cls, filename: str):
-        pass
+    def rm_if_exist(cls, filename: str) -> None: ...
 
     @classmethod
     @abstractmethod
-    def symlink(cls, src_path: str, dst_path: str, **kwargs):
-        pass
+    def symlink(cls, src_path: str, dst_path: str, **kwargs: Any) -> None: ...
 
     @classmethod
     @abstractmethod
@@ -1348,28 +1346,29 @@ def open_at(cls, path: str) -> TextIO: ...
 
     @classmethod
     @abstractmethod
-    def mkdir_p(cls, path: str):
-        pass
+    def mkdir_p(cls, path: str) -> None: ...
 
     @classmethod
     @abstractmethod
-    def imwrite(cls, path: str, image):
-        pass
+    def imwrite(cls, path: str, image: NDArray) -> None: ...
 
     @classmethod
     @abstractmethod
-    def imread(cls, path: str, grayscale=False, unchanged=False, anydepth=False):
-        pass
+    def imread(
+        cls,
+        path: str,
+        grayscale: bool = False,
+        unchanged: bool = False,
+        anydepth: bool = False,
+    ) -> NDArray: ...
 
     @classmethod
     @abstractmethod
-    def image_size(cls, path: str):
-        pass
+    def image_size(cls, path: str) -> Tuple[int, int]: ...
 
     @classmethod
     @abstractmethod
-    def timestamp(cls, path: str):
-        pass
+    def timestamp(cls, path: str) -> float: ...
 
 
 class IoFilesystemDefault(IoFilesystemBase):
@@ -1377,8 +1376,7 @@ def __init__(self) -> None:
         self.type = "default"
 
     @classmethod
-    def exists(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
+    def exists(cls, path: str) -> bool:
         return os.path.exists(path)
 
     @classmethod
@@ -1386,13 +1384,11 @@ def ls(cls, path: str) -> List[str]:
         return os.listdir(path)
 
     @classmethod
-    def isfile(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
+    def isfile(cls, path: str) -> bool:
         return os.path.isfile(path)
 
     @classmethod
-    def isdir(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `bool`.
+    def isdir(cls, path: str) -> bool:
         return os.path.isdir(path)
 
     @classmethod
@@ -1406,7 +1402,7 @@ def rm_if_exist(cls, filename: str) -> None:
                 os.remove(filename)
 
     @classmethod
-    def symlink(cls, src_path: str, dst_path: str, **kwargs):
+    def symlink(cls, src_path: str, dst_path: str, **kwargs: Any) -> None:
         os.symlink(src_path, dst_path, **kwargs)
 
     @classmethod
@@ -1430,8 +1426,8 @@ def open_at(cls, path: str) -> TextIO:
         return open(path, "at")
 
     @classmethod
-    def mkdir_p(cls, path: str):
-        return os.makedirs(path, exist_ok=True)
+    def mkdir_p(cls, path: str) -> None:
+        os.makedirs(path, exist_ok=True)
 
     @classmethod
     def imread(
@@ -1440,12 +1436,12 @@ def imread(
         grayscale: bool = False,
         unchanged: bool = False,
         anydepth: bool = False,
-    ):
+    ) -> NDArray:
         with cls.open_rb(path) as fb:
             return imread_from_fileobject(fb, grayscale, unchanged, anydepth)
 
     @classmethod
-    def imwrite(cls, path: str, image) -> None:
+    def imwrite(cls, path: str, image: NDArray) -> None:
         with cls.open_wb(path) as fwb:
             imwrite_from_fileobject(fwb, image, path)
 
@@ -1455,6 +1451,5 @@ def image_size(cls, path: str) -> Tuple[int, int]:
             return image_size_from_fileobject(fb)
 
     @classmethod
-    def timestamp(cls, path: str) -> str:
-        # pyre-fixme[7]: Expected `str` but got `float`.
+    def timestamp(cls, path: str) -> float:
         return os.path.getmtime(path)

From 187867f0ec99122d65ca8a36eddec64214e52ee2 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Thu, 24 Apr 2025 23:04:25 -0700
Subject: [PATCH 121/235] remove noisy log

Summary:
removing a log that happens every time a GPS constraint is added. We do not have any other log in the entire bundle library. It seems we do not need that one neither. It becomes rather noisy and makes it harder to follow the higher-level flow. See an example [here](https://www.internalfb.com/logarithm/search/chronos?filters=[%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22EXACT_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22clusterName%22%2C%22values%22%3A[%22dw-global-chronosgp%22]%7D%2C%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22EXACT_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22jobInstanceID%22%2C%22values%22%3A[%22117093600086037066%22]%7D%2C%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22EXACT_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22sessionId%22%2C%22values%22%3A[%222105022387006102788%22]%7D%2C%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22EXACT_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22containerID%22%2C%22values%22%3A[%22117093600086037066%22]%7D%2C%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22SUBSTRING_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22logMessage%22%2C%22values%22%3A[%22asyncnxdb.ftw.8062%3A12936361747%22]%7D%2C%7B%22combine_type%22%3A%22OR%22%2C%22match_type%22%3A%22EXACT_MATCH%22%2C%22modifiers%22%3A%7B%22case_insensitive%22%3Afalse%2C%22not_match%22%3Afalse%7D%2C%22name%22%3A%22streamId%22%2C%22values%22%3A[%22stderr%22]%7D]&timeRange=%7B%22start%22%3A%7B%22instant%22%3A%222025-04-24T11%3A00%3A59Z%22%2C%22timezoneID%22%3A1%7D%2C%22end%22%3A%7B%22instant%22%3A%222025-04-24T14%3A34%3A45Z%22%2C%22timezoneID%22%3A1%7D%7D&view=%22MONACO%22)

```
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.819 2612417 reconstruction.py:1450] -------------------------------------------------------
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.834 2612417 reconstruction.py:721] 6tAriB8LDHXS0RehTYafN9 resection inliers: 729 / 771
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.846 2612417 reconstruction.py:1474] Adding 6tAriB8LDHXS0RehTYafN9 to the reconstruction
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969669 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance exkR6GHwmu97dPoOClJ4XU, count: 1, avg pos: -24.3398  9.79252  1.99995, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969727 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance X2DMGYk6gnAfQts5RHh0vL, count: 1, avg pos: -15.2683 0.937179  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969749 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance uWSA7JlIBVDLbRvoYm8wy3, count: 1, avg pos: -19.648 8.54131 1.99996, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969771 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance xzvyMGohENnYA3fW92gjHi, count: 1, avg pos: -27.5425  10.6014  1.99993, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969791 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance F9YCUL6scrtbNh1VfXiZgB, count: 1, avg pos: -15.4032  2.71519  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969811 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance vS0W74oTt9RlcfrLV6x3JH, count: 1, avg pos: -15.898 4.43929 1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969830 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance ibMzl37T6OySB0xQVDqERA, count: 1, avg pos: -15.2235   1.5375  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969859 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance 5EOuR7iJlNChxGaQHBv0dc, count: 1, avg pos: -18.9972  7.04735  1.99997, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969878 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance NdPqjab04Zok3i5pIsgJEc, count: 1, avg pos: -15.4032  2.71519  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969902 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance bTFBvVWIw8OUQrH7gh9efS, count: 1, avg pos: -18.1727  5.29675  1.99997, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969919 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance jAuNnSQGT3ZL7heoY41lgq, count: 1, avg pos: -19.648 8.54131 1.99996, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969939 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance PaUG8REWkzcK5julMiYqJ1, count: 1, avg pos: -15.2683 0.937179  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969960 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance 6tAriB8LDHXS0RehTYafN9, count: 1, avg pos: -30.4304  10.6705  1.99992, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.969986 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance zx6g8rl1ndM25V3ebCjvUR, count: 1, avg pos: -15.1004  3.60056  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970005 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance 72aSQMyr1TRUPK8XjVAbvd, count: 1, avg pos: -13.2918  4.50606  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970023 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance mBWKqVX2AQSZdxoYyNMgls, count: 1, avg pos: -24.3398  9.79252  1.99995, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970044 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance ALknFHMYQIZrsgaNv0XPh8, count: 1, avg pos: -17.4666  3.73878  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970067 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance NZBEma9AwKCziWMTHueIvs, count: 1, avg pos: -15.2235   1.5375  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970094 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance S4QiMbhfCl7FacdBqHpwj2, count: 1, avg pos: -15.6374   1.7532  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970115 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance YfqCxFhQveJKZlXAjt2c1i, count: 1, avg pos: -18.9972  7.04735  1.99997, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970137 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance EflJnteZSN4UgDMqwu5G0r, count: 1, avg pos: -19.8375  8.80979  1.99996, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970155 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance iZXtbmpjDGoKalYrJ7excv, count: 1, avg pos: -12.0215   4.2051  1.99999, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970173 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance OBA3l8ysCXwHQfj5MctVNF, count: 1, avg pos: -29.5429  11.9556  1.99992, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970196 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance CIySLlzJhka4wTx5orW7tv, count: 1, avg pos: -14.4772  4.24308  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970216 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance BOlf4pA5XirDZzbcFCYVN7, count: 1, avg pos: -16.2796  1.79833  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970234 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance oAjNLDXsBhrW3S2QwT9EU7, count: 1, avg pos: -15.898 4.43929 1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970253 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance TWqE5ZAk31aDYwKvjLMIgQ, count: 1, avg pos: -17.4666  3.73878  1.99998, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970280 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance Ug1G8r9c7nXuBpzjDVfJET, count: 1, avg pos: -20.0704  8.38427  1.99996, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970301 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance Cc4g3zIrV7YXhundLG61sm, count: 1, avg pos: -27.5425  10.6014  1.99993, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:03.970350 2612417 ba_helpers.cc:211] bundle_use_gps: 1, adding average GPS prior to rig instance Bf23NrgnHiI7dYL60MhQ4X, count: 1, avg pos: -27.5425  10.6014  1.99993, avg std: 15, scale group: dummy
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:05.558 2612417 reconstruction.py:65] Ran LOCAL bundle in 1.61 secs.with 30/13661/46598 (3.41) shots/points/proj. (avg. length)
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:05.719 2612417 reconstruction.py:1245] Removed outliers: 0
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:05.719 2612417 reconstruction.py:1523] Reconstruction now has 100 shots.
[asyncnxdb.ftw.8062:12936361747]: I0424 04:19:05.767 2612417 reconstruction.py:1530] -------------------------------------------------------
```

Reviewed By: xeob

Differential Revision: D73590090

fbshipit-source-id: 18bf202eb406df6a17c3c02aec4277a90b99143a
---
 opensfm/src/sfm/src/ba_helpers.cc | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index c6d6fbd00..85ed5747a 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -208,12 +208,6 @@ py::tuple BAHelpers::BundleLocal(
 
     // only add averaged rig position constraints to moving instances
     if (!fix_instance && gps_count > 0) {
-      LOG(INFO) << "bundle_use_gps: " << config["bundle_use_gps"].cast<bool>()
-                << ", adding average GPS prior to rig instance "
-                << rig_instance_id << ", count: " << gps_count
-                << ", avg pos: " << average_position.transpose()
-                << ", avg std: " << average_std
-                << ", scale group: " << gps_scale_group;
       average_position /= gps_count;
       average_std /= gps_count;
       ba.AddRigInstancePositionPrior(rig_instance_id, average_position,

From 41e5b8952c6a7076573c55c25414bc000f49a80f Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Mon, 5 May 2025 04:48:04 -0700
Subject: [PATCH 122/235] remove debug logs

Summary:
Before:
```
2025-04-29 02:52:14,264 INFO: -------------------------------------------------------
2025-04-29 02:52:14,267 INFO: 22.jpg resection inliers: 50 / 52
2025-04-29 02:52:14,268 INFO: Adding 22.jpg to the reconstruction
2025-04-29 02:52:14,275 INFO: Re-triangulating
2025-04-29 02:52:14,275 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,275 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,275 INFO: GPS constraints X (6) - Xp (6)
2025-04-29 02:52:14,276 INFO: Shots and/or GCPs are well-conditioned. Using naive 3D-3D alignment.
2025-04-29 02:52:14,276 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,276 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,276 INFO: GPS constraints X (6) - Xp (6)
2025-04-29 02:52:14,518 INFO: Ran GLOBAL bundle in 0.24 secs.with 6/487/1138 (2.34) shots/points/proj. (avg. length)
2025-04-29 02:52:14,518 DEBUG: Ceres Solver Report: Iterations: 101, Initial cost: 8.076824e+01, Final cost: 4.447466e+01, Termination: NO_CONVERGENCE
2025-04-29 02:52:14,570 INFO: Ran GLOBAL bundle in 0.02 secs.with 6/435/1033 (2.37) shots/points/proj. (avg. length)
2025-04-29 02:52:14,570 DEBUG: Ceres Solver Report: Iterations: 9, Initial cost: 4.147005e+01, Final cost: 3.698874e+01, Termination: CONVERGENCE
2025-04-29 02:52:14,572 INFO: Removed outliers: 0
2025-04-29 02:52:14,572 INFO: Reconstruction now has 6 shots.
2025-04-29 02:52:14,572 INFO: -------------------------------------------------------
2025-04-29 02:52:14,574 INFO: 28.jpg resection inliers: 18 / 20
2025-04-29 02:52:14,575 INFO: Adding 28.jpg to the reconstruction
2025-04-29 02:52:14,597 INFO: Ran LOCAL bundle in 0.02 secs.with 6/494/1182 (2.39) shots/points/proj. (avg. length)
2025-04-29 02:52:14,597 DEBUG: Ceres Solver Report: Iterations: 8, Initial cost: 6.099325e+01, Final cost: 4.481871e+01, Termination: CONVERGENCE
2025-04-29 02:52:14,599 INFO: Removed outliers: 0
2025-04-29 02:52:14,599 INFO: Reconstruction now has 7 shots.
2025-04-29 02:52:14,599 INFO: -------------------------------------------------------
2025-04-29 02:52:14,602 INFO: 29.jpg resection inliers: 12 / 18
2025-04-29 02:52:14,603 INFO: Adding 29.jpg to the reconstruction
2025-04-29 02:52:14,608 INFO: Re-triangulating
2025-04-29 02:52:14,608 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,608 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,608 INFO: GPS constraints X (8) - Xp (8)
2025-04-29 02:52:14,609 INFO: Shots and/or GCPs are well-conditioned. Using naive 3D-3D alignment.
2025-04-29 02:52:14,609 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,609 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,609 INFO: GPS constraints X (8) - Xp (8)
2025-04-29 02:52:14,639 INFO: Ran GLOBAL bundle in 0.03 secs.with 8/588/1398 (2.38) shots/points/proj. (avg. length)
2025-04-29 02:52:14,639 DEBUG: Ceres Solver Report: Iterations: 8, Initial cost: 7.072505e+01, Final cost: 5.534893e+01, Termination: CONVERGENCE
2025-04-29 02:52:14,708 INFO: Ran GLOBAL bundle in 0.03 secs.with 8/569/1371 (2.41) shots/points/proj. (avg. length)
2025-04-29 02:52:14,708 DEBUG: Ceres Solver Report: Iterations: 9, Initial cost: 6.128178e+01, Final cost: 5.419012e+01, Termination: CONVERGENCE
2025-04-29 02:52:14,710 INFO: Removed outliers: 0
2025-04-29 02:52:14,710 INFO: Reconstruction now has 8 shots.
2025-04-29 02:52:14,710 INFO: -------------------------------------------------------
2025-04-29 02:52:14,711 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,711 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,711 INFO: GPS constraints X (8) - Xp (8)
2025-04-29 02:52:14,711 INFO: Shots and/or GCPs are well-conditioned. Using naive 3D-3D alignment.
2025-04-29 02:52:14,711 INFO: Collecting alignment constraints - bundle_use_gps:True bundle_use_gcp: True
2025-04-29 02:52:14,711 INFO: GCP constraints X (0) - Xp (0)
2025-04-29 02:52:14,711 INFO: GPS constraints X (8) - Xp (8)
2025-04-29 02:52:14,738 INFO: Ran GLOBAL bundle in 0.02 secs.with 8/569/1371 (2.41) shots/points/proj. (avg. length)
2025-04-29 02:52:14,738 DEBUG: Ceres Solver Report: Iterations: 7, Initial cost: 5.426797e+01, Final cost: 5.419008e+01, Termination: CONVERGENCE
2025-04-29 02:52:14,740 INFO: Removed outliers: 0
2025-04-29 02:52:14,743 INFO: Reconstruction 0: 15 images, 2577 points
2025-04-29 02:52:14,743 INFO: Reconstruction 1: 8 images, 569 points
2025-04-29 02:52:14,743 INFO: Reconstruction 2: 6 images, 656 points
```

after
```
2025-04-29 02:59:43,495 INFO: -------------------------------------------------------
2025-04-29 02:59:43,498 INFO: 27.jpg resection inliers: 31 / 39
2025-04-29 02:59:43,499 INFO: Adding 27.jpg to the reconstruction
2025-04-29 02:59:43,509 INFO: Re-triangulating
2025-04-29 02:59:43,510 INFO: Shots and/or GCPs are well-conditioned. Using naive 3D-3D alignment.
2025-04-29 02:59:43,759 INFO: Ran GLOBAL bundle in 0.23 secs.with 27/3810/9319 (2.45) shots/points/proj. (avg. length)
2025-04-29 02:59:43,759 DEBUG: Ceres Solver Report: Iterations: 11, Initial cost: 3.029746e+02, Final cost: 2.628480e+02, Termination: CONVERGENCE
2025-04-29 02:59:44,565 INFO: Ran GLOBAL bundle in 0.55 secs.with 27/3823/9383 (2.45) shots/points/proj. (avg. length)
2025-04-29 02:59:44,565 DEBUG: Ceres Solver Report: Iterations: 28, Initial cost: 3.264498e+02, Final cost: 2.854518e+02, Termination: CONVERGENCE
2025-04-29 02:59:44,578 INFO: Removed outliers: 13
2025-04-29 02:59:44,579 INFO: Reconstruction now has 27 shots.
2025-04-29 02:59:44,580 INFO: -------------------------------------------------------
2025-04-29 02:59:44,582 INFO: 28.jpg resection inliers: 15 / 18
2025-04-29 02:59:44,583 INFO: Adding 28.jpg to the reconstruction
2025-04-29 02:59:44,604 INFO: Ran LOCAL bundle in 0.02 secs.with 5/509/1258 (2.47) shots/points/proj. (avg. length)
2025-04-29 02:59:44,604 DEBUG: Ceres Solver Report: Iterations: 7, Initial cost: 4.533193e+01, Final cost: 3.416239e+01, Termination: CONVERGENCE
2025-04-29 02:59:44,606 INFO: Removed outliers: 0
2025-04-29 02:59:44,606 INFO: Reconstruction now has 28 shots.
2025-04-29 02:59:44,608 INFO: -------------------------------------------------------
2025-04-29 02:59:44,610 INFO: 29.jpg resection inliers: 12 / 16
2025-04-29 02:59:44,611 INFO: Adding 29.jpg to the reconstruction
2025-04-29 02:59:44,640 INFO: Ran LOCAL bundle in 0.02 secs.with 6/593/1466 (2.47) shots/points/proj. (avg. length)
2025-04-29 02:59:44,641 DEBUG: Ceres Solver Report: Iterations: 7, Initial cost: 6.070500e+01, Final cost: 4.778278e+01, Termination: CONVERGENCE
2025-04-29 02:59:44,643 INFO: Removed outliers: 2
2025-04-29 02:59:44,643 INFO: Reconstruction now has 29 shots.
2025-04-29 02:59:44,644 INFO: -------------------------------------------------------
2025-04-29 02:59:44,645 INFO: Shots and/or GCPs are well-conditioned. Using naive 3D-3D alignment.
2025-04-29 02:59:44,923 INFO: Ran GLOBAL bundle in 0.26 secs.with 29/3956/9711 (2.45) shots/points/proj. (avg. length)
2025-04-29 02:59:44,923 DEBUG: Ceres Solver Report: Iterations: 12, Initial cost: 2.912816e+02, Final cost: 2.892122e+02, Termination: CONVERGENCE
2025-04-29 02:59:44,937 INFO: Removed outliers: 1
2025-04-29 02:59:44,957 INFO: Reconstruction 0: 29 images, 3956 points
```

Reviewed By: xeob

Differential Revision: D73843312

fbshipit-source-id: 0f5b64e50f2b23de5e18a65c2b3366bad972adae
---
 opensfm/align.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index b2a14e2df..0ee303a31 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -124,15 +124,11 @@ def alignment_constraints(
     """Gather alignment constraints to be used by checking bundle_use_gcp and bundle_use_gps."""
 
     X, Xp = [], []
-    logger.info(
-        f"Collecting alignment constraints - bundle_use_gps:{config['bundle_use_gps']} bundle_use_gcp: {config['bundle_use_gcp']}"
-    )
     # Get Ground Control Point correspondences
     if gcp and config["bundle_use_gcp"]:
         triangulated, measured = triangulate_all_gcp(reconstruction, gcp)
         X.extend(triangulated)
         Xp.extend(measured)
-    logger.info(f"GCP constraints X ({len(X)}) - Xp ({len(Xp)})")
     # Get camera center correspondences
     if use_gps and config["bundle_use_gps"]:
         for rig_instance in reconstruction.rig_instances.values():
@@ -144,7 +140,6 @@ def alignment_constraints(
             if len(gpses) > 0:
                 X.append(rig_instance.pose.get_origin())
                 Xp.append(np.average(gpses, axis=0))
-    logger.info(f"GPS constraints X ({len(X)}) - Xp ({len(Xp)})")
     return X, Xp
 
 

From 00300ade5856a5365f3fb19d3e388e848309b027 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Thu, 15 May 2025 05:14:41 -0700
Subject: [PATCH 123/235] Introduce the use of anaconda for dependencies
 (#1093)

Summary:
This PR switches the dependencies management to anaconda (C++ + Python deps), while ensuring it works on :
 - Ubuntu 24.04
 - Fedora 42
 - MacOS Sequoia

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1093

Reviewed By: YanNoun

Differential Revision: D74713257

Pulled By: paulinus

fbshipit-source-id: bbca46025ae3f6f0c6042369b857b023cdfff3a8
---
 conda.yml                             | 31 +++++++++++++++
 doc/source/building.rst               | 57 ++++++++-------------------
 opensfm/src/CMakeLists.txt            |  4 +-
 opensfm/src/features/src/matching.cc  |  1 +
 opensfm/src/foundation/python_types.h |  1 +
 opensfm/src/geo/python/pybind.cc      |  1 +
 opensfm/src/geometry/python/pybind.cc |  1 +
 opensfm/src/geometry/triangulation.h  |  9 ++---
 opensfm/src/map/pybind_utils.h        |  1 +
 opensfm/src/map/python/pybind.cc      |  1 +
 10 files changed, 60 insertions(+), 47 deletions(-)
 create mode 100644 conda.yml

diff --git a/conda.yml b/conda.yml
new file mode 100644
index 000000000..472a4ad3d
--- /dev/null
+++ b/conda.yml
@@ -0,0 +1,31 @@
+name: opensfm
+dependencies:
+    - python=3.8
+    - cmake=3.31
+    - make
+    - libxcrypt
+    - opencv
+    - ceres-solver=2.1
+    - conda-forge::llvm-openmp
+    - conda-forge::cxx-compiler
+    - pip
+    - pip:
+        - cloudpickle==0.4.0
+        - exifread==2.1.2
+        - flask==2.3.2
+        - fpdf2==2.4.6
+        - joblib==0.14.1
+        - matplotlib
+        - networkx==2.5
+        - numpy>=1.19
+        - Pillow>=8.1.1
+        - pyproj>=1.9.5.1
+        - pytest==6.2.0
+        - python-dateutil>=2.7
+        - pyyaml>5.4
+        - scipy>=1.10.0
+        - Sphinx==4.2.0
+        - six
+        - xmltodict==0.10.2
+        - wheel
+        - sphinx_rtd_theme
diff --git a/doc/source/building.rst b/doc/source/building.rst
index 56a76ec96..dd1ad3cf0 100644
--- a/doc/source/building.rst
+++ b/doc/source/building.rst
@@ -20,58 +20,35 @@ If you already have the code or you downloaded a release_, make sure to update t
 Install dependencies
 --------------------
 
-OpenSfM depends on the following libraries that need to be installed before building it.
+OpenSfM depends on multiple libraries (OpenCV_, `Ceres Solver`_, ...) and python packages that need to be installed before building it.
 
-* OpenCV_
-* `Ceres Solver`_
+The way to install these dependencies depends on your system. We recommend using a virtual environment manager such as anaconda or miniconda, not to mess up with your current setup. Anaconda will take care of installing both systems and python dependencies.
 
-Python dependencies can be installed with::
+Installing dependencies using Conda (recommended)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    pip install -r requirements.txt
+Creating a conda environment will take care of installing all dependencies. Make sure you have conda or miniconda installed.  From the project root directory, run::
 
+    conda env create --file conda.yml --yes
 
-Installing dependencies on Ubuntu
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+You can then activate the anaconda environment with::
 
-See this `Dockerfile <https://github.com/mapillary/OpenSfM/blob/main/Dockerfile>`_ for the commands to install all dependencies on Ubuntu 20.04.
+    conda activate opensfm
 
-Installing dependencies on Fedora
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+and you are ready to build OpenSfM.
 
-Tested on Fedora 33 & 34
+(Anaconda dependencies installation has been tested under MacOS (Sequoia), Ubuntu 24.04 and Fedora 42.)
 
-    sudo dnf install zlib-devel libjpeg-devel python3-devel g++ ceres-solver-devel opencv-devel python3-opencv eigen3-devel libomp cmake glog-devel
-
-There's an `issue <https://github.com/ceres-solver/ceres-solver/issues/491>`_ with the gflags-config.cmake distributed with Fedora. This quick workaround works::
-
-    sudo sed -i "s^set (GFLAGS_INCLUDE_DIR.*^set (GFLAGS_INCLUDE_DIR "/usr/include")^" /usr/lib64/cmake/gflags/gflags-config.cmake
+Installing dependencies on Ubuntu
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Install python dependencies before building::
+If you are not using conda, see this `Dockerfile <https://github.com/mapillary/OpenSfM/blob/main/Dockerfile>`_ for the commands to install all dependencies on Ubuntu 20.04.
 
-    cd ~/src/OpenSfM && pip install -r requirements.txt
 
 Installing dependencies on MacOSX
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Install OpenCV and the Ceres solver using::
-
-    brew install opencv
-    brew install ceres-solver
-    brew install libomp
-    sudo pip install -r requirements.txt
-
-Make sure you update your ``PYTHONPATH`` to include ``/usr/local/lib/python3.7/site-packages`` where OpenCV have been installed. For example with::
-
-    export PYTHONPATH=/usr/local/lib/python3.7/site-packages:$PYTHONPATH
-
-Also, in order for Cmake to recognize the libraries installed by Brew, make sure that C_INCLUDE_PATH, CPLUS_INCLUDE_PATH, DYLD_LIBRARY_PATH environment variables are set correctly. For example, you can run::
-
-    export C_INCLUDE_PATH=/usr/local/include
-    export CPLUS_INCLUDE_PATH=/usr/local/include
-    export DYLD_LIBRARY_PATH=$HOME/local/lib64
-
-.. note:: Note on OpenCV 3
-    When running OpenSfM on top of OpenCV version 3.0 the `OpenCV Contrib`_ modules are required for extracting SIFT or SURF features.
+While it is possible to install all dependencies using brew, we recommend using the conda instructions above instead.
 
 
 Installing dependencies on Windows
@@ -106,7 +83,7 @@ Building the library
 
 Once the dependencies have been installed, you can build OpenSfM by running the following command from the main folder::
 
-    python3 setup.py build
+    python setup.py build
 
 Building Docker images
 ----------------------
@@ -124,8 +101,8 @@ Building the documentation
 To build the documentation and browse it locally use::
 
     pip install sphinx_rtd_theme
-    python3 setup.py build_doc
-    python3 -m http.server --directory build/doc/html/
+    python setup.py build_doc
+    python -m http.server --directory build/doc/html/
 
 and browse `http://localhost:8000/ <http://localhost:8000/>`_
 
diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index 0aa29d365..98fd8e096 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -17,7 +17,6 @@ endif()
 
 ####### Compilation Options #######
 # Visibility stuff
-cmake_policy(SET CMP0063 NEW)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 set(CMAKE_CXX_VISIBILITY_INLINES ON)
 
@@ -39,6 +38,9 @@ add_definitions(-DVL_DISABLE_AVX)
 
 # Use the version of vlfeat in ./src/third_party/vlfeat
 add_definitions(-DINPLACE_VLFEAT)
+if(NOT USE_SSE2)
+  add_definitions(-DVL_DISABLE_SSE2)
+endif()
 
 if (WIN32)
     # Missing math constant
diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index 33f833e9c..e2ff9735c 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -1,5 +1,6 @@
 #include <features/matching.h>
 #include <foundation/optional.h>
+#include <foundation/python_types.h>
 #include <foundation/types.h>
 #include <pybind11/pybind11.h>
 
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index c9fcd28b6..cf03413a0 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -2,6 +2,7 @@
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
+#include <cstdint>
 #include <iostream>
 #include <vector>
 
diff --git a/opensfm/src/geo/python/pybind.cc b/opensfm/src/geo/python/pybind.cc
index f54c5f008..bd1703b37 100644
--- a/opensfm/src/geo/python/pybind.cc
+++ b/opensfm/src/geo/python/pybind.cc
@@ -1,3 +1,4 @@
+#include <foundation/python_types.h>
 #include <geo/geo.h>
 #include <pybind11/eigen.h>
 #include <pybind11/pybind11.h>
diff --git a/opensfm/src/geometry/python/pybind.cc b/opensfm/src/geometry/python/pybind.cc
index 44239b6dc..e42fd9a2d 100644
--- a/opensfm/src/geometry/python/pybind.cc
+++ b/opensfm/src/geometry/python/pybind.cc
@@ -1,3 +1,4 @@
+#include <foundation/python_types.h>
 #include <geometry/absolute_pose.h>
 #include <geometry/camera.h>
 #include <geometry/essential.h>
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index ae54c4d7f..4685245e5 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -92,13 +92,10 @@ std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
   A(0, 1) = -A(1, 0);
   A(1, 1) = -bearings.row(1).dot(bearings.row(1));
 
-  const T eps = T(1e-30);
+  const T eps = T(1e-10);
   const T det = A.determinant();
-#ifdef __aarch64__
-  if (std::abs<T>(det) < eps) {
-#else
-  if (abs(det) < eps) {
-#endif
+
+  if (-eps < det && det < eps) {
     return std::make_pair(false, Eigen::Matrix<T, 3, 1>());
   }
   const auto lambdas = A.inverse() * b;
diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index bcb878176..725e666d8 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <foundation/python_types.h>
 #include <map/shot.h>
 #include <pybind11/functional.h>
 #include <pybind11/pybind11.h>
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index 8f96f464c..13ecad21c 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -1,4 +1,5 @@
 #include <foundation/optional.h>
+#include <foundation/python_types.h>
 #include <foundation/types.h>
 #include <geometry/camera.h>
 #include <geometry/pose.h>

From 713ea6ea50715f0e305c105a989d5187afa7c9a0 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Mon, 19 May 2025 19:42:03 -0700
Subject: [PATCH 124/235] Fix CQS signal performance-unnecessary-value-param in
 fbcode/mapillary/opensfm/opensfm/src/dense

Reviewed By: dtolnay

Differential Revision: D74993593

fbshipit-source-id: 09accf98ae02661698b794592ecaf07343085a23
---
 opensfm/src/dense/depthmap_bind.h | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/opensfm/src/dense/depthmap_bind.h b/opensfm/src/dense/depthmap_bind.h
index d2972c49e..dc7e12ad1 100644
--- a/opensfm/src/dense/depthmap_bind.h
+++ b/opensfm/src/dense/depthmap_bind.h
@@ -7,9 +7,10 @@ namespace dense {
 
 class DepthmapEstimatorWrapper {
  public:
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
-               foundation::pyarray_d t, foundation::pyarray_uint8 image,
-               foundation::pyarray_uint8 mask) {
+  void AddView(const foundation::pyarray_d& K, const foundation::pyarray_d& R,
+               const foundation::pyarray_d& t,
+               const foundation::pyarray_uint8& image,
+               const foundation::pyarray_uint8& mask) {
     if ((image.shape(0) != mask.shape(0)) ||
         (image.shape(1) != mask.shape(1))) {
       throw std::invalid_argument("image and mask must have matching shapes.");
@@ -55,7 +56,7 @@ class DepthmapEstimatorWrapper {
     return ComputeReturnValues(result);
   }
 
-  py::object ComputeReturnValues(const DepthmapEstimatorResult &result) {
+  py::object ComputeReturnValues(const DepthmapEstimatorResult& result) {
     py::list retn;
     retn.append(foundation::py_array_from_data(
         result.depth.ptr<float>(0), result.depth.rows, result.depth.cols));
@@ -78,8 +79,9 @@ class DepthmapCleanerWrapper {
 
   void SetMinConsistentViews(int n) { dc_.SetMinConsistentViews(n); }
 
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
-               foundation::pyarray_d t, foundation::pyarray_f depth) {
+  void AddView(const foundation::pyarray_d& K, const foundation::pyarray_d& R,
+               const foundation::pyarray_d& t,
+               const foundation::pyarray_f& depth) {
     dc_.AddView(K.data(), R.data(), t.data(), depth.data(), depth.shape(1),
                 depth.shape(0));
   }
@@ -102,10 +104,12 @@ class DepthmapPrunerWrapper {
  public:
   void SetSameDepthThreshold(float t) { dp_.SetSameDepthThreshold(t); }
 
-  void AddView(foundation::pyarray_d K, foundation::pyarray_d R,
-               foundation::pyarray_d t, foundation::pyarray_f depth,
-               foundation::pyarray_f plane, foundation::pyarray_uint8 color,
-               foundation::pyarray_uint8 label) {
+  void AddView(const foundation::pyarray_d& K, const foundation::pyarray_d& R,
+               const foundation::pyarray_d& t,
+               const foundation::pyarray_f& depth,
+               const foundation::pyarray_f& plane,
+               const foundation::pyarray_uint8& color,
+               const foundation::pyarray_uint8& label) {
     if ((depth.shape(0) != plane.shape(0)) ||
         (depth.shape(1) != plane.shape(1))) {
       throw std::invalid_argument("depth and plane must have matching shapes.");

From ffcedf3e55df20730abf3d70e57153cea599eb70 Mon Sep 17 00:00:00 2001
From: Kamil Nikel <kami@meta.com>
Date: Tue, 20 May 2025 15:27:44 -0700
Subject: [PATCH 125/235] Add mem_ceiling and mem_ratio parameters to
 data.config

Summary: This allows us to control the memory we want to allocate for processing. It also fixes OOM issues (e.g. in Chronos) when the memory available is host's memory, but the process gets killed when beyond the allocated memory.

Reviewed By: YanNoun

Differential Revision: D74814977

fbshipit-source-id: d7c64d73f288499698c2c6c76b48bd3429aa7c14
---
 opensfm/features_processing.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 671facfde..16c509e66 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -21,14 +21,14 @@ def run_features_processing(data: DataSetBase, images: List[str], force: bool) -
     default_queue_size = 10
     max_queue_size = 200
 
-    mem_available = log.memory_available()
+    mem_ceiling = data.config.get("mem_ceiling", log.memory_available())
+
     processes = data.config["processes"]
-    if mem_available:
-        # Use 90% of available memory
-        ratio_use = 0.9
-        mem_available *= ratio_use
+    if mem_ceiling:
+        ratio_use = data.config.get("mem_ratio", 0.9)
+        mem_available = mem_ceiling * ratio_use
         logger.info(
-            f"Planning to use {mem_available} MB of RAM for both processing queue and parallel processing."
+            f"Planning to use {mem_available} MB of RAM (out of {mem_ceiling} MB RAM available) for both processing queue and parallel processing. Memory ratio is {ratio_use}."
         )
 
         # 50% for the queue / 50% for parallel processing

From a8bea86e186e6bbc4074daed468ede96d4532afe Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Thu, 22 May 2025 07:59:02 -0700
Subject: [PATCH 126/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm/opensfm/src/dense/python

Reviewed By: dtolnay

Differential Revision: D75215570

fbshipit-source-id: 94e33e97ef15021041520dd35c1143dc0881d03e
---
 opensfm/src/dense/python/pybind.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/dense/python/pybind.cc b/opensfm/src/dense/python/pybind.cc
index ceba592e5..da65c3668 100644
--- a/opensfm/src/dense/python/pybind.cc
+++ b/opensfm/src/dense/python/pybind.cc
@@ -1,7 +1,6 @@
 #include <dense/depthmap_bind.h>
 #include <dense/openmvs_exporter.h>
 #include <foundation/python_types.h>
-#include <pybind11/eigen.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 

From 27ab752b85995a88725e3540e5325bc6a2891d44 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Tue, 27 May 2025 12:24:47 -0700
Subject: [PATCH 127/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm/opensfm/src/geometry/test

Reviewed By: dtolnay

Differential Revision: D75441383

fbshipit-source-id: 9fbf8d1ccf35bf1d07660c725f5a1f71a167fdb6
---
 opensfm/src/geometry/test/camera_functions_test.cc | 2 --
 opensfm/src/geometry/test/covariance_test.cc       | 2 --
 2 files changed, 4 deletions(-)

diff --git a/opensfm/src/geometry/test/camera_functions_test.cc b/opensfm/src/geometry/test/camera_functions_test.cc
index 0384ea4f2..5ea44a6e4 100644
--- a/opensfm/src/geometry/test/camera_functions_test.cc
+++ b/opensfm/src/geometry/test/camera_functions_test.cc
@@ -5,8 +5,6 @@
 #include <gtest/gtest.h>
 
 #include <Eigen/Dense>
-#include <random>
-#include <unsupported/Eigen/AutoDiff>
 
 class FunctionFixture : public ::testing::Test {
  public:
diff --git a/opensfm/src/geometry/test/covariance_test.cc b/opensfm/src/geometry/test/covariance_test.cc
index 0049e27d9..d551bcda0 100644
--- a/opensfm/src/geometry/test/covariance_test.cc
+++ b/opensfm/src/geometry/test/covariance_test.cc
@@ -8,8 +8,6 @@
 
 #include <Eigen/Dense>
 #include <cmath>
-#include <random>
-#include <unsupported/Eigen/AutoDiff>
 
 #include "geometry/transformations_functions.h"
 

From b761d315beff871c928518f6467ea2509b0855b1 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Wed, 28 May 2025 00:21:29 -0700
Subject: [PATCH 128/235] Stop checking for numpy version in conftest

Summary: To have a consistent print format in doc tests, we were checking if numpy version was newer than 1.13 and, if so, setting the print format to the one in 1.13. This stops supporting numpy 1.13 or lower and just asumes a newer version is used.

Reviewed By: DodgySpaniard

Differential Revision: D75464843

fbshipit-source-id: 82a019bf2b35a3416adf6075e3e552b1533d5b89
---
 opensfm/test/conftest.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/opensfm/test/conftest.py b/opensfm/test/conftest.py
index 13c43dd19..b0a20689a 100644
--- a/opensfm/test/conftest.py
+++ b/opensfm/test/conftest.py
@@ -1,6 +1,5 @@
 # pyre-unsafe
 from collections import defaultdict
-from distutils.version import LooseVersion
 from typing import Dict, List, Tuple
 
 import numpy as np
@@ -18,9 +17,12 @@ def pytest_configure(config) -> None:
 
 
 def use_legacy_numpy_printoptions() -> None:
-    """Ensure numpy use legacy print formant."""
-    if LooseVersion(np.__version__).version[:2] > [1, 13]:
-        np.set_printoptions(legacy="1.13")
+    """Ensure that numpy prints in a consistent way across versions.
+
+    This is needed so that doctests are always tested using the same print format,
+    which matches the one used in the docstrings.
+    """
+    np.set_printoptions(legacy="1.13")
 
 
 @pytest.fixture(scope="module")

From 90f89171b6f95698f90bfe1934aa47d0ec3c324e Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Mon, 2 Jun 2025 00:35:16 -0700
Subject: [PATCH 129/235] make reconstruction comparisons handle different geo
 references

Summary:
When comparing reconstructions, we were assuming that they were in the same reference frame, but this in not the case even for the synthetically generated ones.

We add a method to change the refenece frame of reconstruction and use it before comparing a reconstruction to another

Differential Revision:
D75475832

Privacy Context Container: L1137435

fbshipit-source-id: c41bb75a7778baee614314159d31ceb76624ed0a
---
 opensfm/synthetic_data/synthetic_metrics.py | 37 +++++++++++++++------
 opensfm/synthetic_data/synthetic_scene.py   | 21 ++++++++----
 opensfm/test/test_stats.py                  |  6 ++--
 opensfm/test/test_synthetic_metrics.py      | 36 ++++++++++++++++++++
 4 files changed, 81 insertions(+), 19 deletions(-)
 create mode 100644 opensfm/test/test_synthetic_metrics.py

diff --git a/opensfm/synthetic_data/synthetic_metrics.py b/opensfm/synthetic_data/synthetic_metrics.py
index d51ffea0f..675297b81 100644
--- a/opensfm/synthetic_data/synthetic_metrics.py
+++ b/opensfm/synthetic_data/synthetic_metrics.py
@@ -1,10 +1,11 @@
 # pyre-unsafe
+import copy
 from typing import Dict, List, Tuple
 
 import cv2
 import numpy as np
 import opensfm.transformations as tf
-from opensfm import align, multiview, pymap, types
+from opensfm import align, geo, multiview, pymap, types
 
 
 def points_errors(
@@ -125,20 +126,34 @@ def aligned_to_reference(
                 coords2.append(shot2.pose.get_origin())
 
     s, A, b = find_alignment(coords1, coords2)
-    aligned = _copy_reconstruction(reconstruction)
+    aligned = copy.deepcopy(reconstruction)
     align.apply_similarity(aligned, s, A, b)
     return aligned
 
 
-def _copy_reconstruction(reconstruction: types.Reconstruction) -> types.Reconstruction:
-    copy = types.Reconstruction()
-    for camera in reconstruction.cameras.values():
-        copy.add_camera(camera)
-    for shot in reconstruction.shots.values():
-        copy.add_shot(shot)
-    for point in reconstruction.points.values():
-        copy.add_point(point)
-    return copy
+def change_geo_reference(
+    reconstruction: types.Reconstruction,
+    latitude: float,
+    longitude: float,
+    altitude: float,
+) -> types.Reconstruction:
+    """Change the geo reference of a reconstruction.
+
+    This assumes that the new lla is close enough that rotation differences
+    between references can be ignored.
+    """
+    t_old_new = reconstruction.reference.to_topocentric(latitude, longitude, altitude)
+
+    s = 1.0
+    A = np.eye(3)
+    b = -np.array(t_old_new)
+    aligned = copy.deepcopy(reconstruction)
+    aligned.reference = geo.TopocentricConverter(latitude, longitude, altitude)
+    align.apply_similarity(aligned, s, A, b)
+    for shot in aligned.shots.values():
+        if shot.metadata.gps_position.has_value:
+            shot.metadata.gps_position.value = shot.metadata.gps_position.value + b
+    return aligned
 
 
 def rmse(errors: np.ndarray) -> float:
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index 34d4b9034..f3a7e5466 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -8,6 +8,7 @@
 import opensfm.synthetic_data.synthetic_generator as sg
 import opensfm.synthetic_data.synthetic_metrics as sm
 from opensfm import geo, pygeometry, pymap, types
+from opensfm.reconstruction_helpers import exif_to_metadata
 
 
 def get_camera(
@@ -452,6 +453,11 @@ def __init__(
             causal_gps_noise=causal_gps_noise,
         )
 
+        for shot in self.reconstruction.shots.values():
+            shot.metadata = exif_to_metadata(
+                self.exifs[shot.id], False, self.reconstruction.reference
+            )
+
         if generate_projections:
             (self.features, self.tracks_manager, self.gcps) = sg.generate_track_data(
                 reconstruction,
@@ -473,15 +479,18 @@ def compare(
     reconstruction: types.Reconstruction,
 ) -> Dict[str, float]:
     """Compare a reconstruction with reference groundtruth."""
+    geo = reference.reference
+
     completeness = sm.completeness_errors(reference, reconstruction)
 
-    absolute_position = sm.position_errors(reference, reconstruction)
-    absolute_rotation = sm.rotation_errors(reference, reconstruction)
-    absolute_points = sm.points_errors(reference, reconstruction)
-    absolute_gps = sm.gps_errors(reconstruction)
-    absolute_gcp = sm.gcp_errors(reconstruction, gcps)
+    geo_referenced = sm.change_geo_reference(reconstruction, geo.lat, geo.lon, geo.alt)
+    absolute_position = sm.position_errors(reference, geo_referenced)
+    absolute_rotation = sm.rotation_errors(reference, geo_referenced)
+    absolute_points = sm.points_errors(reference, geo_referenced)
+    absolute_gps = sm.gps_errors(geo_referenced)
+    absolute_gcp = sm.gcp_errors(geo_referenced, gcps)
 
-    aligned = sm.aligned_to_reference(reference, reconstruction)
+    aligned = sm.aligned_to_reference(reference, geo_referenced)
     aligned_position = sm.position_errors(reference, aligned)
     aligned_rotation = sm.rotation_errors(reference, aligned)
     aligned_points = sm.points_errors(reference, aligned)
diff --git a/opensfm/test/test_stats.py b/opensfm/test/test_stats.py
index 2511fb255..15067bc3f 100644
--- a/opensfm/test/test_stats.py
+++ b/opensfm/test/test_stats.py
@@ -130,7 +130,7 @@ def test_reconstruction_statistics_normal(
     )
 
     assert reconstruction_statistics["components"] == 1
-    assert not reconstruction_statistics["has_gps"]
+    assert reconstruction_statistics["has_gps"]
     assert not reconstruction_statistics["has_gcp"]
     assert 4900 < reconstruction_statistics["initial_points_count"] < 5000
     assert reconstruction_statistics["initial_shots_count"] == 20
@@ -257,7 +257,9 @@ def test_gps_errors_normal(
 ) -> None:
     reference = scene_synthetic.reconstruction
     gps_errors = stats.gps_errors([reference])
-    assert gps_errors == {}
+    assert set(gps_errors.keys()) == {"average_error", "error", "mean", "std"}
+    # scene_synthetic generated GPS noise is 5 meters
+    assert 3.0 < gps_errors["average_error"] < 7.0
 
 
 def test_gps_errors_null(
diff --git a/opensfm/test/test_synthetic_metrics.py b/opensfm/test/test_synthetic_metrics.py
new file mode 100644
index 000000000..77644b160
--- /dev/null
+++ b/opensfm/test/test_synthetic_metrics.py
@@ -0,0 +1,36 @@
+# pyre-strict
+import numpy as np
+from opensfm.synthetic_data import synthetic_metrics, synthetic_scene
+
+
+def test_change_geo_reference(
+    scene_synthetic: synthetic_scene.SyntheticInputData,
+) -> None:
+    original = scene_synthetic.reconstruction
+    lat = original.reference.lat + 0.001  # about 111 m
+    lon = original.reference.lon + 0.002
+    alt = original.reference.alt + 2.34
+
+    aligned = synthetic_metrics.change_geo_reference(original, lat, lon, alt)
+
+    for shot_id in original.shots:
+        original_position = original.shots[shot_id].pose.get_origin()
+        aligned_position = aligned.shots[shot_id].pose.get_origin()
+        aligned_lla = aligned.reference.to_lla(*aligned_position)
+        aligned_in_original = original.reference.to_topocentric(*aligned_lla)
+        assert np.allclose(original_position, aligned_in_original, atol=0.01)
+
+        assert original.shots[shot_id].metadata.gps_position.has_value
+        assert aligned.shots[shot_id].metadata.gps_position.has_value
+        original_gps_prior = original.shots[shot_id].metadata.gps_position.value
+        aligned_gps_prior = aligned.shots[shot_id].metadata.gps_position.value
+        aligned_gps_lla = aligned.reference.to_lla(*aligned_gps_prior)
+        aligned_gps_in_original = original.reference.to_topocentric(*aligned_gps_lla)
+        assert np.allclose(original_gps_prior, aligned_gps_in_original, atol=0.01)
+
+    for point_id in original.points:
+        original_position = original.points[point_id].coordinates
+        aligned_position = aligned.points[point_id].coordinates
+        aligned_lla = aligned.reference.to_lla(*aligned_position)
+        aligned_in_original = original.reference.to_topocentric(*aligned_lla)
+        assert np.allclose(original_position, aligned_in_original, atol=0.01)

From 8c59bb5bbdd15845639208d86f161430078fbdf4 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 130/235] annotate matching

Differential Revision: D76518693

fbshipit-source-id: 570ce0807e69b1f866000975a57a866bc8c94789
---
 opensfm/context.py  |  23 +++++---
 opensfm/matching.py | 130 ++++++++++++++++++++++----------------------
 2 files changed, 79 insertions(+), 74 deletions(-)

diff --git a/opensfm/context.py b/opensfm/context.py
index d62a841e8..4cf7558ef 100644
--- a/opensfm/context.py
+++ b/opensfm/context.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 
@@ -8,19 +8,18 @@
     pass  # Windows
 import ctypes
 import sys
-from typing import Optional
+from typing import Callable, List, Optional, TypeVar
 
 import cv2
 from joblib import delayed, Parallel, parallel_backend
 
-
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-abspath = os.path.dirname(os.path.realpath(__file__))
-SENSOR_DATA = os.path.join(abspath, "data", "sensor_data.json")
-CAMERA_CALIBRATION = os.path.join(abspath, "data", "camera_calibration.yaml")
-BOW_PATH = os.path.join(abspath, "data", "bow")
+abspath: str = os.path.dirname(os.path.realpath(__file__))
+SENSOR_DATA: str = os.path.join(abspath, "data", "sensor_data.json")
+CAMERA_CALIBRATION: str = os.path.join(abspath, "data", "camera_calibration.yaml")
+BOW_PATH: str = os.path.join(abspath, "data", "bow")
 
 
 # Handle different OpenCV versions
@@ -31,17 +30,23 @@
 )
 OPENCV3: bool = int(cv2.__version__.split(".")[0]) >= 3
 
+flann_Index: Optional[cv2.flann_Index] = None
 if hasattr(cv2, "flann_Index"):
     flann_Index = cv2.flann_Index
 elif hasattr(cv2, "flann") and hasattr(cv2.flann, "Index"):
     flann_Index = cv2.flann.Index
 else:
     logger.warning("Unable to find flann Index")
-    flann_Index = None
 
 
 # Parallel processes
-def parallel_map(func, args, num_proc: int, max_batch_size: int = 1):
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+def parallel_map(
+    func: Callable[[T], R], args: List[T], num_proc: int, max_batch_size: int = 1
+) -> List[R]:
     """Run function for all arguments using multiple processes."""
     # De-activate/Restore any inner OpenCV threading
     threads_used = cv2.getNumThreads()
diff --git a/opensfm/matching.py b/opensfm/matching.py
index c9146e24b..32f5ce551 100644
--- a/opensfm/matching.py
+++ b/opensfm/matching.py
@@ -1,10 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from timeit import default_timer as timer
 from typing import Any, Dict, Generator, List, Optional, Sized, Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import (
     context,
     feature_loader,
@@ -187,7 +188,7 @@ def match_unwrap_args(
         Dict[str, Any],
         Optional[Dict[str, pygeometry.Pose]],
     ],
-) -> Tuple[str, str, np.ndarray]:
+) -> Tuple[str, str, NDArray]:
     """Wrapper for parallel processing of pair matching.
 
     Compute all pair matchings of a given image and save them.
@@ -219,7 +220,7 @@ def match_descriptors(
     camera2: pygeometry.Camera,
     data: DataSetBase,
     config_override: Dict[str, Any],
-) -> np.ndarray:
+) -> NDArray:
     """Perform descriptor matching for a pair of images."""
     # Override parameters
     overriden_config = data.config.copy()
@@ -261,7 +262,7 @@ def _match_descriptors_guided_impl(
     relative_pose: pygeometry.Pose,
     data: DataSetBase,
     overriden_config: Dict[str, Any],
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, str]:
+) -> Tuple[NDArray, NDArray, NDArray, str]:
     """Perform descriptor guided matching for a pair of images, using their relative pose. It also apply static objects removal."""
     guided_matcher_override = "BRUTEFORCE"
     matcher_type = overriden_config["matcher_type"].upper()
@@ -341,7 +342,7 @@ def _match_descriptors_impl(
     camera2: pygeometry.Camera,
     data: DataSetBase,
     overriden_config: Dict[str, Any],
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, str]:
+) -> Tuple[NDArray, NDArray, NDArray, str]:
     """Perform descriptor matching for a pair of images. It also apply static objects removal."""
     dummy = np.array([])
     matcher_type = overriden_config["matcher_type"].upper()
@@ -465,7 +466,7 @@ def match_robust(
     data: DataSetBase,
     config_override: Dict[str, Any],
     input_is_masked: bool = True,
-) -> np.ndarray:
+) -> NDArray:
     """Perform robust geometry matching on a set of matched descriptors indexes."""
     # Override parameters
     overriden_config = data.config.copy()
@@ -541,14 +542,14 @@ def match_robust(
 def _match_robust_impl(
     im1: str,
     im2: str,
-    p1: np.ndarray,
-    p2: np.ndarray,
-    matches: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
+    matches: NDArray,
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
     data: DataSetBase,
     overriden_config: Dict[str, Any],
-) -> np.ndarray:
+) -> NDArray:
     """Perform robust geometry matching on a set of matched descriptors indexes."""
     # robust matching
     rmatches = robust_match(p1, p2, camera1, camera2, matches, overriden_config)
@@ -564,7 +565,7 @@ def match(
     data: DataSetBase,
     config_override: Dict[str, Any],
     guided_matching_pose: Optional[pygeometry.Pose],
-) -> np.ndarray:
+) -> NDArray:
     """Perform full matching (descriptor+robust, optionally guided) for a pair of images."""
     # Override parameters
     overriden_config = data.config.copy()
@@ -631,12 +632,12 @@ def match(
 
 
 def match_words(
-    f1: np.ndarray,
-    words1: np.ndarray,
-    f2: np.ndarray,
-    words2: np.ndarray,
+    f1: NDArray,
+    words1: NDArray,
+    f2: NDArray,
+    words2: NDArray,
     config: Dict[str, Any],
-) -> np.ndarray:
+) -> NDArray:
     """Match using words and apply Lowe's ratio filter.
 
     Args:
@@ -652,10 +653,10 @@ def match_words(
 
 
 def match_words_symmetric(
-    f1: np.ndarray,
-    words1: np.ndarray,
-    f2: np.ndarray,
-    words2: np.ndarray,
+    f1: NDArray,
+    words1: NDArray,
+    f2: NDArray,
+    words2: NDArray,
     config: Dict[str, Any],
 ) -> List[Tuple[int, int]]:
     """Match using words in both directions and keep consistent matches.
@@ -676,7 +677,7 @@ def match_words_symmetric(
 
 
 def match_flann(
-    index: Any, f2: np.ndarray, config: Dict[str, Any]
+    index: cv2.flann_Index, f2: NDArray, config: Dict[str, Any]
 ) -> List[Tuple[int, int]]:
     """Match using FLANN and apply Lowe's ratio filter.
 
@@ -686,14 +687,18 @@ def match_flann(
         config: config parameters
     """
     search_params = dict(checks=config["flann_checks"])
-    results, dists = index.knnSearch(f2, 2, params=search_params)
+    results, dists = index.knnSearch(f2, 2, params=search_params)  # pyre-ignore[16]
     squared_ratio = config["lowes_ratio"] ** 2  # Flann returns squared L2 distances
     good = dists[:, 0] < squared_ratio * dists[:, 1]
     return list(zip(results[good, 0], good.nonzero()[0]))
 
 
 def match_flann_symmetric(
-    fi: np.ndarray, indexi: Any, fj: np.ndarray, indexj: Any, config: Dict[str, Any]
+    fi: NDArray,
+    indexi: cv2.flann_Index,
+    fj: NDArray,
+    indexj: cv2.flann_Index,
+    config: Dict[str, Any],
 ) -> List[Tuple[int, int]]:
     """Match using FLANN in both directions and keep consistent matches.
 
@@ -712,10 +717,10 @@ def match_flann_symmetric(
 
 
 def match_brute_force(
-    f1: np.ndarray,
-    f2: np.ndarray,
+    f1: NDArray,
+    f2: NDArray,
     config: Dict[str, Any],
-    maskij: Optional[np.ndarray] = None,
+    maskij: Optional[NDArray] = None,
 ) -> List[Tuple[int, int]]:
     """Brute force matching and Lowe's ratio filtering.
 
@@ -744,19 +749,14 @@ def match_brute_force(
             m, n = match
             if m.distance < ratio * n.distance:
                 good_matches.append(m)
-    return _convert_matches_to_vector(good_matches)
-
-
-def _convert_matches_to_vector(matches: List[Any]) -> List[Tuple[int, int]]:
-    """Convert Dmatch object to matrix form."""
-    return [(mm.queryIdx, mm.trainIdx) for mm in matches]
+    return [(mm.queryIdx, mm.trainIdx) for mm in good_matches]
 
 
 def match_brute_force_symmetric(
-    fi: np.ndarray,
-    fj: np.ndarray,
+    fi: NDArray,
+    fj: NDArray,
     config: Dict[str, Any],
-    maskij: Optional[np.ndarray] = None,
+    maskij: Optional[NDArray] = None,
 ) -> List[Tuple[int, int]]:
     """Match with brute force in both directions and keep consistent matches.
 
@@ -774,11 +774,11 @@ def match_brute_force_symmetric(
 
 
 def robust_match_fundamental(
-    p1: np.ndarray,
-    p2: np.ndarray,
-    matches: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
+    matches: NDArray,
     config: Dict[str, Any],
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[NDArray, NDArray]:
     """Filter matches by estimating the Fundamental matrix via RANSAC."""
     if len(matches) < 8:
         return np.array([]), np.array([])
@@ -798,10 +798,10 @@ def robust_match_fundamental(
 
 
 def compute_inliers_bearings(
-    b1: np.ndarray,
-    b2: np.ndarray,
-    R: np.ndarray,
-    t: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
+    R: NDArray,
+    t: NDArray,
     threshold: float = 0.01,
 ) -> List[bool]:
     """Compute points that can be triangulated.
@@ -839,8 +839,8 @@ def compute_inliers_bearings(
 
 
 def compute_inliers_bearing_epipolar(
-    b1: np.ndarray, b2: np.ndarray, pose: pygeometry.Pose, threshold: float
-) -> np.ndarray:
+    b1: NDArray, b2: NDArray, pose: pygeometry.Pose, threshold: float
+) -> NDArray:
     """Compute mask of epipolarly consistent bearings, given two lists of bearings
 
     Args:
@@ -861,13 +861,13 @@ def compute_inliers_bearing_epipolar(
 
 
 def robust_match_calibrated(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
-    matches: np.ndarray,
+    matches: NDArray,
     config: Dict[str, Any],
-) -> np.ndarray:
+) -> NDArray:
     """Filter matches by estimating the Essential matrix via RANSAC."""
 
     if len(matches) < 8:
@@ -896,13 +896,13 @@ def robust_match_calibrated(
 
 
 def robust_match(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
-    matches: np.ndarray,
+    matches: NDArray,
     config: Dict[str, Any],
-) -> np.ndarray:
+) -> NDArray:
     """Filter matches by fitting a geometric model.
 
     If cameras are perspective without distortion, then the Fundamental
@@ -921,7 +921,7 @@ def robust_match(
         return robust_match_calibrated(p1, p2, camera1, camera2, matches, config)
 
 
-def unfilter_matches(matches, m1, m2) -> np.ndarray:
+def unfilter_matches(matches: NDArray, m1: NDArray, m2: NDArray) -> NDArray:
     """Given matches and masking arrays, get matches with un-masked indexes."""
     i1 = np.flatnonzero(m1)
     i2 = np.flatnonzero(m2)
@@ -933,10 +933,10 @@ def apply_adhoc_filters(
     matches: List[Tuple[int, int]],
     im1: str,
     camera1: pygeometry.Camera,
-    p1: np.ndarray,
+    p1: NDArray,
     im2: str,
     camera2: pygeometry.Camera,
-    p2: np.ndarray,
+    p2: NDArray,
 ) -> List[Tuple[int, int]]:
     """Apply a set of filters functions defined further below
     for removing static data in images.
@@ -950,7 +950,7 @@ def apply_adhoc_filters(
 
 
 def _non_static_matches(
-    p1: np.ndarray, p2: np.ndarray, matches: List[Tuple[int, int]]
+    p1: NDArray, p2: NDArray, matches: List[Tuple[int, int]]
 ) -> List[Tuple[int, int]]:
     """Remove matches with same position in both images.
 
@@ -973,8 +973,8 @@ def _non_static_matches(
 
 
 def _not_on_pano_poles_matches(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     matches: List[Tuple[int, int]],
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
@@ -1000,8 +1000,8 @@ def _not_on_pano_poles_matches(
 
 
 def _not_on_vermont_watermark(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     matches: List[Tuple[int, int]],
     im1: str,
     im2: str,
@@ -1018,7 +1018,7 @@ def _not_on_vermont_watermark(
     return matches
 
 
-def _vermont_valid_mask(p: np.ndarray) -> bool:
+def _vermont_valid_mask(p: NDArray) -> bool:
     """Check if pixel inside the valid region.
 
     Pixel coord Y should be larger than 50.
@@ -1028,8 +1028,8 @@ def _vermont_valid_mask(p: np.ndarray) -> bool:
 
 
 def _not_on_blackvue_watermark(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     matches: List[Tuple[int, int]],
     im1: str,
     im2: str,
@@ -1046,7 +1046,7 @@ def _not_on_blackvue_watermark(
     return matches
 
 
-def _blackvue_valid_mask(p: np.ndarray) -> bool:
+def _blackvue_valid_mask(p: NDArray) -> bool:
     """Check if pixel inside the valid region.
 
     Pixel coord Y should be smaller than h - 70.

From 87f84add08b1f8f097f7018f83cda8d148f5a734 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 131/235] annotate features

Reviewed By: DodgySpaniard

Differential Revision: D76518702

fbshipit-source-id: 64f0fb856ed8b6f9638cd3508f80ea0e3aad2541
---
 opensfm/feature_loading.py     |  15 +++--
 opensfm/features.py            | 102 +++++++++++++++++----------------
 opensfm/features_processing.py |  59 ++++++++++++-------
 3 files changed, 100 insertions(+), 76 deletions(-)

diff --git a/opensfm/feature_loading.py b/opensfm/feature_loading.py
index 8c0be75eb..156cf9874 100644
--- a/opensfm/feature_loading.py
+++ b/opensfm/feature_loading.py
@@ -1,9 +1,12 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from functools import lru_cache
-from typing import Any, Optional, Tuple
+from typing import Optional, Tuple
+
+import cv2
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import features as ft, masking, pygeometry
 from opensfm.dataset_base import DataSetBase
 
@@ -26,7 +29,7 @@ def clear_cache(self) -> None:
         self.load_words.cache_clear()
 
     @lru_cache(1000)
-    def load_mask(self, data: DataSetBase, image: str) -> Optional[np.ndarray]:
+    def load_mask(self, data: DataSetBase, image: str) -> Optional[NDArray]:
         all_features_data = self._load_all_data_unmasked(data, image)
         if not all_features_data:
             return None
@@ -88,7 +91,7 @@ def load_bearings(
         image: str,
         masked: bool,
         camera: pygeometry.Camera,
-    ) -> Optional[np.ndarray]:
+    ) -> Optional[NDArray]:
         if masked:
             features_data = self._load_all_data_masked(data, image)
         else:
@@ -174,7 +177,7 @@ def load_features_index(
         image: str,
         masked: bool,
         segmentation_in_descriptor: bool,
-    ) -> Optional[Tuple[ft.FeaturesData, Any]]:
+    ) -> Optional[Tuple[ft.FeaturesData, cv2.flann_Index]]:
         features_data = self.load_all_data(
             data, image, masked, segmentation_in_descriptor
         )
@@ -189,7 +192,7 @@ def load_features_index(
         )
 
     @lru_cache(200)
-    def load_words(self, data: DataSetBase, image: str, masked: bool) -> np.ndarray:
+    def load_words(self, data: DataSetBase, image: str, masked: bool) -> NDArray:
         words = data.load_words(image)
         if masked:
             mask = self.load_mask(data, image)
diff --git a/opensfm/features.py b/opensfm/features.py
index d877eea0b..a87d80a14 100644
--- a/opensfm/features.py
+++ b/opensfm/features.py
@@ -1,12 +1,13 @@
-# pyre-unsafe
+# pyre-strict
 """Tools to extract features."""
 
 import logging
 import time
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Union
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import context, pyfeatures
 
 
@@ -14,16 +15,16 @@
 
 
 class SemanticData:
-    segmentation: np.ndarray
-    instances: Optional[np.ndarray]
+    segmentation: NDArray
+    instances: Optional[NDArray]
     labels: List[Dict[str, Any]]
 
     def __init__(
         self,
-        segmentation: np.ndarray,
-        instances: Optional[np.ndarray],
+        segmentation: NDArray,
+        instances: Optional[NDArray],
         labels: List[Dict[str, Any]],
-    ):
+    ) -> None:
         self.segmentation = segmentation
         self.instances = instances
         self.labels = labels
@@ -31,7 +32,7 @@ def __init__(
     def has_instances(self) -> bool:
         return self.instances is not None
 
-    def mask(self, mask: np.ndarray) -> "SemanticData":
+    def mask(self, mask: NDArray) -> "SemanticData":
         try:
             segmentation = self.segmentation[mask]
             instances = self.instances
@@ -47,30 +48,30 @@ def mask(self, mask: np.ndarray) -> "SemanticData":
 
 
 class FeaturesData:
-    points: np.ndarray
-    descriptors: Optional[np.ndarray]
-    colors: np.ndarray
+    points: NDArray
+    descriptors: Optional[NDArray]
+    colors: NDArray
     semantic: Optional[SemanticData]
-    depths: Optional[np.ndarray]  # New field. This field is not serialized yet
+    depths: Optional[NDArray]  # New field. This field is not serialized yet
 
     FEATURES_VERSION: int = 3
     FEATURES_HEADER: str = "OPENSFM_FEATURES_VERSION"
 
     def __init__(
         self,
-        points: np.ndarray,
-        descriptors: Optional[np.ndarray],
-        colors: np.ndarray,
+        points: NDArray,
+        descriptors: Optional[NDArray],
+        colors: NDArray,
         semantic: Optional[SemanticData],
-        depths: Optional[np.ndarray] = None,
-    ):
+        depths: Optional[NDArray] = None,
+    ) -> None:
         self.points = points
         self.descriptors = descriptors
         self.colors = colors
         self.semantic = semantic
         self.depths = depths
 
-    def get_segmentation(self) -> Optional[np.ndarray]:
+    def get_segmentation(self) -> Optional[NDArray]:
         semantic = self.semantic
         if not semantic:
             return None
@@ -84,7 +85,7 @@ def has_instances(self) -> bool:
             return False
         return semantic.instances is not None
 
-    def mask(self, mask: np.ndarray) -> "FeaturesData":
+    def mask(self, mask: NDArray) -> "FeaturesData":
         if self.semantic:
             masked_semantic = self.semantic.mask(mask)
         else:
@@ -94,9 +95,10 @@ def mask(self, mask: np.ndarray) -> "FeaturesData":
             self.descriptors[mask] if self.descriptors is not None else None,
             self.colors[mask],
             masked_semantic,
+            self.depths[mask] if self.depths is not None else None,
         )
 
-    def save(self, fileobject: Any, config: Dict[str, Any]):
+    def save(self, fileobject: Union[str, BinaryIO], config: Dict[str, Any]) -> None:
         """Save features from file (path like or file object like)"""
         feature_type = config["feature_type"].upper()
         if (
@@ -139,7 +141,9 @@ def save(self, fileobject: Any, config: Dict[str, Any]):
             )
 
     @classmethod
-    def from_file(cls, fileobject: Any, config: Dict[str, Any]) -> "FeaturesData":
+    def from_file(
+        cls, fileobject: Union[str, BinaryIO], config: Dict[str, Any]
+    ) -> "FeaturesData":
         """Load features from file (path like or file object like)"""
         s = np.load(fileobject, allow_pickle=False)
         version = cls._features_file_version(s)
@@ -155,7 +159,7 @@ def _features_file_version(cls, obj: Dict[str, Any]) -> int:
 
     @classmethod
     def _from_file_v0(
-        cls, data: Dict[str, np.ndarray], config: Dict[str, Any]
+        cls, data: Dict[str, NDArray], config: Dict[str, Any]
     ) -> "FeaturesData":
         """Base version of features file
 
@@ -172,7 +176,7 @@ def _from_file_v0(
 
     @classmethod
     def _from_file_v1(
-        cls, data: Dict[str, np.ndarray], config: Dict[str, Any]
+        cls, data: Dict[str, NDArray], config: Dict[str, Any]
     ) -> "FeaturesData":
         """Version 1 of features file
 
@@ -272,7 +276,7 @@ def _from_file_v3(
         )
 
 
-def resized_image(image: np.ndarray, max_size: int) -> np.ndarray:
+def resized_image(image: NDArray, max_size: int) -> NDArray:
     """Resize image to feature_process_size."""
     h, w = image.shape[:2]
     size = max(w, h)
@@ -283,7 +287,7 @@ def resized_image(image: np.ndarray, max_size: int) -> np.ndarray:
         return image
 
 
-def root_feature(desc: np.ndarray, l2_normalization: bool = False) -> np.ndarray:
+def root_feature(desc: NDArray, l2_normalization: bool = False) -> NDArray:
     if l2_normalization:
         s2 = np.linalg.norm(desc, axis=1)
         desc = (desc.T / s2).T
@@ -293,8 +297,8 @@ def root_feature(desc: np.ndarray, l2_normalization: bool = False) -> np.ndarray
 
 
 def root_feature_surf(
-    desc: np.ndarray, l2_normalization: bool = False, partial: bool = False
-) -> np.ndarray:
+    desc: NDArray, l2_normalization: bool = False, partial: bool = False
+) -> NDArray:
     """
     Experimental square root mapping of surf-like feature, only work for 64-dim surf now
     """
@@ -316,8 +320,8 @@ def root_feature_surf(
 
 
 def normalized_image_coordinates(
-    pixel_coords: np.ndarray, width: int, height: int
-) -> np.ndarray:
+    pixel_coords: NDArray, width: int, height: int
+) -> NDArray:
     size = max(width, height)
     p = np.empty((len(pixel_coords), 2))
     p[:, 0] = (pixel_coords[:, 0] + 0.5 - width / 2.0) / size
@@ -326,8 +330,8 @@ def normalized_image_coordinates(
 
 
 def denormalized_image_coordinates(
-    norm_coords: np.ndarray, width: int, height: int
-) -> np.ndarray:
+    norm_coords: NDArray, width: int, height: int
+) -> NDArray:
     size = max(width, height)
     p = np.empty((len(norm_coords), 2))
     p[:, 0] = norm_coords[:, 0] * size - 0.5 + width / 2.0
@@ -336,11 +340,11 @@ def denormalized_image_coordinates(
 
 
 def normalize_features(
-    points: np.ndarray, desc: np.ndarray, colors: np.ndarray, width: int, height: int
+    points: NDArray, desc: NDArray, colors: NDArray, width: int, height: int
 ) -> Tuple[
-    np.ndarray,
-    np.ndarray,
-    np.ndarray,
+    NDArray,
+    NDArray,
+    NDArray,
 ]:
     """Normalize feature coordinates and size."""
     points[:, :2] = normalized_image_coordinates(points[:, :2], width, height)
@@ -348,7 +352,7 @@ def normalize_features(
     return points, desc, colors
 
 
-def _in_mask(point: np.ndarray, width: int, height: int, mask: np.ndarray) -> bool:
+def _in_mask(point: NDArray, width: int, height: int, mask: NDArray) -> bool:
     """Check if a point is inside a binary mask."""
     u = mask.shape[1] * (point[0] + 0.5) / width
     v = mask.shape[0] * (point[1] + 0.5) / height
@@ -356,8 +360,8 @@ def _in_mask(point: np.ndarray, width: int, height: int, mask: np.ndarray) -> bo
 
 
 def extract_features_sift(
-    image: np.ndarray, config: Dict[str, Any], features_count: int
-) -> Tuple[np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], features_count: int
+) -> Tuple[NDArray, NDArray]:
     sift_edge_threshold = config["sift_edge_threshold"]
     sift_peak_threshold = float(config["sift_peak_threshold"])
     sift_nfeatures = config["sift_nfeatures"]
@@ -412,8 +416,8 @@ def extract_features_sift(
 
 
 def extract_features_surf(
-    image: np.ndarray, config: Dict[str, Any], features_count: int
-) -> Tuple[np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], features_count: int
+) -> Tuple[NDArray, NDArray]:
     surf_hessian_threshold = config["surf_hessian_threshold"]
     if context.OPENCV3:
         try:
@@ -477,8 +481,8 @@ def akaze_descriptor_type(name: str) -> pyfeatures.AkazeDescriptorType:
 
 
 def extract_features_akaze(
-    image: np.ndarray, config: Dict[str, Any], features_count: int
-) -> Tuple[np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], features_count: int
+) -> Tuple[NDArray, NDArray]:
     options = pyfeatures.AKAZEOptions()
     options.omax = config["akaze_omax"]
     akaze_descriptor_name = config["akaze_descriptor"]
@@ -506,8 +510,8 @@ def extract_features_akaze(
 
 
 def extract_features_hahog(
-    image: np.ndarray, config: Dict[str, Any], features_count: int
-) -> Tuple[np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], features_count: int
+) -> Tuple[NDArray, NDArray]:
     t = time.time()
     points, desc = pyfeatures.hahog(
         image.astype(np.float32) / 255,  # VlFeat expects pixel values between 0, 1
@@ -531,8 +535,8 @@ def extract_features_hahog(
 
 
 def extract_features_orb(
-    image: np.ndarray, config: Dict[str, Any], features_count: int
-) -> Tuple[np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], features_count: int
+) -> Tuple[NDArray, NDArray]:
     if context.OPENCV3:
         detector = cv2.ORB_create(nfeatures=features_count)
         descriptor = detector
@@ -557,8 +561,8 @@ def extract_features_orb(
 
 
 def extract_features(
-    image: np.ndarray, config: Dict[str, Any], is_panorama: bool
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    image: NDArray, config: Dict[str, Any], is_panorama: bool
+) -> Tuple[NDArray, NDArray, NDArray]:
     """Detect features in a color or gray-scale image.
 
     The type of feature detected is determined by the ``feature_type``
@@ -628,7 +632,7 @@ def extract_features(
     return normalize_features(points, desc, colors, image.shape[1], image.shape[0])
 
 
-def build_flann_index(descriptors: np.ndarray, config: Dict[str, Any]) -> Any:
+def build_flann_index(descriptors: NDArray, config: Dict[str, Any]) -> cv2.flann_Index:
     # FLANN_INDEX_LINEAR = 0
     FLANN_INDEX_KDTREE = 1
     FLANN_INDEX_KMEANS = 2
diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 16c509e66..145c1abef 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -1,13 +1,14 @@
-# pyre-unsafe
+# pyre-strict
 import itertools
 import logging
 import math
 import queue
 import threading
 from timeit import default_timer as timer
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, cast, Dict, List, Optional, Tuple, Union
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import bow, features, io, log, masking, pygeometry, upright
 from opensfm.context import parallel_map
 from opensfm.dataset_base import DataSetBase
@@ -15,6 +16,21 @@
 
 logger: logging.Logger = logging.getLogger(__name__)
 
+ProcessQueue = queue.Queue[
+    Optional[
+        Tuple[str, NDArray, Optional[NDArray], Optional[NDArray], DataSetBase, bool]
+    ]
+]
+ProducerArgs = Tuple[
+    ProcessQueue,
+    DataSetBase,
+    List[str],
+    "Counter",
+    int,
+    bool,
+]
+ConsumerArgs = ProcessQueue
+
 
 def run_features_processing(data: DataSetBase, images: List[str], force: bool) -> None:
     """Main entry point for running features extraction on a list of images."""
@@ -47,8 +63,8 @@ def run_features_processing(data: DataSetBase, images: List[str], force: bool) -
         f"Expecting to queue at most {expected_images} images while parallel processing of {processes} images."
     )
 
-    process_queue = queue.Queue(expected_images)
-    arguments: List[Tuple[str, Any]] = []
+    process_queue: ProcessQueue = queue.Queue(expected_images)
+    arguments: List[Tuple[str, Union[ProducerArgs, ConsumerArgs]]] = []
 
     if processes == 1:
         for image in images:
@@ -76,7 +92,7 @@ def run_features_processing(data: DataSetBase, images: List[str], force: bool) -
                 )
             )
         for _ in range(processes):
-            arguments.append(("consumer", (process_queue)))
+            arguments.append(("consumer", process_queue))
         parallel_map(process, arguments, processes, 1)
 
 
@@ -103,7 +119,7 @@ def average_processing_size(data: DataSetBase) -> float:
 
 
 def is_high_res_panorama(
-    data: DataSetBase, image_key: str, image_array: np.ndarray
+    data: DataSetBase, image_key: str, image_array: NDArray
 ) -> bool:
     """Detect if image is a panorama."""
     exif = data.load_exif(image_key)
@@ -127,7 +143,7 @@ class Counter:
 
     def __init__(self) -> None:
         self.number_of_read = 0
-        self.counter = itertools.count()
+        self.counter: itertools.count[int] = itertools.count()
         self.read_lock = threading.Lock()
 
     def increment(self) -> None:
@@ -140,18 +156,18 @@ def value(self) -> int:
         return value
 
 
-def process(args: Tuple[str, Any]) -> None:
+def process(args: Tuple[str, Union[ProducerArgs, ConsumerArgs]]) -> None:
     process_type, real_args = args
     if process_type == "producer":
-        queue, data, images, counter, expected, force = real_args
+        queue, data, images, counter, expected, force = cast(ProducerArgs, real_args)
         read_images(queue, data, images, counter, expected, force)
     if process_type == "consumer":
-        queue = real_args
+        queue = cast(ConsumerArgs, real_args)
         run_detection(queue)
 
 
 def read_images(
-    queue: queue.Queue,
+    queue: ProcessQueue,
     data: DataSetBase,
     images: List[str],
     counter: Counter,
@@ -167,7 +183,8 @@ def read_images(
             instances_array = data.load_instances(image)
         else:
             segmentation_array, instances_array = None, None
-        args = image, image_array, segmentation_array, instances_array, data, force
+        args = (image, image_array, segmentation_array, instances_array, data, force)
+
         queue.put(args, block=True, timeout=full_queue_timeout)
         counter.increment()
         if counter.value() == expected:
@@ -175,7 +192,7 @@ def read_images(
             queue.put(None)
 
 
-def run_detection(queue: queue.Queue):
+def run_detection(queue: ProcessQueue) -> None:
     while True:
         args = queue.get()
         if args is None:
@@ -189,12 +206,12 @@ def run_detection(queue: queue.Queue):
 
 
 def bake_segmentation(
-    image: np.ndarray,
-    points: np.ndarray,
-    segmentation: Optional[np.ndarray],
-    instances: Optional[np.ndarray],
+    image: NDArray,
+    points: NDArray,
+    segmentation: Optional[NDArray],
+    instances: Optional[NDArray],
     exif: Dict[str, Any],
-) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
+) -> Tuple[Optional[NDArray], Optional[NDArray]]:
     exif_height, exif_width, exif_orientation = (
         exif["height"],
         exif["width"],
@@ -227,9 +244,9 @@ def bake_segmentation(
 
 def detect(
     image: str,
-    image_array: np.ndarray,
-    segmentation_array: Optional[np.ndarray],
-    instances_array: Optional[np.ndarray],
+    image_array: NDArray,
+    segmentation_array: Optional[NDArray],
+    instances_array: Optional[NDArray],
     data: DataSetBase,
     force: bool = False,
 ) -> None:

From 9dac7bc9146ea4fc71febf856db5c451b3a9497a Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 132/235] annotate exif

Differential Revision: D76518700

fbshipit-source-id: 53941850271b5ecff517a5bd5153b95ac4f16ab6
---
 opensfm/dataset.py      |   4 +-
 opensfm/dataset_base.py |   4 +-
 opensfm/exif.py         | 104 +++++++++++++++++++++++++---------------
 3 files changed, 69 insertions(+), 43 deletions(-)

diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 939112c08..8ef8fd2d7 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -5,7 +5,7 @@
 import os
 import pickle
 from io import BytesIO
-from typing import Any, Dict, IO, List, Optional, Tuple
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -84,7 +84,7 @@ def _image_file(self, image: str) -> str:
         """Path to the image file."""
         return self.image_files[image]
 
-    def open_image_file(self, image: str) -> IO[bytes]:
+    def open_image_file(self, image: str) -> BinaryIO:
         """Open image file and return file object."""
         return self.io_handler.open_rb(self._image_file(image))
 
diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index 931974621..79f484a66 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -1,7 +1,7 @@
 # pyre-unsafe
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, IO, List, Optional, Tuple
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple
 
 import numpy as np
 from opensfm import features, geo, io, pygeometry, pymap, types
@@ -31,7 +31,7 @@ def images(self) -> List[str]:
         pass
 
     @abstractmethod
-    def open_image_file(self, image: str) -> IO[Any]:
+    def open_image_file(self, image: str) -> BinaryIO:
         pass
 
     @abstractmethod
diff --git a/opensfm/exif.py b/opensfm/exif.py
index 5b71bfdf8..7f5b6f75a 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -1,35 +1,39 @@
-# pyre-unsafe
+# pyre-strict
+
 import datetime
 import logging
 from codecs import decode, encode
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, BinaryIO, Callable, Dict, List, Optional, Tuple, Union
 
 import exifread
 import numpy as np
 import xmltodict as x2d
 from opensfm import pygeometry
+
 from opensfm.dataset_base import DataSetBase
 from opensfm.geo import ecef_from_lla
-from opensfm.pygeometry import Camera
 from opensfm.sensors import camera_calibration, sensor_data
 
 logger: logging.Logger = logging.getLogger(__name__)
-
-inch_in_mm = 25.4
-cm_in_mm = 10
-um_in_mm = 0.001
-default_projection = "perspective"
-maximum_altitude = 1e4
+inch_in_mm: float = 25.4
+cm_in_mm: float = 10
+um_in_mm: float = 0.001
+default_projection: str = "perspective"
+maximum_altitude: float = 1e4
 
 
-def eval_frac(value) -> Optional[float]:
+def eval_frac(
+    value: exifread.utils.Ratio,
+) -> Optional[float]:
     try:
         return float(value.num) / float(value.den)
     except ZeroDivisionError:
         return None
 
 
-def gps_to_decimal(values, reference) -> Optional[float]:
+def gps_to_decimal(
+    values: List[exifread.utils.Ratio], reference: str
+) -> Optional[float]:
     sign = 1 if reference in "NE" else -1
     degrees = eval_frac(values[0])
     minutes = eval_frac(values[1])
@@ -39,7 +43,7 @@ def gps_to_decimal(values, reference) -> Optional[float]:
     return None
 
 
-def get_tag_as_float(tags, key, index: int = 0) -> Optional[float]:
+def get_tag_as_float(tags: Dict[str, Any], key: str, index: int = 0) -> Optional[float]:
     if key in tags:
         val = tags[key].values[index]
         if isinstance(val, exifread.utils.Ratio):
@@ -57,13 +61,18 @@ def get_tag_as_float(tags, key, index: int = 0) -> Optional[float]:
 
 
 def compute_focal(
-    focal_35: Optional[float], focal: Optional[float], sensor_width, sensor_string
+    focal_35: Optional[float],
+    focal: Optional[float],
+    sensor_width: Optional[float],
+    sensor_string: Optional[str],
 ) -> Tuple[float, float]:
     if focal_35 is not None and focal_35 > 0:
         focal_ratio = focal_35 / 36.0  # 35mm film produces 36x24mm pictures.
     else:
         if not sensor_width:
-            sensor_width = sensor_data().get(sensor_string, None)
+            sensor_width = (
+                sensor_data().get(sensor_string, None) if sensor_string else None
+            )
         if sensor_width and focal:
             focal_ratio = focal / sensor_width
             focal_35 = 36.0 * focal_ratio
@@ -80,7 +89,7 @@ def sensor_string(make: str, model: str) -> str:
     return (make.strip() + " " + model.strip()).strip().lower()
 
 
-def camera_id(exif) -> str:
+def camera_id(exif: Dict[str, Any]) -> str:
     return camera_id_(
         exif["make"],
         exif["model"],
@@ -91,7 +100,9 @@ def camera_id(exif) -> str:
     )
 
 
-def camera_id_(make, model, width, height, projection_type, focal) -> str:
+def camera_id_(
+    make: str, model: str, width: int, height: int, projection_type: str, focal: float
+) -> str:
     if make != "unknown":
         # remove duplicate 'make' information in 'model'
         model = model.replace(make, "")
@@ -109,18 +120,21 @@ def camera_id_(make, model, width, height, projection_type, focal) -> str:
 
 
 def extract_exif_from_file(
-    fileobj, image_size_loader, use_exif_size, name=None
+    fileobj: BinaryIO,
+    image_size_loader: Callable[[], Tuple[int, int]],
+    use_exif_size: bool,
+    name: Optional[str] = None,
 ) -> Dict[str, Any]:
     exif_data = EXIF(fileobj, image_size_loader, use_exif_size, name=name)
     d = exif_data.extract_exif()
     return d
 
 
-def unescape_string(s) -> str:
+def unescape_string(s: str) -> str:
     return decode(encode(s, "latin-1", "backslashreplace"), "unicode-escape")
 
 
-def parse_xmp_string(xmp_str: str):
+def parse_xmp_string(xmp_str: str) -> Optional[Dict[str, Any]]:
     for _ in range(2):
         try:
             return x2d.parse(xmp_str)
@@ -129,7 +143,7 @@ def parse_xmp_string(xmp_str: str):
     return None
 
 
-def get_xmp(fileobj) -> List[str]:
+def get_xmp(fileobj: BinaryIO) -> List[Dict[str, Any]]:
     """Extracts XMP metadata from and image fileobj"""
     img_str = str(fileobj.read())
     xmp_start = img_str.find("<x:xmpmeta")
@@ -151,7 +165,7 @@ def get_xmp(fileobj) -> List[str]:
         return []
 
 
-def get_gpano_from_xmp(xmp) -> Dict[str, Any]:
+def get_gpano_from_xmp(xmp: List[Dict[str, Any]]) -> Dict[str, Any]:
     for i in xmp:
         for k in i:
             if "GPano" in k:
@@ -161,15 +175,19 @@ def get_gpano_from_xmp(xmp) -> Dict[str, Any]:
 
 class EXIF:
     def __init__(
-        self, fileobj, image_size_loader, use_exif_size=True, name=None
+        self,
+        fileobj: BinaryIO,
+        image_size_loader: Callable[[], Tuple[int, int]],
+        use_exif_size: bool = True,
+        name: Optional[str] = None,
     ) -> None:
-        self.image_size_loader = image_size_loader
-        self.use_exif_size = use_exif_size
-        self.fileobj = fileobj
-        self.tags = exifread.process_file(fileobj, details=False)
+        self.image_size_loader: Callable[[], Tuple[int, int]] = image_size_loader
+        self.use_exif_size: bool = use_exif_size
+        self.fileobj: BinaryIO = fileobj
+        self.tags: Dict[str, Any] = exifread.process_file(fileobj, details=False)
         fileobj.seek(0)
-        self.xmp = get_xmp(fileobj)
-        self.fileobj_name = self.fileobj.name if name is None else name
+        self.xmp: List[Dict[str, Any]] = get_xmp(fileobj)
+        self.fileobj_name: str = self.fileobj.name if name is None else name
 
     def extract_image_size(self) -> Tuple[int, int]:
         if (
@@ -194,14 +212,15 @@ def extract_image_size(self) -> Tuple[int, int]:
             height, width = self.image_size_loader()
         return width, height
 
-    def _decode_make_model(self, value) -> str:
+    def _decode_make_model(self, value: Union[str, bytes]) -> str:
         """Python 2/3 compatible decoding of make/model field."""
-        if hasattr(value, "decode"):
+        if type(value) is bytes:
             try:
                 return value.decode("utf-8")
             except UnicodeDecodeError:
                 return "unknown"
         else:
+            assert type(value) is str
             return value
 
     def extract_make(self) -> str:
@@ -259,7 +278,7 @@ def extract_sensor_width(self) -> Optional[float]:
         width_in_pixels = self.extract_image_size()[0]
         return width_in_pixels * units_per_pixel * mm_per_unit
 
-    def get_mm_per_unit(self, resolution_unit) -> Optional[float]:
+    def get_mm_per_unit(self, resolution_unit: int) -> Optional[float]:
         """Length of a resolution unit in millimeters.
 
         Uses the values from the EXIF specs in
@@ -268,6 +287,7 @@ def get_mm_per_unit(self, resolution_unit) -> Optional[float]:
         Args:
             resolution_unit: the resolution unit value given in the EXIF
         """
+        global inch_in_mm
         if resolution_unit == 2:  # inch
             return inch_in_mm
         elif resolution_unit == 3:  # cm
@@ -286,7 +306,7 @@ def extract_orientation(self) -> int:
         orientation = 1
         if "Image Orientation" in self.tags:
             value = self.tags.get("Image Orientation").values[0]
-            if type(value) == int and value != 0:
+            if type(value) is int and value != 0:
                 orientation = value
         return orientation
 
@@ -463,7 +483,7 @@ def extract_capture_time(self) -> float:
         )
         return 0.0
 
-    def extract_opk(self, geo) -> Optional[Dict[str, Any]]:
+    def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         opk = None
 
         if self.has_xmp() and geo and "latitude" in geo and "longitude" in geo:
@@ -614,7 +634,7 @@ def extract_exif(self) -> Dict[str, Any]:
         return d
 
 
-def hard_coded_calibration(exif) -> Optional[Dict[str, Any]]:
+def hard_coded_calibration(exif: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     focal = exif["focal_ratio"]
     fmm35 = int(round(focal * 36.0))
     make = exif["make"].strip().lower()
@@ -636,7 +656,7 @@ def hard_coded_calibration(exif) -> Optional[Dict[str, Any]]:
     return None
 
 
-def focal_ratio_calibration(exif) -> Optional[Dict[str, Any]]:
+def focal_ratio_calibration(exif: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     if exif.get("focal_ratio"):
         return {
             "focal": exif["focal_ratio"],
@@ -648,7 +668,7 @@ def focal_ratio_calibration(exif) -> Optional[Dict[str, Any]]:
         }
 
 
-def focal_xy_calibration(exif) -> Optional[Dict[str, Any]]:
+def focal_xy_calibration(exif: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     focal = exif.get("focal_x", exif.get("focal_ratio"))
     if focal:
         return {
@@ -693,7 +713,9 @@ def default_calibration(data: DataSetBase) -> Dict[str, Any]:
     }
 
 
-def calibration_from_metadata(metadata, data: DataSetBase) -> Dict[str, Any]:
+def calibration_from_metadata(
+    metadata: Dict[str, Any], data: DataSetBase
+) -> Dict[str, Any]:
     """Finds the best calibration in one of the calibration sources."""
     pt = metadata.get("projection_type", default_projection).lower()
     if (
@@ -721,8 +743,12 @@ def calibration_from_metadata(metadata, data: DataSetBase) -> Dict[str, Any]:
 
 
 def camera_from_exif_metadata(
-    metadata, data: DataSetBase, calibration_func=calibration_from_metadata
-) -> Camera:
+    metadata: Dict[str, Any],
+    data: DataSetBase,
+    calibration_func: Callable[
+        [Dict[str, Any], DataSetBase], Dict[str, Any]
+    ] = calibration_from_metadata,
+) -> pygeometry.Camera:
     """
     Create a camera object from exif metadata and the calibration
     function that turns metadata into usable calibration parameters.

From d1d50c148e65b07b259514c7a8cd25eb60020d30 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 133/235] annotate tracking

Differential Revision: D76518697

fbshipit-source-id: 49222854b09f8597e1a95b3e0cc16287e7a414b0
---
 opensfm/tracking.py | 65 ++++++++++++++++++++++++---------------------
 1 file changed, 34 insertions(+), 31 deletions(-)

diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index ca03603cf..04e5da48c 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -1,9 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import typing as t
+from typing import cast, Dict, List, Tuple
 
 import networkx as nx
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pymap
 from opensfm.dataset_base import DataSetBase
 from opensfm.pymap import TracksManager
@@ -14,13 +16,13 @@
 
 
 def load_features(
-    dataset: DataSetBase, images: t.List[str]
-) -> t.Tuple[
-    t.Dict[str, np.ndarray],
-    t.Dict[str, np.ndarray],
-    t.Dict[str, np.ndarray],
-    t.Dict[str, np.ndarray],
-    t.Dict[str, np.ndarray],
+    dataset: DataSetBase, images: List[str]
+) -> Tuple[
+    Dict[str, NDArray[np.float64]],
+    Dict[str, NDArray[np.int32]],
+    Dict[str, NDArray[np.int32]],
+    Dict[str, NDArray[np.int32]],
+    Dict[str, NDArray[np.float64]],
 ]:
     logging.info("reading features")
     features = {}
@@ -51,8 +53,8 @@ def load_features(
 
 
 def load_matches(
-    dataset: DataSetBase, images: t.List[str]
-) -> t.Dict[t.Tuple[str, str], t.List[t.Tuple[int, int]]]:
+    dataset: DataSetBase, images: List[str]
+) -> Dict[Tuple[str, str], List[Tuple[int, int]]]:
     matches = {}
     for im1 in images:
         try:
@@ -66,13 +68,13 @@ def load_matches(
 
 
 def create_tracks_manager(
-    features: t.Dict[str, np.ndarray],
-    colors: t.Dict[str, np.ndarray],
-    segmentations: t.Dict[str, np.ndarray],
-    instances: t.Dict[str, np.ndarray],
-    matches: t.Dict[t.Tuple[str, str], t.List[t.Tuple[int, int]]],
+    features: Dict[str, NDArray[np.float64]],
+    colors: Dict[str, NDArray[np.int32]],
+    segmentations: Dict[str, NDArray[np.int32]],
+    instances: Dict[str, NDArray[np.int32]],
+    matches: Dict[Tuple[str, str], List[Tuple[int, int]]],
     min_length: int,
-    depths: t.Dict[str, np.ndarray],
+    depths: Dict[str, NDArray[np.float64]],
     depth_is_radial: bool = True,
     depth_std_deviation: float = 1.0,
 ) -> TracksManager:
@@ -103,10 +105,15 @@ def create_tracks_manager(
                 continue
             x, y, s = features[image][featureid]
             r, g, b = colors[image][featureid]
-            segmentation, instance = (
-                segmentations[image][featureid] if image in segmentations else NO_VALUE,
-                instances[image][featureid] if image in instances else NO_VALUE,
+            segmentation = (
+                int(segmentations[image][featureid])
+                if image in segmentations
+                else NO_VALUE
             )
+            instance = (
+                int(instances[image][featureid]) if image in instances else NO_VALUE
+            )
+
             obs = pymap.Observation(
                 x,
                 y,
@@ -115,11 +122,7 @@ def create_tracks_manager(
                 int(g),
                 int(b),
                 featureid,
-                # pyre-fixme[6]: For 8th argument expected `int` but got
-                #  `Union[ndarray[typing.Any, typing.Any], int]`.
                 segmentation,
-                # pyre-fixme[6]: For 9th argument expected `int` but got
-                #  `Union[ndarray[typing.Any, typing.Any], int]`.
                 instance,
             )
             if image in depths:
@@ -146,7 +149,7 @@ def create_tracks_manager(
 
 def common_tracks(
     tracks_manager: pymap.TracksManager, im1: str, im2: str
-) -> t.Tuple[t.List[str], np.ndarray, np.ndarray]:
+) -> Tuple[List[str], NDArray[np.float64], NDArray[np.float64]]:
     """List of tracks observed in both images.
 
     Args:
@@ -170,34 +173,34 @@ def common_tracks(
     return tracks, p1, p2
 
 
-TPairTracks = t.Tuple[t.List[str], np.ndarray, np.ndarray]
+TPairTracks = Tuple[List[str], NDArray[np.float64], NDArray[np.float64]]
 
 
 def all_common_tracks_with_features(
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
-) -> t.Dict[t.Tuple[str, str], TPairTracks]:
+) -> Dict[Tuple[str, str], TPairTracks]:
     tracks = all_common_tracks(
         tracks_manager, include_features=True, min_common=min_common
     )
-    return t.cast(t.Dict[t.Tuple[str, str], TPairTracks], tracks)
+    return cast(Dict[Tuple[str, str], TPairTracks], tracks)
 
 
 def all_common_tracks_without_features(
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
-) -> t.Dict[t.Tuple[str, str], t.List[str]]:
+) -> Dict[Tuple[str, str], List[str]]:
     tracks = all_common_tracks(
         tracks_manager, include_features=False, min_common=min_common
     )
-    return t.cast(t.Dict[t.Tuple[str, str], t.List[str]], tracks)
+    return cast(Dict[Tuple[str, str], List[str]], tracks)
 
 
 def all_common_tracks(
     tracks_manager: pymap.TracksManager,
     include_features: bool = True,
     min_common: int = 50,
-) -> t.Dict[t.Tuple[str, str], t.Union[TPairTracks, t.List[str]]]:
+) -> Dict[Tuple[str, str], t.Union[TPairTracks, List[str]]]:
     """List of tracks observed by each image pair.
 
     Args:
@@ -227,7 +230,7 @@ def all_common_tracks(
     return common_tracks
 
 
-def _good_track(track: t.List[t.Tuple[str, int]], min_length: int) -> bool:
+def _good_track(track: List[Tuple[str, int]], min_length: int) -> bool:
     if len(track) < min_length:
         return False
     images = [f[0] for f in track]

From 2c85dc022827fb826321217ded03ab31a1546ca9 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 134/235] annotate reconstruction

Reviewed By: DodgySpaniard

Differential Revision: D76518691

fbshipit-source-id: 8785b1bc7cb44bc4bf8a521dd08042fed50e64cb
---
 opensfm/reconstruction.py | 85 ++++++++++++++++++++-------------------
 1 file changed, 43 insertions(+), 42 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index b66454126..4101d72f7 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 """Incremental reconstruction pipeline"""
 
 import datetime
@@ -13,6 +13,7 @@
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import (
     log,
     matching,
@@ -200,7 +201,7 @@ def pairwise_reconstructability(common_tracks: int, rotation_inliers: int) -> fl
 
 
 TPairArguments = Tuple[
-    str, str, np.ndarray, np.ndarray, pygeometry.Camera, pygeometry.Camera, float
+    str, str, NDArray, NDArray, pygeometry.Camera, pygeometry.Camera, float
 ]
 
 
@@ -285,7 +286,7 @@ def add_shot(
 
 
 def _two_view_reconstruction_inliers(
-    b1: np.ndarray, b2: np.ndarray, R: np.ndarray, t: np.ndarray, threshold: float
+    b1: NDArray, b2: NDArray, R: NDArray, t: NDArray, threshold: float
 ) -> List[int]:
     """Returns indices of matches that can be triangulated."""
     ok = matching.compute_inliers_bearings(b1, b2, R, t, threshold)
@@ -295,10 +296,10 @@ def _two_view_reconstruction_inliers(
 
 
 def two_view_reconstruction_plane_based(
-    b1: np.ndarray,
-    b2: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
     threshold: float,
-) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], List[int]]:
+) -> Tuple[Optional[NDArray], Optional[NDArray], List[int]]:
     """Reconstruct two views from point correspondences lying on a plane.
 
     Args:
@@ -333,14 +334,14 @@ def two_view_reconstruction_plane_based(
 
 
 def two_view_reconstruction_and_refinement(
-    b1: np.ndarray,
-    b2: np.ndarray,
-    R: np.ndarray,
-    t: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
+    R: NDArray,
+    t: NDArray,
     threshold: float,
     iterations: int,
     transposed: bool,
-) -> Tuple[np.ndarray, np.ndarray, List[int]]:
+) -> Tuple[NDArray, NDArray, List[int]]:
     """Reconstruct two views using provided rotation and translation.
 
     Args:
@@ -374,7 +375,7 @@ def two_view_reconstruction_and_refinement(
 
 
 def _two_view_rotation_inliers(
-    b1: np.ndarray, b2: np.ndarray, R: np.ndarray, threshold: float
+    b1: NDArray, b2: NDArray, R: NDArray, threshold: float
 ) -> List[int]:
     br2 = R.dot(b2.T).T
     ok = np.linalg.norm(br2 - b1, axis=1) < threshold
@@ -384,12 +385,12 @@ def _two_view_rotation_inliers(
 
 
 def two_view_reconstruction_rotation_only(
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
     threshold: float,
-) -> Tuple[np.ndarray, List[int]]:
+) -> Tuple[NDArray, List[int]]:
     """Find rotation between two views from point correspondences.
 
     Args:
@@ -410,15 +411,15 @@ def two_view_reconstruction_rotation_only(
 
 
 def two_view_reconstruction_5pt(
-    b1: np.ndarray,
-    b2: np.ndarray,
-    R: np.ndarray,
-    t: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
+    R: NDArray,
+    t: NDArray,
     threshold: float,
     iterations: int,
     check_reversal: bool = False,
     reversal_ratio: float = 1.0,
-) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], List[int]]:
+) -> Tuple[Optional[NDArray], Optional[NDArray], List[int]]:
     """Run 5-point reconstruction and refinement, given computed relative rotation and translation.
 
     Optionally, the method will perform reconstruction and refinement for both given and transposed
@@ -482,16 +483,16 @@ def two_view_reconstruction_5pt(
     return R_5p, t_5p, inliers_5p
 
 
-def two_view_reconstruction_general(
-    p1: np.ndarray,
-    p2: np.ndarray,
+def two_view_reconstruction_general(  # pyre-ignore[3]: pyre is not happy with the Dict[str, Any]
+    p1: NDArray,
+    p2: NDArray,
     camera1: pygeometry.Camera,
     camera2: pygeometry.Camera,
     threshold: float,
     iterations: int,
     check_reversal: bool = False,
     reversal_ratio: float = 1.0,
-) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], List[int], Dict[str, Any]]:
+) -> Tuple[Optional[NDArray], Optional[NDArray], List[int], Dict[str, Any]]:
     """Reconstruct two views from point correspondences.
 
     These will try different reconstruction methods and return the
@@ -560,8 +561,8 @@ def reconstruction_from_relative_pose(
     tracks_manager: pymap.TracksManager,
     im1: str,
     im2: str,
-    R: np.ndarray,
-    t: np.ndarray,
+    R: NDArray,
+    t: NDArray,
 ) -> Tuple[Optional[types.Reconstruction], Dict[str, Any]]:
     """Create a reconstruction from 'im1' and 'im2' using the provided rotation 'R' and translation 't'."""
     report = {}
@@ -621,8 +622,8 @@ def bootstrap_reconstruction(
     tracks_manager: pymap.TracksManager,
     im1: str,
     im2: str,
-    p1: np.ndarray,
-    p2: np.ndarray,
+    p1: NDArray,
+    p2: NDArray,
 ) -> Tuple[Optional[types.Reconstruction], Dict[str, Any]]:
     """Start a reconstruction using two shots."""
     logger.info("Starting reconstruction with {} and {}".format(im1, im2))
@@ -790,7 +791,7 @@ def resect_reconstruction(
     tracks_manager2: pymap.TracksManager,
     threshold: float,
     min_inliers: int,
-) -> Tuple[bool, np.ndarray, List[Tuple[str, str]]]:
+) -> Tuple[bool, NDArray, List[Tuple[str, str]]]:
     """Compute a similarity transform `similarity` such as :
 
     reconstruction2 = T . reconstruction1
@@ -833,7 +834,7 @@ def get_observations(self, track_id: str) -> Dict[str, pymap.Observation]:
         pass
 
     @abstractmethod
-    def store_track_coordinates(self, track_id: str, coordinates: np.ndarray) -> None:
+    def store_track_coordinates(self, track_id: str, coordinates: NDArray) -> None:
         """Stores coordinates of triangulated track."""
         pass
 
@@ -867,7 +868,7 @@ def get_observations(self, track_id: str) -> Dict[str, pymap.Observation]:
             if k in self.reconstruction.shots
         }
 
-    def store_track_coordinates(self, track_id: str, coordinates: np.ndarray) -> None:
+    def store_track_coordinates(self, track_id: str, coordinates: NDArray) -> None:
         """Stores coordinates of triangulated track."""
         self.reconstruction.create_point(track_id, coordinates)
 
@@ -890,9 +891,9 @@ class TrackTriangulator:
     tracks_handler: TrackHandlerBase
 
     # caches
-    origins: Dict[str, np.ndarray] = {}
-    rotation_inverses: Dict[str, np.ndarray] = {}
-    Rts: Dict[str, np.ndarray] = {}
+    origins: Dict[str, NDArray] = {}
+    rotation_inverses: Dict[str, NDArray] = {}
+    Rts: Dict[str, NDArray] = {}
 
     def __init__(
         self, reconstruction: types.Reconstruction, tracks_handler: TrackHandlerBase
@@ -900,9 +901,9 @@ def __init__(
         """Build a triangulator for a specific reconstruction."""
         self.reconstruction = reconstruction
         self.tracks_handler = tracks_handler
-        self.origins = {}
-        self.rotation_inverses = {}
-        self.Rts = {}
+        self.origins: Dict[str, NDArray] = {}
+        self.rotation_inverses: Dict[str, NDArray] = {}
+        self.Rts: Dict[str, NDArray] = {}
 
     def triangulate_robust(
         self,
@@ -1076,7 +1077,7 @@ def triangulate_dlt(
                 for shot_id in ids:
                     self.tracks_handler.store_inliers_observation(track, shot_id)
 
-    def _shot_origin(self, shot: pymap.Shot) -> np.ndarray:
+    def _shot_origin(self, shot: pymap.Shot) -> NDArray:
         if shot.id in self.origins:
             return self.origins[shot.id]
         else:
@@ -1084,7 +1085,7 @@ def _shot_origin(self, shot: pymap.Shot) -> np.ndarray:
             self.origins[shot.id] = o
             return o
 
-    def _shot_rotation_inverse(self, shot: pymap.Shot) -> np.ndarray:
+    def _shot_rotation_inverse(self, shot: pymap.Shot) -> NDArray:
         if shot.id in self.rotation_inverses:
             return self.rotation_inverses[shot.id]
         else:
@@ -1092,7 +1093,7 @@ def _shot_rotation_inverse(self, shot: pymap.Shot) -> np.ndarray:
             self.rotation_inverses[shot.id] = r
             return r
 
-    def _shot_Rt(self, shot: pymap.Shot) -> np.ndarray:
+    def _shot_Rt(self, shot: pymap.Shot) -> NDArray:
         if shot.id in self.Rts:
             return self.Rts[shot.id]
         else:
@@ -1264,7 +1265,7 @@ def align_two_reconstruction(
     r2: types.Reconstruction,
     common_tracks: List[Tuple[str, str]],
     threshold: float,
-) -> Tuple[bool, Optional[np.ndarray], List[int]]:
+) -> Tuple[bool, Optional[NDArray], List[int]]:
     """Estimate similarity transform T between two,
     reconstructions r1 and r2 such as r2 = T . r1
     """
@@ -1394,7 +1395,7 @@ class ShouldRetriangulate:
     ratio: float
     reconstruction: types.Reconstruction
 
-    def __init__(self, data, reconstruction) -> None:
+    def __init__(self, data: DataSetBase, reconstruction: types.Reconstruction) -> None:
         self.active = data.config["retriangulation"]
         self.ratio = data.config["retriangulation_ratio"]
         self.reconstruction = reconstruction

From 89d46ebcd7f66ea640d064dd89dab638d6bd8008 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 135/235] annotate align

Reviewed By: DodgySpaniard

Differential Revision: D76518687

fbshipit-source-id: 9033bdb6e9835ee699b2062f7c4f37ade1dcb423
---
 opensfm/align.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index 0ee303a31..5b020e36e 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 """Tools to align a reconstruction to GPS and GCP data."""
 
 import logging
@@ -8,6 +8,7 @@
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import multiview, pygeometry, pymap, transformations as tf, types
 
 
@@ -20,7 +21,7 @@ def align_reconstruction(
     config: Dict[str, Any],
     use_gps: bool = True,
     bias_override: bool = False,
-) -> Optional[Tuple[float, np.ndarray, np.ndarray]]:
+) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Align a reconstruction with GPS and GCP data."""
     has_scaled_rigs = any(
         [True for ri in reconstruction.rig_instances.values() if len(ri.shots) > 1]
@@ -39,7 +40,7 @@ def align_reconstruction(
 
 
 def apply_similarity_pose(
-    pose: pygeometry.Pose, s: float, A: np.ndarray, b: np.ndarray
+    pose: pygeometry.Pose, s: float, A: NDArray, b: NDArray
 ) -> None:
     """Apply a similarity (y = s A x + b) to an object having a 'pose' member."""
     R = pose.get_rotation_matrix()
@@ -51,7 +52,7 @@ def apply_similarity_pose(
 
 
 def apply_similarity(
-    reconstruction: types.Reconstruction, s: float, A: np.ndarray, b: np.ndarray
+    reconstruction: types.Reconstruction, s: float, A: NDArray, b: NDArray
 ) -> None:
     """Apply a similarity (y = s A x + b) to a reconstruction.
 
@@ -79,7 +80,7 @@ def compute_reconstruction_similarity(
     config: Dict[str, Any],
     use_gps: bool,
     use_scale: bool,
-) -> Optional[Tuple[float, np.ndarray, np.ndarray]]:
+) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Compute similarity so that the reconstruction is aligned with GPS and GCP data.
 
     Config parameter `align_method` can be used to choose the alignment method.
@@ -120,7 +121,7 @@ def alignment_constraints(
     reconstruction: types.Reconstruction,
     gcp: List[pymap.GroundControlPoint],
     use_gps: bool,
-) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+) -> Tuple[List[NDArray], List[NDArray]]:
     """Gather alignment constraints to be used by checking bundle_use_gcp and bundle_use_gps."""
 
     X, Xp = [], []
@@ -187,7 +188,7 @@ def compute_naive_similarity(
     gcp: List[pymap.GroundControlPoint],
     use_gps: bool,
     use_scale: bool,
-) -> Optional[Tuple[float, np.ndarray, np.ndarray]]:
+) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Compute similarity with GPS and GCP data using direct 3D-3D matches."""
     X, Xp = alignment_constraints(config, reconstruction, gcp, use_gps)
 
@@ -232,7 +233,7 @@ def compute_orientation_prior_similarity(
     gcp: List[pymap.GroundControlPoint],
     use_gps: bool,
     use_scale: bool,
-) -> Optional[Tuple[float, np.ndarray, np.ndarray]]:
+) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Compute similarity with GPS data assuming particular a camera orientation.
 
     In some cases, using 3D-3D matches directly fails to find proper
@@ -311,7 +312,7 @@ def set_gps_bias(
     config: Dict[str, Any],
     gcp: List[pymap.GroundControlPoint],
     use_scale: bool,
-) -> Optional[Tuple[float, np.ndarray, np.ndarray]]:
+) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Compute and set the bias transform of the GPS coordinate system wrt. to the GCP one."""
 
     # Compute similarity ('gps_bias') that brings the reconstruction on the GCPs ONLY
@@ -364,7 +365,7 @@ def set_gps_bias(
 
 def estimate_ground_plane(
     reconstruction: types.Reconstruction, config: Dict[str, Any]
-) -> Optional[np.ndarray]:
+) -> Optional[NDArray]:
     """Estimate ground plane orientation.
 
     It assumes cameras are all at a similar height and uses the
@@ -407,8 +408,8 @@ def estimate_ground_plane(
 
 
 def get_horizontal_and_vertical_directions(
-    R: np.ndarray, orientation: int
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    R: NDArray, orientation: int
+) -> Tuple[NDArray, NDArray, NDArray]:
     """Get orientation vectors from camera rotation matrix and orientation tag.
 
     Return a 3D vectors pointing to the positive XYZ directions of the image.
@@ -437,7 +438,7 @@ def get_horizontal_and_vertical_directions(
 
 def triangulate_all_gcp(
     reconstruction: types.Reconstruction, gcp: List[pymap.GroundControlPoint]
-) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+) -> Tuple[List[NDArray], List[NDArray]]:
     """Group and triangulate Ground Control Points seen in 2+ images."""
     triangulated, measured = [], []
     for point in gcp:

From 0a94043ba83311e9d9e77d91eff38a2a863e752c Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 136/235] annotate transformations

Reviewed By: DodgySpaniard

Differential Revision: D76518701

fbshipit-source-id: ca703ab5f9c6b5e0762cf9131c2e169670045769
---
 opensfm/transformations.py | 173 ++++++++++++++++++-------------------
 1 file changed, 82 insertions(+), 91 deletions(-)

diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index 23fded2dc..a1bf7b876 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -1,6 +1,6 @@
 # transformations.py
 
-# pyre-unsafe
+# pyre-strict
 
 # Copyright (c) 2006-2013, Christoph Gohlke
 # Copyright (c) 2006-2013, The Regents of the University of California
@@ -191,13 +191,14 @@
 from typing import Dict, List, Optional, Tuple
 
 import numpy
+from numpy.typing import NDArray
 
 __version__ = "2013.06.29"
 __docformat__ = "restructuredtext en"
-__all__ = []
+__all__: List[str] = []
 
 
-def identity_matrix() -> numpy.ndarray:
+def identity_matrix() -> NDArray:
     """Return 4x4 identity/unit matrix.
 
     >>> I = identity_matrix()
@@ -212,7 +213,7 @@ def identity_matrix() -> numpy.ndarray:
     return numpy.identity(4)
 
 
-def translation_matrix(direction: numpy.ndarray) -> numpy.ndarray:
+def translation_matrix(direction: NDArray) -> NDArray:
     """Return matrix to translate by direction vector.
 
     >>> v = numpy.random.random(3) - 0.5
@@ -225,7 +226,7 @@ def translation_matrix(direction: numpy.ndarray) -> numpy.ndarray:
     return M
 
 
-def translation_from_matrix(matrix: numpy.ndarray) -> numpy.ndarray:
+def translation_from_matrix(matrix: NDArray) -> NDArray:
     """Return translation vector from translation matrix.
 
     >>> v0 = numpy.random.random(3) - 0.5
@@ -237,7 +238,7 @@ def translation_from_matrix(matrix: numpy.ndarray) -> numpy.ndarray:
     return numpy.array(matrix, copy=False)[:3, 3].copy()
 
 
-def reflection_matrix(point: numpy.ndarray, normal: numpy.ndarray) -> numpy.ndarray:
+def reflection_matrix(point: NDArray, normal: NDArray) -> NDArray:
     """Return matrix to mirror at plane defined by point and normal vector.
 
     >>> v0 = numpy.random.random(4) - 0.5
@@ -264,8 +265,8 @@ def reflection_matrix(point: numpy.ndarray, normal: numpy.ndarray) -> numpy.ndar
 
 
 def reflection_from_matrix(
-    matrix: numpy.ndarray,
-) -> Tuple[numpy.ndarray, numpy.ndarray]:
+    matrix: NDArray,
+) -> Tuple[NDArray, NDArray]:
     """Return mirror plane point and normal vector from reflection matrix.
 
     >>> v0 = numpy.random.random(3) - 0.5
@@ -296,9 +297,9 @@ def reflection_from_matrix(
 
 def rotation_matrix(
     angle: float,
-    direction: numpy.ndarray,
-    point: Optional[numpy.ndarray] = None,
-) -> numpy.ndarray:
+    direction: NDArray,
+    point: Optional[NDArray] = None,
+) -> NDArray:
     """Return matrix to rotate about axis defined by point and direction.
 
     >>> R = rotation_matrix(math.pi/2, [0, 0, 1], [1, 0, 0])
@@ -347,8 +348,8 @@ def rotation_matrix(
 
 
 def rotation_from_matrix(
-    matrix: numpy.ndarray,
-) -> Tuple[float, numpy.ndarray, numpy.ndarray]:
+    matrix: NDArray,
+) -> Tuple[float, NDArray, NDArray]:
     """Return rotation angle and axis from rotation matrix.
 
     >>> angle = (numpy.random.random() - 0.5) * (2*math.pi)
@@ -389,10 +390,10 @@ def rotation_from_matrix(
 
 
 def scale_matrix(
-    factor: numpy.ndarray,
-    origin: Optional[numpy.ndarray] = None,
-    direction: Optional[numpy.ndarray] = None,
-) -> numpy.ndarray:
+    factor: NDArray,
+    origin: Optional[NDArray] = None,
+    direction: Optional[NDArray] = None,
+) -> NDArray:
     """Return matrix to scale by factor around origin in direction.
 
     Use factor -1 for point symmetry.
@@ -428,8 +429,8 @@ def scale_matrix(
 
 
 def scale_from_matrix(
-    matrix: numpy.ndarray,
-) -> Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]:
+    matrix: NDArray,
+) -> Tuple[NDArray, NDArray, NDArray]:
     """Return scaling factor, origin and direction from scaling matrix.
 
     >>> factor = numpy.random.random() * 10 - 5
@@ -475,12 +476,12 @@ def scale_from_matrix(
 
 
 def projection_matrix(
-    point: numpy.ndarray,
-    normal: numpy.ndarray,
-    direction: Optional[numpy.ndarray] = None,
-    perspective: Optional[numpy.ndarray] = None,
+    point: NDArray,
+    normal: NDArray,
+    direction: Optional[NDArray] = None,
+    perspective: Optional[NDArray] = None,
     pseudo: bool = False,
-) -> numpy.ndarray:
+) -> NDArray:
     """Return matrix to project onto plane defined by point and normal.
 
     Using either perspective point, projection direction, or none of both.
@@ -541,10 +542,8 @@ def projection_matrix(
 
 
 def projection_from_matrix(
-    matrix: numpy.ndarray, pseudo: bool = False
-) -> Tuple[
-    numpy.ndarray, numpy.ndarray, Optional[numpy.ndarray], Optional[numpy.ndarray], bool
-]:
+    matrix: NDArray, pseudo: bool = False
+) -> Tuple[NDArray, NDArray, Optional[NDArray], Optional[NDArray], bool]:
     """Return projection plane and perspective point from projection matrix.
 
     Return values are same as arguments for projection_matrix function:
@@ -617,14 +616,14 @@ def projection_from_matrix(
 
 
 def clip_matrix(
-    left: numpy.ndarray,
-    right: numpy.ndarray,
-    bottom: numpy.ndarray,
-    top: numpy.ndarray,
-    near: numpy.ndarray,
-    far: numpy.ndarray,
+    left: NDArray,
+    right: NDArray,
+    bottom: NDArray,
+    top: NDArray,
+    near: NDArray,
+    far: NDArray,
     perspective: bool = False,
-) -> numpy.ndarray:
+) -> NDArray:
     """Return matrix to obtain normalized device coordinates from frustum.
 
     The frustum bounds are axis-aligned along x (left, right),
@@ -682,10 +681,10 @@ def clip_matrix(
 
 def shear_matrix(
     angle: float,
-    direction: numpy.ndarray,
-    point: numpy.ndarray,
-    normal: numpy.ndarray,
-) -> numpy.ndarray:
+    direction: NDArray,
+    point: NDArray,
+    normal: NDArray,
+) -> NDArray:
     """Return matrix to shear by angle along direction vector on shear plane.
 
     The shear plane is defined by a point and normal vector. The direction
@@ -717,8 +716,8 @@ def shear_matrix(
 
 
 def shear_from_matrix(
-    matrix: numpy.ndarray,
-) -> Tuple[float, numpy.ndarray, numpy.ndarray, numpy.ndarray]:
+    matrix: NDArray,
+) -> Tuple[float, NDArray, NDArray, NDArray]:
     """Return shear angle, direction and plane from shear matrix.
 
     # Test disabled because it fails from time to time.
@@ -765,8 +764,8 @@ def shear_from_matrix(
 
 
 def decompose_matrix(
-    matrix: numpy.ndarray,
-) -> Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray]:
+    matrix: NDArray,
+) -> Tuple[NDArray, NDArray, NDArray, NDArray, NDArray]:
     """Return sequence of transformations from transformation matrix.
 
     matrix : array_like
@@ -852,12 +851,12 @@ def decompose_matrix(
 
 
 def compose_matrix(
-    scale: Optional[numpy.ndarray] = None,
-    shear: Optional[numpy.ndarray] = None,
-    angles: Optional[numpy.ndarray] = None,
-    translate: Optional[numpy.ndarray] = None,
-    perspective: Optional[numpy.ndarray] = None,
-) -> numpy.ndarray:
+    scale: Optional[NDArray] = None,
+    shear: Optional[NDArray] = None,
+    angles: Optional[NDArray] = None,
+    translate: Optional[NDArray] = None,
+    perspective: Optional[NDArray] = None,
+) -> NDArray:
     """Return transformation matrix from sequence of transformations.
 
     This is the inverse of the decompose_matrix function.
@@ -909,9 +908,7 @@ def compose_matrix(
     return M
 
 
-def orthogonalization_matrix(
-    lengths: numpy.ndarray, angles: numpy.ndarray
-) -> numpy.ndarray:
+def orthogonalization_matrix(lengths: NDArray, angles: NDArray) -> NDArray:
     """Return orthogonalization matrix for crystallographic cell coordinates.
 
     Angles are expected in degrees.
@@ -942,12 +939,12 @@ def orthogonalization_matrix(
 
 
 def affine_matrix_from_points(
-    v0: numpy.ndarray,
-    v1: numpy.ndarray,
+    v0: NDArray,
+    v1: NDArray,
     shear: bool = True,
     scale: bool = True,
     usesvd: bool = True,
-) -> numpy.ndarray:
+) -> NDArray:
     r"""Return affine transform matrix to register two point sets.
 
     v0 and v1 are shape (ndims, \*) arrays of at least ndims non-homogeneous
@@ -1060,8 +1057,8 @@ def affine_matrix_from_points(
 
 
 def superimposition_matrix(
-    v0: numpy.ndarray, v1: numpy.ndarray, scale: bool = False, usesvd: bool = True
-) -> numpy.ndarray:
+    v0: NDArray, v1: NDArray, scale: bool = False, usesvd: bool = True
+) -> NDArray:
     r"""Return matrix to transform given 3D point set into second point set.
 
     v0 and v1 are shape (3, \*) or (4, \*) arrays of at least 3 points.
@@ -1111,7 +1108,7 @@ def superimposition_matrix(
     return affine_matrix_from_points(v0, v1, shear=False, scale=scale, usesvd=usesvd)
 
 
-def euler_matrix(ai: float, aj: float, ak: float, axes: str = "sxyz") -> numpy.ndarray:
+def euler_matrix(ai: float, aj: float, ak: float, axes: str = "sxyz") -> NDArray:
     """Return homogeneous rotation matrix from Euler angles and axis sequence.
 
     ai, aj, ak : Euler's roll, pitch and yaw angles
@@ -1179,7 +1176,7 @@ def euler_matrix(ai: float, aj: float, ak: float, axes: str = "sxyz") -> numpy.n
 
 
 def euler_from_matrix(
-    matrix: numpy.ndarray, axes: str = "sxyz"
+    matrix: NDArray, axes: str = "sxyz"
 ) -> Tuple[float, float, float]:
     """Return Euler angles from rotation matrix for specified axis sequence.
 
@@ -1276,7 +1273,7 @@ def euler_from_matrix(
 
 
 def euler_from_quaternion(
-    quaternion: numpy.ndarray, axes: str = "sxyz"
+    quaternion: NDArray, axes: str = "sxyz"
 ) -> Tuple[float, float, float]:
     """Return Euler angles from quaternion for specified axis sequence.
 
@@ -1289,8 +1286,8 @@ def euler_from_quaternion(
 
 
 def quaternion_from_euler(
-    ai: numpy.ndarray, aj: numpy.ndarray, ak: numpy.ndarray, axes: str = "sxyz"
-) -> numpy.ndarray:
+    ai: NDArray, aj: NDArray, ak: NDArray, axes: str = "sxyz"
+) -> NDArray:
     """Return quaternion from Euler angles and axis sequence.
 
     ai, aj, ak : Euler's roll, pitch and yaw angles
@@ -1354,7 +1351,7 @@ def quaternion_from_euler(
     return q
 
 
-def quaternion_about_axis(angle: numpy.ndarray, axis: numpy.ndarray) -> numpy.ndarray:
+def quaternion_about_axis(angle: NDArray, axis: NDArray) -> NDArray:
     """Return quaternion for rotation about axis.
 
     >>> q = quaternion_about_axis(0.123, [1, 0, 0])
@@ -1370,7 +1367,7 @@ def quaternion_about_axis(angle: numpy.ndarray, axis: numpy.ndarray) -> numpy.nd
     return q
 
 
-def quaternion_matrix(quaternion: numpy.ndarray) -> numpy.ndarray:
+def quaternion_matrix(quaternion: NDArray) -> NDArray:
     """Return homogeneous rotation matrix from quaternion.
 
     >>> M = quaternion_matrix([0.99810947, 0.06146124, 0, 0])
@@ -1400,9 +1397,7 @@ def quaternion_matrix(quaternion: numpy.ndarray) -> numpy.ndarray:
     )
 
 
-def quaternion_from_matrix(
-    matrix: numpy.ndarray, isprecise: bool = False
-) -> numpy.ndarray:
+def quaternion_from_matrix(matrix: NDArray, isprecise: bool = False) -> NDArray:
     """Return quaternion from rotation matrix.
 
     If isprecise is True, the input matrix is assumed to be a precise rotation
@@ -1483,9 +1478,7 @@ def quaternion_from_matrix(
     return q
 
 
-def quaternion_multiply(
-    quaternion1: numpy.ndarray, quaternion0: numpy.ndarray
-) -> numpy.ndarray:
+def quaternion_multiply(quaternion1: NDArray, quaternion0: NDArray) -> NDArray:
     """Return multiplication of two quaternions.
 
     >>> q = quaternion_multiply([4, 1, -2, 3], [8, -5, 6, 7])
@@ -1506,7 +1499,7 @@ def quaternion_multiply(
     )
 
 
-def quaternion_conjugate(quaternion: numpy.ndarray) -> numpy.ndarray:
+def quaternion_conjugate(quaternion: NDArray) -> NDArray:
     """Return conjugate of quaternion.
 
     >>> q0 = random_quaternion()
@@ -1520,7 +1513,7 @@ def quaternion_conjugate(quaternion: numpy.ndarray) -> numpy.ndarray:
     return q
 
 
-def quaternion_inverse(quaternion: numpy.ndarray) -> numpy.ndarray:
+def quaternion_inverse(quaternion: NDArray) -> NDArray:
     """Return inverse of quaternion.
 
     >>> q0 = random_quaternion()
@@ -1534,7 +1527,7 @@ def quaternion_inverse(quaternion: numpy.ndarray) -> numpy.ndarray:
     return q / numpy.dot(q, q)
 
 
-def quaternion_real(quaternion: numpy.ndarray) -> float:
+def quaternion_real(quaternion: NDArray) -> float:
     """Return real part of quaternion.
 
     >>> quaternion_real([3, 0, 1, 2])
@@ -1544,7 +1537,7 @@ def quaternion_real(quaternion: numpy.ndarray) -> float:
     return float(quaternion[0])
 
 
-def quaternion_imag(quaternion: numpy.ndarray) -> numpy.ndarray:
+def quaternion_imag(quaternion: NDArray) -> NDArray:
     """Return imaginary part of quaternion.
 
     >>> quaternion_imag([3, 0, 1, 2])
@@ -1555,12 +1548,12 @@ def quaternion_imag(quaternion: numpy.ndarray) -> numpy.ndarray:
 
 
 def quaternion_slerp(
-    quat0: numpy.ndarray,
-    quat1: numpy.ndarray,
-    fraction: numpy.ndarray,
+    quat0: NDArray,
+    quat1: NDArray,
+    fraction: NDArray,
     spin: int = 0,
     shortestpath: bool = True,
-) -> numpy.ndarray:
+) -> NDArray:
     """Return spherical linear interpolation between two quaternions.
 
     >>> q0 = random_quaternion()
@@ -1601,7 +1594,7 @@ def quaternion_slerp(
     return q0
 
 
-def random_quaternion(rand: Optional[numpy.ndarray] = None) -> numpy.ndarray:
+def random_quaternion(rand: Optional[NDArray] = None) -> NDArray:
     """Return uniform random unit quaternion.
 
     rand: array like or None
@@ -1630,7 +1623,7 @@ def random_quaternion(rand: Optional[numpy.ndarray] = None) -> numpy.ndarray:
     )
 
 
-def random_rotation_matrix(rand: Optional[numpy.ndarray] = None) -> numpy.ndarray:
+def random_rotation_matrix(rand: Optional[NDArray] = None) -> NDArray:
     """Return uniform random rotation matrix.
 
     rand: array like
@@ -1683,7 +1676,7 @@ def random_rotation_matrix(rand: Optional[numpy.ndarray] = None) -> numpy.ndarra
 
 
 def vector_norm(
-    data: numpy.ndarray, axis: Optional[int] = None, out: Optional[numpy.ndarray] = None
+    data: NDArray, axis: Optional[int] = None, out: Optional[NDArray] = None
 ) -> float:
     """Return length, i.e. Euclidean norm, of ndarray along axis.
 
@@ -1728,8 +1721,8 @@ def vector_norm(
 
 
 def unit_vector(
-    data: numpy.ndarray, axis: Optional[int] = None, out: Optional[numpy.ndarray] = None
-) -> numpy.ndarray:
+    data: NDArray, axis: Optional[int] = None, out: Optional[NDArray] = None
+) -> NDArray:
     """Return ndarray normalized by length, i.e. Euclidean norm, along axis.
 
     >>> v0 = numpy.random.random(3)
@@ -1772,7 +1765,7 @@ def unit_vector(
     return data
 
 
-def random_vector(size: int) -> numpy.ndarray:
+def random_vector(size: int) -> NDArray:
     """Return array of random doubles in the half-open interval [0.0, 1.0).
 
     >>> v = random_vector(10000)
@@ -1787,9 +1780,7 @@ def random_vector(size: int) -> numpy.ndarray:
     return numpy.random.random(size)
 
 
-def vector_product(
-    v0: numpy.ndarray, v1: numpy.ndarray, axis: int = 0
-) -> numpy.ndarray:
+def vector_product(v0: NDArray, v1: NDArray, axis: int = 0) -> NDArray:
     """Return vector perpendicular to vectors.
 
     >>> v = vector_product([2, 0, 0], [0, 3, 0])
@@ -1811,7 +1802,7 @@ def vector_product(
 
 
 def angle_between_vectors(
-    v0: numpy.ndarray, v1: numpy.ndarray, directed: bool = True, axis: int = 0
+    v0: NDArray, v1: NDArray, directed: bool = True, axis: int = 0
 ) -> float:
     """Return angle between vectors.
 
@@ -1844,7 +1835,7 @@ def angle_between_vectors(
     return numpy.arccos(dot if directed else numpy.fabs(dot))
 
 
-def inverse_matrix(matrix: numpy.ndarray) -> numpy.ndarray:
+def inverse_matrix(matrix: NDArray) -> NDArray:
     """Return inverse of square transformation matrix.
 
     >>> M0 = random_rotation_matrix()
@@ -1860,7 +1851,7 @@ def inverse_matrix(matrix: numpy.ndarray) -> numpy.ndarray:
     return numpy.linalg.inv(matrix)
 
 
-def concatenate_matrices(*matrices: List[numpy.ndarray]) -> numpy.ndarray:
+def concatenate_matrices(*matrices: List[NDArray]) -> NDArray:
     """Return concatenation of series of transformation matrices.
 
     >>> M = numpy.random.rand(16).reshape((4, 4)) - 0.5
@@ -1876,7 +1867,7 @@ def concatenate_matrices(*matrices: List[numpy.ndarray]) -> numpy.ndarray:
     return M
 
 
-def is_same_transform(matrix0: numpy.ndarray, matrix1: numpy.ndarray) -> numpy.ndarray:
+def is_same_transform(matrix0: NDArray, matrix1: NDArray) -> NDArray:
     """Return True if two matrices perform same transformation.
 
     >>> is_same_transform(numpy.identity(4), numpy.identity(4))

From 05c77ec0ac92d0bbec19f981f08eeac6a865a5b5 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 137/235] onnotate pair_selection

Reviewed By: DodgySpaniard

Differential Revision: D76518698

fbshipit-source-id: 0fb0211c22c95a597df9ef83a94d18d20a3247a6
---
 opensfm/pairs_selection.py | 47 ++++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index a20d4e581..7904b6501 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 import logging
 import math
@@ -8,6 +8,7 @@
 
 import numpy as np
 import scipy.spatial as spatial
+from numpy.typing import NDArray
 from opensfm import bow, context, feature_loader, geo, geometry, vlad
 from opensfm.dataset_base import DataSetBase
 
@@ -32,7 +33,7 @@ def sorted_pair(im1: str, im2: str) -> Tuple[str, str]:
 
 def get_gps_point(
     exif: Dict[str, Any], reference: geo.TopocentricConverter
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[NDArray, NDArray]:
     """Return GPS-based representative point. Direction is returned as Z oriented (vertical assumption)"""
     gps = exif["gps"]
     altitude = 0
@@ -55,7 +56,7 @@ def sign(x: float) -> float:
 
 def get_gps_opk_point(
     exif: Dict[str, Any], reference: geo.TopocentricConverter
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> Tuple[NDArray, NDArray]:
     """Return GPS-based representative point."""
 
     opk = exif["opk"]
@@ -73,7 +74,7 @@ def get_gps_opk_point(
 
 
 def find_best_altitude(
-    origin: Dict[str, np.ndarray], directions: Dict[str, np.ndarray]
+    origin: Dict[str, NDArray], directions: Dict[str, NDArray]
 ) -> float:
     """Find the altitude that minimize X/Y bounding box. Domain is [0, MAXIMUM_Z].
     'origin' contains per-image positions in worl coordinates
@@ -105,7 +106,7 @@ def find_best_altitude(
 
 def get_representative_points(
     images: List[str], exifs: Dict[str, Any], reference: geo.TopocentricConverter
-) -> Dict[str, np.ndarray]:
+) -> Dict[str, NDArray]:
     """Return a topocentric point for each image, that is suited to run distance-based pair selection."""
     origin = {}
     directions = {}
@@ -210,7 +211,7 @@ def match_candidates_by_distance(
     return pairs
 
 
-def norm_2d(vec: np.ndarray) -> float:
+def norm_2d(vec: NDArray) -> float:
     """Return the 2D norm of a vector."""
     return math.sqrt(vec[0] ** 2 + vec[1] ** 2)
 
@@ -226,9 +227,9 @@ def match_candidates_by_graph(
     if len(images_cand) < 4 or rounds < 1:
         return set()
 
-    images_cand_set = set(images_cand)
-    images_ref_set = set(images_ref)
-    images = list(images_cand_set | images_ref_set)
+    images_cand_set: Set[str] = set(images_cand)
+    images_ref_set: Set[str] = set(images_ref)
+    images: List[str] = list(images_cand_set | images_ref_set)
 
     representative_points = get_representative_points(images, exifs, reference)
 
@@ -236,7 +237,9 @@ def match_candidates_by_graph(
     for i, point in enumerate(representative_points.values()):
         points[i] = point[0:2]
 
-    def produce_edges(triangles):
+    def produce_edges(
+        triangles: List[Tuple[int, int, int]],
+    ) -> Iterable[Tuple[Tuple[str, str], Tuple[int, int]]]:
         for triangle in triangles:
             for vertex1, vertex2 in combinations(triangle, 2):
                 image1, image2 = images[vertex1], images[vertex2]
@@ -353,7 +356,7 @@ def match_candidates_with_vlad(
     max_gps_distance: float,
     max_gps_neighbors: int,
     enforce_other_cameras: bool,
-    histograms: Dict[str, np.ndarray],
+    histograms: Dict[str, NDArray],
 ) -> Dict[Tuple[str, str], float]:
     """Find candidate matching pairs using VLAD-based distance.
      If max_gps_distance > 0, then we use first restrain a set of
@@ -395,7 +398,7 @@ def compute_vlad_affinity(
     reference: geo.TopocentricConverter,
     max_gps_distance: float,
     max_gps_neighbors: int,
-    histograms: Dict[str, np.ndarray],
+    histograms: Dict[str, NDArray],
 ) -> List[Tuple[str, List[float], List[str]]]:
     """Compute affinity scores between references and candidates
     images using VLAD-based distance.
@@ -431,7 +434,7 @@ def preempt_candidates(
     reference: geo.TopocentricConverter,
     max_gps_neighbors: int,
     max_gps_distance: float,
-) -> Tuple[Dict[str, list], Set[str]]:
+) -> Tuple[Dict[str, List[str]], Set[str]]:
     """Preempt candidates using GPS to reduce set of images
     from which to load data to save RAM.
     """
@@ -486,9 +489,9 @@ def construct_pairs(
 
 def create_parallel_matching_args(
     data: DataSetBase,
-    preempted_cand: Dict[str, list],
-    histograms: Dict[str, np.ndarray],
-) -> Tuple[List[Tuple[str, list, Dict[str, np.ndarray]]], int, int]:
+    preempted_cand: Dict[str, List[str]],
+    histograms: Dict[str, NDArray],
+) -> Tuple[List[Tuple[str, List[str], Dict[str, NDArray]]], int, int]:
     """Create arguments to matching function"""
     args = [(im, cands, histograms) for im, cands in preempted_cand.items()]
 
@@ -502,7 +505,7 @@ def create_parallel_matching_args(
 
 
 def match_bow_unwrap_args(
-    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]],
+    args: Tuple[str, Iterable[str], Dict[str, NDArray]],
 ) -> Tuple[str, List[float], List[str]]:
     """Wrapper for parallel processing of BoW"""
     image, other_images, histograms = args
@@ -510,7 +513,7 @@ def match_bow_unwrap_args(
 
 
 def match_vlad_unwrap_args(
-    args: Tuple[str, Iterable[str], Dict[str, np.ndarray]],
+    args: Tuple[str, Iterable[str], Dict[str, NDArray]],
 ) -> Tuple[str, List[float], List[str]]:
     """Wrapper for parallel processing of VLAD"""
     image, other_images, histograms = args
@@ -682,7 +685,7 @@ def match_candidates_from_metadata(
 
 
 def bow_distances(
-    image: str, other_images: Iterable[str], histograms: Dict[str, np.ndarray]
+    image: str, other_images: Iterable[str], histograms: Dict[str, NDArray]
 ) -> Tuple[str, List[float], List[str]]:
     """Compute BoW-based distance (L1 on histogram of words)
     between an image and other images.
@@ -701,7 +704,7 @@ def bow_distances(
     return image, distances, other
 
 
-def load_histograms(data: DataSetBase, images: Iterable[str]) -> Dict[str, np.ndarray]:
+def load_histograms(data: DataSetBase, images: Iterable[str]) -> Dict[str, NDArray]:
     """Load BoW histograms of given images"""
     min_num_feature = 8
 
@@ -726,7 +729,7 @@ def load_histograms(data: DataSetBase, images: Iterable[str]) -> Dict[str, np.nd
 
 def vlad_histogram_unwrap_args(
     args: Tuple[DataSetBase, str],
-) -> Optional[Tuple[str, np.ndarray]]:
+) -> Optional[Tuple[str, NDArray]]:
     """Helper function for multithreaded VLAD computation.
 
     Returns the image and its descriptor.
@@ -740,7 +743,7 @@ def vlad_histogram_unwrap_args(
         return None
 
 
-def vlad_histograms(images: Iterable[str], data: DataSetBase) -> Dict[str, np.ndarray]:
+def vlad_histograms(images: Iterable[str], data: DataSetBase) -> Dict[str, NDArray]:
     """Construct VLAD histograms from the image features.
 
     Returns a dictionary of VLAD vectors for the images.

From dd0ff7ddbbe79ccb53ba0f0f5073a77b9700e456 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 138/235] more annotations

Reviewed By: DodgySpaniard

Differential Revision: D76518685

fbshipit-source-id: 43f7b50961e5c75a47d7d5f77e37ef45c89bad13
---
 opensfm/config.py |  4 ++--
 opensfm/stats.py  | 25 ++++++++++++++-----------
 opensfm/types.py  | 26 +++++++-------------------
 3 files changed, 23 insertions(+), 32 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 04fdcb3f7..cd1cb4d91 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import os
 from dataclasses import asdict, dataclass
 from typing import Any, Dict, IO, Union
@@ -386,7 +386,7 @@ def default_config() -> Dict[str, Any]:
     return asdict(OpenSfMConfig())
 
 
-def load_config(filepath) -> Dict[str, Any]:
+def load_config(filepath: str) -> Dict[str, Any]:
     """DEPRECATED: = Load config from a config.yaml filepath"""
     if not os.path.isfile(filepath):
         return default_config()
diff --git a/opensfm/stats.py b/opensfm/stats.py
index fd62af125..389737441 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import datetime
 import math
 import os
@@ -6,20 +6,21 @@
 import statistics
 from collections import defaultdict
 from functools import lru_cache
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import matplotlib as mpl
 import matplotlib.cm as cm
 import matplotlib.colors as colors
 import matplotlib.pyplot as plt
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import feature_loader, io, multiview, pygeometry, pymap, types
 from opensfm.dataset import DataSet, DataSetBase
 
 RESIDUAL_PIXEL_CUTOFF = 4
 
 
-def _norm2d(point: np.ndarray) -> float:
+def _norm2d(point: NDArray) -> float:
     return math.sqrt(point[0] * point[0] + point[1] * point[1])
 
 
@@ -35,7 +36,7 @@ def _length_histogram(
     return list(hist.keys()), list(hist.values())
 
 
-def _gps_errors(reconstruction: types.Reconstruction) -> List[np.ndarray]:
+def _gps_errors(reconstruction: types.Reconstruction) -> List[NDArray]:
     errors = []
     for shot in reconstruction.shots.values():
         if shot.metadata.gps_position.has_value:
@@ -47,7 +48,7 @@ def _gps_errors(reconstruction: types.Reconstruction) -> List[np.ndarray]:
     return errors
 
 
-def _gps_gcp_errors_stats(errors: Optional[np.ndarray]) -> Dict[str, Any]:
+def _gps_gcp_errors_stats(errors: Optional[NDArray]) -> Dict[str, Any]:
     if errors is None or len(errors) == 0:
         return {}
 
@@ -109,9 +110,11 @@ def gcp_errors(
 
 def _compute_errors(
     reconstructions: List[types.Reconstruction], tracks_manager: pymap.TracksManager
-) -> Any:
+) -> Callable[[int, pymap.ErrorType], Dict[str, Dict[str, NDArray]]]:
     @lru_cache(10)
-    def _compute_errors_cached(index, error_type) -> Dict[str, Dict[str, np.ndarray]]:
+    def _compute_errors_cached(
+        index: int, error_type: pymap.ErrorType
+    ) -> Dict[str, Dict[str, NDArray]]:
         return reconstructions[index].map.compute_reprojection_errors(
             tracks_manager,
             error_type,
@@ -122,17 +125,17 @@ def _compute_errors_cached(index, error_type) -> Dict[str, Dict[str, np.ndarray]
 
 def _get_valid_observations(
     reconstructions: List[types.Reconstruction], tracks_manager: pymap.TracksManager
-) -> Any:
+) -> Callable[[int], Dict[str, Dict[str, pymap.Observation]]]:
     @lru_cache(10)
     def _get_valid_observations_cached(
-        index,
+        index: int,
     ) -> Dict[str, Dict[str, pymap.Observation]]:
         return reconstructions[index].map.get_valid_observations(tracks_manager)
 
     return _get_valid_observations_cached
 
 
-THist = Tuple[np.ndarray, np.ndarray]
+THist = Tuple[NDArray, NDArray]
 
 
 def _projection_error(
@@ -472,7 +475,7 @@ def _heatmap_buckets(camera: pygeometry.Camera) -> Tuple[int, int]:
         return buckets, int(buckets / camera.width * camera.height)
 
 
-def _get_gaussian_kernel(radius: int, ratio: float) -> np.ndarray:
+def _get_gaussian_kernel(radius: int, ratio: float) -> NDArray:
     std_dev = radius / ratio
     half_kernel = list(range(1, radius + 1))
     kernel = np.array(half_kernel + [radius + 1] + list(reversed(half_kernel)))
diff --git a/opensfm/types.py b/opensfm/types.py
index 3a830524a..edcea1dd0 100644
--- a/opensfm/types.py
+++ b/opensfm/types.py
@@ -1,9 +1,10 @@
-# pyre-unsafe
+# pyre-strict
 """Basic types for building a reconstruction."""
 
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pygeometry, pymap
 from opensfm.geo import TopocentricConverter
 
@@ -11,19 +12,6 @@
 PANOSHOT_RIG_PREFIX = "panoshot_"
 
 
-class ShotMesh:
-    """Triangular mesh of points visible in a shot
-
-    Attributes:
-        vertices: (list of vectors) mesh vertices
-        faces: (list of triplets) triangles' topology
-    """
-
-    def __init__(self):
-        self.vertices = None
-        self.faces = None
-
-
 class Reconstruction:
     """Defines the reconstructed scene.
 
@@ -38,7 +26,7 @@ def __init__(self) -> None:
         """Defaut constructor"""
         self._setup_from_map(pymap.Map())
 
-    def _setup_from_map(self, map_obj: pymap.Map):
+    def _setup_from_map(self, map_obj: pymap.Map) -> None:
         self.map = map_obj
         self.camera_view = pymap.CameraView(self.map)
         self.bias_view = pymap.BiasView(self.map)
@@ -48,7 +36,7 @@ def _setup_from_map(self, map_obj: pymap.Map):
         self.pano_shot_view = pymap.PanoShotView(self.map)
         self.landmark_view = pymap.LandmarkView(self.map)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return (
             "<Reconstruction"
             f" cameras={len(self.cameras)}"
@@ -296,7 +284,7 @@ def remove_pano_shot(self, shot_id: str) -> None:
         self.map.remove_pano_shot(shot_id)
 
     def create_point(
-        self, point_id: str, coord: Optional[np.ndarray] = None
+        self, point_id: str, coord: Optional[NDArray] = None
     ) -> pymap.Landmark:
         if coord is None:
             return self.map.create_landmark(point_id, np.array([0, 0, 0]))
@@ -335,7 +323,7 @@ def add_observation(
     def remove_observation(self, shot_id: str, lm_id: str) -> None:
         self.map.remove_observation(shot_id, lm_id)
 
-    def __deepcopy__(self, d):
+    def __deepcopy__(self, d: Dict[str, Any]) -> "Reconstruction":
         rec_cpy = Reconstruction()
 
         copy_observations = False

From 094d1499e0a1c6e72b052fdde5a594db47997451 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 139/235] annotate geo

Reviewed By: DodgySpaniard

Differential Revision: D76518689

fbshipit-source-id: 03a2abf4e6d91e57dd085506dc31dc4f032a2a6b
---
 annotation_gui_gcp/run_ba.py |   2 +-
 opensfm/geo.py               | 143 +++++++++++++++++++++++++++++++----
 opensfm/pairs_selection.py   |   2 +-
 opensfm/test/test_geo.py     |   4 +-
 4 files changed, 133 insertions(+), 18 deletions(-)

diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index 9737a7688..cf65c6c5e 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -245,7 +245,7 @@ def add_gcp_to_bundle(
                     f"Could not triangulate GCP '{point.id}'."
                     f"Using {enu} (derived from lat,lon)"
                 )
-                coordinates = enu
+                coordinates = np.array(enu)
             else:
                 logger.warning(
                     "Cannot initialize GCP '{}'." "  Ignoring it".format(point.id)
diff --git a/opensfm/geo.py b/opensfm/geo.py
index d5ee44258..0d8229b8e 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -1,14 +1,26 @@
-# pyre-unsafe
-from typing import Tuple
+# pyre-strict
+from typing import overload, Sequence, Tuple, Union
 
 import numpy as np
-from numpy import ndarray
+from numpy.typing import NDArray
+
+Scalars = Union[float, NDArray]
 
 WGS84_a = 6378137.0
 WGS84_b = 6356752.314245
 
 
-def ecef_from_lla(lat, lon, alt: float) -> Tuple[float, ...]:
+@overload
+def ecef_from_lla(lat: float, lon: float, alt: float) -> Tuple[float, float, float]: ...
+@overload
+def ecef_from_lla(
+    lat: NDArray, lon: NDArray, alt: NDArray
+) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+
+def ecef_from_lla(
+    lat: Scalars, lon: Scalars, alt: Scalars
+) -> Tuple[Scalars, Scalars, Scalars]:
     """
     Compute ECEF XYZ from latitude, longitude and altitude.
 
@@ -32,7 +44,17 @@ def ecef_from_lla(lat, lon, alt: float) -> Tuple[float, ...]:
     return x, y, z
 
 
-def lla_from_ecef(x, y, z):
+@overload
+def lla_from_ecef(x: float, y: float, z: float) -> Tuple[float, float, float]: ...
+@overload
+def lla_from_ecef(
+    x: NDArray, y: NDArray, z: NDArray
+) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+
+def lla_from_ecef(
+    x: Scalars, y: Scalars, z: Scalars
+) -> Tuple[Scalars, Scalars, Scalars]:
     """
     Compute latitude, longitude and altitude from ECEF XYZ.
 
@@ -43,6 +65,7 @@ def lla_from_ecef(x, y, z):
     b = WGS84_b
     ea = np.sqrt((a**2 - b**2) / a**2)
     eb = np.sqrt((a**2 - b**2) / b**2)
+    # pyre-ignore[6]: pyre ignores that x,y are all either scalars or arrays
     p = np.sqrt(x**2 + y**2)
     theta = np.arctan2(z * a, p * b)
     lon = np.arctan2(y, x)
@@ -54,7 +77,7 @@ def lla_from_ecef(x, y, z):
     return np.degrees(lat), np.degrees(lon), alt
 
 
-def ecef_from_topocentric_transform(lat, lon, alt: float) -> ndarray:
+def ecef_from_topocentric_transform(lat: float, lon: float, alt: float) -> NDArray:
     """
     Transformation from a topocentric frame at reference position to ECEF.
 
@@ -81,7 +104,9 @@ def ecef_from_topocentric_transform(lat, lon, alt: float) -> ndarray:
     )
 
 
-def ecef_from_topocentric_transform_finite_diff(lat, lon, alt: float) -> ndarray:
+def ecef_from_topocentric_transform_finite_diff(
+    lat: float, lon: float, alt: float
+) -> NDArray:
     """
     Transformation from a topocentric frame at reference position to ECEF.
 
@@ -128,7 +153,34 @@ def ecef_from_topocentric_transform_finite_diff(lat, lon, alt: float) -> ndarray
     )
 
 
-def topocentric_from_lla(lat, lon, alt: float, reflat, reflon, refalt: float):
+@overload
+def topocentric_from_lla(
+    lat: float,
+    lon: float,
+    alt: float,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[float, float, float]: ...
+@overload
+def topocentric_from_lla(
+    lat: NDArray,
+    lon: NDArray,
+    alt: NDArray,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+
+def topocentric_from_lla(
+    lat: Scalars,
+    lon: Scalars,
+    alt: Scalars,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[Scalars, Scalars, Scalars]:
     """
     Transform from lat, lon, alt to topocentric XYZ.
 
@@ -142,6 +194,7 @@ def topocentric_from_lla(lat, lon, alt: float, reflat, reflon, refalt: float):
     True
     """
     T = np.linalg.inv(ecef_from_topocentric_transform(reflat, reflon, refalt))
+    # pyre-ignore[6]: pyre gets confused with Scalar vs float vs NDarray
     x, y, z = ecef_from_lla(lat, lon, alt)
     tx = T[0, 0] * x + T[0, 1] * y + T[0, 2] * z + T[0, 3]
     ty = T[1, 0] * x + T[1, 1] * y + T[1, 2] * z + T[1, 3]
@@ -149,7 +202,34 @@ def topocentric_from_lla(lat, lon, alt: float, reflat, reflon, refalt: float):
     return tx, ty, tz
 
 
-def lla_from_topocentric(x, y, z, reflat, reflon, refalt: float):
+@overload
+def lla_from_topocentric(
+    x: float,
+    y: float,
+    z: float,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[float, float, float]: ...
+@overload
+def lla_from_topocentric(
+    x: NDArray,
+    y: NDArray,
+    z: NDArray,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+
+def lla_from_topocentric(
+    x: Scalars,
+    y: Scalars,
+    z: Scalars,
+    reflat: float,
+    reflon: float,
+    refalt: float,
+) -> Tuple[Scalars, Scalars, Scalars]:
     """
     Transform from topocentric XYZ to lat, lon, alt.
     """
@@ -160,7 +240,20 @@ def lla_from_topocentric(x, y, z, reflat, reflon, refalt: float):
     return lla_from_ecef(ex, ey, ez)
 
 
-def gps_distance(latlon_1, latlon_2):
+@overload
+def gps_distance(latlon_1: Sequence[float], latlon_2: Sequence[float]) -> float: ...
+@overload
+def gps_distance(
+    latlon_1: Sequence[NDArray], latlon_2: Sequence[NDArray]
+) -> NDArray: ...
+@overload
+def gps_distance(latlon_1: NDArray, latlon_2: NDArray) -> NDArray: ...
+
+
+def gps_distance(
+    latlon_1: Union[Sequence[Scalars], NDArray],
+    latlon_2: Union[Sequence[Scalars], NDArray],
+) -> Scalars:
     """
     Distance between two (lat,lon) pairs.
 
@@ -180,19 +273,41 @@ def gps_distance(latlon_1, latlon_2):
 class TopocentricConverter:
     """Convert to and from a topocentric reference frame."""
 
-    def __init__(self, reflat, reflon, refalt):
+    def __init__(self, reflat: float, reflon: float, refalt: float) -> None:
         """Init the converter given the reference origin."""
         self.lat = reflat
         self.lon = reflon
         self.alt = refalt
 
-    def to_topocentric(self, lat, lon, alt):
+    @overload
+    def to_topocentric(
+        self, lat: float, lon: float, alt: float
+    ) -> Tuple[float, float, float]: ...
+    @overload
+    def to_topocentric(
+        self, lat: NDArray, lon: NDArray, alt: NDArray
+    ) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+    def to_topocentric(
+        self, lat: Scalars, lon: Scalars, alt: Scalars
+    ) -> Tuple[Scalars, Scalars, Scalars]:
         """Convert lat, lon, alt to topocentric x, y, z."""
+        # pyre-ignore[6]: pyre gets confused with Scalar vs float vs NDarray
         return topocentric_from_lla(lat, lon, alt, self.lat, self.lon, self.alt)
 
-    def to_lla(self, x, y, z):
+    @overload
+    def to_lla(self, x: float, y: float, z: float) -> Tuple[float, float, float]: ...
+    @overload
+    def to_lla(
+        self, x: NDArray, y: NDArray, z: NDArray
+    ) -> Tuple[NDArray, NDArray, NDArray]: ...
+
+    def to_lla(
+        self, x: Scalars, y: Scalars, z: Scalars
+    ) -> Tuple[Scalars, Scalars, Scalars]:
         """Convert topocentric x, y, z to lat, lon, alt."""
+        # pyre-ignore[6]: pyre gets confused with Scalar vs float vs NDarray
         return lla_from_topocentric(x, y, z, self.lat, self.lon, self.alt)
 
-    def __eq__(self, o):
+    def __eq__(self, o: "TopocentricConverter") -> bool:
         return np.allclose([self.lat, self.lon, self.alt], (o.lat, o.lon, o.alt))
diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 7904b6501..27bef216a 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -39,7 +39,7 @@ def get_gps_point(
     altitude = 0
     direction = np.array([0, 0, 1])
     return (
-        reference.to_topocentric(gps["latitude"], gps["longitude"], altitude),
+        np.array(reference.to_topocentric(gps["latitude"], gps["longitude"], altitude)),
         direction,
     )
 
diff --git a/opensfm/test/test_geo.py b/opensfm/test/test_geo.py
index d0b74f850..41f431450 100644
--- a/opensfm/test/test_geo.py
+++ b/opensfm/test/test_geo.py
@@ -7,7 +7,7 @@ def test_ecef_lla_consistency() -> None:
     lla_before = [46.5274109, 6.5722075, 402.16]
     ecef = geo.ecef_from_lla(lla_before[0], lla_before[1], lla_before[2])
     lla_after = geo.lla_from_ecef(ecef[0], ecef[1], ecef[2])
-    assert np.allclose(lla_after, lla_before)
+    assert np.allclose(np.array(lla_after), lla_before)
 
 
 def test_ecef_lla_topocentric_consistency() -> None:
@@ -19,7 +19,7 @@ def test_ecef_lla_topocentric_consistency() -> None:
     lla_after = geo.lla_from_topocentric(
         enu[0], enu[1], enu[2], lla_ref[0], lla_ref[1], lla_ref[2]
     )
-    assert np.allclose(lla_after, lla_before)
+    assert np.allclose(np.array(lla_after), lla_before)
 
 
 def test_ecef_lla_consistency_pygeo() -> None:

From ac534bd282cf41847ffcd34a51afedc550375225 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 140/235] more pyre-strict

Reviewed By: DodgySpaniard

Differential Revision: D76518690

fbshipit-source-id: a00964933d9ac2b31ecbea85be903b1eb1c8af8b
---
 opensfm/bow.py          | 30 ++++++++++++++++++++----------
 opensfm/dataset_base.py | 23 ++++++++++++-----------
 opensfm/mesh.py         | 21 ++++++++++-----------
 opensfm/report.py       | 21 +++++++++++++--------
 opensfm/rig.py          |  2 +-
 opensfm/sensors.py      |  2 +-
 opensfm/vlad.py         | 15 +++++++--------
 7 files changed, 64 insertions(+), 50 deletions(-)

diff --git a/opensfm/bow.py b/opensfm/bow.py
index f4746c469..0202ca066 100644
--- a/opensfm/bow.py
+++ b/opensfm/bow.py
@@ -1,21 +1,25 @@
-# pyre-unsafe
+# pyre-strict
 import os.path
+from typing import Any, Dict, Optional, Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import context
 
 
 class BagOfWords:
-    def __init__(self, words, frequencies):
+    def __init__(self, words: NDArray, frequencies: NDArray) -> None:
         self.words = words
         self.frequencies = frequencies
-        self.weights = np.log(frequencies.sum() / frequencies)
+        self.weights: NDArray = np.log(frequencies.sum() / frequencies)
         FLANN_INDEX_KDTREE = 1
         flann_params = {"algorithm": FLANN_INDEX_KDTREE, "trees": 8, "checks": 300}
-        self.index = context.flann_Index(words, flann_params)
+        self.index: cv2.flann_Index = context.flann_Index(words, flann_params)
 
-    def map_to_words(self, descriptors, k, matcher_type="FLANN"):
+    def map_to_words(
+        self, descriptors: NDArray, k: int, matcher_type: str = "FLANN"
+    ) -> NDArray:
         if matcher_type == "FLANN":
             params = {"checks": 200}
             idx, dist = self.index.knnSearch(descriptors, k, params=params)
@@ -26,11 +30,17 @@ def map_to_words(self, descriptors, k, matcher_type="FLANN"):
             idx = np.array(idx).astype(np.int32)
         return idx
 
-    def histogram(self, words):
+    def histogram(self, words: NDArray) -> NDArray:
         h = np.bincount(words, minlength=len(self.words)) * self.weights
         return h / h.sum()
 
-    def bow_distance(self, w1, w2, h1=None, h2=None):
+    def bow_distance(
+        self,
+        w1: NDArray,
+        w2: NDArray,
+        h1: Optional[NDArray] = None,
+        h2: Optional[NDArray] = None,
+    ) -> float:
         if h1 is None:
             h1 = self.histogram(w1)
         if h2 is None:
@@ -38,7 +48,7 @@ def bow_distance(self, w1, w2, h1=None, h2=None):
         return np.fabs(h1 - h2).sum()
 
 
-def load_bow_words_and_frequencies(config):
+def load_bow_words_and_frequencies(config: Dict[str, Any]) -> Tuple[NDArray, NDArray]:
     if config["bow_file"] == "bow_hahog_root_uchar_10000.npz":
         assert config["feature_type"] == "HAHOG"
         assert config["feature_root"]
@@ -49,7 +59,7 @@ def load_bow_words_and_frequencies(config):
     return bow["words"], bow["frequencies"]
 
 
-def load_vlad_words_and_frequencies(config):
+def load_vlad_words_and_frequencies(config: Dict[str, Any]) -> Tuple[NDArray, NDArray]:
     if config["vlad_file"] == "bow_hahog_root_uchar_64.npz":
         assert config["feature_type"] == "HAHOG"
         assert config["feature_root"]
@@ -60,6 +70,6 @@ def load_vlad_words_and_frequencies(config):
     return vlad["words"], vlad["frequencies"]
 
 
-def load_bows(config) -> BagOfWords:
+def load_bows(config: Dict[str, Any]) -> BagOfWords:
     words, frequencies = load_bow_words_and_frequencies(config)
     return BagOfWords(words, frequencies)
diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index 79f484a66..e9c2adc9e 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -1,9 +1,10 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from abc import ABC, abstractmethod
 from typing import Any, BinaryIO, Dict, List, Optional, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import features, geo, io, pygeometry, pymap, types
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -41,7 +42,7 @@ def load_image(
         unchanged: bool = False,
         anydepth: bool = False,
         grayscale: bool = False,
-    ) -> np.ndarray:
+    ) -> NDArray:
         pass
 
     @abstractmethod
@@ -49,19 +50,19 @@ def image_size(self, image: str) -> Tuple[int, int]:
         pass
 
     @abstractmethod
-    def load_mask(self, image: str) -> Optional[np.ndarray]:
+    def load_mask(self, image: str) -> Optional[NDArray]:
         pass
 
     @abstractmethod
-    def load_instances(self, image: str) -> Optional[np.ndarray]:
+    def load_instances(self, image: str) -> Optional[NDArray]:
         pass
 
     @abstractmethod
-    def segmentation_labels(self) -> List[Any]:
+    def segmentation_labels(self) -> List[Dict[str, Any]]:
         pass
 
     @abstractmethod
-    def load_segmentation(self, image: str) -> Optional[np.ndarray]:
+    def load_segmentation(self, image: str) -> Optional[NDArray]:
         pass
 
     @abstractmethod
@@ -105,11 +106,11 @@ def words_exist(self, image: str) -> bool:
         pass
 
     @abstractmethod
-    def load_words(self, image: str) -> np.ndarray:
+    def load_words(self, image: str) -> NDArray:
         pass
 
     @abstractmethod
-    def save_words(self, image: str, words: np.ndarray) -> None:
+    def save_words(self, image: str, words: NDArray) -> None:
         pass
 
     @abstractmethod
@@ -117,11 +118,11 @@ def matches_exists(self, image: str) -> bool:
         pass
 
     @abstractmethod
-    def load_matches(self, image: str) -> Dict[str, np.ndarray]:
+    def load_matches(self, image: str) -> Dict[str, NDArray]:
         pass
 
     @abstractmethod
-    def save_matches(self, image: str, matches: Dict[str, np.ndarray]) -> None:
+    def save_matches(self, image: str, matches: Dict[str, NDArray]) -> None:
         pass
 
     @abstractmethod
@@ -147,7 +148,7 @@ def save_reconstruction(
         self,
         reconstruction: List[types.Reconstruction],
         filename: Optional[str] = None,
-        minify=False,
+        minify: bool = False,
     ) -> None:
         pass
 
diff --git a/opensfm/mesh.py b/opensfm/mesh.py
index a393e4bb1..42f77f05f 100644
--- a/opensfm/mesh.py
+++ b/opensfm/mesh.py
@@ -1,12 +1,11 @@
-#!/usr/bin/env python3
-
-# pyre-unsafe
+# pyre-strict
 import itertools
 import logging
 from typing import Any, List, Tuple
 
 import numpy as np
 import scipy.spatial
+from numpy.typing import NDArray
 from opensfm import pygeometry, pymap, types
 
 
@@ -15,7 +14,7 @@
 
 def triangle_mesh(
     shot_id: str, r: types.Reconstruction, tracks_manager: pymap.TracksManager
-) -> Tuple[List[Any], List[Any]]:
+) -> Tuple[List[List[float]], List[List[int]]]:
     """
     Create triangle meshes in a list
     """
@@ -49,14 +48,14 @@ def triangle_mesh(
 
 def triangle_mesh_perspective(
     shot_id: str, r: types.Reconstruction, tracks_manager: pymap.TracksManager
-) -> Tuple[List[Any], List[Any]]:
+) -> Tuple[List[List[float]], List[List[int]]]:
     shot = r.shots[shot_id]
     cam = shot.camera
 
     dx = float(cam.width) / 2 / max(cam.width, cam.height)
     dy = float(cam.height) / 2 / max(cam.width, cam.height)
     pixels = [[-dx, -dy], [-dx, dy], [dx, dy], [dx, -dy]]
-    vertices = [None for i in range(4)]
+    vertices = [[0.0, 0.0, 0.0] for i in range(4)]
     for track_id in tracks_manager.get_shot_observations(shot_id):
         if track_id in r.points:
             point = r.points[track_id]
@@ -94,7 +93,7 @@ def triangle_mesh_perspective(
 
 def back_project_no_distortion(
     shot: pymap.Shot, pixel: List[float], depth: float
-) -> np.ndarray:
+) -> NDArray:
     """
     Back-project a pixel of a perspective camera ignoring its radial distortion
     """
@@ -107,14 +106,14 @@ def back_project_no_distortion(
 
 def triangle_mesh_fisheye(
     shot_id: str, r: types.Reconstruction, tracks_manager: pymap.TracksManager
-) -> Tuple[List[Any], List[Any]]:
+) -> Tuple[List[List[float]], List[List[int]]]:
     shot = r.shots[shot_id]
 
     bearings = []
     vertices = []
 
     # Add boundary vertices
-    num_circle_points = 20
+    num_circle_points: int = 20
     for i in range(num_circle_points):
         a = 2 * np.pi * float(i) / num_circle_points
         point = 30 * np.array([np.cos(a), np.sin(a), 0])
@@ -145,7 +144,7 @@ def triangle_mesh_fisheye(
     faces = tri.simplices.tolist()
 
     # Remove faces having only boundary vertices
-    def good_face(face: List[Any]) -> bool:
+    def good_face(face: List[int]) -> bool:
         return (
             face[0] >= num_circle_points
             or face[1] >= num_circle_points
@@ -159,7 +158,7 @@ def good_face(face: List[Any]) -> bool:
 
 def triangle_mesh_spherical(
     shot_id: str, r: types.Reconstruction, tracks_manager: pymap.TracksManager
-) -> Tuple[List[Any], List[Any]]:
+) -> Tuple[List[List[float]], List[List[int]]]:
     shot = r.shots[shot_id]
 
     bearings = []
diff --git a/opensfm/report.py b/opensfm/report.py
index 4be661f44..4ce77f00b 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -1,9 +1,9 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 import subprocess
 import tempfile
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
 
 import PIL
 from fpdf import FPDF
@@ -15,9 +15,9 @@
 
 class Report:
     def __init__(self, data: DataSet) -> None:
-        self.output_path = os.path.join(data.data_path, "stats")
-        self.dataset_name = os.path.basename(data.data_path)
-        self.io_handler = data.io_handler
+        self.output_path: str = os.path.join(data.data_path, "stats")
+        self.dataset_name: str = os.path.basename(data.data_path)
+        self.io_handler: io.IoFilesystemBase = data.io_handler
 
         self.mapi_light_light_green = [210, 245, 226]
         self.mapi_light_green = [5, 203, 99]
@@ -37,7 +37,7 @@ def __init__(self, data: DataSet) -> None:
         self.cell_height = 7
         self.total_size = 190
 
-        self.stats = self._read_stats_file("stats.json")
+        self.stats: Dict[str, Any] = self._read_stats_file("stats.json")
 
     def save_report(self, filename: str) -> None:
         bytestring = self.pdf.output(dest="S")
@@ -47,7 +47,12 @@ def save_report(self, filename: str) -> None:
         with self.io_handler.open_wb(os.path.join(self.output_path, filename)) as fwb:
             fwb.write(bytestring)
 
-    def _make_table(self, columns_names, rows, row_header=False) -> None:
+    def _make_table(
+        self,
+        columns_names: Optional[List[str]],
+        rows: List[List[str]],
+        row_header: bool = False,
+    ) -> None:
         self.pdf.set_font("Helvetica", "", self.h3)
         self.pdf.set_line_width(0.3)
 
@@ -90,7 +95,7 @@ def _make_table(self, columns_names, rows, row_header=False) -> None:
                 self.pdf.cell(size, self.cell_height, col, align="L")
             self.pdf.set_xy(self.margin, self.pdf.get_y() + self.cell_height)
 
-    def _read_stats_file(self, filename) -> Dict[str, Any]:
+    def _read_stats_file(self, filename: str) -> Dict[str, Any]:
         file_path = os.path.join(self.output_path, filename)
         with self.io_handler.open_rt(file_path) as fin:
             return io.json_load(fin)
diff --git a/opensfm/rig.py b/opensfm/rig.py
index 3f8949929..bbf5fd3db 100644
--- a/opensfm/rig.py
+++ b/opensfm/rig.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 """Tool for handling rigs"""
 
 import logging
diff --git a/opensfm/sensors.py b/opensfm/sensors.py
index d00a289a4..b91f115df 100644
--- a/opensfm/sensors.py
+++ b/opensfm/sensors.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from functools import lru_cache
 from typing import Any, Dict, List
 
diff --git a/opensfm/vlad.py b/opensfm/vlad.py
index d09e3db22..64d7cd18c 100644
--- a/opensfm/vlad.py
+++ b/opensfm/vlad.py
@@ -1,15 +1,14 @@
-# pyre-unsafe
+# pyre-strict
 from functools import lru_cache
 from typing import Dict, Iterable, List, Optional, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import bow, feature_loader, pyfeatures
 from opensfm.dataset_base import DataSetBase
 
 
-def unnormalized_vlad(
-    features: np.ndarray, centers: np.ndarray
-) -> Optional[np.ndarray]:
+def unnormalized_vlad(features: NDArray, centers: NDArray) -> Optional[NDArray]:
     """Compute unnormalized VLAD histograms from a set of
     features in relation to centers.
 
@@ -22,7 +21,7 @@ def unnormalized_vlad(
     return pyfeatures.compute_vlad_descriptor(features, centers)
 
 
-def signed_square_root_normalize(v: np.ndarray) -> np.ndarray:
+def signed_square_root_normalize(v: NDArray) -> NDArray:
     """Compute Signed Square Root (SSR) normalization on
     a vector.
 
@@ -34,7 +33,7 @@ def signed_square_root_normalize(v: np.ndarray) -> np.ndarray:
 
 
 def vlad_distances(
-    image: str, other_images: Iterable[str], histograms: Dict[str, np.ndarray]
+    image: str, other_images: Iterable[str], histograms: Dict[str, NDArray]
 ) -> Tuple[str, List[float], List[str]]:
     """Compute VLAD-based distance (L2 on VLAD-histogram)
     between an image and other images.
@@ -54,12 +53,12 @@ def clear_cache(self) -> None:
         self.vlad_histogram.cache_clear()
 
     @lru_cache(1)
-    def load_words(self, data: DataSetBase) -> np.ndarray:
+    def load_words(self, data: DataSetBase) -> NDArray:
         words, _ = bow.load_vlad_words_and_frequencies(data.config)
         return words
 
     @lru_cache(1000)
-    def vlad_histogram(self, data: DataSetBase, image: str) -> Optional[np.ndarray]:
+    def vlad_histogram(self, data: DataSetBase, image: str) -> Optional[NDArray]:
         words = self.load_words(data)
         features_data = feature_loader.instance.load_all_data(
             data, image, masked=True, segmentation_in_descriptor=False

From 0fd5127daa2657f30360735925f9133054f3a1ae Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 141/235] annotate multiview and remove unused ransac

Reviewed By: DodgySpaniard

Differential Revision: D76518695

fbshipit-source-id: 863fa1db040b19b91714cd9d97c68446f42a0e48
---
 opensfm/multiview.py | 262 +++++++------------------------------------
 1 file changed, 42 insertions(+), 220 deletions(-)

diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index af3c1c116..982204ee4 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -1,14 +1,14 @@
-# pyre-unsafe
+# pyre-strict
 import math
-import random
 from typing import Any, Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pygeometry, pymap, pyrobust, transformations as tf
 
 
-def nullspace(A: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def nullspace(A: NDArray) -> Tuple[NDArray, NDArray]:
     """Compute the null space of A.
 
     Return the smallest singular value and the corresponding vector.
@@ -17,29 +17,29 @@ def nullspace(A: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     return s[-1], vh[-1]
 
 
-def homogeneous(x: np.ndarray) -> np.ndarray:
+def homogeneous(x: NDArray) -> NDArray:
     """Add a column of ones to x."""
     s = x.shape[:-1] + (1,)
     return np.hstack((x, np.ones(s)))
 
 
-def homogeneous_vec(x: np.ndarray) -> np.ndarray:
+def homogeneous_vec(x: NDArray) -> NDArray:
     """Add a column of zeros to x."""
     s = x.shape[:-1] + (1,)
     return np.hstack((x, np.zeros(s)))
 
 
-def euclidean(x: np.ndarray) -> np.ndarray:
+def euclidean(x: NDArray) -> NDArray:
     """Divide by last column and drop it."""
     return x[..., :-1] / x[..., -1:]
 
 
-def cross_product_matrix(x: np.ndarray) -> np.ndarray:
+def cross_product_matrix(x: NDArray) -> NDArray:
     """Return the matrix representation of x's cross product"""
     return np.array([[0, -x[2], x[1]], [x[2], 0, -x[0]], [-x[1], x[0], 0]])
 
 
-def P_from_KRt(K: np.ndarray, R: np.ndarray, t: np.ndarray) -> np.ndarray:
+def P_from_KRt(K: NDArray, R: NDArray, t: NDArray) -> NDArray:
     """P = K[R|t]."""
     P = np.empty((3, 4))
     P[:, :3] = np.dot(K, R)
@@ -47,7 +47,7 @@ def P_from_KRt(K: np.ndarray, R: np.ndarray, t: np.ndarray) -> np.ndarray:
     return P
 
 
-def KRt_from_P(P: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+def KRt_from_P(P: NDArray) -> Tuple[NDArray, NDArray, NDArray]:
     """Factorize the camera matrix into K,R,t as P = K[R|t].
 
     >>> K = np.array([[1, 2, 3],
@@ -80,7 +80,7 @@ def KRt_from_P(P: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     return K, R, t
 
 
-def rq(A: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def rq(A: NDArray) -> Tuple[NDArray, NDArray]:
     """Decompose a matrix into a triangular times rotation.
     (from PCV)
 
@@ -104,7 +104,7 @@ def rq(A: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     return R[:, ::-1], Q[::-1, :]
 
 
-def vector_angle(u: np.ndarray, v: np.ndarray) -> float:
+def vector_angle(u: NDArray, v: NDArray) -> float:
     """Angle between two vectors.
 
     >>> u = [ 0.99500417, -0.33333333, -0.09983342]
@@ -120,8 +120,8 @@ def vector_angle(u: np.ndarray, v: np.ndarray) -> float:
 
 
 def decompose_similarity_transform(
-    T: np.ndarray,
-) -> Tuple[float, np.ndarray, np.ndarray]:
+    T: NDArray,
+) -> Tuple[float, NDArray, NDArray]:
     """Decompose the similarity transform to scale, rotation and translation"""
     m, n = T.shape[0:2]
     assert m == n
@@ -130,185 +130,9 @@ def decompose_similarity_transform(
     return s, A / s, b
 
 
-def ransac_max_iterations(
-    kernel: Any, inliers: np.ndarray, failure_probability: float
-) -> float:
-    if len(inliers) >= kernel.num_samples():
-        return 0
-    inlier_ratio = float(len(inliers)) / kernel.num_samples()
-    n = kernel.required_samples
-    return math.log(failure_probability) / math.log(1.0 - inlier_ratio**n)
-
-
-TRansacSolution = Tuple[np.ndarray, np.ndarray, float]
-
-
-def ransac(kernel: Any, threshold: float) -> TRansacSolution:
-    """Robustly fit a model to data.
-
-    >>> x = np.array([1., 2., 3.])
-    >>> y = np.array([2., 4., 7.])
-    >>> kernel = TestLinearKernel(x, y)
-    >>> model, inliers, error = ransac(kernel, 0.1)
-    >>> np.allclose(model, 2.0)
-    True
-    >>> inliers
-    array([0, 1])
-    >>> np.allclose(error, 0.1)
-    True
-    """
-    max_iterations = 1000
-    best_error = float("inf")
-    best_model = None
-    best_inliers = []
-    i = 0
-    while i < max_iterations:
-        try:
-            samples = kernel.sampling()
-        except AttributeError:
-            samples = random.sample(
-                range(kernel.num_samples()), kernel.required_samples
-            )
-        models = kernel.fit(samples)
-        for model in models:
-            errors = kernel.evaluate(model)
-            inliers = np.flatnonzero(np.fabs(errors) < threshold)
-            error = np.fabs(errors).clip(0, threshold).sum()
-            if len(inliers) and error < best_error:
-                best_error = error
-                best_model = model
-                best_inliers = inliers
-                max_iterations = min(
-                    max_iterations, ransac_max_iterations(kernel, best_inliers, 0.01)
-                )
-        i += 1
-    # pyre-fixme[7]: Expected `Tuple[ndarray[typing.Any, typing.Any],
-    #  ndarray[typing.Any, typing.Any], float]` but got `Tuple[typing.Any,
-    #  Union[List[typing.Any], ndarray[typing.Any, dtype[typing.Any]]], typing.Any]`.
-    return best_model, best_inliers, best_error
-
-
-class TestLinearKernel:
-    """A kernel for the model y = a * x.
-
-    >>> x = np.array([1., 2., 3.])
-    >>> y = np.array([2., 4., 7.])
-    >>> kernel = TestLinearKernel(x, y)
-    >>> models = kernel.fit([0])
-    >>> models
-    [2.0]
-    >>> errors = kernel.evaluate(models[0])
-    >>> np.allclose(errors, [0., 0., 1.])
-    True
-    """
-
-    required_samples = 1
-
-    def __init__(self, x: np.ndarray, y: np.ndarray) -> None:
-        self.x: np.ndarray = x
-        self.y: np.ndarray = y
-
-    def num_samples(self) -> int:
-        return len(self.x)
-
-    def fit(self, samples: np.ndarray) -> List[float]:
-        x = self.x[samples[0]]
-        y = self.y[samples[0]]
-        # pyre-fixme[7]: Expected `List[float]` but got `List[ndarray[typing.Any,
-        #  dtype[typing.Any]]]`.
-        return [y / x]
-
-    def evaluate(self, model: np.ndarray) -> np.ndarray:
-        return self.y - model * self.x
-
-
-class PlaneKernel:
-    """
-    A kernel for estimating plane from on-plane points and vectors
-    """
-
-    def __init__(
-        self, points, vectors, verticals, point_threshold=1.0, vector_threshold=5.0
-    ) -> None:
-        self.points = points
-        self.vectors = vectors
-        self.verticals = verticals
-        self.required_samples = 3
-        self.point_threshold = point_threshold
-        self.vector_threshold = vector_threshold
-
-    def num_samples(self) -> int:
-        return len(self.points)
-
-    def sampling(self) -> Dict[str, Any]:
-        samples = {}
-        if len(self.vectors) > 0:
-            samples["points"] = self.points[
-                random.sample(range(len(self.points)), 2), :
-            ]
-            samples["vectors"] = [
-                self.vectors[i] for i in random.sample(range(len(self.vectors)), 1)
-            ]
-        else:
-            samples["points"] = self.points[
-                :, random.sample(range(len(self.points)), 3)
-            ]
-            samples["vectors"] = None
-        return samples
-
-    def fit(self, samples: Dict[str, np.ndarray]) -> List[np.ndarray]:
-        model = fit_plane(samples["points"], samples["vectors"], self.verticals)
-        return [model]
-
-    def evaluate(self, model) -> np.ndarray:
-        # only evaluate on points
-        normal = model[0:3]
-        normal_norm = np.linalg.norm(normal) + 1e-10
-        point_error = np.abs(model.T.dot(homogeneous(self.points).T)) / normal_norm
-        vectors = np.array(self.vectors)
-        vector_norm = np.sum(vectors * vectors, axis=1)
-        vectors = (vectors.T / vector_norm).T
-        vector_error = abs(
-            np.rad2deg(abs(np.arccos(vectors.dot(normal) / normal_norm))) - 90
-        )
-        vector_error[vector_error < self.vector_threshold] = 0.0
-        vector_error[vector_error >= self.vector_threshold] = self.point_threshold + 0.1
-        point_error[point_error < self.point_threshold] = 0.0
-        point_error[point_error >= self.point_threshold] = self.point_threshold + 0.1
-        errors = np.hstack((point_error, vector_error))
-        return errors
-
-
-def fit_plane_ransac(
-    points: np.ndarray,
-    vectors: np.ndarray,
-    verticals: np.ndarray,
-    point_threshold: float = 1.2,
-    vector_threshold: float = 5.0,
-) -> TRansacSolution:
-    vectors = np.array([v / math.pi * 180.0 for v in vectors])
-    kernel = PlaneKernel(
-        points - points.mean(axis=0),
-        vectors,
-        verticals,
-        point_threshold,
-        vector_threshold,
-    )
-    p, inliers, error = ransac(kernel, point_threshold)
-    num_point = points.shape[0]
-    points_inliers = points[inliers[inliers < num_point], :]
-    vectors_inliers = np.array(
-        [vectors[i - num_point] for i in inliers[inliers >= num_point]]
-    )
-    p = fit_plane(
-        points_inliers - points_inliers.mean(axis=0), vectors_inliers, verticals
-    )
-    return p, inliers, error
-
-
 def fit_plane(
-    points: np.ndarray, vectors: Optional[np.ndarray], verticals: Optional[np.ndarray]
-) -> np.ndarray:
+    points: NDArray, vectors: Optional[NDArray], verticals: Optional[NDArray]
+) -> NDArray:
     """Estimate a plane from on-plane points and vectors.
 
     >>> x = [[0,0,0], [1,0,0], [0,1,0]]
@@ -351,7 +175,7 @@ def fit_plane(
     return p
 
 
-def plane_horizontalling_rotation(p: np.ndarray) -> Optional[np.ndarray]:
+def plane_horizontalling_rotation(p: NDArray) -> Optional[NDArray]:
     """Compute a rotation that brings p to z=0
 
     >>> p = [1.0, 2.0, 3.0]
@@ -388,8 +212,8 @@ def plane_horizontalling_rotation(p: np.ndarray) -> Optional[np.ndarray]:
 
 
 def fit_similarity_transform(
-    p1: np.ndarray, p2: np.ndarray, max_iterations: int = 1000, threshold: float = 1
-) -> Tuple[np.ndarray, np.ndarray]:
+    p1: NDArray, p2: NDArray, max_iterations: int = 1000, threshold: float = 1
+) -> Tuple[NDArray, NDArray]:
     """Fit a similarity transform T such as p2 = T . p1 between two points sets p1 and p2"""
     # TODO (Yubin): adapt to RANSAC class
 
@@ -427,12 +251,12 @@ def fit_similarity_transform(
     return best_T, best_inliers
 
 
-def K_from_camera(camera: Dict[str, Any]) -> np.ndarray:
+def K_from_camera(camera: Dict[str, Any]) -> NDArray:
     f = float(camera["focal"])
     return np.array([[f, 0.0, 0.0], [0.0, f, 0.0], [0.0, 0.0, 1.0]])
 
 
-def focal_from_homography(H: np.ndarray) -> np.ndarray:
+def focal_from_homography(H: NDArray) -> NDArray:
     """Solve for w = H w H^t, with w = diag(a, a, b)
 
     >>> K = np.diag([0.8, 0.8, 1])
@@ -458,9 +282,7 @@ def focal_from_homography(H: np.ndarray) -> np.ndarray:
     return focal
 
 
-def R_from_homography(
-    H: np.ndarray, f1: np.ndarray, f2: np.ndarray
-) -> Optional[np.ndarray]:
+def R_from_homography(H: NDArray, f1: NDArray, f2: NDArray) -> Optional[NDArray]:
     # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
     K1 = np.diag([f1, f1, 1])
     # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
@@ -471,7 +293,7 @@ def R_from_homography(
     return R
 
 
-def project_to_rotation_matrix(A: np.ndarray) -> Optional[np.ndarray]:
+def project_to_rotation_matrix(A: NDArray) -> Optional[NDArray]:
     try:
         u, d, vt = np.linalg.svd(A)
     except np.linalg.linalg.LinAlgError:
@@ -479,7 +301,7 @@ def project_to_rotation_matrix(A: np.ndarray) -> Optional[np.ndarray]:
     return u.dot(vt)
 
 
-def camera_up_vector(rotation_matrix: np.ndarray) -> np.ndarray:
+def camera_up_vector(rotation_matrix: NDArray) -> NDArray:
     """Unit vector pointing to zenit in camera coords.
 
     :param rotation: camera pose rotation
@@ -487,7 +309,7 @@ def camera_up_vector(rotation_matrix: np.ndarray) -> np.ndarray:
     return rotation_matrix[:, 2]
 
 
-def camera_compass_angle(rotation_matrix: np.ndarray) -> float:
+def camera_compass_angle(rotation_matrix: NDArray) -> float:
     """Compass angle of a camera
 
     Angle between world's Y axis and camera's Z axis projected
@@ -502,7 +324,7 @@ def camera_compass_angle(rotation_matrix: np.ndarray) -> float:
 
 def rotation_matrix_from_up_vector_and_compass(
     up_vector: List[float], compass_angle: float
-) -> np.ndarray:
+) -> NDArray:
     """Camera rotation given up_vector and compass.
 
     >>> d = [1, 2, 3]
@@ -541,8 +363,8 @@ def rotation_matrix_from_up_vector_and_compass(
 
 
 def motion_from_plane_homography(
-    H: np.ndarray,
-) -> Optional[List[Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]]]:
+    H: NDArray,
+) -> Optional[List[Tuple[NDArray, NDArray, NDArray, NDArray]]]:
     """Compute candidate camera motions from a plane-induced homography.
 
     Returns up to 8 motions.
@@ -619,12 +441,12 @@ def motion_from_plane_homography(
 
 
 def absolute_pose_known_rotation_ransac(
-    bs: np.ndarray,
-    Xs: np.ndarray,
+    bs: NDArray,
+    Xs: NDArray,
     threshold: float,
     iterations: int,
     probability: float,
-) -> np.ndarray:
+) -> NDArray:
     params = pyrobust.RobustEstimatorParams()
     params.iterations = iterations
     result = pyrobust.ransac_absolute_pose_known_rotation(
@@ -637,12 +459,12 @@ def absolute_pose_known_rotation_ransac(
 
 
 def absolute_pose_ransac(
-    bs: np.ndarray,
-    Xs: np.ndarray,
+    bs: NDArray,
+    Xs: NDArray,
     threshold: float,
     iterations: int,
     probability: float,
-) -> np.ndarray:
+) -> NDArray:
     params = pyrobust.RobustEstimatorParams()
     params.iterations = iterations
     result = pyrobust.ransac_absolute_pose(
@@ -657,12 +479,12 @@ def absolute_pose_ransac(
 
 
 def relative_pose_ransac(
-    b1: np.ndarray,
-    b2: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
     threshold: float,
     iterations: int,
     probability: float,
-) -> np.ndarray:
+) -> NDArray:
     params = pyrobust.RobustEstimatorParams()
     params.iterations = iterations
     result = pyrobust.ransac_relative_pose(
@@ -677,12 +499,12 @@ def relative_pose_ransac(
 
 
 def relative_pose_ransac_rotation_only(
-    b1: np.ndarray,
-    b2: np.ndarray,
+    b1: NDArray,
+    b2: NDArray,
     threshold: float,
     iterations: int,
     probability: float,
-) -> np.ndarray:
+) -> NDArray:
     params = pyrobust.RobustEstimatorParams()
     params.iterations = iterations
     result = pyrobust.ransac_relative_rotation(
@@ -692,8 +514,8 @@ def relative_pose_ransac_rotation_only(
 
 
 def relative_pose_optimize_nonlinear(
-    b1: np.ndarray, b2: np.ndarray, t: np.ndarray, R: np.ndarray, iterations: int
-) -> np.ndarray:
+    b1: NDArray, b2: NDArray, t: NDArray, R: NDArray, iterations: int
+) -> NDArray:
     Rt = np.zeros((3, 4))
     Rt[:3, :3] = R.T
     Rt[:, 3] = -R.T.dot(t)
@@ -711,7 +533,7 @@ def triangulate_gcp(
     reproj_threshold: float = 0.02,
     min_ray_angle_degrees: float = 1.0,
     min_depth: float = 0.001,
-) -> Optional[np.ndarray]:
+) -> Optional[NDArray]:
     """Compute the reconstructed position of a GCP from observations."""
 
     os, bs, ids = [], [], []

From efcd1e20ffd5d6a633bdcc9574e2f73d995aa105 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 142/235] annotate commands

Reviewed By: DodgySpaniard

Differential Revision: D76518684

fbshipit-source-id: 03ce568bb9669f4811e8335ae94605fc9d4723b1
---
 opensfm/commands/__init__.py               |  8 ++++++--
 opensfm/commands/align_submodels.py        |  2 +-
 opensfm/commands/bundle.py                 |  2 +-
 opensfm/commands/command.py                |  4 ++--
 opensfm/commands/command_runner.py         | 10 +++++++---
 opensfm/commands/compute_depthmaps.py      |  2 +-
 opensfm/commands/compute_statistics.py     |  2 +-
 opensfm/commands/create_rig.py             |  2 +-
 opensfm/commands/create_submodels.py       |  2 +-
 opensfm/commands/create_tracks.py          |  2 +-
 opensfm/commands/detect_features.py        |  2 +-
 opensfm/commands/export_bundler.py         |  2 +-
 opensfm/commands/export_colmap.py          |  2 +-
 opensfm/commands/export_geocoords.py       |  2 +-
 opensfm/commands/export_openmvs.py         |  2 +-
 opensfm/commands/export_ply.py             |  2 +-
 opensfm/commands/export_pmvs.py            |  2 +-
 opensfm/commands/export_report.py          |  2 +-
 opensfm/commands/export_visualsfm.py       |  2 +-
 opensfm/commands/extend_reconstruction.py  |  2 +-
 opensfm/commands/extract_metadata.py       |  2 +-
 opensfm/commands/match_features.py         |  2 +-
 opensfm/commands/mesh.py                   |  2 +-
 opensfm/commands/reconstruct.py            |  2 +-
 opensfm/commands/reconstruct_from_prior.py |  2 +-
 opensfm/commands/undistort.py              |  2 +-
 26 files changed, 38 insertions(+), 30 deletions(-)

diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index fb41eac10..6d0aecffa 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -1,4 +1,8 @@
-# pyre-unsafe
+# pyre-strict
+
+from types import ModuleType
+from typing import List
+
 from . import (
     align_submodels,
     bundle,
@@ -27,7 +31,7 @@
 from .command_runner import command_runner
 
 
-opensfm_commands = [
+opensfm_commands: List[ModuleType] = [
     extract_metadata,
     detect_features,
     match_features,
diff --git a/opensfm/commands/align_submodels.py b/opensfm/commands/align_submodels.py
index d9059d0ec..8823d173e 100644
--- a/opensfm/commands/align_submodels.py
+++ b/opensfm/commands/align_submodels.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import align_submodels
diff --git a/opensfm/commands/bundle.py b/opensfm/commands/bundle.py
index b3ee44676..238f80143 100644
--- a/opensfm/commands/bundle.py
+++ b/opensfm/commands/bundle.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import bundle
diff --git a/opensfm/commands/command.py b/opensfm/commands/command.py
index 083874bb3..3ce5a17aa 100644
--- a/opensfm/commands/command.py
+++ b/opensfm/commands/command.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 from timeit import default_timer as timer
 
@@ -11,7 +11,7 @@ class CommandBase:
     name = "Undefined command"
     help = "Undefined command help"
 
-    def run(self, data, args: argparse.Namespace) -> None:
+    def run(self, data: DataSet, args: argparse.Namespace) -> None:
         start = timer()
         self.run_impl(data, args)
         end = timer()
diff --git a/opensfm/commands/command_runner.py b/opensfm/commands/command_runner.py
index 025e64ab4..22daa73dd 100644
--- a/opensfm/commands/command_runner.py
+++ b/opensfm/commands/command_runner.py
@@ -1,12 +1,16 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
-from typing import Any, Callable, List
+from types import ModuleType
+from typing import Callable, ContextManager, List
 
 from opensfm import log
+from opensfm.dataset import DataSet
 
 
 def command_runner(
-    all_commands_types: List[Any], dataset_factory: Callable, dataset_choices: List[str]
+    all_commands_types: List[ModuleType],
+    dataset_factory: Callable[[str, str], ContextManager[DataSet]],
+    dataset_choices: List[str],
 ) -> None:
     """Main entry point for running the passed SfM commands types."""
     log.setup()
diff --git a/opensfm/commands/compute_depthmaps.py b/opensfm/commands/compute_depthmaps.py
index 4abb83b75..2e6b68ec2 100644
--- a/opensfm/commands/compute_depthmaps.py
+++ b/opensfm/commands/compute_depthmaps.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import compute_depthmaps
diff --git a/opensfm/commands/compute_statistics.py b/opensfm/commands/compute_statistics.py
index fdee55f68..0117a93ae 100644
--- a/opensfm/commands/compute_statistics.py
+++ b/opensfm/commands/compute_statistics.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import compute_statistics
diff --git a/opensfm/commands/create_rig.py b/opensfm/commands/create_rig.py
index ff8588d54..4a8766e36 100644
--- a/opensfm/commands/create_rig.py
+++ b/opensfm/commands/create_rig.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 import json
 
diff --git a/opensfm/commands/create_submodels.py b/opensfm/commands/create_submodels.py
index 9c5e06c9c..bb62a497e 100644
--- a/opensfm/commands/create_submodels.py
+++ b/opensfm/commands/create_submodels.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import create_submodels
diff --git a/opensfm/commands/create_tracks.py b/opensfm/commands/create_tracks.py
index 14b67ce11..7d4d45244 100644
--- a/opensfm/commands/create_tracks.py
+++ b/opensfm/commands/create_tracks.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import create_tracks
diff --git a/opensfm/commands/detect_features.py b/opensfm/commands/detect_features.py
index 145bfc7e9..a36cb1c78 100644
--- a/opensfm/commands/detect_features.py
+++ b/opensfm/commands/detect_features.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import detect_features
diff --git a/opensfm/commands/export_bundler.py b/opensfm/commands/export_bundler.py
index a27c0ee51..f06c66d4b 100644
--- a/opensfm/commands/export_bundler.py
+++ b/opensfm/commands/export_bundler.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_bundler
diff --git a/opensfm/commands/export_colmap.py b/opensfm/commands/export_colmap.py
index f16c2d875..21c7fb5b2 100644
--- a/opensfm/commands/export_colmap.py
+++ b/opensfm/commands/export_colmap.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_colmap
diff --git a/opensfm/commands/export_geocoords.py b/opensfm/commands/export_geocoords.py
index 6768058b4..f8b05b9bc 100644
--- a/opensfm/commands/export_geocoords.py
+++ b/opensfm/commands/export_geocoords.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_geocoords
diff --git a/opensfm/commands/export_openmvs.py b/opensfm/commands/export_openmvs.py
index 29ba91ca3..a12d90633 100644
--- a/opensfm/commands/export_openmvs.py
+++ b/opensfm/commands/export_openmvs.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_openmvs
diff --git a/opensfm/commands/export_ply.py b/opensfm/commands/export_ply.py
index 07d86fc87..2817065b2 100644
--- a/opensfm/commands/export_ply.py
+++ b/opensfm/commands/export_ply.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_ply
diff --git a/opensfm/commands/export_pmvs.py b/opensfm/commands/export_pmvs.py
index 7d6fd3f7b..a0d22bdca 100644
--- a/opensfm/commands/export_pmvs.py
+++ b/opensfm/commands/export_pmvs.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_pmvs
diff --git a/opensfm/commands/export_report.py b/opensfm/commands/export_report.py
index 71f876683..2ad3b08f2 100644
--- a/opensfm/commands/export_report.py
+++ b/opensfm/commands/export_report.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_report
diff --git a/opensfm/commands/export_visualsfm.py b/opensfm/commands/export_visualsfm.py
index 847f2db8c..1a6fbf9d0 100644
--- a/opensfm/commands/export_visualsfm.py
+++ b/opensfm/commands/export_visualsfm.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import export_visualsfm
diff --git a/opensfm/commands/extend_reconstruction.py b/opensfm/commands/extend_reconstruction.py
index 8e4443060..9ec01c604 100644
--- a/opensfm/commands/extend_reconstruction.py
+++ b/opensfm/commands/extend_reconstruction.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import extend_reconstruction
diff --git a/opensfm/commands/extract_metadata.py b/opensfm/commands/extract_metadata.py
index 1e2331745..f41dfba13 100644
--- a/opensfm/commands/extract_metadata.py
+++ b/opensfm/commands/extract_metadata.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import extract_metadata
diff --git a/opensfm/commands/match_features.py b/opensfm/commands/match_features.py
index 494fcb70f..c8f08fc4a 100644
--- a/opensfm/commands/match_features.py
+++ b/opensfm/commands/match_features.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import match_features
diff --git a/opensfm/commands/mesh.py b/opensfm/commands/mesh.py
index ab58e8eb6..5451430a8 100644
--- a/opensfm/commands/mesh.py
+++ b/opensfm/commands/mesh.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import mesh
diff --git a/opensfm/commands/reconstruct.py b/opensfm/commands/reconstruct.py
index fb5bf4291..0df0030f1 100644
--- a/opensfm/commands/reconstruct.py
+++ b/opensfm/commands/reconstruct.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm import reconstruction
diff --git a/opensfm/commands/reconstruct_from_prior.py b/opensfm/commands/reconstruct_from_prior.py
index f7281e971..0ffc91794 100644
--- a/opensfm/commands/reconstruct_from_prior.py
+++ b/opensfm/commands/reconstruct_from_prior.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import reconstruct_from_prior
diff --git a/opensfm/commands/undistort.py b/opensfm/commands/undistort.py
index 0939af676..51125380e 100644
--- a/opensfm/commands/undistort.py
+++ b/opensfm/commands/undistort.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 
 from opensfm.actions import undistort

From 4235f8adcdbdc14baa2262c4bca05de5bfa7ceb4 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 143/235] annotate actions

Reviewed By: DodgySpaniard

Differential Revision: D76518696

fbshipit-source-id: 3cf56526df9efd8246802e642b6472dfb355a620
---
 opensfm/actions/align_submodels.py        |  2 +-
 opensfm/actions/bundle.py                 |  2 +-
 opensfm/actions/compute_depthmaps.py      |  4 ++--
 opensfm/actions/compute_statistics.py     |  2 +-
 opensfm/actions/create_rig.py             |  4 ++--
 opensfm/actions/create_submodels.py       |  6 ++---
 opensfm/actions/create_tracks.py          | 10 +++++---
 opensfm/actions/detect_features.py        |  2 +-
 opensfm/actions/export_bundler.py         | 15 +++++++-----
 opensfm/actions/export_geocoords.py       | 15 ++++++------
 opensfm/actions/export_openmvs.py         | 13 +++++++----
 opensfm/actions/export_ply.py             |  8 +++++--
 opensfm/actions/export_pmvs.py            | 28 +++++++++++++----------
 opensfm/actions/export_report.py          |  2 +-
 opensfm/actions/export_visualsfm.py       | 13 +++++++----
 opensfm/actions/extend_reconstruction.py  |  2 +-
 opensfm/actions/extract_metadata.py       |  2 +-
 opensfm/actions/match_features.py         | 10 ++++++--
 opensfm/actions/mesh.py                   |  2 +-
 opensfm/actions/reconstruct.py            |  2 +-
 opensfm/actions/reconstruct_from_prior.py |  2 +-
 opensfm/actions/undistort.py              |  2 +-
 22 files changed, 90 insertions(+), 58 deletions(-)

diff --git a/opensfm/actions/align_submodels.py b/opensfm/actions/align_submodels.py
index 91ac0875b..91cf74a2f 100644
--- a/opensfm/actions/align_submodels.py
+++ b/opensfm/actions/align_submodels.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm.dataset import DataSet
 from opensfm.large import metadataset, tools
 
diff --git a/opensfm/actions/bundle.py b/opensfm/actions/bundle.py
index ebbc5cab2..ef976f643 100644
--- a/opensfm/actions/bundle.py
+++ b/opensfm/actions/bundle.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Optional
 
 import opensfm.reconstruction as orec
diff --git a/opensfm/actions/compute_depthmaps.py b/opensfm/actions/compute_depthmaps.py
index fd61a5d1c..0a6801491 100644
--- a/opensfm/actions/compute_depthmaps.py
+++ b/opensfm/actions/compute_depthmaps.py
@@ -1,11 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import os
 
 from opensfm import dataset, dense
 from opensfm.dataset import DataSet
 
 
-def run_dataset(data: DataSet, subfolder, interactive) -> None:
+def run_dataset(data: DataSet, subfolder: str, interactive: bool) -> None:
     """Compute depthmap on a dataset with has SfM ran already.
 
     Args:
diff --git a/opensfm/actions/compute_statistics.py b/opensfm/actions/compute_statistics.py
index da0a05a07..f79779b7e 100644
--- a/opensfm/actions/compute_statistics.py
+++ b/opensfm/actions/compute_statistics.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 
diff --git a/opensfm/actions/create_rig.py b/opensfm/actions/create_rig.py
index 5d5466b73..9747bdfde 100644
--- a/opensfm/actions/create_rig.py
+++ b/opensfm/actions/create_rig.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from typing import Dict, List
 
@@ -11,7 +11,7 @@
 
 
 def run_dataset(
-    data: DataSet, method, definition: Dict[str, str], output_debug
+    data: DataSet, method: str, definition: Dict[str, str], output_debug: bool
 ) -> None:
     """Given a dataset that contains rigs, construct rig data files.
 
diff --git a/opensfm/actions/create_submodels.py b/opensfm/actions/create_submodels.py
index 237e64d2d..e151c84d5 100644
--- a/opensfm/actions/create_submodels.py
+++ b/opensfm/actions/create_submodels.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from collections import defaultdict
 
@@ -32,7 +32,7 @@ def run_dataset(data: DataSet) -> None:
     meta_data.create_submodels(meta_data.load_clusters_with_neighbors())
 
 
-def _create_image_list(data: DataSet, meta_data) -> None:
+def _create_image_list(data: DataSet, meta_data: MetaDataSet) -> None:
     ills = []
     for image in data.images():
         exif = data.load_exif(image)
@@ -105,7 +105,7 @@ def _cluster_images(meta_data: MetaDataSet, cluster_size: float) -> None:
     meta_data.save_clusters(images, positions, labels, centers)
 
 
-def _add_cluster_neighbors(meta_data: MetaDataSet, max_distance) -> None:
+def _add_cluster_neighbors(meta_data: MetaDataSet, max_distance: float) -> None:
     images, positions, labels, centers = meta_data.load_clusters()
     clusters = tools.add_cluster_neighbors(positions, labels, centers, max_distance)
 
diff --git a/opensfm/actions/create_tracks.py b/opensfm/actions/create_tracks.py
index b3af1554e..b57b810d4 100644
--- a/opensfm/actions/create_tracks.py
+++ b/opensfm/actions/create_tracks.py
@@ -1,7 +1,7 @@
-# pyre-unsafe
+# pyre-strict
 from timeit import default_timer as timer
 
-from opensfm import io, tracking
+from opensfm import io, pymap, tracking
 from opensfm.dataset_base import DataSetBase
 
 
@@ -38,7 +38,11 @@ def run_dataset(data: DataSetBase) -> None:
 
 
 def write_report(
-    data: DataSetBase, tracks_manager, features_time, matches_time, tracks_time
+    data: DataSetBase,
+    tracks_manager: pymap.TracksManager,
+    features_time: float,
+    matches_time: float,
+    tracks_time: float,
 ) -> None:
     view_graph = [
         (k[0], k[1], v) for k, v in tracks_manager.get_all_pairs_connectivity().items()
diff --git a/opensfm/actions/detect_features.py b/opensfm/actions/detect_features.py
index 9bf47cfed..0aa6ac6ad 100644
--- a/opensfm/actions/detect_features.py
+++ b/opensfm/actions/detect_features.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from timeit import default_timer as timer
 
diff --git a/opensfm/actions/export_bundler.py b/opensfm/actions/export_bundler.py
index 6fd72a6dd..8c9ca5c93 100644
--- a/opensfm/actions/export_bundler.py
+++ b/opensfm/actions/export_bundler.py
@@ -1,12 +1,15 @@
-# pyre-unsafe
+# pyre-strict
 import os
+from typing import List
 
 import numpy as np
-from opensfm import io
+from opensfm import io, pymap, types
 from opensfm.dataset import DataSet
 
 
-def run_dataset(data: DataSet, list_path, bundle_path, undistorted) -> None:
+def run_dataset(
+    data: DataSet, list_path: str, bundle_path: str, undistorted: bool
+) -> None:
     """Export reconstruction to bundler format.
 
     Args:
@@ -37,9 +40,9 @@ def run_dataset(data: DataSet, list_path, bundle_path, undistorted) -> None:
 
 
 def export_bundler(
-    image_list,
-    reconstructions,
-    track_manager,
+    image_list: List[str],
+    reconstructions: List[types.Reconstruction],
+    track_manager: pymap.TracksManager,
     bundle_file_path: str,
     list_file_path: str,
 ) -> None:
diff --git a/opensfm/actions/export_geocoords.py b/opensfm/actions/export_geocoords.py
index 1f5980eec..966ef1445 100644
--- a/opensfm/actions/export_geocoords.py
+++ b/opensfm/actions/export_geocoords.py
@@ -1,10 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 from typing import List, Sequence
 
 import numpy as np
 import pyproj
+from numpy.typing import NDArray
 from opensfm import io, types
 from opensfm.dataset import DataSet, UndistortedDataSet
 from opensfm.geo import TopocentricConverter
@@ -69,7 +70,7 @@ def run_dataset(
 
 def _get_transformation(
     reference: TopocentricConverter, projection: pyproj.Proj
-) -> np.ndarray:
+) -> NDArray:
     """Get the linear transform from reconstruction coords to geocoords."""
     p = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
     q = [_transform(point, reference, projection) for point in p]
@@ -85,7 +86,7 @@ def _get_transformation(
     return transformation
 
 
-def _write_transformation(transformation: np.ndarray, filename: str) -> None:
+def _write_transformation(transformation: NDArray, filename: str) -> None:
     """Write the 4x4 matrix transformation to a text file."""
     with io.open_wt(filename) as fout:
         for row in transformation:
@@ -94,7 +95,7 @@ def _write_transformation(transformation: np.ndarray, filename: str) -> None:
 
 
 def _transform(
-    point: Sequence, reference: TopocentricConverter, projection: pyproj.Proj
+    point: Sequence[float], reference: TopocentricConverter, projection: pyproj.Proj
 ) -> List[float]:
     """Transform on point from local coords to a proj4 projection."""
     lat, lon, altitude = reference.to_lla(point[0], point[1], point[2])
@@ -103,7 +104,7 @@ def _transform(
 
 
 def _transform_image_positions(
-    reconstructions: List[types.Reconstruction], transformation: np.ndarray, output: str
+    reconstructions: List[types.Reconstruction], transformation: NDArray, output: str
 ) -> None:
     A, b = transformation[:3, :3], transformation[:3, 3]
 
@@ -121,7 +122,7 @@ def _transform_image_positions(
 
 
 def _transform_reconstruction(
-    reconstruction: types.Reconstruction, transformation: np.ndarray
+    reconstruction: types.Reconstruction, transformation: NDArray
 ) -> None:
     """Apply a transformation to a reconstruction in-place."""
     A, b = transformation[:3, :3], transformation[:3, 3]
@@ -137,7 +138,7 @@ def _transform_reconstruction(
 
 
 def _transform_dense_point_cloud(
-    udata: UndistortedDataSet, transformation: np.ndarray, output_path: str
+    udata: UndistortedDataSet, transformation: NDArray, output_path: str
 ) -> None:
     """Apply a transformation to the merged point cloud."""
     A, b = transformation[:3, :3], transformation[:3, 3]
diff --git a/opensfm/actions/export_openmvs.py b/opensfm/actions/export_openmvs.py
index 22d1fee32..8600b18d2 100644
--- a/opensfm/actions/export_openmvs.py
+++ b/opensfm/actions/export_openmvs.py
@@ -1,12 +1,14 @@
-# pyre-unsafe
+# pyre-strict
 import os
 
+from typing import Dict, Optional
+
 import numpy as np
-from opensfm import io, pydense
+from opensfm import io, pydense, pymap, types
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
-def run_dataset(data: DataSet, image_list) -> None:
+def run_dataset(data: DataSet, image_list: str) -> None:
     """Export reconstruction to OpenMVS format."""
 
     udata = data.undistorted_dataset()
@@ -25,7 +27,10 @@ def run_dataset(data: DataSet, image_list) -> None:
 
 
 def export(
-    reconstruction, tracks_manager, udata: UndistortedDataSet, export_only
+    reconstruction: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+    udata: UndistortedDataSet,
+    export_only: Optional[Dict[str, bool]],
 ) -> None:
     exporter = pydense.OpenMVSExporter()
     for camera in reconstruction.cameras.values():
diff --git a/opensfm/actions/export_ply.py b/opensfm/actions/export_ply.py
index 41c6f558d..be84025de 100644
--- a/opensfm/actions/export_ply.py
+++ b/opensfm/actions/export_ply.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import os
 
 import numpy as np
@@ -8,7 +8,11 @@
 
 
 def run_dataset(
-    data: DataSet, no_cameras: bool, no_points: bool, depthmaps, point_num_views: bool
+    data: DataSet,
+    no_cameras: bool,
+    no_points: bool,
+    depthmaps: bool,
+    point_num_views: bool,
 ) -> None:
     """Export reconstruction to PLY format
 
diff --git a/opensfm/actions/export_pmvs.py b/opensfm/actions/export_pmvs.py
index fb9bb9153..7eac4c239 100644
--- a/opensfm/actions/export_pmvs.py
+++ b/opensfm/actions/export_pmvs.py
@@ -1,17 +1,21 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
+from typing import Dict, Optional
 
 import cv2
+import networkx as nx
 import numpy as np
-from opensfm import features, io, tracking
+from opensfm import features, io, pymap, tracking, types
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def run_dataset(data: DataSet, points, image_list, output, undistorted) -> None:
+def run_dataset(
+    data: DataSet, points: bool, image_list: str, output: str, undistorted: bool
+) -> None:
     """Export reconstruction to PLY format
 
     Args:
@@ -69,16 +73,16 @@ def run_dataset(data: DataSet, points, image_list, output, undistorted) -> None:
 
 
 def export(
-    reconstruction,
-    index,
-    image_graph,
-    tracks_manager,
-    base_output_path,
+    reconstruction: types.Reconstruction,
+    index: int,
+    image_graph: Optional[nx.Graph],
+    tracks_manager: Optional[pymap.TracksManager],
+    base_output_path: str,
     data: DataSet,
-    undistorted,
+    undistorted: bool,
     udata: UndistortedDataSet,
-    with_points,
-    export_only,
+    with_points: bool,
+    export_only: Optional[Dict[str, bool]],
 ) -> None:
     logger.info("Reconstruction %d" % index)
     output_path = os.path.join(base_output_path, "recon%d" % index)
@@ -102,7 +106,7 @@ def export(
         if image_graph:
             adj_indices = []
             for adj_image in image_graph[image]:
-                weight = image_graph[image][adj_image]["weight"]
+                weight = float(image_graph[image][adj_image]["weight"])
                 if weight > 0 and adj_image in shot_index:
                     adj_indices.append(shot_index[adj_image])
 
diff --git a/opensfm/actions/export_report.py b/opensfm/actions/export_report.py
index d20ac0a3a..e717862d8 100644
--- a/opensfm/actions/export_report.py
+++ b/opensfm/actions/export_report.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import report
 from opensfm.dataset import DataSet
 
diff --git a/opensfm/actions/export_visualsfm.py b/opensfm/actions/export_visualsfm.py
index 60d444ce8..2f7defbdd 100644
--- a/opensfm/actions/export_visualsfm.py
+++ b/opensfm/actions/export_visualsfm.py
@@ -1,16 +1,17 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 import sys
+from typing import Dict, Optional
 
-from opensfm import io, transformations as tf
+from opensfm import io, pymap, transformations as tf, types
 from opensfm.dataset import DataSet, UndistortedDataSet
 
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def run_dataset(data: DataSet, points, image_list) -> None:
+def run_dataset(data: DataSet, points: bool, image_list: str) -> None:
     udata = data.undistorted_dataset()
 
     validate_image_names(data, udata)
@@ -30,7 +31,11 @@ def run_dataset(data: DataSet, points, image_list) -> None:
 
 
 def export(
-    reconstruction, tracks_manager, udata: UndistortedDataSet, with_points, export_only
+    reconstruction: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+    udata: UndistortedDataSet,
+    with_points: bool,
+    export_only: Optional[Dict[str, bool]],
 ) -> None:
     lines = ["NVM_V3", "", str(len(reconstruction.shots))]
     shot_size_cache = {}
diff --git a/opensfm/actions/extend_reconstruction.py b/opensfm/actions/extend_reconstruction.py
index 179ae5eaa..9d62fd5fe 100644
--- a/opensfm/actions/extend_reconstruction.py
+++ b/opensfm/actions/extend_reconstruction.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Optional
 
 from opensfm import io, reconstruction
diff --git a/opensfm/actions/extract_metadata.py b/opensfm/actions/extract_metadata.py
index 1fc2d8e93..2ed770b76 100644
--- a/opensfm/actions/extract_metadata.py
+++ b/opensfm/actions/extract_metadata.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 import logging
 from functools import partial
diff --git a/opensfm/actions/match_features.py b/opensfm/actions/match_features.py
index d11e8b3c7..561a7b237 100644
--- a/opensfm/actions/match_features.py
+++ b/opensfm/actions/match_features.py
@@ -1,5 +1,6 @@
-# pyre-unsafe
+# pyre-strict
 from timeit import default_timer as timer
+from typing import Any, Dict, List, Tuple
 
 from opensfm import io, matching
 from opensfm.dataset_base import DataSetBase
@@ -18,7 +19,12 @@ def run_dataset(data: DataSetBase) -> None:
     write_report(data, preport, list(pairs_matches.keys()), end - start)
 
 
-def write_report(data: DataSetBase, preport, pairs, wall_time) -> None:
+def write_report(
+    data: DataSetBase,
+    preport: Dict[str, Any],
+    pairs: List[Tuple[str, str]],
+    wall_time: float,
+) -> None:
     report = {
         "wall_time": wall_time,
         "num_pairs": len(pairs),
diff --git a/opensfm/actions/mesh.py b/opensfm/actions/mesh.py
index 203e3bf86..4f753f6af 100644
--- a/opensfm/actions/mesh.py
+++ b/opensfm/actions/mesh.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import mesh
 from opensfm.dataset_base import DataSetBase
 
diff --git a/opensfm/actions/reconstruct.py b/opensfm/actions/reconstruct.py
index 766e3e060..0034b0355 100644
--- a/opensfm/actions/reconstruct.py
+++ b/opensfm/actions/reconstruct.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 
diff --git a/opensfm/actions/reconstruct_from_prior.py b/opensfm/actions/reconstruct_from_prior.py
index baf59b1b7..41b37b9ad 100644
--- a/opensfm/actions/reconstruct_from_prior.py
+++ b/opensfm/actions/reconstruct_from_prior.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 
diff --git a/opensfm/actions/undistort.py b/opensfm/actions/undistort.py
index 5d9bcd220..13fae2f95 100644
--- a/opensfm/actions/undistort.py
+++ b/opensfm/actions/undistort.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import os
 from typing import Optional
 

From 07485b7ccd4faea2ff990351d0df403c73f53fed Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 144/235] annotate export_colmap

Reviewed By: DodgySpaniard

Differential Revision: D76518686

fbshipit-source-id: 05ffc6a49de2998dbd8e1843825ec60a571cb4b4
---
 opensfm/actions/export_colmap.py | 211 +++++++++++++++++++++----------
 1 file changed, 141 insertions(+), 70 deletions(-)

diff --git a/opensfm/actions/export_colmap.py b/opensfm/actions/export_colmap.py
index 5c384fb42..42e1b326b 100644
--- a/opensfm/actions/export_colmap.py
+++ b/opensfm/actions/export_colmap.py
@@ -29,7 +29,7 @@
 #
 # Author: Johannes L. Schoenberger (jsch at inf.ethz.ch)
 
-# pyre-unsafe
+# pyre-strict
 
 # This script is based on an original implementation by True Price.
 
@@ -40,13 +40,31 @@
 import tempfile
 import typing as t
 from struct import pack
-from typing import Tuple
+from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, TypeVar
 
 import numpy as np
-from opensfm import features, matching
+from numpy.typing import DTypeLike, NDArray
+from opensfm import features, io, matching, pygeometry
 from opensfm.dataset import DataSet
 
-I_3 = np.eye(3)
+T = TypeVar("T")
+
+I_3: NDArray = np.eye(3)
+
+
+class Camera(Protocol):
+    width: int
+    height: int
+    projection_type: str
+    focal: float
+    k1: float
+    k2: float
+    k3: float = 0.0
+    k4: float = 0.0
+    p1: float = 0.0
+    p2: float = 0.0
+    aspect_ratio: float = 1.0
+    principal_point: Tuple[float, float] = (0.0, 0.0)
 
 
 def run_dataset(data: DataSet, binary: bool) -> None:
@@ -93,7 +111,7 @@ def run_dataset(data: DataSet, binary: bool) -> None:
 
 IS_PYTHON3: bool = int(sys.version_info[0]) >= 3
 
-MAX_IMAGE_ID = 2**31 - 1
+MAX_IMAGE_ID: int = 2**31 - 1
 
 CREATE_CAMERAS_TABLE = """CREATE TABLE IF NOT EXISTS cameras (
     camera_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
@@ -166,19 +184,19 @@ def run_dataset(data: DataSet, binary: bool) -> None:
 )
 
 
-def image_ids_to_pair_id(image_id1, image_id2) -> int:
+def image_ids_to_pair_id(image_id1: int, image_id2: int) -> int:
     if image_id1 > image_id2:
         image_id1, image_id2 = image_id2, image_id1
     return image_id1 * MAX_IMAGE_ID + image_id2
 
 
-def pair_id_to_image_ids(pair_id) -> Tuple[int, int]:
+def pair_id_to_image_ids(pair_id: int) -> Tuple[int, int]:
     image_id2 = pair_id % MAX_IMAGE_ID
     image_id1 = (pair_id - image_id2) // MAX_IMAGE_ID
     return image_id1, image_id2
 
 
-def array_to_blob(array) -> bytes:
+def array_to_blob(array: NDArray) -> bytes:
     if IS_PYTHON3:
         return array.tobytes()
     else:
@@ -186,7 +204,9 @@ def array_to_blob(array) -> bytes:
         return np.getbuffer(array)
 
 
-def blob_to_array(blob, dtype, shape: Tuple[int] = (-1,)):
+def blob_to_array(
+    blob: bytes, dtype: DTypeLike, shape: Tuple[int, ...] = (-1,)
+) -> NDArray:
     if IS_PYTHON3:
         # pyre-fixme[20]: Argument `sep` expected.
         return np.fromstring(blob, dtype=dtype).reshape(*shape)
@@ -196,28 +216,46 @@ def blob_to_array(blob, dtype, shape: Tuple[int] = (-1,)):
 
 class COLMAPDatabase(sqlite3.Connection):
     @staticmethod
-    def connect(database_path) -> t.Any:
+    def connect(database_path: str) -> "COLMAPDatabase":
         return sqlite3.connect(database_path, factory=COLMAPDatabase)
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super(COLMAPDatabase, self).__init__(*args, **kwargs)
 
-        self.create_tables = lambda: self.executescript(CREATE_ALL)
-        self.create_cameras_table = lambda: self.executescript(CREATE_CAMERAS_TABLE)
-        self.create_descriptors_table = lambda: self.executescript(
-            CREATE_DESCRIPTORS_TABLE
+        self.create_tables: Callable[[], sqlite3.Cursor] = lambda: self.executescript(
+            CREATE_ALL
+        )
+        self.create_cameras_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_CAMERAS_TABLE)
+        )
+        self.create_descriptors_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_DESCRIPTORS_TABLE)
+        )
+        self.create_images_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_IMAGES_TABLE)
+        )
+        self.create_two_view_geometries_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_TWO_VIEW_GEOMETRIES_TABLE)
         )
-        self.create_images_table = lambda: self.executescript(CREATE_IMAGES_TABLE)
-        self.create_two_view_geometries_table = lambda: self.executescript(
-            CREATE_TWO_VIEW_GEOMETRIES_TABLE
+        self.create_keypoints_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_KEYPOINTS_TABLE)
+        )
+        self.create_matches_table: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_MATCHES_TABLE)
+        )
+        self.create_name_index: Callable[[], sqlite3.Cursor] = (
+            lambda: self.executescript(CREATE_NAME_INDEX)
         )
-        self.create_keypoints_table = lambda: self.executescript(CREATE_KEYPOINTS_TABLE)
-        self.create_matches_table = lambda: self.executescript(CREATE_MATCHES_TABLE)
-        self.create_name_index = lambda: self.executescript(CREATE_NAME_INDEX)
 
     def add_camera(
-        self, model, width, height, params, prior_focal_length=False, camera_id=None
-    ) -> t.Any:
+        self,
+        model: int,
+        width: int,
+        height: int,
+        params: NDArray,
+        prior_focal_length: bool = False,
+        camera_id: Optional[int] = None,
+    ) -> Optional[int]:
         params = np.asarray(params, np.float64)
         cursor = self.execute(
             "INSERT INTO cameras VALUES (?, ?, ?, ?, ?, ?)",
@@ -233,8 +271,13 @@ def add_camera(
         return cursor.lastrowid
 
     def add_image(
-        self, name, camera_id, prior_q=(0, 0, 0, 0), prior_t=(0, 0, 0), image_id=None
-    ) -> t.Any:
+        self,
+        name: str,
+        camera_id: int,
+        prior_q: Tuple[float, float, float, float] = (0, 0, 0, 0),
+        prior_t: Tuple[float, float, float] = (0, 0, 0),
+        image_id: Optional[int] = None,
+    ) -> Optional[int]:
         cursor = self.execute(
             "INSERT INTO images VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
@@ -252,7 +295,7 @@ def add_image(
         )
         return cursor.lastrowid
 
-    def add_keypoints(self, image_id, keypoints) -> None:
+    def add_keypoints(self, image_id: int, keypoints: NDArray) -> None:
         assert len(keypoints.shape) == 2
         assert keypoints.shape[1] in [2, 4, 6]
 
@@ -262,14 +305,14 @@ def add_keypoints(self, image_id, keypoints) -> None:
             (image_id,) + keypoints.shape + (array_to_blob(keypoints),),
         )
 
-    def add_descriptors(self, image_id, descriptors) -> None:
+    def add_descriptors(self, image_id: int, descriptors: NDArray) -> None:
         descriptors = np.ascontiguousarray(descriptors, np.uint8)
         self.execute(
             "INSERT INTO descriptors VALUES (?, ?, ?, ?)",
             (image_id,) + descriptors.shape + (array_to_blob(descriptors),),
         )
 
-    def add_matches(self, image_id1, image_id2, matches) -> None:
+    def add_matches(self, image_id1: int, image_id2: int, matches: NDArray) -> None:
         assert len(matches.shape) == 2
         assert matches.shape[1] == 2
 
@@ -284,7 +327,14 @@ def add_matches(self, image_id1, image_id2, matches) -> None:
         )
 
     def add_two_view_geometry(
-        self, image_id1, image_id2, matches, F=I_3, E=I_3, H=I_3, config=2
+        self,
+        image_id1: int,
+        image_id2: int,
+        matches: NDArray,
+        F: NDArray = I_3,
+        E: NDArray = I_3,
+        H: NDArray = I_3,
+        config: int = 2,
     ) -> None:
         assert len(matches.shape) == 2
         assert matches.shape[1] == 2
@@ -320,7 +370,7 @@ def add_two_view_geometry(
 COLMAP_ID_MAP = {"brown": 6, "perspective": 3, "fisheye": 9, "fisheye_opencv": 5}
 
 
-def camera_to_colmap_params(camera) -> t.Tuple[float, ...]:
+def camera_to_colmap_params(camera: pygeometry.Camera) -> Tuple[float, ...]:
     w = camera.width
     h = camera.height
     normalizer = max(w, h)
@@ -354,7 +404,9 @@ def camera_to_colmap_params(camera) -> t.Tuple[float, ...]:
         raise ValueError("Can't convert {camera.projection_type} to COLMAP")
 
 
-def export_cameras(data, db) -> t.Tuple[t.Dict[str, int], t.Dict[str, int]]:
+def export_cameras(
+    data: DataSet, db: COLMAPDatabase
+) -> t.Tuple[t.Dict[str, int], t.Dict[str, int]]:
     camera_map = {}
     for camera_model, camera in data.load_camera_models().items():
         if data.camera_models_overrides_exists():
@@ -380,7 +432,9 @@ def export_cameras(data, db) -> t.Tuple[t.Dict[str, int], t.Dict[str, int]]:
     return images_map, camera_map
 
 
-def export_features(data, db, images_map) -> t.Dict[str, np.ndarray]:
+def export_features(
+    data: DataSet, db: COLMAPDatabase, images_map: t.Dict[str, int]
+) -> t.Dict[str, NDArray]:
     features_map = {}
     for image in data.images():
         width = data.load_exif(image)["width"]
@@ -396,7 +450,13 @@ def export_features(data, db, images_map) -> t.Dict[str, np.ndarray]:
     return features_map
 
 
-def export_matches(data, db, features_map, images_map) -> None:
+def export_matches(
+    data: DataSet,
+    db: COLMAPDatabase,
+    features_map: Dict[str, NDArray],
+    images_map: Dict[str, int],
+) -> None:
+    """Export matches between images to the COLMAP database."""
     matches_per_pair = {}
     for image1 in data.images():
         matches = data.load_matches(image1)
@@ -424,7 +484,9 @@ def export_matches(data, db, features_map, images_map) -> None:
             db.add_matches(images_map[pair[0]], images_map[pair[1]], inliers)
 
 
-def export_cameras_reconstruction(data, path, camera_map, binary: bool = False) -> None:
+def export_cameras_reconstruction(
+    data: DataSet, path: str, camera_map: Dict[str, int], binary: bool = False
+) -> None:
     reconstructions = data.load_reconstruction()
     cameras = {}
     for reconstruction in reconstructions:
@@ -432,10 +494,10 @@ def export_cameras_reconstruction(data, path, camera_map, binary: bool = False)
             cameras[camera_id] = camera
 
     if binary:
-        fout = data.io_handler.open_wb(os.path.join(path, "cameras.bin"))
-        fout.write(pack("<Q", len(cameras)))
+        fout_bin = data.io_handler.open_wb(os.path.join(path, "cameras.bin"))
+        fout_bin.write(pack("<Q", len(cameras)))
     else:
-        fout = data.io_handler.open_wt(os.path.join(path, "cameras.txt"))
+        fout_txt = data.io_handler.open_wt(os.path.join(path, "cameras.txt"))
 
     for camera_id, camera in cameras.items():
         colmap_id = camera_map[camera_id]
@@ -444,32 +506,39 @@ def export_cameras_reconstruction(data, path, camera_map, binary: bool = False)
         h = camera.height
         params = camera_to_colmap_params(camera)
         if binary:
-            fout.write(pack("<2i", colmap_id, COLMAP_ID_MAP[camera.projection_type]))
-            fout.write(pack("<2Q", w, h))
-            fout.write(pack(f"<{len(params)}d", *params))
+            fout_bin.write(
+                pack("<2i", colmap_id, COLMAP_ID_MAP[camera.projection_type])
+            )
+            fout_bin.write(pack("<2Q", w, h))
+            fout_bin.write(pack(f"<{len(params)}d", *params))
         else:
             str_out = "%d %s %d %d"
             for _param in params:
                 str_out += " %f"
             str_out += "\n"
-            fout.write(str_out % (colmap_id, colmap_type, w, h, *params))
-    fout.close()
+            fout_txt.write(str_out % (colmap_id, colmap_type, w, h, *params))
 
 
 def export_images_reconstruction(
-    data, path, camera_map, images_map, features_map, points_map, binary: bool = False
+    data: DataSet,
+    path: str,
+    camera_map: Dict[str, int],
+    images_map: Dict[str, int],
+    features_map: Dict[str, NDArray],
+    points_map: Dict[str, int],
+    binary: bool = False,
 ) -> None:
     reconstructions = data.load_reconstruction()
     tracks_manager = data.load_tracks_manager()
 
     if binary:
-        fout = data.io_handler.open_wb(os.path.join(path, "images.bin"))
+        fout_bin = data.io_handler.open_wb(os.path.join(path, "images.bin"))
         n_ims = 0
         for reconstruction in reconstructions:
             n_ims += len(reconstruction.shots)
-        fout.write(pack("<Q", n_ims))
+        fout_bin.write(pack("<Q", n_ims))
     else:
-        fout = data.io_handler.open_wt(os.path.join(path, "images.txt"))
+        fout_txt = data.io_handler.open_wt(os.path.join(path, "images.txt"))
 
     for reconstruction in reconstructions:
         for shot_id, shot in reconstruction.shots.items():
@@ -480,12 +549,12 @@ def export_images_reconstruction(
             q = angle_axis_to_quaternion(shot.pose.rotation)
 
             if binary:
-                fout.write(pack("<I", colmap_shot_id))
-                fout.write(pack("<7d", *(list(q) + list(t))))
-                fout.write(pack("<I", colmap_camera_id))
+                fout_bin.write(pack("<I", colmap_shot_id))
+                fout_bin.write(pack("<7d", *(list(q) + list(t))))
+                fout_bin.write(pack("<I", colmap_camera_id))
                 for char in shot_id:
-                    fout.write(pack("<c", char.encode("utf-8")))
-                fout.write(pack("<c", b"\x00"))
+                    fout_bin.write(pack("<c", char.encode("utf-8")))
+                fout_bin.write(pack("<c", b"\x00"))
             format_line = "%d %f %f %f %f %f %f %f %d %s\n"
             format_tuple = [
                 colmap_shot_id,
@@ -520,30 +589,31 @@ def export_images_reconstruction(
             format_line += "\n"
 
             if binary:
-                fout.write(pack("<Q", len(points_tuple) // 3))
+                fout_bin.write(pack("<Q", len(points_tuple) // 3))
                 for i in range(0, len(points_tuple), 3):
                     x, y, colmap_point_id = points_tuple[i : i + 3]
-                    fout.write(pack("<2d", x, y))
-                    fout.write(pack("<Q", colmap_point_id))
+                    fout_bin.write(pack("<2d", x, y))
+                    fout_bin.write(pack("<Q", colmap_point_id))
             else:
-                fout.write(format_line % tuple(format_tuple + points_tuple))
-    fout.close()
+                fout_txt.write(format_line % tuple(format_tuple + points_tuple))
 
 
-def export_points_reconstruction(data, path, images_map, binary: bool = False):
+def export_points_reconstruction(
+    data: DataSet, path: str, images_map: Dict[str, int], binary: bool = False
+) -> Dict[str, int]:
     reconstructions = data.load_reconstruction()
     tracks_manager = data.load_tracks_manager()
 
     points_map = {}
 
     if binary:
-        fout = data.io_handler.open_wb(os.path.join(path, "points3D.bin"))
+        fout_bin = data.io_handler.open_wb(os.path.join(path, "points3D.bin"))
         n_points = 0
         for reconstruction in reconstructions:
             n_points += len(reconstruction.points)
-        fout.write(pack("<Q", n_points))
+        fout_bin.write(pack("<Q", n_points))
     else:
-        fout = data.io_handler.open_wt(os.path.join(path, "points3D.txt"))
+        fout_txt = data.io_handler.open_wt(os.path.join(path, "points3D.txt"))
 
     i = 0
     for reconstruction in reconstructions:
@@ -563,10 +633,10 @@ def export_points_reconstruction(data, path, images_map, binary: bool = False):
             ]
 
             if binary:
-                fout.write(pack("<Q", int(i)))
-                fout.write(pack("<3d", c[0], c[1], c[2]))  # Position
-                fout.write(pack("<3B", *[int(i) for i in cl]))  # Color
-                fout.write(pack("<d", 0.0))  # Error
+                fout_bin.write(pack("<Q", int(i)))
+                fout_bin.write(pack("<3d", c[0], c[1], c[2]))  # Position
+                fout_bin.write(pack("<3B", *[int(i) for i in cl]))  # Color
+                fout_bin.write(pack("<d", 0.0))  # Error
 
             track_tuple = []
             for image, obs in tracks_manager.get_track_observations(point.id).items():
@@ -577,18 +647,17 @@ def export_points_reconstruction(data, path, images_map, binary: bool = False):
             format_line += "\n"
 
             if binary:
-                fout.write(pack("<Q", len(track_tuple) // 2))  # Track length
+                fout_bin.write(pack("<Q", len(track_tuple) // 2))  # Track length
                 for el in track_tuple:
-                    fout.write(pack("<i", el))  # Track
+                    fout_bin.write(pack("<i", el))  # Track
             else:
-                fout.write(format_line % tuple(format_tuple + track_tuple))
+                fout_txt.write(format_line % tuple(format_tuple + track_tuple))
             points_map[point.id] = i
             i += 1
-    fout.close()
     return points_map
 
 
-def angle_axis_to_quaternion(angle_axis: np.ndarray) -> t.List[float]:
+def angle_axis_to_quaternion(angle_axis: NDArray) -> List[float]:
     angle = np.linalg.norm(angle_axis)
 
     x = angle_axis[0] / angle
@@ -603,7 +672,9 @@ def angle_axis_to_quaternion(angle_axis: np.ndarray) -> t.List[float]:
     return [qw, qx, qy, qz]
 
 
-def export_ini_file(path, db_path, images_path, io_handler) -> None:
+def export_ini_file(
+    path: str, db_path: str, images_path: str, io_handler: io.IoFilesystemBase
+) -> None:
     with io_handler.open_wt(os.path.join(path, "project.ini")) as fout:
         fout.write("log_to_stderr=false\nlog_level=2\n")
         fout.write("database_path=%s\n" % db_path)

From 5b1c5e137f11e91088d473d807e49bc5df4f2a94 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 145/235] annotate tests

Reviewed By: DodgySpaniard

Differential Revision: D76518692

fbshipit-source-id: fb08b4045978c7387ac0483c5705cf07fc10d781
---
 opensfm/test/conftest.py                      | 11 +++---
 opensfm/test/data_generation.py               |  8 ++--
 opensfm/test/test_bundle.py                   | 14 ++++---
 opensfm/test/test_commands.py                 |  7 +++-
 opensfm/test/test_dataset.py                  |  3 +-
 opensfm/test/test_datastructures.py           | 18 +++++----
 opensfm/test/test_dense.py                    |  2 +-
 opensfm/test/test_geo.py                      |  2 +-
 opensfm/test/test_geometry.py                 |  2 +-
 opensfm/test/test_io.py                       |  9 +++--
 opensfm/test/test_matching.py                 | 22 +++++++----
 opensfm/test/test_multiview.py                | 38 ++++++++++++++-----
 opensfm/test/test_pairs_selection.py          | 21 +++++-----
 opensfm/test/test_reconstruction_alignment.py | 11 ++++--
 .../test/test_reconstruction_incremental.py   |  2 +-
 opensfm/test/test_reconstruction_resect.py    | 19 +++++++---
 .../test_reconstruction_shot_neighborhood.py  | 11 ++++--
 .../test/test_reconstruction_triangulation.py |  2 +-
 opensfm/test/test_rig.py                      |  2 +-
 opensfm/test/test_robust.py                   | 35 +++++++++++------
 opensfm/test/test_stats.py                    |  2 +-
 opensfm/test/test_triangulation.py            |  6 +--
 opensfm/test/test_types.py                    | 11 ++++--
 opensfm/test/test_undistort.py                |  2 +-
 opensfm/test/test_vlad.py                     |  2 +-
 opensfm/test/utils.py                         |  2 +-
 26 files changed, 168 insertions(+), 96 deletions(-)

diff --git a/opensfm/test/conftest.py b/opensfm/test/conftest.py
index b0a20689a..bc6512e93 100644
--- a/opensfm/test/conftest.py
+++ b/opensfm/test/conftest.py
@@ -1,9 +1,10 @@
-# pyre-unsafe
+# pyre-strict
 from collections import defaultdict
 from typing import Dict, List, Tuple
 
 import numpy as np
 import pytest
+from numpy.typing import NDArray
 from opensfm import geo, multiview, pygeometry, pymap, types
 from opensfm.synthetic_data import (
     synthetic_dataset as sd,
@@ -129,8 +130,8 @@ def scene_synthetic_triangulation() -> synthetic_scene.SyntheticInputData:
 @pytest.fixture(scope="module")
 def pairs_and_poses() -> (
     Tuple[
-        Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
-        Dict[Tuple[str, str], List[Tuple[List[np.ndarray]]]],
+        Dict[Tuple[str, str], List[Tuple[List[NDArray]]]],
+        Dict[Tuple[str, str], List[Tuple[List[NDArray]]]],
         pygeometry.Camera,
         sd.SyntheticFeatures,
         pymap.TracksManager,
@@ -165,7 +166,7 @@ def pairs_and_poses() -> (
 @pytest.fixture(scope="module")
 def pairs_and_their_E(
     pairs_and_poses,
-) -> List[Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]]:
+) -> List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]]:
     pairs, poses, camera, _, _, _ = pairs_and_poses
 
     pairs = sorted(zip(pairs.values(), poses.values()), key=lambda x: -len(x[0]))
@@ -197,7 +198,7 @@ def pairs_and_their_E(
 @pytest.fixture(scope="module")
 def shots_and_their_points(
     pairs_and_poses,
-) -> List[Tuple[pygeometry.Pose, np.ndarray, np.ndarray]]:
+) -> List[Tuple[pygeometry.Pose, NDArray, NDArray]]:
     _, _, _, _, tracks_manager, reconstruction = pairs_and_poses
 
     ret_shots = []
diff --git a/opensfm/test/data_generation.py b/opensfm/test/data_generation.py
index 821f3a8b1..8e48845a9 100644
--- a/opensfm/test/data_generation.py
+++ b/opensfm/test/data_generation.py
@@ -1,5 +1,6 @@
-# pyre-unsafe
+# pyre-strict
 import os
+from typing import Any, Dict
 
 import opensfm.dataset
 import yaml
@@ -9,11 +10,12 @@
 try:
     from libfb.py import parutil
 
-    DATA_PATH = parutil.get_dir_path("mapillary/opensfm/opensfm/test/data")
+    DATA_PATH: str = parutil.get_dir_path("mapillary/opensfm/opensfm/test/data")
 except ImportError:
     DATA_PATH = os.path.abspath("data")
 
 
+# pyre-fixme[2]: switch from tmpdir to tmp_path
 def create_berlin_test_folder(tmpdir) -> opensfm.dataset.DataSet:
     src = os.path.join(DATA_PATH, "berlin")
     dst = str(tmpdir.mkdir("berlin"))
@@ -23,6 +25,6 @@ def create_berlin_test_folder(tmpdir) -> opensfm.dataset.DataSet:
     return opensfm.dataset.DataSet(dst)
 
 
-def save_config(config, path) -> None:
+def save_config(config: Dict[str, Any], path: str) -> None:
     with io.open_wt(os.path.join(path, "config.yaml")) as fout:
         yaml.safe_dump(config, fout, default_flow_style=False)
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index 61240add8..b394fe0b6 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -1,8 +1,9 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 
 import numpy as np
 import pytest
+from numpy.typing import NDArray
 from opensfm import (
     config,
     geometry,
@@ -13,6 +14,7 @@
     tracking,
     types,
 )
+from opensfm.synthetic_data import synthetic_scene
 
 
 def test_unicode_strings_in_bundle() -> None:
@@ -89,14 +91,16 @@ def test_singleton_pan_tilt_roll(bundle_adjuster: pybundle.BundleAdjuster) -> No
     assert np.allclose(ptr, (pan, tilt, roll))
 
 
-def _projection_errors_std(points) -> float:
+def _projection_errors_std(points: pymap.LandmarkView) -> float:
     all_errors = []
     for p in points.values():
         all_errors += p.reprojection_errors.values()
     return np.std(all_errors)
 
 
-def test_bundle_projection_fixed_internals(scene_synthetic) -> None:
+def test_bundle_projection_fixed_internals(
+    scene_synthetic: synthetic_scene.SyntheticInputData,
+) -> None:
     reference = scene_synthetic.reconstruction
     camera_priors = dict(reference.cameras.items())
     rig_priors = dict(reference.rig_cameras.items())
@@ -667,7 +671,7 @@ def test_heatmaps_position(bundle_adjuster: pybundle.BundleAdjuster) -> None:
     sa.add_reconstruction_instance("123", 1, "3")
     sa.set_scale_sharing("123", True)
 
-    def bell_heatmap(size, r, mu_x, mu_y):
+    def bell_heatmap(size: int, r: float, mu_x: float, mu_y: float) -> NDArray:
         sigma_x = r * 0.5
         sigma_y = r * 0.5
         x = np.linspace(-r, r, size)
@@ -692,7 +696,7 @@ def bell_heatmap(size, r, mu_x, mu_y):
     hmap_size, hmap_r = 101, 10
     res = 2 * hmap_r / (hmap_size - 1)
     hmap = bell_heatmap(size=hmap_size, r=hmap_r, mu_x=hmap_x, mu_y=hmap_y)
-    sa.add_heatmap("hmap1", hmap.flatten(), hmap_size, res)
+    sa.add_heatmap("hmap1", hmap.flatten().tolist(), hmap_size, res)
     x1_offset, y1_offset = 2, 0
     x2_offset, y2_offset = 0, 2
     x3_offset, y3_offset = -2, 0
diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index a5890bcd9..fc3cf5b13 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -1,18 +1,21 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 from os.path import join
+from types import ModuleType
+from typing import List
 
 from opensfm import commands, dataset
 from opensfm.test import data_generation, utils
 
 
-def run_command(command, args) -> None:
+def run_command(command: ModuleType, args: List[str]) -> None:
     parser = argparse.ArgumentParser()
     command.add_arguments(parser)
     parsed_args = parser.parse_args(args)
     command.run(dataset.DataSet(parsed_args.dataset), parsed_args)
 
 
+# pyre-fixme[2]: switch from tmpdir to tmp_path
 def test_run_all(tmpdir) -> None:
     data = data_generation.create_berlin_test_folder(tmpdir)
     run_all_commands = [
diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 83e829854..1a6b1acb9 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,10 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 
 from opensfm import features
 from opensfm.test import data_generation
 
 
+# pyre-fixme[2]: switch from tmpdir to tmp_path
 def test_dataset_load_features_sift(tmpdir) -> None:
     data = data_generation.create_berlin_test_folder(tmpdir)
 
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index ee4dc700c..dc86ddd00 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -1,8 +1,8 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 
 import random
-from typing import Tuple
+from typing import Dict, Optional, Tuple, Union
 
 import numpy as np
 import pytest
@@ -19,8 +19,8 @@
 
 def _create_reconstruction(
     n_cameras: int = 0,
-    n_shots_cam=None,
-    n_pano_shots_cam=None,
+    n_shots_cam: Optional[Dict[str, int]] = None,
+    n_pano_shots_cam: Optional[Dict[str, int]] = None,
     n_points: int = 0,
     dist_to_shots: bool = False,
     dist_to_pano_shots: bool = False,
@@ -146,7 +146,9 @@ def test_camera_iterators() -> None:
         assert cam is rec.cameras[cam.id]
 
 
-def _check_common_cam_properties(cam1, cam2) -> None:
+def _check_common_cam_properties(
+    cam1: pygeometry.Camera, cam2: pygeometry.Camera
+) -> None:
     assert cam1.id == cam2.id
     assert cam1.width == cam2.width
     assert cam1.height == cam2.height
@@ -327,7 +329,9 @@ def test_spherical_camera() -> None:
 
 
 # Test Metadata
-def _help_measurement_test(measurement, attr, val) -> None:
+def _help_measurement_test(
+    measurement: object, attr: str, val: Union[float, str]
+) -> None:
     # Test metadata's has_value properties
     assert getattr(measurement, attr).has_value is False
     getattr(measurement, attr).value = val
@@ -357,7 +361,7 @@ def test_shot_measurement_setter_and_getter() -> None:
     _help_measurement_test(m1, "sequence_key", "key_test")
 
 
-def _helper_populate_metadata(m) -> None:
+def _helper_populate_metadata(m: pymap.ShotMeasurements) -> None:
     m.capture_time.value = np.random.rand(1)
     m.gps_position.value = np.random.rand(3)
     m.gps_accuracy.value = np.random.rand(1)
diff --git a/opensfm/test/test_dense.py b/opensfm/test/test_dense.py
index a53b7aba6..316b0ed8e 100644
--- a/opensfm/test/test_dense.py
+++ b/opensfm/test/test_dense.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 from opensfm import dense, pygeometry, types
 
diff --git a/opensfm/test/test_geo.py b/opensfm/test/test_geo.py
index 41f431450..387e813bc 100644
--- a/opensfm/test/test_geo.py
+++ b/opensfm/test/test_geo.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 from opensfm import geo, pygeo
 
diff --git a/opensfm/test/test_geometry.py b/opensfm/test/test_geometry.py
index 4d5890198..18704c607 100644
--- a/opensfm/test/test_geometry.py
+++ b/opensfm/test/test_geometry.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 from opensfm import geometry
 
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 76feec6bf..30ce514c8 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -1,15 +1,16 @@
-# pyre-unsafe
+# pyre-strict
 import json
 import os.path
 from io import StringIO
+from typing import List
 
 import numpy as np
 
-from opensfm import io, pygeometry, types
+from opensfm import io, pygeometry, pymap, types
 from opensfm.test import data_generation, utils
 
 
-filename = os.path.join(
+filename: str = os.path.join(
     data_generation.DATA_PATH, "berlin", "reconstruction_example.json"
 )
 
@@ -131,7 +132,7 @@ def test_read_write_ground_control_points() -> None:
 }
     """
 
-    def check_points(points) -> None:
+    def check_points(points: List[pymap.GroundControlPoint]) -> None:
         assert len(points) == 2
         p1, p2 = points
         if p1.id != "1":
diff --git a/opensfm/test/test_matching.py b/opensfm/test/test_matching.py
index a2d9ce962..0936772f4 100644
--- a/opensfm/test/test_matching.py
+++ b/opensfm/test/test_matching.py
@@ -1,14 +1,18 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Any, Dict, List, Set, Tuple
 
 import numpy as np
-from opensfm import bow, config, matching, pairs_selection, pyfeatures
-from opensfm.synthetic_data import synthetic_dataset
+from numpy.typing import NDArray
+from opensfm import bow, config, matching, pairs_selection, pyfeatures, pygeometry
+from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
 
 def compute_words(
-    features: np.ndarray, bag_of_words, num_words, bow_matcher_type
-) -> np.ndarray:
+    features: NDArray,
+    bag_of_words: bow.BagOfWords,
+    num_words: int,
+    bow_matcher_type: str,
+) -> NDArray:
     closest_words = bag_of_words.map_to_words(features, num_words, bow_matcher_type)
     if closest_words is None:
         return np.array([], dtype=np.int32)
@@ -18,7 +22,7 @@ def compute_words(
 
 def example_features(
     nfeatures: int, config: Dict[str, Any]
-) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+) -> Tuple[List[NDArray], List[NDArray]]:
     words, frequencies = bow.load_bow_words_and_frequencies(config)
     bag_of_words = bow.BagOfWords(words, frequencies)
 
@@ -79,7 +83,7 @@ def test_unfilter_matches() -> None:
     assert res[1][1] == 6
 
 
-def test_match_images(scene_synthetic) -> None:
+def test_match_images(scene_synthetic: synthetic_scene.SyntheticInputData) -> None:
     reference = scene_synthetic.reconstruction
     synthetic = synthetic_dataset.SyntheticDataSet(
         reference,
@@ -136,7 +140,9 @@ def test_ordered_pairs() -> None:
     }
 
 
-def test_triangulation_inliers(pairs_and_their_E) -> None:
+def test_triangulation_inliers(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, f2, _, pose in pairs_and_their_E:
         Rt = pose.get_cam_to_world()[:3]
 
diff --git a/opensfm/test/test_multiview.py b/opensfm/test/test_multiview.py
index 81134b891..77dd7449f 100644
--- a/opensfm/test/test_multiview.py
+++ b/opensfm/test/test_multiview.py
@@ -1,11 +1,13 @@
-# pyre-unsafe
+# pyre-strict
 import copy
+from typing import List, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import multiview, pygeometry, transformations as tf
 
 
-def normalized(x: np.ndarray) -> np.ndarray:
+def normalized(x: NDArray) -> NDArray:
     return x / np.linalg.norm(x)
 
 
@@ -34,7 +36,9 @@ def test_motion_from_plane_homography() -> None:
     assert any(goodness)
 
 
-def test_essential_five_points(pairs_and_their_E) -> None:
+def test_essential_five_points(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     exact_found = 0
     for f1, f2, E, _ in pairs_and_their_E:
         result = pygeometry.essential_five_points(f1[0:5, :], f2[0:5, :])
@@ -52,7 +56,9 @@ def test_essential_five_points(pairs_and_their_E) -> None:
     assert exact_found >= exacts
 
 
-def test_absolute_pose_three_points(shots_and_their_points) -> None:
+def test_absolute_pose_three_points(
+    shots_and_their_points: List[Tuple[pygeometry.Pose, NDArray, NDArray]],
+) -> None:
     exact_found = 0
     for pose, bearings, points in shots_and_their_points:
         result = pygeometry.absolute_pose_three_points(bearings, points)
@@ -65,7 +71,9 @@ def test_absolute_pose_three_points(shots_and_their_points) -> None:
     assert exact_found >= exacts
 
 
-def test_absolute_pose_n_points(shots_and_their_points) -> None:
+def test_absolute_pose_n_points(
+    shots_and_their_points: List[Tuple[pygeometry.Pose, NDArray, NDArray]],
+) -> None:
     for pose, bearings, points in shots_and_their_points:
         result = pygeometry.absolute_pose_n_points(bearings, points)
 
@@ -73,7 +81,9 @@ def test_absolute_pose_n_points(shots_and_their_points) -> None:
         assert np.linalg.norm(expected - result, ord="fro") < 1e-5
 
 
-def test_absolute_pose_n_points_known_rotation(shots_and_their_points) -> None:
+def test_absolute_pose_n_points_known_rotation(
+    shots_and_their_points: List[Tuple[pygeometry.Pose, NDArray, NDArray]],
+) -> None:
     for pose, bearings, points in shots_and_their_points:
         R = pose.get_rotation_matrix()
         p_rotated = np.array([R.dot(p) for p in points])
@@ -82,7 +92,9 @@ def test_absolute_pose_n_points_known_rotation(shots_and_their_points) -> None:
         assert np.linalg.norm(pose.translation - result) < 1e-6
 
 
-def test_essential_n_points(pairs_and_their_E) -> None:
+def test_essential_n_points(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, NDArray]],
+) -> None:
     for f1, f2, E, _ in pairs_and_their_E:
         f1 /= np.linalg.norm(f1, axis=1)[:, None]
         f2 /= np.linalg.norm(f2, axis=1)[:, None]
@@ -97,7 +109,9 @@ def test_essential_n_points(pairs_and_their_E) -> None:
         assert np.linalg.norm(E - E_found, ord="fro") < 1e-6
 
 
-def test_relative_pose_from_essential(pairs_and_their_E) -> None:
+def test_relative_pose_from_essential(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, f2, E, pose in pairs_and_their_E:
         result = pygeometry.relative_pose_from_essential(E, f1, f2)
 
@@ -108,7 +122,9 @@ def test_relative_pose_from_essential(pairs_and_their_E) -> None:
         assert np.allclose(expected, result, rtol=1e-10)
 
 
-def test_relative_rotation(pairs_and_their_E) -> None:
+def test_relative_rotation(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, _, _, _ in pairs_and_their_E:
         vec_x = np.random.rand(3)
         vec_x /= np.linalg.norm(vec_x)
@@ -126,7 +142,9 @@ def test_relative_rotation(pairs_and_their_E) -> None:
         assert np.allclose(rotation, result, rtol=1e-10)
 
 
-def test_relative_pose_refinement(pairs_and_their_E) -> None:
+def test_relative_pose_refinement(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     exact_found = 0
     for f1, f2, _, pose in pairs_and_their_E:
         pose = copy.deepcopy(pose)
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index a91c4549e..6518b1385 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -1,7 +1,7 @@
-# pyre-unsafe
+# pyre-strict
 import argparse
 import os.path
-from typing import Any, Dict, Generator
+from typing import Any, Dict, Iterator
 
 import numpy as np
 import pytest
@@ -15,7 +15,7 @@
 
 
 @pytest.fixture(scope="module", autouse=True)
-def clear_cache() -> Generator[None, Any, Any]:
+def clear_cache() -> Iterator[None]:
     """
     Clear feature loader cache to avoid using cached
     masks etc from berlin dataset which has the same
@@ -27,6 +27,7 @@ def clear_cache() -> Generator[None, Any, Any]:
 
 
 @pytest.fixture(scope="module", autouse=True)
+# pyre-fixme[2]: switch from tmpdir to tmp_path
 def lund_path(tmpdir_factory) -> str:
     """
     Precompute exif and features to avoid doing
@@ -78,8 +79,8 @@ def match_candidates_from_metadata(
     assert count >= assert_count
 
 
-def create_match_candidates_config(**kwargs) -> Dict[str, Any]:
-    config = {
+def create_match_candidates_config(**kwargs: Any) -> Dict[str, Any]:
+    config: Dict[str, Any] = {
         "matcher_type": "BRUTEFORCE",
         "matching_gps_distance": 0,
         "matching_gps_neighbors": 0,
@@ -96,14 +97,14 @@ def create_match_candidates_config(**kwargs) -> Dict[str, Any]:
     return config
 
 
-def test_match_candidates_from_metadata_vlad(lund_path) -> None:
+def test_match_candidates_from_metadata_vlad(lund_path: str) -> None:
     config = create_match_candidates_config(matching_vlad_neighbors=NEIGHBORS)
     data_generation.save_config(config, lund_path)
     data = dataset.DataSet(lund_path)
     match_candidates_from_metadata(data, assert_count=5)
 
 
-def test_match_candidates_from_metadata_bow(lund_path) -> None:
+def test_match_candidates_from_metadata_bow(lund_path: str) -> None:
     config = create_match_candidates_config(
         matching_bow_neighbors=NEIGHBORS, matcher_type="WORDS"
     )
@@ -112,21 +113,21 @@ def test_match_candidates_from_metadata_bow(lund_path) -> None:
     match_candidates_from_metadata(data, assert_count=5)
 
 
-def test_match_candidates_from_metadata_gps(lund_path) -> None:
+def test_match_candidates_from_metadata_gps(lund_path: str) -> None:
     config = create_match_candidates_config(matching_gps_neighbors=NEIGHBORS)
     data_generation.save_config(config, lund_path)
     data = dataset.DataSet(lund_path)
     match_candidates_from_metadata(data)
 
 
-def test_match_candidates_from_metadata_time(lund_path) -> None:
+def test_match_candidates_from_metadata_time(lund_path: str) -> None:
     config = create_match_candidates_config(matching_time_neighbors=NEIGHBORS)
     data_generation.save_config(config, lund_path)
     data = dataset.DataSet(lund_path)
     match_candidates_from_metadata(data)
 
 
-def test_match_candidates_from_metadata_graph(lund_path) -> None:
+def test_match_candidates_from_metadata_graph(lund_path: str) -> None:
     config = create_match_candidates_config(matching_graph_rounds=50)
     data_generation.save_config(config, lund_path)
     data = dataset.DataSet(lund_path)
diff --git a/opensfm/test/test_reconstruction_alignment.py b/opensfm/test/test_reconstruction_alignment.py
index e68fdb7cd..008230ff5 100644
--- a/opensfm/test/test_reconstruction_alignment.py
+++ b/opensfm/test/test_reconstruction_alignment.py
@@ -1,15 +1,18 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pybundle, pygeometry
 
 
-def get_shot_origin(shot) -> np.ndarray:
+def get_shot_origin(shot: pybundle.RAShot) -> NDArray:
     """Compute the origin of a shot."""
-    pose = pygeometry.Pose([shot.rx, shot.ry, shot.rz], [shot.tx, shot.ty, shot.tz])
+    pose = pygeometry.Pose(
+        np.array([shot.rx, shot.ry, shot.rz]), np.array([shot.tx, shot.ty, shot.tz])
+    )
     return pose.get_origin()
 
 
-def get_reconstruction_origin(r) -> np.ndarray:
+def get_reconstruction_origin(r: pybundle.RAReconstruction) -> NDArray:
     """Compute the origin of a reconstruction."""
     s = r.scale
     pose = pygeometry.Pose(
diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index 1d3320e34..26320a3c1 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import reconstruction
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_reconstruction_resect.py b/opensfm/test/test_reconstruction_resect.py
index 06e40487f..ca6703768 100644
--- a/opensfm/test/test_reconstruction_resect.py
+++ b/opensfm/test/test_reconstruction_resect.py
@@ -1,7 +1,8 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import config, multiview, pymap, reconstruction, types
 
 
@@ -49,7 +50,10 @@ def test_corresponding_tracks() -> None:
 
 
 def copy_cluster_points(
-    cluster: types.Reconstruction, tracks_manager: pymap.TracksManager, points, noise
+    cluster: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+    points: pymap.LandmarkView,
+    noise: float,
 ) -> types.Reconstruction:
     for shot in cluster.shots:
         for point in tracks_manager.get_shot_observations(shot):
@@ -61,7 +65,10 @@ def copy_cluster_points(
 
 
 def split_synthetic_reconstruction(
-    scene, tracks_manager: pymap.TracksManager, cluster_size, point_noise
+    scene: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+    cluster_size: int,
+    point_noise: float,
 ) -> Tuple[types.Reconstruction, types.Reconstruction]:
     cluster1 = types.Reconstruction()
     cluster2 = types.Reconstruction()
@@ -80,7 +87,7 @@ def split_synthetic_reconstruction(
 
 def move_and_scale_cluster(
     cluster: types.Reconstruction,
-) -> Tuple[types.Reconstruction, np.ndarray, float]:
+) -> Tuple[types.Reconstruction, NDArray, float]:
     scale = np.random.rand(1)
     translation = np.random.rand(3)
     for point in cluster.points.values():
@@ -88,7 +95,9 @@ def move_and_scale_cluster(
     return cluster, translation, scale
 
 
-def test_absolute_pose_generalized_shot(scene_synthetic_cube) -> None:
+def test_absolute_pose_generalized_shot(
+    scene_synthetic_cube: Tuple[types.Reconstruction, pymap.TracksManager],
+) -> None:
     """Whole reconstruction resection (generalized pose) on a toy
     reconstruction with 0.01 meter point noise and zero outliers."""
     noise = 0.01
diff --git a/opensfm/test/test_reconstruction_shot_neighborhood.py b/opensfm/test/test_reconstruction_shot_neighborhood.py
index d0c0c810b..7af4dd8b2 100644
--- a/opensfm/test/test_reconstruction_shot_neighborhood.py
+++ b/opensfm/test/test_reconstruction_shot_neighborhood.py
@@ -1,13 +1,16 @@
-# pyre-unsafe
-import networkx as nx
+# pyre-strict
+from typing import List
+
 from opensfm import pygeometry, pymap, pysfm, reconstruction, types
 
 
-def _add_shot(rec, shot_id, cam) -> None:
+def _add_shot(rec: types.Reconstruction, shot_id: str, cam: pygeometry.Camera) -> None:
     rec.create_shot(shot_id, cam.id)
 
 
-def _add_point(rec, point_id, observations) -> None:
+def _add_point(
+    rec: types.Reconstruction, point_id: str, observations: List[str]
+) -> None:
     rec.create_point(point_id)
     for shot_id in observations:
         obs = pymap.Observation(100, 200, 0.5, 255, 0, 0, int(point_id))
diff --git a/opensfm/test/test_reconstruction_triangulation.py b/opensfm/test/test_reconstruction_triangulation.py
index 9f631872a..b41070072 100644
--- a/opensfm/test/test_reconstruction_triangulation.py
+++ b/opensfm/test/test_reconstruction_triangulation.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import reconstruction
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_rig.py b/opensfm/test/test_rig.py
index 08818b8de..3e41575b2 100644
--- a/opensfm/test/test_rig.py
+++ b/opensfm/test/test_rig.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 """Test the rig module."""
 
 import numpy as np
diff --git a/opensfm/test/test_robust.py b/opensfm/test/test_robust.py
index 9255cb663..6954febc3 100644
--- a/opensfm/test/test_robust.py
+++ b/opensfm/test/test_robust.py
@@ -1,19 +1,20 @@
-# pyre-unsafe
+# pyre-strict
 import copy
-from typing import Tuple
+from typing import List, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pygeometry, pyrobust
 
 
-def line_data() -> Tuple[int, int, np.ndarray, int]:
+def line_data() -> Tuple[int, int, NDArray, int]:
     a, b = 2, 3
     samples = 100
     x = np.linspace(0, 100, samples)
     return a, b, x, samples
 
 
-def similarity_data() -> Tuple[np.ndarray, np.ndarray, int, np.ndarray, int]:
+def similarity_data() -> Tuple[NDArray, NDArray, int, NDArray, int]:
     rotation = np.array([0.1, 0.2, 0.3])
     translation = np.array([4, 5, 6])
     scale = 2
@@ -23,7 +24,7 @@ def similarity_data() -> Tuple[np.ndarray, np.ndarray, int, np.ndarray, int]:
     return rotation, translation, scale, x, samples
 
 
-def add_outliers(ratio_outliers: float, x: np.ndarray, min: float, max: float) -> None:
+def add_outliers(ratio_outliers: float, x: NDArray, min: float, max: float) -> None:
     for index in np.random.permutation(len(x))[: int(ratio_outliers * len(x))]:
         shape = x[index].shape
         noise = np.random.uniform(min, max, size=shape)
@@ -186,7 +187,9 @@ def test_outliers_similarity_ransac() -> None:
     )
 
 
-def test_uniform_essential_ransac(pairs_and_their_E) -> None:
+def test_uniform_essential_ransac(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, f2, _, _ in pairs_and_their_E:
         points = np.concatenate((f1, f2), axis=1)
 
@@ -207,7 +210,9 @@ def test_uniform_essential_ransac(pairs_and_their_E) -> None:
         assert len(result.inliers_indices) == len(f1) == len(f2)
 
 
-def test_outliers_essential_ransac(pairs_and_their_E) -> None:
+def test_outliers_essential_ransac(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, f2, _, _ in pairs_and_their_E:
         points = np.concatenate((f1, f2), axis=1)
 
@@ -233,7 +238,9 @@ def test_outliers_essential_ransac(pairs_and_their_E) -> None:
         assert np.isclose(len(result.inliers_indices), inliers_count, rtol=tolerance)
 
 
-def test_outliers_relative_pose_ransac(pairs_and_their_E) -> None:
+def test_outliers_relative_pose_ransac(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, f2, _, pose in pairs_and_their_E:
         points = np.concatenate((f1, f2), axis=1)
 
@@ -265,7 +272,9 @@ def test_outliers_relative_pose_ransac(pairs_and_their_E) -> None:
     assert np.linalg.norm(expected - result.lo_model, ord="fro") < 16e-2
 
 
-def test_outliers_relative_rotation_ransac(pairs_and_their_E) -> None:
+def test_outliers_relative_rotation_ransac(
+    pairs_and_their_E: List[Tuple[NDArray, NDArray, NDArray, pygeometry.Pose]],
+) -> None:
     for f1, _, _, _ in pairs_and_their_E:
         vec_x = np.random.rand(3)
         vec_x /= np.linalg.norm(vec_x)
@@ -304,7 +313,9 @@ def test_outliers_relative_rotation_ransac(pairs_and_their_E) -> None:
         assert np.linalg.norm(rotation - result.lo_model, ord="fro") < 8e-2
 
 
-def test_outliers_absolute_pose_ransac(shots_and_their_points) -> None:
+def test_outliers_absolute_pose_ransac(
+    shots_and_their_points: List[Tuple[pygeometry.Pose, NDArray, NDArray]],
+) -> None:
     for pose, bearings, points in shots_and_their_points:
         scale = 1e-3
         bearings = copy.deepcopy(bearings)
@@ -329,7 +340,9 @@ def test_outliers_absolute_pose_ransac(shots_and_their_points) -> None:
         assert np.linalg.norm(expected - result.lo_model, ord="fro") < 8e-2
 
 
-def test_outliers_absolute_pose_known_rotation_ransac(shots_and_their_points) -> None:
+def test_outliers_absolute_pose_known_rotation_ransac(
+    shots_and_their_points: List[Tuple[pygeometry.Pose, NDArray, NDArray]],
+) -> None:
     for pose, bearings, points in shots_and_their_points:
         scale = 1e-3
         bearings = copy.deepcopy(bearings)
diff --git a/opensfm/test/test_stats.py b/opensfm/test/test_stats.py
index 15067bc3f..c7d6416dd 100644
--- a/opensfm/test/test_stats.py
+++ b/opensfm/test/test_stats.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import stats, types
 from opensfm.synthetic_data import synthetic_dataset, synthetic_scene
 
diff --git a/opensfm/test/test_triangulation.py b/opensfm/test/test_triangulation.py
index 01c82810b..b812afddf 100644
--- a/opensfm/test/test_triangulation.py
+++ b/opensfm/test/test_triangulation.py
@@ -1,5 +1,6 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
+from numpy.typing import ArrayLike, NDArray
 from opensfm import io, pygeometry, pymap, reconstruction
 
 
@@ -101,8 +102,7 @@ def test_track_triangulator_coincident_camera_origins() -> None:
     assert not rec.points
 
 
-def unit_vector(x: object) -> np.ndarray:
-    # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
+def unit_vector(x: ArrayLike) -> NDArray:
     return np.array(x) / np.linalg.norm(x)
 
 
diff --git a/opensfm/test/test_types.py b/opensfm/test/test_types.py
index 8e04e66cd..39073a17b 100644
--- a/opensfm/test/test_types.py
+++ b/opensfm/test/test_types.py
@@ -1,9 +1,10 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 import sys
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import pygeometry, pymap, types
 from scipy.stats import special_ortho_group
 
@@ -82,7 +83,7 @@ def test_shot_measurement() -> None:
     assert m.value == 4
 
 
-def _helper_pose_equal_to_T(pose, T_cw) -> None:
+def _helper_pose_equal_to_T(pose: pygeometry.Pose, T_cw: NDArray) -> None:
     assert np.allclose(pose.get_R_world_to_cam(), T_cw[0:3, 0:3])
     assert np.allclose(pose.get_t_world_to_cam(), T_cw[0:3, 3].reshape(3))
     assert np.allclose(pose.translation, T_cw[0:3, 3].reshape(3))
@@ -99,14 +100,16 @@ def _helper_pose_equal_to_T(pose, T_cw) -> None:
     assert np.allclose(pose.get_Rt(), T_cw[0:3, 0:4])
 
 
-def _helper_poses_equal_py_cpp(py_pose, cpp_pose) -> None:
+def _helper_poses_equal_py_cpp(
+    py_pose: pygeometry.Pose, cpp_pose: pygeometry.Pose
+) -> None:
     assert np.allclose(py_pose.translation, cpp_pose.translation)
     assert np.allclose(py_pose.rotation, cpp_pose.rotation)
     assert np.allclose(py_pose.get_rotation_matrix(), cpp_pose.get_rotation_matrix())
     assert np.allclose(py_pose.get_origin(), cpp_pose.get_origin())
 
 
-def _heper_poses_equal(pose1, pose2) -> None:
+def _heper_poses_equal(pose1: pygeometry.Pose, pose2: pygeometry.Pose) -> None:
     assert np.allclose(pose1.translation, pose2.translation)
     assert np.allclose(pose1.rotation, pose2.rotation)
     assert np.allclose(pose1.get_rotation_matrix(), pose2.get_rotation_matrix())
diff --git a/opensfm/test/test_undistort.py b/opensfm/test/test_undistort.py
index c71714fd7..38b389925 100644
--- a/opensfm/test/test_undistort.py
+++ b/opensfm/test/test_undistort.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import itertools
 
 import numpy as np
diff --git a/opensfm/test/test_vlad.py b/opensfm/test/test_vlad.py
index dee12fa08..843a02421 100644
--- a/opensfm/test/test_vlad.py
+++ b/opensfm/test/test_vlad.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 import pytest
 from opensfm import vlad
diff --git a/opensfm/test/utils.py b/opensfm/test/utils.py
index 562bbd1fe..a668f07c7 100644
--- a/opensfm/test/utils.py
+++ b/opensfm/test/utils.py
@@ -1,6 +1,6 @@
 # Test utils for python
 
-# pyre-unsafe
+# pyre-strict
 import numpy as np
 from opensfm import pygeo, pygeometry, pymap
 

From 9b5be94612ef768dd5bc6a575c144158f4ebcd92 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 146/235] more type annotations

Reviewed By: DodgySpaniard

Differential Revision: D76518683

fbshipit-source-id: bc5173cdbc54fa5c49d6266ac000d9ad7fd786c3
---
 bin/opensfm_main.py                   |   2 +-
 opensfm/__init__.py                   |   2 +-
 opensfm/dataset.py                    |   4 +-
 opensfm/dense.py                      | 110 +++++++++++++++++---------
 opensfm/feature_loader.py             |   2 +-
 opensfm/geometry.py                   |  29 +++----
 opensfm/geotag_from_gpx.py            |   2 +-
 opensfm/log.py                        |   2 +-
 opensfm/masking.py                    |  27 +++----
 opensfm/reconstruction_helpers.py     |  15 ++--
 opensfm/src/dense/depthmap_bind.h     |  16 ++--
 opensfm/src/dense/pydense.pyi         |  77 +++++++++++++-----
 opensfm/src/foundation/python_types.h |   2 -
 opensfm/test/test_dense.py            |  12 +--
 opensfm/undistort.py                  |  25 +++---
 opensfm/unionfind.py                  |  19 +++--
 opensfm/upright.py                    |   7 +-
 opensfm/video.py                      |  15 ++--
 18 files changed, 223 insertions(+), 145 deletions(-)

diff --git a/bin/opensfm_main.py b/bin/opensfm_main.py
index 7709b7491..b91abcf9c 100755
--- a/bin/opensfm_main.py
+++ b/bin/opensfm_main.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import sys
 from os.path import abspath, dirname, join
 
diff --git a/opensfm/__init__.py b/opensfm/__init__.py
index 80f3e9871..71f43364a 100644
--- a/opensfm/__init__.py
+++ b/opensfm/__init__.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import (
     pybundle,
     pydense,
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 8ef8fd2d7..529fa31d3 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -886,7 +886,7 @@ def save_raw_depthmap(
         plane: NDArray,
         score: NDArray,
         nghbr: NDArray,
-        nghbrs: NDArray,
+        nghbrs: List[str],
     ) -> None:
         self.io_handler.mkdir_p(self._depthmap_path())
         filepath = self.depthmap_file(image, "raw.npz")
@@ -897,7 +897,7 @@ def save_raw_depthmap(
 
     def load_raw_depthmap(
         self, image: str
-    ) -> Tuple[NDArray, NDArray, NDArray, NDArray, NDArray]:
+    ) -> Tuple[NDArray, NDArray, NDArray, NDArray, List[str]]:
         with self.io_handler.open_rb(self.depthmap_file(image, "raw.npz")) as f:
             o = np.load(f)
             return o["depth"], o["plane"], o["score"], o["nghbr"], o["nghbrs"]
diff --git a/opensfm/dense.py b/opensfm/dense.py
index 11ab78440..9f4042cb4 100644
--- a/opensfm/dense.py
+++ b/opensfm/dense.py
@@ -1,21 +1,22 @@
-# pyre-unsafe
+# pyre-strict
 import logging
-import typing as t
+from typing import Any, Callable, Dict, Iterable, List, Tuple, Union
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import io, log, pydense, pymap, tracking, types
 from opensfm.context import parallel_map
 from opensfm.dataset import UndistortedDataSet
 
-logger = logging.getLogger(__name__)
+logger: logging.Logger = logging.getLogger(__name__)
 
 
 def compute_depthmaps(
     data: UndistortedDataSet,
     graph: pymap.TracksManager,
     reconstruction: types.Reconstruction,
-):
+) -> None:
     """Compute and refine depthmaps for all shots.
 
     Args:
@@ -61,7 +62,9 @@ def compute_depthmaps(
     data.save_point_cloud(*point_cloud, filename="merged.ply")
 
 
-def compute_depthmap_catched(arguments):
+def compute_depthmap_catched(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], float, float, pymap.Shot],
+) -> None:
     try:
         compute_depthmap(arguments)
     except Exception as e:
@@ -69,7 +72,9 @@ def compute_depthmap_catched(arguments):
         logger.exception(e)
 
 
-def clean_depthmap_catched(arguments):
+def clean_depthmap_catched(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], pymap.Shot],
+) -> None:
     try:
         clean_depthmap(arguments)
     except Exception as e:
@@ -77,7 +82,9 @@ def clean_depthmap_catched(arguments):
         logger.exception(e)
 
 
-def prune_depthmap_catched(arguments):
+def prune_depthmap_catched(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], pymap.Shot],
+) -> None:
     try:
         prune_depthmap(arguments)
     except Exception as e:
@@ -85,15 +92,17 @@ def prune_depthmap_catched(arguments):
         logger.exception(e)
 
 
-def compute_depthmap(arguments):
+def compute_depthmap(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], float, float, pymap.Shot],
+) -> None:
     """Compute depthmap for a single shot."""
     log.setup()
 
     data: UndistortedDataSet = arguments[0]
-    neighbors = arguments[1]
-    min_depth = arguments[2]
-    max_depth = arguments[3]
-    shot = arguments[4]
+    neighbors: List[pymap.Shot] = arguments[1]
+    min_depth: float = arguments[2]
+    max_depth: float = arguments[3]
+    shot: pymap.Shot = arguments[4]
 
     method = data.config["depthmap_method"]
 
@@ -128,6 +137,7 @@ def compute_depthmap(arguments):
     neighbor_ids = [i.id for i in neighbors[1:]]
     data.save_raw_depthmap(shot.id, depth, plane, score, nghbr, neighbor_ids)
 
+    image = None
     if data.config["depthmap_save_debug_files"]:
         image = data.load_undistorted_image(shot.id)
         image = scale_down_image(image, depth.shape[1], depth.shape[0])
@@ -140,8 +150,9 @@ def compute_depthmap(arguments):
 
         plt.figure()
         plt.suptitle("Shot: " + shot.id + ", neighbors: " + ", ".join(neighbor_ids))
-        plt.subplot(2, 3, 1)
-        plt.imshow(image)
+        if image is not None:
+            plt.subplot(2, 3, 1)
+            plt.imshow(image)
         plt.subplot(2, 3, 2)
         plt.imshow(color_plane_normals(plane))
         plt.subplot(2, 3, 3)
@@ -156,7 +167,9 @@ def compute_depthmap(arguments):
         plt.show()
 
 
-def clean_depthmap(arguments):
+def clean_depthmap(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], pymap.Shot],
+) -> None:
     """Clean depthmap by checking consistency with neighbors."""
     log.setup()
 
@@ -200,7 +213,9 @@ def clean_depthmap(arguments):
         plt.show()
 
 
-def prune_depthmap(arguments):
+def prune_depthmap(
+    arguments: Tuple[UndistortedDataSet, List[pymap.Shot], pymap.Shot],
+) -> None:
     """Prune depthmap to remove redundant points."""
     log.setup()
 
@@ -225,7 +240,10 @@ def prune_depthmap(arguments):
         data.save_point_cloud(points, normals, colors, labels, "pruned.npz.ply")
 
 
-def aggregate_depthmaps(shot_ids, depthmap_provider):
+def aggregate_depthmaps(
+    shot_ids: Iterable[str],
+    depthmap_provider: Callable[[str], Tuple[NDArray, NDArray, NDArray, NDArray]],
+) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
     """Aggregate depthmaps by concatenation."""
 
     points = []
@@ -249,19 +267,20 @@ def aggregate_depthmaps(shot_ids, depthmap_provider):
 
 def merge_depthmaps(
     data: UndistortedDataSet, reconstruction: types.Reconstruction
-) -> t.Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
     """Merge depthmaps into a single point cloud."""
     shot_ids = [s for s in reconstruction.shots if data.pruned_depthmap_exists(s)]
 
-    def depthmap_provider(shot_id):
+    def depthmap_provider(shot_id: str) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
         return data.load_pruned_depthmap(shot_id)
 
     return merge_depthmaps_from_provider(shot_ids, depthmap_provider)
 
 
 def merge_depthmaps_from_provider(
-    shot_ids: t.Iterable[str], depthmap_provider: t.Callable
-) -> t.Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    shot_ids: Iterable[str],
+    depthmap_provider: Callable[[str], Tuple[NDArray, NDArray, NDArray, NDArray]],
+) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
     """Merge depthmaps into a single point cloud."""
     logger.info("Merging depthmaps")
 
@@ -272,7 +291,9 @@ def merge_depthmaps_from_provider(
     return aggregate_depthmaps(shot_ids, depthmap_provider)
 
 
-def add_views_to_depth_estimator(data: UndistortedDataSet, neighbors, de):
+def add_views_to_depth_estimator(
+    data: UndistortedDataSet, neighbors: List[pymap.Shot], de: pydense.DepthmapEstimator
+) -> None:
     """Add neighboring views to the DepthmapEstimator."""
     num_neighbors = data.config["depthmap_num_matching_views"]
     for shot in neighbors[: num_neighbors + 1]:
@@ -291,7 +312,9 @@ def add_views_to_depth_estimator(data: UndistortedDataSet, neighbors, de):
         de.add_view(K, R, t, image, mask)
 
 
-def add_views_to_depth_cleaner(data: UndistortedDataSet, neighbors, dc):
+def add_views_to_depth_cleaner(
+    data: UndistortedDataSet, neighbors: List[pymap.Shot], dc: pydense.DepthmapCleaner
+) -> None:
     for shot in neighbors:
         if not data.raw_depthmap_exists(shot.id):
             continue
@@ -303,7 +326,7 @@ def add_views_to_depth_cleaner(data: UndistortedDataSet, neighbors, dc):
         dc.add_view(K, R, t, depth)
 
 
-def load_combined_mask(data: UndistortedDataSet, shot):
+def load_combined_mask(data: UndistortedDataSet, shot: pymap.Shot) -> NDArray:
     """Load the undistorted mask.
 
     If no mask exists return an array of ones.
@@ -316,7 +339,7 @@ def load_combined_mask(data: UndistortedDataSet, shot):
         return mask
 
 
-def load_segmentation_labels(data: UndistortedDataSet, shot):
+def load_segmentation_labels(data: UndistortedDataSet, shot: pymap.Shot) -> NDArray:
     """Load the undistorted segmentation labels.
 
     If no segmentation exists return an array of zeros.
@@ -328,7 +351,9 @@ def load_segmentation_labels(data: UndistortedDataSet, shot):
         return np.zeros(size, dtype=np.uint8)
 
 
-def add_views_to_depth_pruner(data: UndistortedDataSet, neighbors, dp):
+def add_views_to_depth_pruner(
+    data: UndistortedDataSet, neighbors: List[pymap.Shot], dp: pydense.DepthmapPruner
+) -> None:
     for shot in neighbors:
         if not data.clean_depthmap_exists(shot.id):
             continue
@@ -345,7 +370,12 @@ def add_views_to_depth_pruner(data: UndistortedDataSet, neighbors, dp):
         dp.add_view(K, R, t, depth, plane, image, labels)
 
 
-def compute_depth_range(tracks_manager, reconstruction, shot, config):
+def compute_depth_range(
+    tracks_manager: pymap.TracksManager,
+    reconstruction: types.Reconstruction,
+    shot: pymap.Shot,
+    config: Dict[str, Any],
+) -> Tuple[float, float]:
     """Compute min and max depth based on reconstruction points."""
     depths = []
     for track in tracks_manager.get_shot_observations(shot.id):
@@ -364,7 +394,7 @@ def compute_depth_range(tracks_manager, reconstruction, shot, config):
 
 def common_tracks_double_dict(
     tracks_manager: pymap.TracksManager,
-) -> t.Dict[str, t.Dict[str, t.List[str]]]:
+) -> Dict[str, Dict[str, List[str]]]:
     """List of track ids observed by each image pair.
 
     Return a dict, ``res``, such that ``res[im1][im2]`` is the list of
@@ -380,10 +410,10 @@ def common_tracks_double_dict(
 
 def find_neighboring_images(
     shot: pymap.Shot,
-    common_tracks: t.Dict[str, t.Dict[str, t.List[str]]],
+    common_tracks: Dict[str, Dict[str, List[str]]],
     reconstruction: types.Reconstruction,
     num_neighbors: int,
-):
+) -> List[pymap.Shot]:
     """Find neighboring images based on common tracks."""
     theta_min = np.pi / 60
     theta_max = np.pi / 6
@@ -408,7 +438,11 @@ def find_neighboring_images(
     return [shot] + [n for n, s in ns[:num_neighbors]]
 
 
-def angle_between_points(origin, p1, p2):
+def angle_between_points(
+    origin: Union[NDArray, List[float]],
+    p1: Union[NDArray, List[float]],
+    p2: Union[NDArray, List[float]],
+) -> float:
     a0 = p1[0] - origin[0]
     a1 = p1[1] - origin[1]
     a2 = p1[2] - origin[2]
@@ -421,28 +455,26 @@ def angle_between_points(origin, p1, p2):
     return np.arccos(dot / np.sqrt(la * lb))
 
 
-def distance_between_shots(shot, other):
+def distance_between_shots(shot: pymap.Shot, other: pymap.Shot) -> float:
     o1 = shot.pose.get_origin()
     o2 = other.pose.get_origin()
     d = o2 - o1
     return np.sqrt(np.sum(d**2))
 
 
-def scale_image(
-    image: np.ndarray, width: int, height: int, interpolation: int
-) -> np.ndarray:
+def scale_image(image: NDArray, width: int, height: int, interpolation: int) -> NDArray:
     return cv2.resize(image, (width, height), interpolation=interpolation)
 
 
 def scale_down_image(
-    image: np.ndarray, width: int, height: int, interpolation=cv2.INTER_AREA
-) -> np.ndarray:
+    image: NDArray, width: int, height: int, interpolation: int = cv2.INTER_AREA
+) -> NDArray:
     width = min(width, image.shape[1])
     height = min(height, image.shape[0])
     return scale_image(image, width, height, interpolation)
 
 
-def depthmap_to_ply(shot, depth, image):
+def depthmap_to_ply(shot: pymap.Shot, depth: NDArray, image: NDArray) -> str:
     """Export depthmap points as a PLY string"""
     height, width = depth.shape
     K = shot.camera.get_K_in_pixel_coordinates(width, height)
@@ -462,7 +494,7 @@ def depthmap_to_ply(shot, depth, image):
     return io.points_to_ply_string(vertices)
 
 
-def color_plane_normals(plane):
+def color_plane_normals(plane: NDArray) -> NDArray:
     norm = np.linalg.norm(plane, axis=2)
     normal = plane / norm[..., np.newaxis]
     normal[..., 1] *= -1  # Reverse Y because it points down
diff --git a/opensfm/feature_loader.py b/opensfm/feature_loader.py
index d9a3ad086..79d2d0949 100644
--- a/opensfm/feature_loader.py
+++ b/opensfm/feature_loader.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from opensfm import feature_loading
 
 
diff --git a/opensfm/geometry.py b/opensfm/geometry.py
index 43cd52a12..8daf50750 100644
--- a/opensfm/geometry.py
+++ b/opensfm/geometry.py
@@ -1,16 +1,17 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import transformations
 
 
-def rotation_from_angle_axis(angle_axis: np.ndarray) -> np.ndarray:
+def rotation_from_angle_axis(angle_axis: NDArray) -> NDArray:
     return cv2.Rodrigues(np.asarray(angle_axis))[0]
 
 
-def rotation_from_ptr(pan: float, tilt: float, roll: float) -> np.ndarray:
+def rotation_from_ptr(pan: float, tilt: float, roll: float) -> NDArray:
     """World-to-camera rotation matrix from pan, tilt and roll."""
     R1 = rotation_from_angle_axis(np.array([0.0, 0.0, roll]))
     R2 = rotation_from_angle_axis(np.array([tilt + np.pi / 2, 0.0, 0.0]))
@@ -19,7 +20,7 @@ def rotation_from_ptr(pan: float, tilt: float, roll: float) -> np.ndarray:
 
 
 def ptr_from_rotation(
-    rotation_matrix: np.ndarray,
+    rotation_matrix: NDArray,
 ) -> Tuple[float, float, float]:
     """Pan tilt and roll from camera rotation matrix"""
     pan = pan_from_rotation(rotation_matrix)
@@ -28,18 +29,18 @@ def ptr_from_rotation(
     return pan, tilt, roll
 
 
-def pan_from_rotation(rotation_matrix: np.ndarray) -> float:
+def pan_from_rotation(rotation_matrix: NDArray) -> float:
     Rt_ez = np.dot(rotation_matrix.T, [0, 0, 1])
     return np.arctan2(Rt_ez[0], Rt_ez[1])
 
 
-def tilt_from_rotation(rotation_matrix: np.ndarray) -> float:
+def tilt_from_rotation(rotation_matrix: NDArray) -> float:
     Rt_ez = np.dot(rotation_matrix.T, [0, 0, 1])
     l = np.linalg.norm(Rt_ez[:2])
     return np.arctan2(-Rt_ez[2], l)
 
 
-def roll_from_rotation(rotation_matrix: np.ndarray) -> float:
+def roll_from_rotation(rotation_matrix: NDArray) -> float:
     Rt_ex = np.dot(rotation_matrix.T, [1, 0, 0])
     Rt_ez = np.dot(rotation_matrix.T, [0, 0, 1])
     a = np.cross(Rt_ez, [0, 0, 1])
@@ -48,7 +49,7 @@ def roll_from_rotation(rotation_matrix: np.ndarray) -> float:
     return np.arcsin(np.dot(Rt_ez, b))
 
 
-def rotation_from_ptr_v2(pan: float, tilt: float, roll: float) -> np.ndarray:
+def rotation_from_ptr_v2(pan: float, tilt: float, roll: float) -> NDArray:
     """Camera rotation matrix from pan, tilt and roll.
 
     This is the implementation used in the Single Image Calibration code.
@@ -57,7 +58,7 @@ def rotation_from_ptr_v2(pan: float, tilt: float, roll: float) -> np.ndarray:
     return transformations.euler_matrix(pan, tilt, roll, "szxz")[:3, :3]
 
 
-def ptr_from_rotation_v2(rotation_matrix: np.ndarray) -> Tuple[float, float, float]:
+def ptr_from_rotation_v2(rotation_matrix: NDArray) -> Tuple[float, float, float]:
     """Pan tilt and roll from camera rotation matrix.
 
     This is the implementation used in the Single Image Calibration code.
@@ -68,7 +69,7 @@ def ptr_from_rotation_v2(rotation_matrix: np.ndarray) -> Tuple[float, float, flo
     return pan, tilt - np.pi / 2, roll
 
 
-def rotation_from_opk(omega: float, phi: float, kappa: float) -> np.ndarray:
+def rotation_from_opk(omega: float, phi: float, kappa: float) -> NDArray:
     """World-to-camera rotation matrix from pan, tilt and roll."""
 
     # Omega (ω), the rotation around the Χ axis. (East)
@@ -87,7 +88,7 @@ def rotation_from_opk(omega: float, phi: float, kappa: float) -> np.ndarray:
 
 
 def opk_from_rotation(
-    rotation_matrix: np.ndarray,
+    rotation_matrix: NDArray,
 ) -> Tuple[float, float, float]:
     """Omega, phi, kappa from camera rotation matrix"""
     Rc = np.array([[1, 0, 0], [0, -1, 0], [0, 0, -1]])
@@ -98,13 +99,13 @@ def opk_from_rotation(
     return omega, phi, kappa
 
 
-def omega_from_rotation(rotation_matrix: np.ndarray) -> float:
+def omega_from_rotation(rotation_matrix: NDArray) -> float:
     return np.arctan2(-rotation_matrix[1, 2], rotation_matrix[2, 2])
 
 
-def phi_from_rotation(rotation_matrix: np.ndarray) -> float:
+def phi_from_rotation(rotation_matrix: NDArray) -> float:
     return np.arcsin(rotation_matrix[0, 2])
 
 
-def kappa_from_rotation(rotation_matrix: np.ndarray) -> float:
+def kappa_from_rotation(rotation_matrix: NDArray) -> float:
     return np.arctan2(-rotation_matrix[0, 1], rotation_matrix[0, 0])
diff --git a/opensfm/geotag_from_gpx.py b/opensfm/geotag_from_gpx.py
index 3e0632ad6..a69ab62f2 100644
--- a/opensfm/geotag_from_gpx.py
+++ b/opensfm/geotag_from_gpx.py
@@ -59,7 +59,7 @@ def utc_to_localtime(utc_time):
     return utc_time - utc_offset_timedelta
 
 
-def get_lat_lon_time(gpx_file, gpx_time: str = "utc"):
+def get_lat_lon_time(gpx_file: str, gpx_time: str = "utc"):
     """
     Read location and time stamps from a track in a GPX file.
 
diff --git a/opensfm/log.py b/opensfm/log.py
index ecca50c12..6ee33c3dc 100644
--- a/opensfm/log.py
+++ b/opensfm/log.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import os
 from typing import Optional
diff --git a/opensfm/masking.py b/opensfm/masking.py
index d33d4dcf4..8fc98f43f 100644
--- a/opensfm/masking.py
+++ b/opensfm/masking.py
@@ -1,18 +1,17 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 from typing import List, Optional, Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import upright
 from opensfm.dataset_base import DataSetBase
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def mask_from_segmentation(
-    segmentation: np.ndarray, ignore_values: List[int]
-) -> np.ndarray:
+def mask_from_segmentation(segmentation: NDArray, ignore_values: List[int]) -> NDArray:
     """Binary mask that is 0 for pixels with segmentation value to ignore."""
     mask = np.ones(segmentation.shape, dtype=np.uint8)
     for value in ignore_values:
@@ -21,8 +20,8 @@ def mask_from_segmentation(
 
 
 def combine_masks(
-    mask1: Optional[np.ndarray], mask2: Optional[np.ndarray]
-) -> Optional[np.ndarray]:
+    mask1: Optional[NDArray], mask2: Optional[NDArray]
+) -> Optional[NDArray]:
     """Combine two masks as mask1 AND mask2.
 
     Ignore any missing mask argument.
@@ -41,9 +40,9 @@ def combine_masks(
 
 
 def _resize_masks_to_match(
-    im1: np.ndarray,
-    im2: np.ndarray,
-) -> Tuple[np.ndarray, np.ndarray]:
+    im1: NDArray,
+    im2: NDArray,
+) -> Tuple[NDArray, NDArray]:
     h, w = max(im1.shape, im2.shape)
     if im1.shape != (h, w):
         im1 = cv2.resize(im1, (w, h), interpolation=cv2.INTER_NEAREST)
@@ -55,9 +54,9 @@ def _resize_masks_to_match(
 def load_features_mask(
     data: DataSetBase,
     image: str,
-    points: np.ndarray,
-    mask_image: Optional[np.ndarray] = None,
-) -> np.ndarray:
+    points: NDArray,
+    mask_image: Optional[NDArray] = None,
+) -> NDArray:
     """Load a feature-wise mask.
 
     This is a binary array true for features that lie inside the
@@ -99,7 +98,7 @@ def load_features_mask(
     return np.array(mask, dtype=bool)
 
 
-def _load_segmentation_mask(data: DataSetBase, image: str) -> Optional[np.ndarray]:
+def _load_segmentation_mask(data: DataSetBase, image: str) -> Optional[NDArray]:
     """Build a mask from segmentation ignore values.
 
     The mask is non-zero only for pixels with segmentation
@@ -116,7 +115,7 @@ def _load_segmentation_mask(data: DataSetBase, image: str) -> Optional[np.ndarra
     return mask_from_segmentation(segmentation, ignore_values)
 
 
-def _load_combined_mask(data: DataSetBase, image: str) -> Optional[np.ndarray]:
+def _load_combined_mask(data: DataSetBase, image: str) -> Optional[NDArray]:
     """Combine binary mask with segmentation mask.
 
     Return a mask that is non-zero only where the binary
diff --git a/opensfm/reconstruction_helpers.py b/opensfm/reconstruction_helpers.py
index 48aa4663b..292612bea 100644
--- a/opensfm/reconstruction_helpers.py
+++ b/opensfm/reconstruction_helpers.py
@@ -1,9 +1,10 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import math
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, Optional
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import exif as oexif, geometry, multiview, pygeometry, pymap, rig, types
 from opensfm.dataset_base import DataSetBase
 
@@ -11,7 +12,7 @@
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def guess_gravity_up_from_orientation_tag(orientation: int) -> np.ndarray:
+def guess_gravity_up_from_orientation_tag(orientation: int) -> NDArray:
     """Guess upward vector in camera coordinates given the orientation tag.
 
     Assumes camera is looking towards the horizon and horizon is horizontal
@@ -37,7 +38,7 @@ def guess_gravity_up_from_orientation_tag(orientation: int) -> np.ndarray:
     raise RuntimeError(f"Error: Unknown orientation tag: {orientation}")
 
 
-def shot_gravity_up_in_image_axis(shot: pymap.Shot) -> Optional[np.ndarray]:
+def shot_gravity_up_in_image_axis(shot: pymap.Shot) -> Optional[NDArray]:
     """Get or guess shot's gravity up direction."""
     if shot.metadata.gravity_down.has_value:
         return -shot.metadata.gravity_down.value
@@ -54,14 +55,14 @@ def shot_gravity_up_in_image_axis(shot: pymap.Shot) -> Optional[np.ndarray]:
     return guess_gravity_up_from_orientation_tag(orientation)
 
 
-def rotation_from_shot_metadata(shot: pymap.Shot) -> Optional[np.ndarray]:
+def rotation_from_shot_metadata(shot: pymap.Shot) -> Optional[NDArray]:
     rotation = rotation_from_angles(shot)
     if rotation is None:
         rotation = rotation_from_orientation_compass(shot)
     return rotation
 
 
-def rotation_from_orientation_compass(shot: pymap.Shot) -> Optional[np.ndarray]:
+def rotation_from_orientation_compass(shot: pymap.Shot) -> Optional[NDArray]:
     up_vector = shot_gravity_up_in_image_axis(shot)
     if up_vector is None:
         return None
@@ -72,7 +73,7 @@ def rotation_from_orientation_compass(shot: pymap.Shot) -> Optional[np.ndarray]:
     return multiview.rotation_matrix_from_up_vector_and_compass(list(up_vector), angle)
 
 
-def rotation_from_angles(shot: pymap.Shot) -> Optional[np.ndarray]:
+def rotation_from_angles(shot: pymap.Shot) -> Optional[NDArray]:
     if not shot.metadata.opk_angles.has_value:
         return None
     opk_degrees = shot.metadata.opk_angles.value
diff --git a/opensfm/src/dense/depthmap_bind.h b/opensfm/src/dense/depthmap_bind.h
index dc7e12ad1..83dfca782 100644
--- a/opensfm/src/dense/depthmap_bind.h
+++ b/opensfm/src/dense/depthmap_bind.h
@@ -29,7 +29,7 @@ class DepthmapEstimatorWrapper {
 
   void SetMinPatchSD(float sd) { de_.SetMinPatchSD(sd); }
 
-  py::object ComputePatchMatch() {
+  py::list ComputePatchMatch() {
     DepthmapEstimatorResult result;
     {
       py::gil_scoped_release release;
@@ -38,7 +38,7 @@ class DepthmapEstimatorWrapper {
     return ComputeReturnValues(result);
   }
 
-  py::object ComputePatchMatchSample() {
+  py::list ComputePatchMatchSample() {
     DepthmapEstimatorResult result;
     {
       py::gil_scoped_release release;
@@ -47,7 +47,7 @@ class DepthmapEstimatorWrapper {
     return ComputeReturnValues(result);
   }
 
-  py::object ComputeBruteForce() {
+  py::list ComputeBruteForce() {
     DepthmapEstimatorResult result;
     {
       py::gil_scoped_release release;
@@ -56,7 +56,7 @@ class DepthmapEstimatorWrapper {
     return ComputeReturnValues(result);
   }
 
-  py::object ComputeReturnValues(const DepthmapEstimatorResult& result) {
+  py::list ComputeReturnValues(const DepthmapEstimatorResult& result) {
     py::list retn;
     retn.append(foundation::py_array_from_data(
         result.depth.ptr<float>(0), result.depth.rows, result.depth.cols));
@@ -66,7 +66,7 @@ class DepthmapEstimatorWrapper {
         result.score.ptr<float>(0), result.score.rows, result.score.cols));
     retn.append(foundation::py_array_from_data(
         result.nghbr.ptr<int>(0), result.nghbr.rows, result.nghbr.cols));
-    return std::move(retn);
+    return retn;
   }
 
  private:
@@ -86,7 +86,7 @@ class DepthmapCleanerWrapper {
                 depth.shape(0));
   }
 
-  py::object Clean() {
+  foundation::pyarray_f Clean() {
     cv::Mat depth;
     {
       py::gil_scoped_release release;
@@ -126,7 +126,7 @@ class DepthmapPrunerWrapper {
                 color.data(), label.data(), depth.shape(1), depth.shape(0));
   }
 
-  py::object Prune() {
+  py::list Prune() {
     std::vector<float> points;
     std::vector<float> normals;
     std::vector<unsigned char> colors;
@@ -143,7 +143,7 @@ class DepthmapPrunerWrapper {
     retn.append(foundation::py_array_from_data(normals.data(), n, 3));
     retn.append(foundation::py_array_from_data(colors.data(), n, 3));
     retn.append(foundation::py_array_from_data(labels.data(), n));
-    return std::move(retn);
+    return retn;
   }
 
  private:
diff --git a/opensfm/src/dense/pydense.pyi b/opensfm/src/dense/pydense.pyi
index 498f19bf2..5f37f9447 100644
--- a/opensfm/src/dense/pydense.pyi
+++ b/opensfm/src/dense/pydense.pyi
@@ -7,41 +7,82 @@
 # Tip: Be sure to run this with the build mode you use for your project, e.g.,
 # @//arvr/mode/linux/opt (or dev) in arvr.
 #
-# Ignore errors for [5] global variable types and [24] untyped generics.
-# pyre-ignore-all-errors[5,24]
+# Ignore errors for [24] untyped generics.
+# pyre-ignore-all-errors[24]
 
 import numpy
 from typing import *
-__all__  = [
-"DepthmapCleaner",
-"DepthmapEstimator",
-"DepthmapPruner",
-"OpenMVSExporter"
+
+__all__ = [
+    "DepthmapCleaner",
+    "DepthmapEstimator",
+    "DepthmapPruner",
+    "OpenMVSExporter",
+    "StaticExtensionLoader",
 ]
+
 class DepthmapCleaner:
     def __init__(self) -> None: ...
-    def add_view(self, arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: numpy.ndarray) -> None: ...
-    def clean(self) -> object: ...
+    def add_view(
+        self,
+        arg0: numpy.typing.NDArray,
+        arg1: numpy.typing.NDArray,
+        arg2: numpy.typing.NDArray,
+        arg3: numpy.typing.NDArray,
+    ) -> None: ...
+    def clean(self) -> numpy.typing.NDArray: ...
     def set_min_consistent_views(self, arg0: int) -> None: ...
     def set_same_depth_threshold(self, arg0: float) -> None: ...
+
 class DepthmapEstimator:
     def __init__(self) -> None: ...
-    def add_view(self, arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: numpy.ndarray, arg4: numpy.ndarray) -> None: ...
-    def compute_brute_force(self) -> object: ...
-    def compute_patch_match(self) -> object: ...
-    def compute_patch_match_sample(self) -> object: ...
+    def add_view(
+        self,
+        arg0: numpy.typing.NDArray,
+        arg1: numpy.typing.NDArray,
+        arg2: numpy.typing.NDArray,
+        arg3: numpy.typing.NDArray,
+        arg4: numpy.typing.NDArray,
+    ) -> None: ...
+    def compute_brute_force(self) -> list: ...
+    def compute_patch_match(self) -> list: ...
+    def compute_patch_match_sample(self) -> list: ...
     def set_depth_range(self, arg0: float, arg1: float, arg2: int) -> None: ...
     def set_min_patch_sd(self, arg0: float) -> None: ...
     def set_patch_size(self, arg0: int) -> None: ...
     def set_patchmatch_iterations(self, arg0: int) -> None: ...
+
 class DepthmapPruner:
     def __init__(self) -> None: ...
-    def add_view(self, arg0: numpy.ndarray, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: numpy.ndarray, arg4: numpy.ndarray, arg5: numpy.ndarray, arg6: numpy.ndarray) -> None: ...
-    def prune(self) -> object: ...
+    def add_view(
+        self,
+        arg0: numpy.typing.NDArray,
+        arg1: numpy.typing.NDArray,
+        arg2: numpy.typing.NDArray,
+        arg3: numpy.typing.NDArray,
+        arg4: numpy.typing.NDArray,
+        arg5: numpy.typing.NDArray,
+        arg6: numpy.typing.NDArray,
+    ) -> None: ...
+    def prune(self) -> list: ...
     def set_same_depth_threshold(self, arg0: float) -> None: ...
+
 class OpenMVSExporter:
     def __init__(self) -> None: ...
-    def add_camera(self, arg0: str, arg1: numpy.ndarray, arg2: int, arg3: int) -> None: ...
-    def add_point(self, arg0: numpy.ndarray, arg1: list) -> None: ...
-    def add_shot(self, arg0: str, arg1: str, arg2: str, arg3: str, arg4: numpy.ndarray, arg5: numpy.ndarray) -> None: ...
+    def add_camera(
+        self, arg0: str, arg1: numpy.typing.NDArray, arg2: int, arg3: int
+    ) -> None: ...
+    def add_point(self, arg0: numpy.typing.NDArray, arg1: list) -> None: ...
+    def add_shot(
+        self,
+        arg0: str,
+        arg1: str,
+        arg2: str,
+        arg3: str,
+        arg4: numpy.typing.NDArray,
+        arg5: numpy.typing.NDArray,
+    ) -> None: ...
     def export(self, arg0: str) -> None: ...
+
+class StaticExtensionLoader:
+    pass
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index cf03413a0..d70949082 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -2,8 +2,6 @@
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
-#include <cstdint>
-#include <iostream>
 #include <vector>
 
 #include "opencv2/core/core.hpp"
diff --git a/opensfm/test/test_dense.py b/opensfm/test/test_dense.py
index 316b0ed8e..cc3f95858 100644
--- a/opensfm/test/test_dense.py
+++ b/opensfm/test/test_dense.py
@@ -4,17 +4,17 @@
 
 
 def test_angle_between_points() -> None:
-    origin = [0, 0, 0]
-    p1 = [1, 0, 0]
-    p2 = [0, 1, 0]
+    origin = [0.0, 0.0, 0.0]
+    p1 = [1.0, 0.0, 0.0]
+    p2 = [0.0, 1.0, 0.0]
 
     res = dense.angle_between_points(origin, p1, p2)
 
     assert np.allclose(res, np.pi / 2)
 
-    origin = [10, 15, 20]
-    p1 = [10, 16, 20]
-    p2 = [10, 16, 21]
+    origin = [10.0, 15.0, 20.0]
+    p1 = [10.0, 16.0, 20.0]
+    p2 = [10.0, 16.0, 21.0]
 
     res = dense.angle_between_points(origin, p1, p2)
 
diff --git a/opensfm/undistort.py b/opensfm/undistort.py
index 8c3e0fe68..bf983f7ff 100644
--- a/opensfm/undistort.py
+++ b/opensfm/undistort.py
@@ -1,10 +1,11 @@
-# pyre-unsafe
+# pyre-strict
 import itertools
 import logging
-from typing import Dict, Iterator, List, Optional
+from typing import Dict, Iterator, List, Optional, Tuple
 
 import cv2
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import (
     features,
     features_processing,
@@ -124,7 +125,9 @@ def undistort_reconstruction_with_images(
     return undistorted_shots
 
 
-def undistort_image_and_masks(arguments) -> None:
+def undistort_image_and_masks(
+    arguments: Tuple[pymap.Shot, List[pymap.Shot], DataSetBase, UndistortedDataSet],
+) -> None:
     shot, undistorted_shots, data, udata = arguments
     log.setup()
     logger.debug("Undistorting image {}".format(shot.id))
@@ -161,10 +164,10 @@ def undistort_image_and_masks(arguments) -> None:
 def undistort_image(
     shot: pymap.Shot,
     undistorted_shots: List[pymap.Shot],
-    original: Optional[np.ndarray],
-    interpolation,
+    original: Optional[NDArray],
+    interpolation: int,
     max_size: int,
-) -> Dict[str, np.ndarray]:
+) -> Dict[str, NDArray]:
     """Undistort an image into a set of undistorted ones.
 
     Args:
@@ -216,7 +219,7 @@ def undistort_image(
         )
 
 
-def scale_image(image: np.ndarray, max_size: int) -> np.ndarray:
+def scale_image(image: NDArray, max_size: int) -> NDArray:
     """Scale an image not to exceed max_size."""
     height, width = image.shape[:2]
     factor = max_size / float(max(height, width))
@@ -353,12 +356,12 @@ def perspective_views_of_a_panorama(
 
 
 def render_perspective_view_of_a_panorama(
-    image: np.ndarray,
+    image: NDArray,
     panoshot: pymap.Shot,
     perspectiveshot: pymap.Shot,
-    interpolation=cv2.INTER_LINEAR,
-    borderMode=cv2.BORDER_WRAP,
-) -> np.ndarray:
+    interpolation: int = cv2.INTER_LINEAR,
+    borderMode: int = cv2.BORDER_WRAP,
+) -> NDArray:
     """Render a perspective view of a panorama."""
     # Get destination pixel coordinates
     dst_shape = (perspectiveshot.camera.height, perspectiveshot.camera.width)
diff --git a/opensfm/unionfind.py b/opensfm/unionfind.py
index aca3e8951..abbcab63c 100644
--- a/opensfm/unionfind.py
+++ b/opensfm/unionfind.py
@@ -1,7 +1,10 @@
 # Source: https://www.ics.uci.edu/~eppstein/PADS/UnionFind.py
 # Licence: MIT
 
-# pyre-unsafe
+# pyre-strict
+from typing import Dict, Generic, Hashable, Iterator, TypeVar
+
+T = TypeVar("T", bound=Hashable)
 
 
 # This is PADS, a library of Python Algorithms and Data Structures
@@ -44,7 +47,7 @@
 """
 
 
-class UnionFind:
+class UnionFind(Generic[T]):
     """Union-find data structure.
 
     Each unionFind instance X maintains a family of disjoint sets of
@@ -61,12 +64,12 @@ class UnionFind:
       in X, it is added to X as one of the members of the merged set.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Create a new empty union-find structure."""
-        self.weights = {}
-        self.parents = {}
+        self.weights: Dict[T, int] = {}
+        self.parents: Dict[T, T] = {}
 
-    def __getitem__(self, object):
+    def __getitem__(self, object: T) -> T:
         """Find and return the name of the set containing the object."""
 
         # check for previously unknown object
@@ -87,11 +90,11 @@ def __getitem__(self, object):
             self.parents[ancestor] = root
         return root
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[T]:
         """Iterate through all items ever found or unioned by this structure."""
         return iter(self.parents)
 
-    def union(self, *objects):
+    def union(self, *objects: T) -> None:
         """Find the sets containing the objects and merge them all."""
         roots = [self[x] for x in objects]
         heaviest = max((self.weights[r], r) for r in roots)[1]
diff --git a/opensfm/upright.py b/opensfm/upright.py
index 31ee383cd..9fbc5518f 100644
--- a/opensfm/upright.py
+++ b/opensfm/upright.py
@@ -1,17 +1,18 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Optional
 
 import numpy as np
+from numpy.typing import NDArray
 
 
 def opensfm_to_upright(
-    coords: np.ndarray,
+    coords: NDArray,
     width: int,
     height: int,
     orientation: int,
     new_width: Optional[int] = None,
     new_height: Optional[int] = None,
-) -> np.ndarray:
+) -> NDArray:
     """
     Transform opensfm coordinates to upright coordinates, correcting for EXIF orientation.
 
diff --git a/opensfm/video.py b/opensfm/video.py
index 8dc855ad2..45028b6e3 100644
--- a/opensfm/video.py
+++ b/opensfm/video.py
@@ -1,15 +1,15 @@
-# pyre-unsafe
+# pyre-strict
 import datetime
 import os
 from subprocess import PIPE, Popen
-from typing import List
+from typing import List, Optional
 
 import cv2
 import dateutil.parser
 from opensfm import context, geotag_from_gpx, io
 
 
-def video_orientation(video_file) -> int:
+def video_orientation(video_file: str) -> int:
     # Rotation
     # pyre-fixme[16]: Optional type has no attribute `read`.
     rotation = Popen(
@@ -33,14 +33,13 @@ def video_orientation(video_file) -> int:
 
 
 def import_video_with_gpx(
-    video_file,
-    gpx_file,
+    video_file: str,
+    gpx_file: str,
     output_path: str,
     dx: float,
-    dt=None,
-    start_time=None,
+    dt: Optional[float] = None,
+    start_time: Optional[str] = None,
     visual: bool = False,
-    image_description=None,
 ) -> List[str]:
     points = geotag_from_gpx.get_lat_lon_time(gpx_file)
 

From c581cc1974946dfab18fb52569ceef420e75e549 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Sun, 15 Jun 2025 12:06:55 -0700
Subject: [PATCH 147/235] annotate synthetic data

Reviewed By: DodgySpaniard

Differential Revision: D76518688

fbshipit-source-id: 66e8d3ea147b5a500d2e7f51e0a1f1bb61cf21db
---
 opensfm/synthetic_data/synthetic_dataset.py   | 31 +++++----
 opensfm/synthetic_data/synthetic_examples.py  |  2 +-
 opensfm/synthetic_data/synthetic_generator.py | 65 ++++++++++---------
 opensfm/synthetic_data/synthetic_metrics.py   | 21 +++---
 opensfm/synthetic_data/synthetic_scene.py     | 37 ++++++-----
 5 files changed, 79 insertions(+), 77 deletions(-)

diff --git a/opensfm/synthetic_data/synthetic_dataset.py b/opensfm/synthetic_data/synthetic_dataset.py
index bff82e6a9..b78e71178 100644
--- a/opensfm/synthetic_data/synthetic_dataset.py
+++ b/opensfm/synthetic_data/synthetic_dataset.py
@@ -1,11 +1,12 @@
-# pyre-unsafe
+# pyre-strict
 import collections
 import logging
 import os
 import shelve
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+from typing import Any, Dict, Iterator, List, MutableMapping, Optional, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import features as oft, geo, io, pygeometry, pymap, tracking, types
 from opensfm.dataset import DataSet
 
@@ -13,7 +14,7 @@
 
 
 class SyntheticFeatures(collections.abc.MutableMapping):
-    database: Union[Dict[str, oft.FeaturesData], shelve.Shelf]
+    database: MutableMapping[str, oft.FeaturesData]
 
     def __init__(self, on_disk_filename: Optional[str]) -> None:
         if on_disk_filename:
@@ -28,16 +29,16 @@ def sync(self) -> None:
         database = self.database
         if type(database) is dict:
             return
-        else:
+        elif type(database) is shelve.Shelf:
             database.sync()
 
-    def __getitem__(self, key) -> oft.FeaturesData:
+    def __getitem__(self, key: str) -> oft.FeaturesData:
         return self.database.__getitem__(key)
 
-    def __setitem__(self, key, item) -> None:
+    def __setitem__(self, key: str, item: oft.FeaturesData) -> None:
         return self.database.__setitem__(key, item)
 
-    def __delitem__(self, key) -> None:
+    def __delitem__(self, key: str) -> None:
         return self.database.__delitem__(key)
 
     def __iter__(self) -> Iterator[str]:
@@ -73,16 +74,16 @@ def __init__(
         self.gcps = gcps
         self.features = features
         self.tracks_manager = tracks_manager
-        self.image_list = list(reconstruction.shots.keys())
+        self.image_list: List[str] = list(reconstruction.shots.keys())
         self.reference = reconstruction.reference
-        self.matches = None
+        self.matches: Optional[Dict[str, Dict[str, NDArray]]] = None
         self.config["use_altitude_tag"] = True
         self.config["align_method"] = "naive"
 
     def images(self) -> List[str]:
         return self.image_list
 
-    def _raise_if_absent_image(self, image: str):
+    def _raise_if_absent_image(self, image: str) -> None:
         if image not in self.image_list:
             raise RuntimeError("Image isn't present in the synthetic dataset")
 
@@ -121,10 +122,8 @@ def features_exist(self, image: str) -> bool:
             return False
         return image in feat
 
-    def load_words(self, image: str):
-        self._raise_if_absent_image(image)
-        n_closest = 50
-        return [image] * n_closest
+    def load_words(self, image: str) -> NDArray:
+        raise NotImplementedError
 
     def load_features(self, image: str) -> Optional[oft.FeaturesData]:
         self._raise_if_absent_image(image)
@@ -146,7 +145,7 @@ def matches_exists(self, image: str) -> bool:
             return False
         return True
 
-    def load_matches(self, image: str) -> Dict[str, np.ndarray]:
+    def load_matches(self, image: str) -> Dict[str, NDArray]:
         self._raise_if_absent_image(image)
         self._check_and_create_matches()
         if self.matches is not None:
@@ -161,7 +160,7 @@ def _check_and_create_matches(self) -> None:
         if self.matches is None:
             self.matches = self._construct_matches()
 
-    def _construct_matches(self) -> Dict[str, Any]:
+    def _construct_matches(self) -> Dict[str, Dict[str, NDArray]]:
         matches = {}
         tracks_manager = self.load_tracks_manager()
         for im1 in self.images():
diff --git a/opensfm/synthetic_data/synthetic_examples.py b/opensfm/synthetic_data/synthetic_examples.py
index 2632854b5..129399cf5 100644
--- a/opensfm/synthetic_data/synthetic_examples.py
+++ b/opensfm/synthetic_data/synthetic_examples.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 from typing import Optional
 
 import opensfm.synthetic_data.synthetic_scene as ss
diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index f856af382..b0d72bd61 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import logging
 import math
 import time
@@ -10,6 +10,7 @@
 import opensfm.synthetic_data.synthetic_dataset as sd
 import scipy.signal as signal
 import scipy.spatial as spatial
+from numpy.typing import NDArray
 from opensfm import (
     features as oft,
     geo,
@@ -25,20 +26,20 @@
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-def derivative(func: Callable, x: np.ndarray) -> np.ndarray:
+def derivative(func: Callable[[float], NDArray], x: float) -> NDArray:
     eps = 1e-10
     d = (func(x + eps) - func(x)) / eps
     d /= np.linalg.norm(d)
     return d
 
 
-def samples_generator_random_count(count: int) -> np.ndarray:
+def samples_generator_random_count(count: int) -> NDArray:
     return np.random.rand(count)
 
 
 def samples_generator_interval(
     length: float, end: float, interval: float, interval_noise: float
-) -> np.ndarray:
+) -> NDArray:
     samples = np.linspace(0, end / length, num=int(end / interval))
     samples += np.random.normal(
         0.0, float(interval_noise) / float(length), samples.shape
@@ -47,8 +48,8 @@ def samples_generator_interval(
 
 
 def generate_samples_and_local_frame(
-    samples: np.ndarray, shape: Callable
-) -> Tuple[np.ndarray, np.ndarray]:
+    samples: NDArray, shape: Callable[[float], NDArray]
+) -> Tuple[NDArray, NDArray]:
     points = []
     tangents = []
     for i in samples:
@@ -61,8 +62,8 @@ def generate_samples_and_local_frame(
 
 
 def generate_samples_shifted(
-    samples: np.ndarray, shape: Callable, shift: float
-) -> np.ndarray:
+    samples: NDArray, shape: Callable[[float], NDArray], shift: float
+) -> NDArray:
     plane_points = []
     for i in samples:
         point = shape(i)
@@ -74,8 +75,8 @@ def generate_samples_shifted(
 
 
 def generate_z_plane(
-    samples: np.ndarray, shape: Callable, thickness: float
-) -> np.ndarray:
+    samples: NDArray, shape: Callable[[float], NDArray], thickness: float
+) -> NDArray:
     plane_points = []
     for i in samples:
         point = shape(i)
@@ -89,8 +90,8 @@ def generate_z_plane(
 
 
 def generate_xy_planes(
-    samples: np.ndarray, shape: Callable, z_size: float, y_size: float
-) -> np.ndarray:
+    samples: NDArray, shape: Callable[[float], NDArray], z_size: float, y_size: float
+) -> NDArray:
     xy1 = generate_samples_shifted(samples, shape, y_size)
     xy2 = generate_samples_shifted(samples, shape, -y_size)
     xy1 = np.insert(xy1, 2, values=np.random.rand(xy1.shape[0]) * z_size, axis=1)
@@ -99,16 +100,16 @@ def generate_xy_planes(
 
 
 def generate_street(
-    samples: np.ndarray, shape: Callable, height: float, width: float
-) -> Tuple[np.ndarray, np.ndarray]:
+    samples: NDArray, shape: Callable[[float], NDArray], height: float, width: float
+) -> Tuple[NDArray, NDArray]:
     walls = generate_xy_planes(samples, shape, height, width)
     floor = generate_z_plane(samples, shape, width)
     return walls, floor
 
 
 def generate_cameras(
-    samples: np.ndarray, shape: Callable, height: float
-) -> Tuple[np.ndarray, np.ndarray]:
+    samples: NDArray, shape: Callable[[float], NDArray], height: float
+) -> Tuple[NDArray, NDArray]:
     positions, rotations = generate_samples_and_local_frame(samples, shape)
     positions = np.insert(positions, 2, values=height, axis=1)
     rotations = np.insert(rotations, 2, values=0, axis=2)
@@ -117,8 +118,8 @@ def generate_cameras(
 
 
 def line_generator(
-    length: float, center_x: float, center_y: float, transpose: bool, point: np.ndarray
-) -> np.ndarray:
+    length: float, center_x: float, center_y: float, transpose: bool, point: float
+) -> NDArray:
     x = point * length
     if transpose:
         return np.transpose(
@@ -133,13 +134,13 @@ def line_generator(
         return np.transpose(np.array([x + center_x, center_y]))
 
 
-def ellipse_generator(x_size: float, y_size: float, point: float) -> np.ndarray:
+def ellipse_generator(x_size: float, y_size: float, point: float) -> NDArray:
     y = np.sin(point * 2 * np.pi) * y_size / 2
     x = np.cos(point * 2 * np.pi) * x_size / 2
     return np.transpose(np.array([x, y]))
 
 
-def perturb_points(points: np.ndarray, sigmas: List[float]) -> None:
+def perturb_points(points: NDArray, sigmas: List[float]) -> None:
     eps = 1e-10
     gaussian = np.array([max(s, eps) for s in sigmas])
     for point in points:
@@ -148,7 +149,7 @@ def perturb_points(points: np.ndarray, sigmas: List[float]) -> None:
 
 def generate_causal_noise(
     dimensions: int, sigma: float, n: int, scale: float
-) -> List[np.ndarray]:
+) -> List[NDArray]:
     dims = [np.arange(-scale, scale) for _ in range(dimensions)]
     mesh = np.meshgrid(*dims)
     dist = np.linalg.norm(mesh, axis=0)
@@ -254,7 +255,7 @@ def _gps_dop(shot: pymap.Shot) -> float:
     return exifs
 
 
-def perturb_rotations(rotations: np.ndarray, angle_sigma: float) -> None:
+def perturb_rotations(rotations: NDArray, angle_sigma: float) -> None:
     for i in range(len(rotations)):
         rotation = rotations[i]
         rodrigues = cv2.Rodrigues(rotation)[0].ravel()
@@ -265,7 +266,7 @@ def perturb_rotations(rotations: np.ndarray, angle_sigma: float) -> None:
 
 
 def add_points_to_reconstruction(
-    points: np.ndarray, color: np.ndarray, reconstruction: types.Reconstruction
+    points: NDArray, color: NDArray, reconstruction: types.Reconstruction
 ) -> None:
     shift = len(reconstruction.points)
     for i in range(points.shape[0]):
@@ -275,8 +276,8 @@ def add_points_to_reconstruction(
 
 def add_shots_to_reconstruction(
     shots: List[List[str]],
-    positions: List[np.ndarray],
-    rotations: List[np.ndarray],
+    positions: List[NDArray],
+    rotations: List[NDArray],
     rig_cameras: List[pymap.RigCamera],
     cameras: List[pygeometry.Camera],
     reconstruction: types.Reconstruction,
@@ -308,13 +309,13 @@ def add_shots_to_reconstruction(
 
 
 def create_reconstruction(
-    points: List[np.ndarray],
-    colors: List[np.ndarray],
+    points: List[NDArray],
+    colors: List[NDArray],
     cameras: List[List[pygeometry.Camera]],
     shot_ids: List[List[str]],
     rig_shots: List[List[List[Tuple[str, str]]]],
-    rig_positions: List[np.ndarray],
-    rig_rotations: List[np.ndarray],
+    rig_positions: List[NDArray],
+    rig_rotations: List[NDArray],
     rig_cameras: List[List[pymap.RigCamera]],
     reference: Optional[geo.TopocentricConverter],
 ) -> Reconstruction:
@@ -355,7 +356,7 @@ def generate_track_data(
     projection_noise: float,
     gcp_noise: Tuple[float, float],
     gcps_count: Optional[int],
-    gcp_shift: Optional[np.ndarray],
+    gcp_shift: Optional[NDArray],
     on_disk_features_filename: Optional[str],
 ) -> Tuple[
     sd.SyntheticFeatures, pymap.TracksManager, Dict[str, pymap.GroundControlPoint]
@@ -490,7 +491,7 @@ def generate_track_data(
     return features, tracks_manager, gcps
 
 
-def _is_in_front(point: np.ndarray, center: np.ndarray, z_axis: np.ndarray) -> bool:
+def _is_in_front(point: NDArray, center: NDArray, z_axis: NDArray) -> bool:
     return (
         (point[0] - center[0]) * z_axis[0]
         + (point[1] - center[1]) * z_axis[1]
@@ -498,7 +499,7 @@ def _is_in_front(point: np.ndarray, center: np.ndarray, z_axis: np.ndarray) -> b
     ) > 0
 
 
-def _is_inside_camera(projection: np.ndarray, camera: pygeometry.Camera) -> bool:
+def _is_inside_camera(projection: NDArray, camera: pygeometry.Camera) -> bool:
     w, h = float(camera.width), float(camera.height)
     w2 = float(2 * camera.width)
     h2 = float(2 * camera.height)
diff --git a/opensfm/synthetic_data/synthetic_metrics.py b/opensfm/synthetic_data/synthetic_metrics.py
index 675297b81..f405404ab 100644
--- a/opensfm/synthetic_data/synthetic_metrics.py
+++ b/opensfm/synthetic_data/synthetic_metrics.py
@@ -1,16 +1,17 @@
-# pyre-unsafe
+# pyre-strict
 import copy
 from typing import Dict, List, Tuple
 
 import cv2
 import numpy as np
 import opensfm.transformations as tf
+from numpy.typing import NDArray
 from opensfm import align, geo, multiview, pymap, types
 
 
 def points_errors(
     reference: types.Reconstruction, candidate: types.Reconstruction
-) -> np.ndarray:
+) -> NDArray:
     common_points = set(reference.points.keys()).intersection(
         set(candidate.points.keys())
     )
@@ -32,7 +33,7 @@ def completeness_errors(
     )
 
 
-def gps_errors(candidate: types.Reconstruction) -> np.ndarray:
+def gps_errors(candidate: types.Reconstruction) -> NDArray:
     errors = []
     for shot in candidate.shots.values():
         bias = candidate.biases[shot.camera.id]
@@ -44,7 +45,7 @@ def gps_errors(candidate: types.Reconstruction) -> np.ndarray:
 
 def gcp_errors(
     candidate: types.Reconstruction, gcps: Dict[str, pymap.GroundControlPoint]
-) -> np.ndarray:
+) -> NDArray:
     errors = []
     for gcp in gcps.values():
         if not gcp.lla:
@@ -61,7 +62,7 @@ def gcp_errors(
 
 def position_errors(
     reference: types.Reconstruction, candidate: types.Reconstruction
-) -> np.ndarray:
+) -> NDArray:
     common_shots = set(reference.shots.keys()).intersection(set(candidate.shots.keys()))
     errors = []
     for s in common_shots:
@@ -73,7 +74,7 @@ def position_errors(
 
 def rotation_errors(
     reference: types.Reconstruction, candidate: types.Reconstruction
-) -> np.ndarray:
+) -> NDArray:
     common_shots = set(reference.shots.keys()).intersection(set(candidate.shots.keys()))
     errors = []
     for s in common_shots:
@@ -87,8 +88,8 @@ def rotation_errors(
 
 
 def find_alignment(
-    points0: List[np.ndarray], points1: List[np.ndarray]
-) -> Tuple[float, np.ndarray, np.ndarray]:
+    points0: List[NDArray], points1: List[NDArray]
+) -> Tuple[float, NDArray, NDArray]:
     """Compute similarity transform between point sets.
 
     Returns (s, A, b) such that ``points1 = s * A * points0 + b``
@@ -156,9 +157,9 @@ def change_geo_reference(
     return aligned
 
 
-def rmse(errors: np.ndarray) -> float:
+def rmse(errors: NDArray) -> float:
     return np.sqrt(np.mean(errors**2))
 
 
-def mad(errors: np.ndarray) -> float:
+def mad(errors: NDArray) -> float:
     return np.median(np.absolute(errors - np.median(errors)))
diff --git a/opensfm/synthetic_data/synthetic_scene.py b/opensfm/synthetic_data/synthetic_scene.py
index f3a7e5466..fd9846284 100644
--- a/opensfm/synthetic_data/synthetic_scene.py
+++ b/opensfm/synthetic_data/synthetic_scene.py
@@ -1,4 +1,4 @@
-# pyre-unsafe
+# pyre-strict
 import functools
 import math
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
@@ -7,6 +7,7 @@
 import opensfm.synthetic_data.synthetic_dataset as sd
 import opensfm.synthetic_data.synthetic_generator as sg
 import opensfm.synthetic_data.synthetic_metrics as sm
+from numpy.typing import NDArray
 from opensfm import geo, pygeometry, pymap, types
 from opensfm.reconstruction_helpers import exif_to_metadata
 
@@ -31,7 +32,9 @@ def get_camera(
     return camera
 
 
-def get_scene_generator(type: str, length: float, **kwargs) -> functools.partial:
+def get_scene_generator(
+    type: str, length: float, **kwargs: Any
+) -> Callable[[float], NDArray]:
     generator = None
     if type == "circle":
         generator = functools.partial(sg.ellipse_generator, length, length)
@@ -51,9 +54,7 @@ def get_scene_generator(type: str, length: float, **kwargs) -> functools.partial
     return generator
 
 
-def camera_pose(
-    position: np.ndarray, lookat: np.ndarray, up: np.ndarray
-) -> pygeometry.Pose:
+def camera_pose(position: NDArray, lookat: NDArray, up: NDArray) -> pygeometry.Pose:
     """
     Pose from position and look at direction
 
@@ -65,7 +66,7 @@ def camera_pose(
     True
     """
 
-    def normalized(x: np.ndarray) -> np.ndarray:
+    def normalized(x: NDArray) -> NDArray:
         return x / np.linalg.norm(x)
 
     ez = normalized(np.array(lookat) - np.array(position))
@@ -87,7 +88,7 @@ class SyntheticCubeScene(SyntheticScene):
 
     def __init__(self, num_cameras: int, num_points: int, noise: float) -> None:
         self.reconstruction = types.Reconstruction()
-        self.cameras = {}
+        self.cameras: Dict[str, pygeometry.Camera] = {}
         for i in range(num_cameras):
             camera = camera = pygeometry.Camera.create_perspective(0.9, -0.1, 0.01)
             camera.id = "camera%04d" % i
@@ -147,30 +148,30 @@ class SyntheticStreetScene(SyntheticScene):
     the shape.
     """
 
-    generator: Optional[Callable]
-    wall_points: Optional[np.ndarray]
-    floor_points: Optional[np.ndarray]
+    generator: Optional[Callable[[float], NDArray]]
+    wall_points: Optional[NDArray]
+    floor_points: Optional[NDArray]
     shot_ids: List[List[str]]
     cameras: List[List[pygeometry.Camera]]
-    instances_positions: List[np.ndarray]
-    instances_rotations: List[np.ndarray]
+    instances_positions: List[NDArray]
+    instances_rotations: List[NDArray]
     rig_instances: List[List[List[Tuple[str, str]]]]
     rig_cameras: List[List[pymap.RigCamera]]
     width: float
 
     def __init__(
         self,
-        generator: Optional[Callable],
+        generator: Optional[Callable[[float], NDArray]],
         reference: Optional[geo.TopocentricConverter] = None,
     ) -> None:
         self.generator = generator
         self.reference = reference
-        self.wall_points = None
-        self.floor_points = None
+        self.wall_points: Optional[NDArray] = None
+        self.floor_points: Optional[NDArray] = None
         self.shot_ids = []
         self.cameras = []
-        self.instances_positions = []
-        self.instances_rotations = []
+        self.instances_positions: List[NDArray] = []
+        self.instances_rotations: List[NDArray] = []
         self.rig_instances = []
         self.rig_cameras = []
         self.width = 0.0
@@ -440,7 +441,7 @@ def __init__(
         gcp_noise: Tuple[float, float],
         causal_gps_noise: bool,
         gcps_count: Optional[int] = None,
-        gcps_shift: Optional[np.ndarray] = None,
+        gcps_shift: Optional[NDArray] = None,
         on_disk_features_filename: Optional[str] = None,
         generate_projections: bool = True,
     ) -> None:

From 7bfd35d11aee3b48f9927af5542b841570d65fb5 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Tue, 17 Jun 2025 09:43:34 -0700
Subject: [PATCH 148/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm/opensfm/src/sfm/python

Reviewed By: dtolnay

Differential Revision: D76796830

fbshipit-source-id: f83e7274e19ce8cd4be4bbd9a82cfea440326e1e
---
 opensfm/src/sfm/python/pybind.cc | 2 --
 1 file changed, 2 deletions(-)

diff --git a/opensfm/src/sfm/python/pybind.cc b/opensfm/src/sfm/python/pybind.cc
index 77466e1dd..55e66686c 100644
--- a/opensfm/src/sfm/python/pybind.cc
+++ b/opensfm/src/sfm/python/pybind.cc
@@ -8,8 +8,6 @@
 #include <sfm/retriangulation.h>
 #include <sfm/tracks_helpers.h>
 
-#include <optional>
-
 PYBIND11_MODULE(pysfm, m) {
   py::module::import("opensfm.pymap");
   py::module::import("opensfm.pygeometry");

From b7150fe18c391066d0b031e7fe5003597498c66d Mon Sep 17 00:00:00 2001
From: Emmanuel Ferdman <emmanuelferdman@gmail.com>
Date: Wed, 25 Jun 2025 01:53:37 -0700
Subject: [PATCH 149/235] fix: correct logger warnings (#1095)

Summary:
## PR Summary
This small PR migrates from the deprecated `logger.warn` to the recommended `logger.warning` method to solve:
```python
/tmp/opensfm/opensfm/pairs_selection.py:610: DeprecationWarning: The 'warn' function is deprecated, use 'warning' instead
```

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1095

Reviewed By: DodgySpaniard

Differential Revision: D77231687

Pulled By: fabianschenk

fbshipit-source-id: 167a0287dbba76f757eff275fc84362a4698a5f0
---
 opensfm/pairs_selection.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 27bef216a..054f1cfa9 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -610,7 +610,7 @@ def match_candidates_from_metadata(
 
     if not all(map(has_gps_info, exifs.values())):
         if gps_neighbors != 0:
-            logger.warn(
+            logger.warning(
                 "Not all images have GPS info. " "Disabling matching_gps_neighbors."
             )
         gps_neighbors = 0

From 752e008c185d2be89189c02c11139bb0466a6ea7 Mon Sep 17 00:00:00 2001
From: Yann Noutary <ynoutary@fb.com>
Date: Wed, 25 Jun 2025 05:01:57 -0700
Subject: [PATCH 150/235] Remove build warnings (#1094)

Summary:
This PR removes all the annoying build warnings that we had by :
  - Setting CMake policy
  - Add C++ warning ignores in third-party libraries only, since we're very unlikely to touch this code ever again
  - Fix the actual warnings in the rest of OpenSfM code

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1094

Test Plan:
Imported from GitHub, without a `Test Plan:` line.

Rollback Plan:

Reviewed By: DodgySpaniard

Differential Revision: D77231900

Pulled By: fabianschenk

fbshipit-source-id: 49f9f65393af15b2c7b925817898a82399b188e8
---
 opensfm/src/CMakeLists.txt                       | 12 ++++++++++--
 opensfm/src/foundation/python_types.h            |  1 +
 opensfm/src/geometry/absolute_pose.h             |  2 +-
 opensfm/src/geometry/python/pybind.cc            |  4 ++--
 opensfm/src/geometry/transformations_functions.h |  4 ++--
 opensfm/src/map/shot.h                           |  6 +++---
 opensfm/src/map/src/shot.cc                      |  4 ++--
 opensfm/src/map/test/tracks_manager_test.cc      |  9 ++++++---
 opensfm/src/robust/line_model.h                  |  2 +-
 opensfm/src/robust/scorer.h                      |  9 ++++++---
 opensfm/src/third_party/akaze/lib/AKAZE.cpp      |  2 +-
 opensfm/src/third_party/vlfeat/CMakeLists.txt    |  5 +++++
 opensfm/src/third_party/vlfeat/vl/covdet.c       | 13 -------------
 13 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index 98fd8e096..d6b5ad80b 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -9,6 +9,10 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 set(CMAKE_MODULE_PATH ${opensfm_SOURCE_DIR}/cmake)
 
+cmake_policy(SET CMP0063 NEW)
+# Re-activate once we can have a decent version of CMake (> 3.27)
+# cmake_policy(SET CMP0148 NEW)
+
 if (WIN32)
 # Place compilation results in opensfm/ folder, not in Debug/ or Release/
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${opensfm_SOURCE_DIR}/..")
@@ -29,8 +33,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Enable all warnings
 if (NOT WIN32)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-sign-compare")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-sign-compare")
 endif()
 
 # For compiling VLFeat
@@ -105,6 +109,10 @@ if (OPENSFM_BUILD_TESTS)
   include_directories(third_party/gtest)
   add_definitions(-DCERES_GFLAGS_NAMESPACE=${GFLAGS_NAMESPACE})
 
+  # Gtest if old now and trigger these
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-field-initializers")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy-with-user-provided-copy")
+
   add_library(gtest
               third_party/gtest/gmock_gtest_all.cc
               third_party/gtest/gmock_main.cc)
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index d70949082..8d45a532e 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -2,6 +2,7 @@
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
+#include <cstdint>
 #include <vector>
 
 #include "opencv2/core/core.hpp"
diff --git a/opensfm/src/geometry/absolute_pose.h b/opensfm/src/geometry/absolute_pose.h
index 2de1894b2..f2ba829c1 100644
--- a/opensfm/src/geometry/absolute_pose.h
+++ b/opensfm/src/geometry/absolute_pose.h
@@ -15,7 +15,7 @@ Eigen::Matrix3d RotationMatrixAroundAxis(const double cos_theta,
 // Perspective-Three-Point Problem" from Ke and al.
 template <class IT>
 std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(IT begin,
-                                                                 IT end) {
+                                                                 IT /* end */) {
   std::vector<Eigen::Matrix<double, 3, 4>> RTs;
 
   const Eigen::Vector3d b1 = begin->first;
diff --git a/opensfm/src/geometry/python/pybind.cc b/opensfm/src/geometry/python/pybind.cc
index e42fd9a2d..86259546a 100644
--- a/opensfm/src/geometry/python/pybind.cc
+++ b/opensfm/src/geometry/python/pybind.cc
@@ -282,7 +282,7 @@ PYBIND11_MODULE(pygeometry, m) {
           py::return_value_policy::copy)
       .def(
           "__deepcopy__",
-          [](const geometry::Camera& c, const py::dict& d) { return c; },
+          [](const geometry::Camera& c, const py::dict& /* d */) { return c; },
           py::return_value_policy::copy);
   m.def("compute_camera_mapping", geometry::ComputeCameraMapping,
         py::call_guard<py::gil_scoped_release>());
@@ -375,7 +375,7 @@ PYBIND11_MODULE(pygeometry, m) {
           py::return_value_policy::copy)
       .def(
           "__deepcopy__",
-          [](const geometry::Pose& p, const py::dict& d) { return p; },
+          [](const geometry::Pose& p, const py::dict& /* d */) { return p; },
           py::return_value_policy::copy)
       .def("inverse", [](const geometry::Pose& p) {
         geometry::Pose new_pose;
diff --git a/opensfm/src/geometry/transformations_functions.h b/opensfm/src/geometry/transformations_functions.h
index d2d2b8261..efb81530b 100644
--- a/opensfm/src/geometry/transformations_functions.h
+++ b/opensfm/src/geometry/transformations_functions.h
@@ -304,7 +304,7 @@ struct Normalize : Functor<3, 0, 3> {
   }
 };
 
-static Mat3d VectorToRotationMatrix(const Vec3d& r) {
+inline Mat3d VectorToRotationMatrix(const Vec3d& r) {
   const auto n = r.norm();
   if (n == 0)  // avoid division by 0
   {
@@ -313,7 +313,7 @@ static Mat3d VectorToRotationMatrix(const Vec3d& r) {
     return Eigen::AngleAxisd(n, r / n).toRotationMatrix();
   }
 }
-static Vec3d RotationMatrixToVector(const Mat3d& R) {
+inline Vec3d RotationMatrixToVector(const Mat3d& R) {
   Eigen::AngleAxisd tmp(R);
   return tmp.axis() * tmp.angle();
 }
diff --git a/opensfm/src/map/shot.h b/opensfm/src/map/shot.h
index 098980e7c..45846fca9 100644
--- a/opensfm/src/map/shot.h
+++ b/opensfm/src/map/shot.h
@@ -71,8 +71,8 @@ class Shot {
 
   // Pose
   void SetPose(const geometry::Pose& pose);
-  const geometry::Pose* const GetPose() const;
-  geometry::Pose* const GetPose();
+  const geometry::Pose* GetPose() const;
+  geometry::Pose* GetPose();
   Mat4d GetWorldToCam() const { return GetPose()->WorldToCamera(); }
   Mat4d GetCamToWorld() const { return GetPose()->CameraToWorld(); }
 
@@ -134,7 +134,7 @@ class Shot {
   bool operator<=(const Shot& shot) const { return id_ <= shot.id_; }
   bool operator>(const Shot& shot) const { return id_ > shot.id_; }
   bool operator>=(const Shot& shot) const { return id_ >= shot.id_; }
-  const geometry::Camera* const GetCamera() const { return shot_camera_; }
+  const geometry::Camera* GetCamera() const { return shot_camera_; }
 
   // Camera-related
   Vec2d Project(const Vec3d& global_pos) const;
diff --git a/opensfm/src/map/src/shot.cc b/opensfm/src/map/src/shot.cc
index fe81b68ff..2356d97b1 100644
--- a/opensfm/src/map/src/shot.cc
+++ b/opensfm/src/map/src/shot.cc
@@ -152,7 +152,7 @@ geometry::Pose Shot::GetPoseInRig() const {
   return rig_camera_pose.Compose(pose_instance);
 }
 
-const geometry::Pose* const Shot::GetPose() const {
+const geometry::Pose* Shot::GetPose() const {
   *pose_ = GetPoseInRig();
   if (IsSingleShotRig(rig_instance_, rig_camera_)) {
     return &rig_instance_->GetPose();
@@ -160,7 +160,7 @@ const geometry::Pose* const Shot::GetPose() const {
   return pose_.get();
 }
 
-geometry::Pose* const Shot::GetPose() {
+geometry::Pose* Shot::GetPose() {
   *pose_ = GetPoseInRig();
   if (IsSingleShotRig(rig_instance_, rig_camera_)) {
     return &rig_instance_->GetPose();
diff --git a/opensfm/src/map/test/tracks_manager_test.cc b/opensfm/src/map/test/tracks_manager_test.cc
index 7d0940172..8fc5da739 100644
--- a/opensfm/src/map/test/tracks_manager_test.cc
+++ b/opensfm/src/map/test/tracks_manager_test.cc
@@ -7,9 +7,12 @@ namespace {
 class TempFile {
  public:
   TempFile() {
-    char tmpname[L_tmpnam];
-    tmpnam(tmpname);
-    filename = std::string(tmpname);
+    char filenameTmp[] = "/tmp/opensfm_tracks_manager_test_XXXXXX";
+    int fd = mkstemp(filenameTmp);
+    if (fd == -1) {
+      std::runtime_error("Could not create temporary file");
+    }
+    filename = std::string(filenameTmp);
   }
 
   ~TempFile() { remove(filename.c_str()); }
diff --git a/opensfm/src/robust/line_model.h b/opensfm/src/robust/line_model.h
index 6af58753f..1a6026a44 100644
--- a/opensfm/src/robust/line_model.h
+++ b/opensfm/src/robust/line_model.h
@@ -9,7 +9,7 @@ class Line : public Model<Line, 1, 1> {
   static const int MINIMAL_SAMPLES = 2;
 
   template <class IT>
-  static int Estimate(IT begin, IT end, Type* models) {
+  static int Estimate(IT begin, IT /* end */, Type* models) {
     const auto x1 = *begin;
     const auto x2 = *(++begin);
     const auto b = (x1[0] * x2[1] - x1[1] * x2[0]) / (x1[0] - x2[0]);
diff --git a/opensfm/src/robust/scorer.h b/opensfm/src/robust/scorer.h
index 2eaba0034..6fccaeb95 100644
--- a/opensfm/src/robust/scorer.h
+++ b/opensfm/src/robust/scorer.h
@@ -23,7 +23,8 @@ class RansacScoring {
   RansacScoring(double threshold) : threshold_(threshold) {}
 
   template <class IT, class T>
-  ScoreInfo<T> Score(IT begin, IT end, const ScoreInfo<T>& best_score) const {
+  ScoreInfo<T> Score(IT begin, IT end,
+                     const ScoreInfo<T>& /* best_score */) const {
     ScoreInfo<T> score;
     for (IT it = begin; it != end; ++it) {
       if (it->norm() < threshold_) {
@@ -62,7 +63,8 @@ class MSacScoring {
   MSacScoring(double threshold) : threshold_(threshold) {}
 
   template <class IT, class T>
-  ScoreInfo<T> Score(IT begin, IT end, const ScoreInfo<T>& best_score) const {
+  ScoreInfo<T> Score(IT begin, IT end,
+                     const ScoreInfo<T>& /* best_score */) const {
     ScoreInfo<T> score;
     for (IT it = begin; it != end; ++it) {
       const auto v = (*it).norm();
@@ -87,7 +89,8 @@ class LMedSScoring : public MedianBasedScoring {
       : MedianBasedScoring(0.5), multiplier_(multiplier) {}
 
   template <class IT, class T>
-  ScoreInfo<T> Score(IT begin, IT end, const ScoreInfo<T>& best_score) const {
+  ScoreInfo<T> Score(IT begin, IT end,
+                     const ScoreInfo<T>& /* best_score */) const {
     const auto median = this->ComputeMedian(begin, end);
     const auto mad = 1.4826 * median;
     const auto threshold = this->multiplier_ * mad;
diff --git a/opensfm/src/third_party/akaze/lib/AKAZE.cpp b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
index 34ff21418..e5eb91bfd 100644
--- a/opensfm/src/third_party/akaze/lib/AKAZE.cpp
+++ b/opensfm/src/third_party/akaze/lib/AKAZE.cpp
@@ -405,7 +405,7 @@ void AKAZE::Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts) {
       std::vector<std::pair<size_t, float> > radiuses(kpts.size());
 
       for (size_t i = 0; i < kpts.size(); ++i) {
-        float radius = 99999999999;
+        float radius = 99999999999.f;
         for (size_t j = 0; j < kpts.size(); ++j) {
           if (kpts[i].response < kpts[j].response) {
             float dx_ = kpts[j].pt.x - kpts[i].pt.x;
diff --git a/opensfm/src/third_party/vlfeat/CMakeLists.txt b/opensfm/src/third_party/vlfeat/CMakeLists.txt
index c24198f68..ca1a04493 100644
--- a/opensfm/src/third_party/vlfeat/CMakeLists.txt
+++ b/opensfm/src/third_party/vlfeat/CMakeLists.txt
@@ -1,5 +1,10 @@
 file(GLOB VLFEAT_SRCS vl/*.c vl/*.h)
 
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-absolute-value")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-but-set-variable")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-logical-not-parentheses")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-tautological-constant-out-of-range-compare")
+
 if( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64" )
     add_definitions( -DVL_DISABLE_SSE2 )
 endif()
diff --git a/opensfm/src/third_party/vlfeat/vl/covdet.c b/opensfm/src/third_party/vlfeat/vl/covdet.c
index 0b0592f0d..e77a85605 100644
--- a/opensfm/src/third_party/vlfeat/vl/covdet.c
+++ b/opensfm/src/third_party/vlfeat/vl/covdet.c
@@ -975,19 +975,6 @@ _vl_resize_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
   }
 }
 
-/** @brief Enlarge buffer
- ** @param buffer
- ** @param bufferSize
- ** @param targetSize
- ** @return error code
- **/
-
-static int
-_vl_enlarge_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
-  if (*bufferSize >= targetSize) return VL_ERR_OK ;
-  return _vl_resize_buffer(buffer,bufferSize,targetSize) ;
-}
-
 /* ---------------------------------------------------------------- */
 /*                                            Finding local extrema */
 /* ---------------------------------------------------------------- */

From 75b8f9c7a1d99b71bf8425dc7bb43c24bf079eb9 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Fri, 27 Jun 2025 03:17:34 -0700
Subject: [PATCH 151/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm/opensfm/src/bundle/test

Differential Revision: D77365217

fbshipit-source-id: 75c011a0fc8a7b4b5d6bad20cd5cfaee5da7645c
---
 opensfm/src/bundle/test/reprojection_errors_test.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/bundle/test/reprojection_errors_test.cc b/opensfm/src/bundle/test/reprojection_errors_test.cc
index 581296c03..3a920de0f 100644
--- a/opensfm/src/bundle/test/reprojection_errors_test.cc
+++ b/opensfm/src/bundle/test/reprojection_errors_test.cc
@@ -3,7 +3,6 @@
 #include <gtest/gtest.h>
 
 #include <Eigen/Dense>
-#include <unsupported/Eigen/AutoDiff>
 
 class ReprojectionError2DFixtureBase : public ::testing::Test {
  public:

From 1dd9a16e95254f9057dcf4c4809066d6bfa02fe2 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Wed, 2 Jul 2025 01:32:21 -0700
Subject: [PATCH 152/235] annotate large

Reviewed By: bal-a

Differential Revision: D77375062

fbshipit-source-id: 82c73345f80fd523f6a8a6e03941dc31d4ec47dc
---
 opensfm/large/metadataset.py | 60 +++++++++++++++--------------
 opensfm/large/tools.py       | 74 ++++++++++++++++++++++--------------
 2 files changed, 78 insertions(+), 56 deletions(-)

diff --git a/opensfm/large/metadataset.py b/opensfm/large/metadataset.py
index 21e9c35b8..645f9deb7 100644
--- a/opensfm/large/metadataset.py
+++ b/opensfm/large/metadataset.py
@@ -1,26 +1,28 @@
-# pyre-unsafe
+# pyre-strict
 import glob
 import os
 import os.path
 import shutil
 import sys
+from typing import Any, Dict, Generator, List, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import config, io
 from opensfm.dataset import DataSet
 
 
 class MetaDataSet:
-    def __init__(self, data_path):
+    def __init__(self, data_path: str) -> None:
         """
         Create meta dataset instance for large scale reconstruction.
 
         :param data_path: Path to directory containing meta dataset
         """
-        self.data_path = os.path.abspath(data_path)
+        self.data_path: str = os.path.abspath(data_path)
 
         config_file = os.path.join(self.data_path, "config.yaml")
-        self.config = config.load_config(config_file)
+        self.config: Dict[str, Any] = config.load_config(config_file)
 
         self._image_list_file_name = "image_list_with_gps.tsv"
         self._clusters_file_name = "clusters.npz"
@@ -32,42 +34,42 @@ def __init__(self, data_path):
 
         io.mkdir_p(self._submodels_path())
 
-    def _submodels_path(self):
+    def _submodels_path(self) -> str:
         return os.path.join(self.data_path, self.config["submodels_relpath"])
 
-    def _submodel_path(self, i):
+    def _submodel_path(self, i: int) -> str:
         """Path to submodel i folder."""
         template = self.config["submodel_relpath_template"]
         return os.path.join(self.data_path, template % i)
 
-    def _submodel_images_path(self, i):
+    def _submodel_images_path(self, i: int) -> str:
         """Path to submodel i images folder."""
         template = self.config["submodel_images_relpath_template"]
         return os.path.join(self.data_path, template % i)
 
-    def _image_groups_path(self):
+    def _image_groups_path(self) -> str:
         return os.path.join(self.data_path, "image_groups.txt")
 
-    def _image_list_path(self):
+    def _image_list_path(self) -> str:
         return os.path.join(self._submodels_path(), self._image_list_file_name)
 
-    def _clusters_path(self):
+    def _clusters_path(self) -> str:
         return os.path.join(self._submodels_path(), self._clusters_file_name)
 
-    def _clusters_with_neighbors_path(self):
+    def _clusters_with_neighbors_path(self) -> str:
         return os.path.join(
             self._submodels_path(), self._clusters_with_neighbors_file_name
         )
 
-    def _clusters_with_neighbors_geojson_path(self):
+    def _clusters_with_neighbors_geojson_path(self) -> str:
         return os.path.join(
             self._submodels_path(), self._clusters_with_neighbors_geojson_file_name
         )
 
-    def _clusters_geojson_path(self):
+    def _clusters_geojson_path(self) -> str:
         return os.path.join(self._submodels_path(), self._clusters_geojson_file_name)
 
-    def _create_symlink(self, base_path, file_path):
+    def _create_symlink(self, base_path: str, file_path: str) -> None:
         src = os.path.join(self.data_path, file_path)
         dst = os.path.join(base_path, file_path)
 
@@ -104,59 +106,61 @@ def _create_symlink(self, base_path, file_path):
                 os.path.join(*[".."] * subfolders, os.path.relpath(src, base_path)), dst
             )
 
-    def image_groups_exists(self):
+    def image_groups_exists(self) -> bool:
         return os.path.isfile(self._image_groups_path())
 
-    def load_image_groups(self):
+    def load_image_groups(self) -> Generator[List[str], None, None]:
         with open(self._image_groups_path()) as fin:
             for line in fin:
                 yield line.split()
 
-    def image_list_exists(self):
+    def image_list_exists(self) -> bool:
         return os.path.isfile(self._image_list_path())
 
-    def create_image_list(self, ills):
+    def create_image_list(self, ills: List[Tuple[str, float, float]]) -> None:
         with io.open_wt(self._image_list_path()) as csvfile:
             for image, lat, lon in ills:
                 csvfile.write("{}\t{}\t{}\n".format(image, lat, lon))
 
-    def images_with_gps(self):
+    def images_with_gps(self) -> Generator[Tuple[str, float, float], None, None]:
         with io.open_rt(self._image_list_path()) as csvfile:
             for line in csvfile:
                 image, lat, lon = line.split("\t")
                 yield image, float(lat), float(lon)
 
-    def save_clusters(self, images, positions, labels, centers):
+    def save_clusters(
+        self, images: NDArray, positions: NDArray, labels: NDArray, centers: NDArray
+    ) -> None:
         filepath = self._clusters_path()
         np.savez_compressed(
             filepath, images=images, positions=positions, labels=labels, centers=centers
         )
 
-    def load_clusters(self):
+    def load_clusters(self) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
         c = np.load(self._clusters_path())
         images = c["images"].ravel()
         labels = c["labels"].ravel()
         return images, c["positions"], labels, c["centers"]
 
-    def save_clusters_with_neighbors(self, clusters):
+    def save_clusters_with_neighbors(self, clusters: List[List[int]]) -> None:
         filepath = self._clusters_with_neighbors_path()
         np.savez_compressed(filepath, clusters=np.array(clusters, dtype=object))
 
-    def load_clusters_with_neighbors(self):
+    def load_clusters_with_neighbors(self) -> NDArray:
         c = np.load(self._clusters_with_neighbors_path(), allow_pickle=True)
         return c["clusters"]
 
-    def save_cluster_with_neighbors_geojson(self, geojson):
+    def save_cluster_with_neighbors_geojson(self, geojson: Dict[str, Any]) -> None:
         filepath = self._clusters_with_neighbors_geojson_path()
         with io.open_wt(filepath) as fout:
             io.json_dump(geojson, fout)
 
-    def save_clusters_geojson(self, geojson):
+    def save_clusters_geojson(self, geojson: Dict[str, Any]) -> None:
         filepath = self._clusters_geojson_path()
         with io.open_wt(filepath) as fout:
             io.json_dump(geojson, fout)
 
-    def remove_submodels(self):
+    def remove_submodels(self) -> None:
         sm = self._submodels_path()
         paths = [
             os.path.join(sm, o)
@@ -166,7 +170,7 @@ def remove_submodels(self):
         for path in paths:
             shutil.rmtree(path)
 
-    def create_submodels(self, clusters):
+    def create_submodels(self, clusters: NDArray) -> None:
         data = DataSet(self.data_path)
         for i, cluster in enumerate(clusters):
             # create sub model dirs
@@ -216,7 +220,7 @@ def create_submodels(self, clusters):
             for filepath in filepaths:
                 self._create_symlink(submodel_path, filepath)
 
-    def get_submodel_paths(self):
+    def get_submodel_paths(self) -> List[str]:
         submodel_paths = []
         for i in range(999999):
             submodel_path = self._submodel_path(i)
diff --git a/opensfm/large/tools.py b/opensfm/large/tools.py
index 72d1d2b2c..69bb2b914 100644
--- a/opensfm/large/tools.py
+++ b/opensfm/large/tools.py
@@ -1,9 +1,8 @@
-# pyre-unsafe
+# pyre-strict
 import itertools
 import logging
-from collections import namedtuple
 from functools import lru_cache
-from typing import Dict, List, Tuple
+from typing import Callable, Dict, List, NamedTuple, Tuple
 
 import cv2
 import networkx as nx
@@ -11,6 +10,7 @@
 import scipy.spatial as spatial
 from networkx.algorithms import bipartite
 from networkx.classes.reportviews import EdgeView
+from numpy.typing import NDArray
 from opensfm import (
     align,
     context,
@@ -22,16 +22,19 @@
     reconstruction,
     types,
 )
+from opensfm.large.metadataset import MetaDataSet
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-PartialReconstruction = namedtuple("PartialReconstruction", ["submodel_path", "index"])
+class PartialReconstruction(NamedTuple):
+    submodel_path: str
+    idx: int
 
 
 def kmeans(
-    samples, nclusters, max_iter: int = 100, attempts: int = 20
-) -> Tuple[np.ndarray, np.ndarray]:
+    samples: NDArray, nclusters: int, max_iter: int = 100, attempts: int = 20
+) -> Tuple[NDArray, NDArray]:
     criteria = (cv2.TERM_CRITERIA_MAX_ITER, max_iter, 1.0)
     flags = cv2.KMEANS_PP_CENTERS
 
@@ -42,8 +45,8 @@ def kmeans(
 
 
 def add_cluster_neighbors(
-    positions, labels, centers, max_distance
-) -> List[List[np.ndarray]]:
+    positions: NDArray, labels: NDArray, centers: NDArray, max_distance: float
+) -> List[List[NDArray]]:
     reflla = np.mean(positions, 0)
     reference = geo.TopocentricConverter(reflla[0], reflla[1], 0)
 
@@ -69,7 +72,9 @@ def add_cluster_neighbors(
     return clusters
 
 
-def connected_reconstructions(reconstruction_shots) -> EdgeView:
+def connected_reconstructions(
+    reconstruction_shots: Dict[PartialReconstruction, Dict[str, pymap.Shot]],
+) -> EdgeView[None]:
     g = nx.Graph()
     for r in reconstruction_shots:
         g.add_node(r, bipartite=0)
@@ -82,7 +87,7 @@ def connected_reconstructions(reconstruction_shots) -> EdgeView:
     return p.edges()
 
 
-def scale_matrix(covariance: np.ndarray) -> np.ndarray:
+def scale_matrix(covariance: NDArray) -> NDArray:
     try:
         L = np.linalg.cholesky(covariance)
     except Exception:
@@ -96,9 +101,7 @@ def scale_matrix(covariance: np.ndarray) -> np.ndarray:
     return np.linalg.inv(L)
 
 
-def invert_similarity(
-    s: float, A: np.ndarray, b: np.ndarray
-) -> Tuple[float, np.ndarray, float]:
+def invert_similarity(s: float, A: NDArray, b: NDArray) -> Tuple[float, NDArray, float]:
     s_inv = 1 / s
     A_inv = A.T
     b_inv = -s_inv * A_inv.dot(b)
@@ -106,11 +109,15 @@ def invert_similarity(
     return s_inv, A_inv, b_inv
 
 
-def partial_reconstruction_name(key) -> str:
-    return str(key.submodel_path) + "_index" + str(key.index)
+def partial_reconstruction_name(key: PartialReconstruction) -> str:
+    return str(key.submodel_path) + "_index" + str(key.idx)
 
 
-def add_camera_constraints_soft(ra, reconstruction_shots, reconstruction_name) -> None:
+def add_camera_constraints_soft(
+    ra: pybundle.ReconstructionAlignment,
+    reconstruction_shots: Dict[PartialReconstruction, Dict[str, pymap.Shot]],
+    reconstruction_name: Callable[[PartialReconstruction], str],
+) -> None:
     added_shots = set()
     for key in reconstruction_shots:
         shots = reconstruction_shots[key]
@@ -149,7 +156,10 @@ def add_camera_constraints_soft(ra, reconstruction_shots, reconstruction_name) -
 
 
 def add_camera_constraints_hard(
-    ra, reconstruction_shots, reconstruction_name, add_common_camera_constraint
+    ra: pybundle.ReconstructionAlignment,
+    reconstruction_shots: Dict[PartialReconstruction, Dict[str, pymap.Shot]],
+    reconstruction_name: Callable[[PartialReconstruction], str],
+    add_common_camera_constraint: bool,
 ) -> None:
     for key in reconstruction_shots:
         shots = reconstruction_shots[key]
@@ -192,7 +202,7 @@ def add_camera_constraints_hard(
 
 @lru_cache(25)
 def load_reconstruction(
-    path, index
+    path: str, index: int
 ) -> Tuple[str, Tuple[types.Reconstruction, pymap.TracksManager]]:
     d1 = dataset.DataSet(path)
     r1 = d1.load_reconstruction()[index]
@@ -200,14 +210,18 @@ def load_reconstruction(
     return (path + ("_%s" % index)), (r1, g1)
 
 
-def add_point_constraints(ra, reconstruction_shots, reconstruction_name) -> None:
+def add_point_constraints(
+    ra: pybundle.ReconstructionAlignment,
+    reconstruction_shots: Dict[PartialReconstruction, Dict[str, pymap.Shot]],
+    reconstruction_name: Callable[[PartialReconstruction], str],
+) -> None:
     connections = connected_reconstructions(reconstruction_shots)
     for connection in connections:
         i1, (r1, g1) = load_reconstruction(
-            connection[0].submodel_path, connection[0].index
+            connection[0].submodel_path, connection[0].idx
         )
         i2, (r2, g2) = load_reconstruction(
-            connection[1].submodel_path, connection[1].index
+            connection[1].submodel_path, connection[1].idx
         )
 
         rec_name1 = reconstruction_name(connection[0])
@@ -239,7 +253,9 @@ def add_point_constraints(ra, reconstruction_shots, reconstruction_name) -> None
             )
 
 
-def load_reconstruction_shots(meta_data) -> Dict[str, pymap.Shot]:
+def load_reconstruction_shots(
+    meta_data: MetaDataSet,
+) -> Dict[PartialReconstruction, Dict[str, pymap.Shot]]:
     reconstruction_shots = {}
     for submodel_path in meta_data.get_submodel_paths():
         data = dataset.DataSet(submodel_path)
@@ -255,11 +271,11 @@ def load_reconstruction_shots(meta_data) -> Dict[str, pymap.Shot]:
 
 
 def align_reconstructions(
-    reconstruction_shots,
-    reconstruction_name,
-    use_points_constraints,
+    reconstruction_shots: Dict[PartialReconstruction, Dict[str, pymap.Shot]],
+    reconstruction_name: Callable[[PartialReconstruction], str],
+    use_points_constraints: bool,
     camera_constraint_type: str = "soft_camera_constraint",
-) -> Dict[str, Tuple[float, np.ndarray, float]]:
+) -> Dict[PartialReconstruction, Tuple[float, NDArray, NDArray]]:
     ra = pybundle.ReconstructionAlignment()
 
     if camera_constraint_type == "soft_camera_constraint":
@@ -285,7 +301,9 @@ def align_reconstructions(
     return transformations
 
 
-def apply_transformations(transformations) -> None:
+def apply_transformations(
+    transformations: Dict[PartialReconstruction, Tuple[float, NDArray, NDArray]],
+) -> None:
     submodels = itertools.groupby(
         sorted(transformations.keys(), key=lambda key: key.submodel_path),
         lambda key: key.submodel_path,
@@ -297,7 +315,7 @@ def apply_transformations(transformations) -> None:
 
         reconstruction = data.load_reconstruction()
         for key in keys:
-            partial_reconstruction = reconstruction[key.index]
+            partial_reconstruction = reconstruction[key.idx]
             s, A, b = transformations[key]
             align.apply_similarity(partial_reconstruction, s, A, b)
 

From 82764b34758df41191f4f29c91f5ef990c244081 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Wed, 2 Jul 2025 02:48:20 -0700
Subject: [PATCH 153/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm/opensfm/src/dense/src

Reviewed By: paulinus

Differential Revision: D77577719

fbshipit-source-id: f577f459621dfe68b4f1796968c473e445a0c559
---
 opensfm/src/dense/src/depthmap.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/dense/src/depthmap.cc b/opensfm/src/dense/src/depthmap.cc
index 3f5d41af1..d96cae68d 100644
--- a/opensfm/src/dense/src/depthmap.cc
+++ b/opensfm/src/dense/src/depthmap.cc
@@ -1,7 +1,6 @@
 #include "../depthmap.h"
 
 #include <cstdint>
-#include <opencv2/opencv.hpp>
 #include <random>
 
 namespace dense {

From 9f9404a7971d5a2d608a04ccd150a507be5737ee Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Mon, 7 Jul 2025 03:20:14 -0700
Subject: [PATCH 154/235] Fix tests it github CI (#1099)

Summary:
* Use simpler tying for python 3.8
* Relax some thresholds for tests that fail locally on an M4 mac

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1099

Test Plan:
Imported from GitHub, without a `Test Plan:` line.

Rollback Plan:

Reviewed By: fabianschenk

Differential Revision: D77851109

Pulled By: paulinus

fbshipit-source-id: ebcefbcb4e980c5e8eb51a9a5ce30cc537ae7bf5
---
 opensfm/features_processing.py                | 21 +++++++++++++++----
 opensfm/large/tools.py                        |  2 ++
 .../test/test_reconstruction_incremental.py   |  4 ++--
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 145c1abef..68b9aa0f5 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -3,6 +3,7 @@
 import logging
 import math
 import queue
+import sys
 import threading
 from timeit import default_timer as timer
 from typing import Any, cast, Dict, List, Optional, Tuple, Union
@@ -16,11 +17,23 @@
 
 logger: logging.Logger = logging.getLogger(__name__)
 
-ProcessQueue = queue.Queue[
-    Optional[
-        Tuple[str, NDArray, Optional[NDArray], Optional[NDArray], DataSetBase, bool]
+
+if sys.version_info >= (3, 9):
+    ProcessQueue = queue.Queue[
+        Optional[
+            Tuple[
+                str,
+                NDArray,
+                Optional[NDArray],
+                Optional[NDArray],
+                DataSetBase,
+                bool,
+            ]
+        ]
     ]
-]
+else:
+    ProcessQueue = queue.Queue
+
 ProducerArgs = Tuple[
     ProcessQueue,
     DataSetBase,
diff --git a/opensfm/large/tools.py b/opensfm/large/tools.py
index 69bb2b914..294199fe7 100644
--- a/opensfm/large/tools.py
+++ b/opensfm/large/tools.py
@@ -1,4 +1,6 @@
 # pyre-strict
+from __future__ import annotations
+
 import itertools
 import logging
 from functools import lru_cache
diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index 26320a3c1..b5aaa8d74 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -35,7 +35,7 @@ def test_reconstruction_incremental(
     assert 0.7 < errors["ratio_points"] < 1.0
 
     assert 0 < errors["aligned_position_rmse"] < 0.03
-    assert 0 < errors["aligned_rotation_rmse"] < 0.0022
+    assert 0 < errors["aligned_rotation_rmse"] < 0.003
     assert 0 < errors["aligned_points_rmse"] < 0.1
 
     # Sanity check that GPS error is similar to the generated gps_noise
@@ -47,7 +47,7 @@ def test_reconstruction_incremental(
 
     # Check that the GPS bias (only translation) is recovered
     translation = reconstructed_scene[0].biases["1"].translation
-    assert 9.9 < translation[0] < 10.312
+    assert 9.9 < translation[0] < 10.32
     assert 99.9 < translation[2] < 100.2
 
 

From 2d3169f8e90921b1008096f096c8f94c395c044b Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Tue, 8 Jul 2025 00:48:23 -0700
Subject: [PATCH 155/235] Use python 3.10 in conda and github action to test it
 (#1100)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1100

Reviewed By: fabianschenk

Differential Revision: D77903806

Pulled By: paulinus

fbshipit-source-id: 7a73ab22c1ff42ca72cdedafa058449615492e25
---
 .github/workflows/conda.yml           | 32 ++++++++++++++++++++++++
 conda.yml                             | 36 +++++++++++++--------------
 opensfm/src/bundle/CMakeLists.txt     |  3 +--
 opensfm/src/dense/CMakeLists.txt      |  2 +-
 opensfm/src/features/CMakeLists.txt   |  1 -
 opensfm/src/foundation/CMakeLists.txt |  2 +-
 opensfm/src/geo/CMakeLists.txt        |  1 -
 opensfm/src/geometry/CMakeLists.txt   |  1 -
 opensfm/src/map/CMakeLists.txt        |  2 --
 opensfm/src/robust/CMakeLists.txt     |  1 -
 opensfm/src/sfm/CMakeLists.txt        |  1 -
 opensfm/src/third_party/pybind11      |  2 +-
 12 files changed, 54 insertions(+), 30 deletions(-)
 create mode 100644 .github/workflows/conda.yml

diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
new file mode 100644
index 000000000..26902cdc7
--- /dev/null
+++ b/.github/workflows/conda.yml
@@ -0,0 +1,32 @@
+name: Ubuntu Conda CI
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build conda environment and run tests
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Setup Miniconda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          environment-file: conda.yml
+          activate-environment: opensfm
+
+      - name: Build OpenSfM
+        shell: bash -l {0}
+        run: python setup.py build
+
+      - name: Run C++ tests
+        shell: bash -l {0}
+        run: cd cmake_build && ctest
+
+      - name: Run Python tests
+        shell: bash -l {0}
+        run: python -m pytest
diff --git a/conda.yml b/conda.yml
index 472a4ad3d..ca5e0533d 100644
--- a/conda.yml
+++ b/conda.yml
@@ -1,31 +1,31 @@
 name: opensfm
 dependencies:
-    - python=3.8
+    - python=3.10
     - cmake=3.31
     - make
     - libxcrypt
-    - opencv
+    - libopencv *=headless*
+    - py-opencv
     - ceres-solver=2.1
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
     - pip
     - pip:
-        - cloudpickle==0.4.0
-        - exifread==2.1.2
-        - flask==2.3.2
-        - fpdf2==2.4.6
-        - joblib==0.14.1
-        - matplotlib
-        - networkx==2.5
-        - numpy>=1.19
-        - Pillow>=8.1.1
-        - pyproj>=1.9.5.1
-        - pytest==6.2.0
-        - python-dateutil>=2.7
-        - pyyaml>5.4
-        - scipy>=1.10.0
+        - cloudpickle==3.1.1
+        - ExifRead==3.3.1
+        - Flask==3.1.1
+        - fpdf2==2.8.3
+        - joblib==1.5.1
+        - matplotlib==3.5.1
+        - networkx==3.4.2
+        - numpy==1.21.5
+        - Pillow==9.0.1
+        - pyproj>=3.3.0
+        - pytest==8.4.0
+        - python-dateutil==2.8.1
+        - PyYAML>=5.4.1
+        - scipy==1.8.0
         - Sphinx==4.2.0
-        - six
-        - xmltodict==0.10.2
+        - xmltodict==0.14.2
         - wheel
         - sphinx_rtd_theme
diff --git a/opensfm/src/bundle/CMakeLists.txt b/opensfm/src/bundle/CMakeLists.txt
index 994e871da..87b6a9587 100644
--- a/opensfm/src/bundle/CMakeLists.txt
+++ b/opensfm/src/bundle/CMakeLists.txt
@@ -54,8 +54,7 @@ pybind11_add_module(pybundle python/pybind.cc)
 target_link_libraries(pybundle PRIVATE
   bundle
   geometry
-  foundation
-  pybind11)
+  foundation)
 set_target_properties(pybundle PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
diff --git a/opensfm/src/dense/CMakeLists.txt b/opensfm/src/dense/CMakeLists.txt
index cbebb5ea0..2728749df 100644
--- a/opensfm/src/dense/CMakeLists.txt
+++ b/opensfm/src/dense/CMakeLists.txt
@@ -23,7 +23,7 @@ endif()
 
 pybind11_add_module(pydense python/pybind.cc)
 target_include_directories(pydense PRIVATE ${GLOG_INCLUDE_DIR})
-target_link_libraries(pydense PRIVATE dense foundation pybind11)
+target_link_libraries(pydense PRIVATE dense foundation)
 set_target_properties(pydense PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
diff --git a/opensfm/src/features/CMakeLists.txt b/opensfm/src/features/CMakeLists.txt
index b131d30a5..6db5b3f10 100644
--- a/opensfm/src/features/CMakeLists.txt
+++ b/opensfm/src/features/CMakeLists.txt
@@ -22,7 +22,6 @@ target_link_libraries(pyfeatures
   PRIVATE
     features
     foundation
-    pybind11
     akaze
 )
 set_target_properties(pyfeatures PROPERTIES
diff --git a/opensfm/src/foundation/CMakeLists.txt b/opensfm/src/foundation/CMakeLists.txt
index 401852277..f7737f327 100644
--- a/opensfm/src/foundation/CMakeLists.txt
+++ b/opensfm/src/foundation/CMakeLists.txt
@@ -12,7 +12,6 @@ set(FOUNDATION_FILES
 add_library(foundation ${FOUNDATION_FILES})
 target_link_libraries(foundation
   PUBLIC
-    pybind11
     ${OpenCV_LIBS}
     ${OpenMP_libomp_LIBRARY}
     Eigen3::Eigen
@@ -22,6 +21,7 @@ target_link_libraries(foundation
 )
 target_include_directories(foundation
   PUBLIC
+    ${PYBIND11_INCLUDE_DIR}
     ${PYTHON_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}
     ${OpenMP_CXX_INCLUDE_DIR}
diff --git a/opensfm/src/geo/CMakeLists.txt b/opensfm/src/geo/CMakeLists.txt
index a9cbae02a..75620d069 100644
--- a/opensfm/src/geo/CMakeLists.txt
+++ b/opensfm/src/geo/CMakeLists.txt
@@ -29,7 +29,6 @@ target_link_libraries(pygeo
   PRIVATE
     geo
     foundation
-    pybind11
 )
 set_target_properties(pygeo PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
diff --git a/opensfm/src/geometry/CMakeLists.txt b/opensfm/src/geometry/CMakeLists.txt
index 32864dddd..c8be4b9b7 100644
--- a/opensfm/src/geometry/CMakeLists.txt
+++ b/opensfm/src/geometry/CMakeLists.txt
@@ -49,7 +49,6 @@ target_link_libraries(pygeometry
   PRIVATE
     geometry
     foundation
-    pybind11
 )
 set_target_properties(pygeometry PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
diff --git a/opensfm/src/map/CMakeLists.txt b/opensfm/src/map/CMakeLists.txt
index 804ffd7d0..74eb67420 100644
--- a/opensfm/src/map/CMakeLists.txt
+++ b/opensfm/src/map/CMakeLists.txt
@@ -20,7 +20,6 @@ set(MAP_FILES
 add_library(map ${MAP_FILES})
 target_link_libraries(map
   PUBLIC
-    pybind11
     Eigen3::Eigen
   PRIVATE
     geo
@@ -41,7 +40,6 @@ target_link_libraries(pymap
     geometry
     foundation
     bundle
-    pybind11
 )
 
 if (OPENSFM_BUILD_TESTS)
diff --git a/opensfm/src/robust/CMakeLists.txt b/opensfm/src/robust/CMakeLists.txt
index ce70749f9..40bdf7a46 100644
--- a/opensfm/src/robust/CMakeLists.txt
+++ b/opensfm/src/robust/CMakeLists.txt
@@ -29,7 +29,6 @@ target_link_libraries(pyrobust
   PRIVATE
     robust
     foundation
-    pybind11
 )
 set_target_properties(pyrobust PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
diff --git a/opensfm/src/sfm/CMakeLists.txt b/opensfm/src/sfm/CMakeLists.txt
index 98c28f413..7f56b791b 100644
--- a/opensfm/src/sfm/CMakeLists.txt
+++ b/opensfm/src/sfm/CMakeLists.txt
@@ -35,7 +35,6 @@ target_include_directories(pysfm PRIVATE ${GLOG_INCLUDE_DIR})
 target_link_libraries(pysfm
   PRIVATE
     foundation
-    pybind11
     sfm
 )
 set_target_properties(pysfm PROPERTIES
diff --git a/opensfm/src/third_party/pybind11 b/opensfm/src/third_party/pybind11
index 9a19306fb..a2e59f0e7 160000
--- a/opensfm/src/third_party/pybind11
+++ b/opensfm/src/third_party/pybind11
@@ -1 +1 @@
-Subproject commit 9a19306fbf30642ca331d0ec88e7da54a96860f9
+Subproject commit a2e59f0e7065404b44dfe92a28aca47ba1378dc4

From a29d55753e82cf2f411fb8a638acc42ea4987d12 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Tue, 8 Jul 2025 06:19:47 -0700
Subject: [PATCH 156/235] Run conda test action on multiple OS (#1101)

Summary: Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1101

Reviewed By: fabianschenk

Differential Revision: D77931758

Pulled By: paulinus

fbshipit-source-id: 6a7ab3d9a7fa03ab69b0735dd03c96f39f3aeac1
---
 .github/workflows/conda.yml | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
index 26902cdc7..c4e502624 100644
--- a/.github/workflows/conda.yml
+++ b/.github/workflows/conda.yml
@@ -1,4 +1,4 @@
-name: Ubuntu Conda CI
+name: Conda CI
 
 on: [push, pull_request]
 
@@ -6,7 +6,12 @@ jobs:
 
   build-test:
     name: Build conda environment and run tests
-    runs-on: ubuntu-22.04
+
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, ubuntu-22.04, macos-latest]
+
+    runs-on: ${{ matrix.os }}
 
     steps:
       - uses: actions/checkout@v2

From 8b50138ef01041aa9227294e17cef3674dc4d5e0 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 8 Jul 2025 09:06:55 -0700
Subject: [PATCH 157/235] fix flacky test

Summary:
When tested on mac using conda, this test started to occasionally fail

The test assumed that after merging multiple tracks managers the resulting tracks will have a particular ordering, which is not guaranted.

Changed the test to accept tracks in any order.

Reviewed By: DodgySpaniard

Differential Revision:
D77933760

Privacy Context Container: L1137435

fbshipit-source-id: d206ece63ba6692ad56aa03c02b7e8bbc915a094
---
 opensfm/src/map/test/tracks_manager_test.cc | 51 +++++++++++++--------
 1 file changed, 31 insertions(+), 20 deletions(-)

diff --git a/opensfm/src/map/test/tracks_manager_test.cc b/opensfm/src/map/test/tracks_manager_test.cc
index 8fc5da739..808f1105e 100644
--- a/opensfm/src/map/test/tracks_manager_test.cc
+++ b/opensfm/src/map/test/tracks_manager_test.cc
@@ -132,30 +132,41 @@ TEST_F(TracksManagerTest, MergeThreeTracksManager) {
   auto merged =
       map::TracksManager::MergeTracksManager({&manager1, &manager2, &manager3});
 
-  std::unordered_map<map::ShotId, map::Observation> track0;
-  track0["1"] = o1;
-  track0["2"] = o2;
-  track0["3"] = o3;
-  track0["4"] = o4;
-  track0["5"] = o5;
-
-  std::unordered_map<map::ShotId, map::Observation> track1;
-  track1["6"] = o6;
-  track1["7"] = o7;
-
-  std::unordered_map<map::ShotId, map::Observation> track2;
-  track2["8"] = o8;
-
-  std::unordered_map<map::ShotId, map::Observation> track3;
-  track3["1"] = o0;
+  const auto track0 = merged.GetTrackObservations("0");
+  const auto track1 = merged.GetTrackObservations("1");
+  const auto track2 = merged.GetTrackObservations("2");
+  const auto track3 = merged.GetTrackObservations("3");
 
   EXPECT_THAT(
       merged.GetTrackIds(),
       ::testing::WhenSorted(::testing::ElementsAre("0", "1", "2", "3")));
-  EXPECT_EQ(merged.GetTrackObservations("0"), track2);
-  EXPECT_EQ(merged.GetTrackObservations("1"), track3);
-  EXPECT_EQ(merged.GetTrackObservations("2"), track1);
-  EXPECT_EQ(merged.GetTrackObservations("3"), track0);
+
+  std::unordered_map<map::ShotId, map::Observation> gt_trackA;
+  gt_trackA["1"] = o1;
+  gt_trackA["2"] = o2;
+  gt_trackA["3"] = o3;
+  gt_trackA["4"] = o4;
+  gt_trackA["5"] = o5;
+
+  std::unordered_map<map::ShotId, map::Observation> gt_trackB;
+  gt_trackB["6"] = o6;
+  gt_trackB["7"] = o7;
+
+  std::unordered_map<map::ShotId, map::Observation> gt_trackC;
+  gt_trackC["8"] = o8;
+
+  std::unordered_map<map::ShotId, map::Observation> gt_trackD;
+  gt_trackD["1"] = o0;
+
+  // Expect the two sets of tracks to be the same for some reordering
+  EXPECT_TRUE(track0 == gt_trackA || track1 == gt_trackA ||
+              track2 == gt_trackA || track3 == gt_trackA);
+  EXPECT_TRUE(track0 == gt_trackB || track1 == gt_trackB ||
+              track2 == gt_trackB || track3 == gt_trackB);
+  EXPECT_TRUE(track0 == gt_trackC || track1 == gt_trackC ||
+              track2 == gt_trackC || track3 == gt_trackC);
+  EXPECT_TRUE(track0 == gt_trackD || track1 == gt_trackD ||
+              track2 == gt_trackD || track3 == gt_trackD);
 }
 
 TEST_F(TracksManagerTest, HasIOFileConsistency) {

From a5f7ec27482590913365e2c5ae42a3a8f517a395 Mon Sep 17 00:00:00 2001
From: Richard Barnes <rbarnes@meta.com>
Date: Tue, 15 Jul 2025 13:11:18 -0700
Subject: [PATCH 158/235] Del redundant-static-def in
 mapillary/opensfm/opensfm/src/geometry/src/triangulation.cc +3

Summary:
LLVM has a warning `-Wdeprecated-redundant-constexpr-static-def` which raises the warning:

> warning: out-of-line definition of constexpr static data member is redundant in C++17 and is deprecated

Since we are now on C++20, we can remove the out-of-line definition of constexpr static data members. This diff does so.

 - If you approve of this diff, please use the "Accept & Ship" button :-)

Reviewed By: meyering

Differential Revision: D78250508

fbshipit-source-id: 78e01cdaedc8c230ea8f7df3175621f548585167
---
 opensfm/src/geometry/src/triangulation.cc | 2 --
 opensfm/src/map/src/observation.cc        | 4 +---
 opensfm/src/map/test/map_test.cc          | 3 ---
 3 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index d29120a3f..e29272b8d 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -70,8 +70,6 @@ struct BearingErrorCost : public ceres::CostFunction {
   const Vec3d &point_;
 };
 
-constexpr int BearingErrorCost::Size;
-
 }  // namespace
 
 namespace geometry {
diff --git a/opensfm/src/map/src/observation.cc b/opensfm/src/map/src/observation.cc
index 61773f4c9..badd93529 100644
--- a/opensfm/src/map/src/observation.cc
+++ b/opensfm/src/map/src/observation.cc
@@ -1,5 +1,3 @@
 #include <map/observation.h>
 
-namespace map {
-constexpr int Observation::NO_SEMANTIC_VALUE;
-}
+namespace map {}
diff --git a/opensfm/src/map/test/map_test.cc b/opensfm/src/map/test/map_test.cc
index 280078dec..ee737cfda 100644
--- a/opensfm/src/map/test/map_test.cc
+++ b/opensfm/src/map/test/map_test.cc
@@ -127,9 +127,6 @@ class ToyMapFixture : public EmptyMapFixture {
   std::array<int, 2> num_shots = {5, 3};
 };
 
-const int ToyMapFixture::num_points;
-const int ToyMapFixture::num_cameras;
-
 TEST_F(ToyMapFixture, ReturnsNumberOfShots) {
   ASSERT_EQ(map.NumberOfShots(), 8);
 }

From cc71548c4652a3074505acd42e09d391f3a6a381 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Mon, 28 Jul 2025 10:23:19 -0700
Subject: [PATCH 159/235] reduce 70% memory usage during reconstructability
 computation

Summary:
In order to compute the list of image pairs (sorted by reconstructability), the existing code load a giant dictionary of <im1, im2> -> <feature_array_im1, feature_array_im2, track ids> in memory. It's expensive to save per-image features in memory, and even more expensive to save the feature array repeatedly when an image is matched with many images.
This change adds a new version of the image pair computation logic. It avoids loading all the feature arrays in memory, but loads the feature arrays lazily when the corresponding images are touched. As a result, this can save more than 70% of memory of that piece of code, which has been a memory bottleneck for opensfm for a long time.

meta-only:

Reviewed By: DodgySpaniard

Differential Revision: D78921836

fbshipit-source-id: 94c7385970b1fde1bcf5c056d70a9dfa4e43364f
---
 opensfm/reconstruction.py | 70 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 67 insertions(+), 3 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 4101d72f7..37adf068c 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -13,6 +13,7 @@
 
 import cv2
 import numpy as np
+from numpy import typing as npt
 from numpy.typing import NDArray
 from opensfm import (
     log,
@@ -1609,6 +1610,50 @@ def triangulation_reconstruction(
     return report, [reconstruction]
 
 
+def _get_common_feature_arrays(
+    tracks_manager: pymap.TracksManager,
+    im1: str,
+    im2: str,
+) -> tuple[npt.NDArray, npt.NDArray]:
+    """Return the feature arrays of common tracks between two images."""
+    features1 = []
+    features2 = []
+    for _, p1, p2 in tracks_manager.get_all_common_observations(im1, im2):
+        features1.append(p1.point)
+        features2.append(p2.point)
+    features1 = np.array(features1)
+    features2 = np.array(features2)
+    return (features1, features2)
+
+
+def compute_image_pairs_sequential(
+    data: DataSetBase,
+    tracks_manager: pymap.TracksManager,
+    min_common: int = 50,
+) -> list[tuple[str, str]]:
+    """Compute all possible pairs of images that share at least `min_common` points.
+    The pairs are sorted by "reconstructability" which is estimated by the
+    pairwise_reconstructability function.
+    """
+    cameras = data.load_camera_models()
+    threshold = 4 * data.config["five_point_algo_threshold"]
+    results = []
+    connectivity = tracks_manager.get_all_pairs_connectivity()
+    for (im1, im2), size in connectivity.items():
+        if size < min_common:
+            continue
+        features1, features2 = _get_common_feature_arrays(tracks_manager, im1, im2)
+        camera1 = cameras[data.load_exif(im1)["camera"]]
+        camera2 = cameras[data.load_exif(im2)["camera"]]
+        result = _compute_pair_reconstructability(
+            (im1, im2, features1, features2, camera1, camera2, threshold)
+        )
+        if result[2] > 0:
+            results.append(result)
+    results.sort(key=lambda x: x[2], reverse=True)
+    return [(im1, im2) for im1, im2, _ in results]
+
+
 def incremental_reconstruction(
     data: DataSetBase, tracks_manager: pymap.TracksManager
 ) -> Tuple[Dict[str, Any], List[types.Reconstruction]]:
@@ -1624,9 +1669,22 @@ def incremental_reconstruction(
     remaining_images = set(images)
     gcp = data.load_ground_control_points()
     logger.info(f"Loaded {len(gcp)} ground control points.")
-    common_tracks = tracking.all_common_tracks_with_features(tracks_manager)
+
+    common_tracks = None
+    if data.config["processes"] > 1:
+        # Get pairs in parallel, preload all features for all
+        # pairs of image. Features of an image can be stored
+        # repeatedly in multiple image pairs.
+        # Pros: fast; Cons: high memory usage
+        common_tracks = tracking.all_common_tracks_with_features(tracks_manager)
+        pairs = compute_image_pairs(common_tracks, data)
+    else:
+        # Get pairs sequentially, load features lazily.
+        # Pros: low memory usage; Cons: slow
+        pairs = compute_image_pairs_sequential(data, tracks_manager)
+    logging.info(f"Estimated reconstructability of {len(pairs)} image pairs.")
+
     reconstructions = []
-    pairs = compute_image_pairs(common_tracks, data)
     chrono.lap("compute_image_pairs")
     report["num_candidate_image_pairs"] = len(pairs)
     report["reconstructions"] = []
@@ -1634,7 +1692,13 @@ def incremental_reconstruction(
         if im1 in remaining_images and im2 in remaining_images:
             rec_report = {}
             report["reconstructions"].append(rec_report)
-            _, p1, p2 = common_tracks[im1, im2]
+            if common_tracks is not None:
+                # Save time if the common features are preloaded
+                _, p1, p2 = common_tracks[im1, im2]
+            else:
+                # At the sacrifice of lazily reloading the features, we avoid
+                # storing features for all view pairs in memory
+                p1, p2 = _get_common_feature_arrays(tracks_manager, im1, im2)
             reconstruction, rec_report["bootstrap"] = bootstrap_reconstruction(
                 data, tracks_manager, im1, im2, p1, p2
             )

From d30aaa0b8735f2fdd89814f9458ab80d896f0c74 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Tue, 29 Jul 2025 03:00:40 -0700
Subject: [PATCH 160/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm

Reviewed By: dtolnay

Differential Revision: D79153420

fbshipit-source-id: 9776d5e72041af179f8c9b420f3940ea1e8d03ad
---
 opensfm/src/bundle/src/bundle_adjuster.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 25f68fa0d..404540349 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -2,7 +2,6 @@
 #include <bundle/error/absolute_motion_errors.h>
 #include <bundle/error/motion_prior_errors.h>
 #include <bundle/error/parameters_errors.h>
-#include <bundle/error/position_functors.h>
 #include <bundle/error/prior_error.h>
 #include <bundle/error/projection_errors.h>
 #include <bundle/error/relative_depth_error.h>

From d28bc9b0ad875b64865f9110f41726390b31f06e Mon Sep 17 00:00:00 2001
From: Blueray <83096078+blueraymusic@users.noreply.github.com>
Date: Thu, 31 Jul 2025 00:05:11 -0700
Subject: [PATCH 161/235] Update import_colmap.py (#1103)

Summary:
Colmap openfsm import error fixed https://github.com/mapillary/OpenSfM/issues/1102 #807

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1103

Reviewed By: DodgySpaniard

Differential Revision: D79257777

Pulled By: fabianschenk

fbshipit-source-id: 8ea3b342177a4421fb33ca2db6d31a057f6eaa0f
---
 bin/import_colmap.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/bin/import_colmap.py b/bin/import_colmap.py
index 95a6a2365..209596049 100755
--- a/bin/import_colmap.py
+++ b/bin/import_colmap.py
@@ -23,7 +23,22 @@
 import opensfm.actions.undistort as osfm_u
 from matplotlib import cm
 from mpl_toolkits.axes_grid1 import make_axes_locatable
-from opensfm import dataset, features, pygeometry, pymap, types
+
+try:
+    from opensfm import dataset, features, pygeometry, pymap, types
+except ImportError:
+    # If ImportError, try importing without 'types'
+    try:
+        from opensfm import dataset, features, pygeometry, pymap
+
+        types = None
+    except ImportError as e:
+        print(f"Fallback import failed: {e}")
+        dataset = features = pygeometry = pymap = types = None
+except Exception as e:
+    print(f"Unexpected error importing OpenSfM: {e}")
+    dataset = features = pygeometry = pymap = types = None
+
 
 EXPORT_DIR_NAME = "opensfm_export"
 logger = logging.getLogger(__name__)

From db70523da9c8d6dda0a7c27091f7f9957b8b7164 Mon Sep 17 00:00:00 2001
From: kielnino <kielnino@users.noreply.github.com>
Date: Thu, 31 Jul 2025 00:07:59 -0700
Subject: [PATCH 162/235] Warn user if ceres loss function is not available
 (#1096)

Summary:
I set TukeyLoss without noticing, that it wasn't used. So in this PR `CreateLossFunction` throws a runtime_error if the loss-function is not implemented, instead of silently using nullptr.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1096

Differential Revision: D79258516

Pulled By: fabianschenk

fbshipit-source-id: 2fdbf8fd811e387907e6cb16d58a0791152c7fd0
---
 opensfm/src/bundle/src/bundle_adjuster.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 404540349..c066a394a 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -424,7 +424,8 @@ ceres::LossFunction *CreateLossFunction(std::string name, double threshold) {
   } else if (name.compare("ArctanLoss") == 0) {
     return new ceres::ArctanLoss(threshold);
   }
-  return nullptr;
+  throw std::runtime_error("ceres::LossFunction with name " + name +
+                           " not found.");
 }
 
 void BundleAdjuster::AddLinearMotion(const std::string &shot0_id,

From 7e5cb4a8c03a8b040abfd53c69204a5033c6e6cc Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Mon, 4 Aug 2025 00:41:55 -0700
Subject: [PATCH 163/235] fbcode/mapillary/opensfm/opensfm/pairs_selection.py

Differential Revision: D79356717

fbshipit-source-id: 3211694e0a9a62b29423efec5508db0906d33d76
---
 opensfm/pairs_selection.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 054f1cfa9..194764883 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -199,7 +199,7 @@ def match_candidates_by_distance(
             point, k=nn, distance_upper_bound=max_distance
         )
 
-        if type(neighbors) == int:  # special case with only one NN
+        if isinstance(neighbors, int):  # special case with only one NN
             neighbors = [neighbors]
 
         for j in neighbors:
@@ -544,7 +544,7 @@ def match_candidates_by_time(
         time = exifs[image_ref]["capture_time"]
         distances, neighbors = tree.query([time], k=nn)
 
-        if type(neighbors) == int:  # special case with only one NN
+        if isinstance(neighbors, int):  # special case with only one NN
             neighbors = [neighbors]
 
         for j in neighbors:

From 7f17b895ca7525da5fd555ea441e02daa2eb31b8 Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Wed, 6 Aug 2025 06:43:30 -0700
Subject: [PATCH 164/235] Fix CQS signal modernize-use-using in
 fbcode/mapillary/opensfm

Differential Revision: D79708438

fbshipit-source-id: 678971b789f73efa7f844a882ae529a25d61e3cf
---
 opensfm/src/geometry/essential.h                   |  2 +-
 opensfm/src/geometry/test/camera_functions_test.cc |  6 +++---
 opensfm/src/map/pybind_utils.h                     | 10 ++++------
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/opensfm/src/geometry/essential.h b/opensfm/src/geometry/essential.h
index e0933f57f..f6f47c7f7 100644
--- a/opensfm/src/geometry/essential.h
+++ b/opensfm/src/geometry/essential.h
@@ -127,7 +127,7 @@ std::vector<Eigen::Matrix<double, 3, 3>> EssentialFivePoints(IT begin, IT end) {
 
   // Compute the solutions from action matrix's eigenvectors.
   Eigen::EigenSolver<Eigen::MatrixXd> es(At);
-  typedef Eigen::EigenSolver<Eigen::MatrixXd>::EigenvectorsType Matc;
+  using Matc = Eigen::EigenSolver<Eigen::MatrixXd>::EigenvectorsType;
   Matc V = es.eigenvectors();
   Matc solutions(4, 10);
   solutions.row(0) = V.row(6).array() / V.row(9).array();
diff --git a/opensfm/src/geometry/test/camera_functions_test.cc b/opensfm/src/geometry/test/camera_functions_test.cc
index 5ea44a6e4..bc33584f1 100644
--- a/opensfm/src/geometry/test/camera_functions_test.cc
+++ b/opensfm/src/geometry/test/camera_functions_test.cc
@@ -115,7 +115,7 @@ TEST_F(FunctionFixture, EvaluatesDerivativesCorrectly) {
   ASSERT_NEAR(expected, evaluated, 1e-20);
 
   /* Jacobian ordering : d_input | d_parameters */
-  typedef Eigen::AutoDiffScalar<VecXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<VecXd>;
   VecX<AScalar> eval_adiff(1);
   eval_adiff(0).value() = in[0];
   eval_adiff(0).derivatives() = VecXd::Unit(7, 0);
@@ -163,7 +163,7 @@ TEST_F(PoseFixture, EvaluatesCorrectly) {
 }
 
 TEST_F(PoseFixture, EvaluatesAllDerivativesCorrectly) {
-  typedef Eigen::AutoDiffScalar<VecXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<VecXd>;
 
   VecX<AScalar> point_adiff(3);
   constexpr int size = 9;
@@ -197,7 +197,7 @@ TEST_F(PoseFixture, EvaluatesAllDerivativesCorrectly) {
 }
 
 TEST_F(PoseFixture, EvaluatesPointDerivativesCorrectly) {
-  typedef Eigen::AutoDiffScalar<VecXd> AScalar;
+  using AScalar = Eigen::AutoDiffScalar<VecXd>;
 
   VecX<AScalar> point_adiff(3);
 
diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index 725e666d8..77a823df0 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -57,9 +57,8 @@ template <return_value_policy Policy = return_value_policy::reference_internal,
           typename... Extra>
 iterator make_ref_value_iterator(Iterator first, Sentinel last,
                                  Extra &&...extra) {
-  typedef detail::sfm_iterator_state<Iterator, Sentinel,
-                                     detail::RefValueIterator, Policy>
-      state;
+  using state = detail::sfm_iterator_state<Iterator, Sentinel,
+                                           detail::RefValueIterator, Policy>;
 
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_value_iterator", pybind11::module_local())
@@ -91,9 +90,8 @@ template <
         pybind11::tuple,  // decltype(&((*std::declval<Iterator>()).second)),
     typename... Extra>
 iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&...extra) {
-  typedef detail::sfm_iterator_state<Iterator, Sentinel, detail::ValueIterator,
-                                     Policy>
-      state;
+  using state = detail::sfm_iterator_state<Iterator, Sentinel,
+                                           detail::ValueIterator, Policy>;
 
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_iterator", pybind11::module_local())

From a2b6fc5a94ef31c3031f5398fa54e8a28d7b9a87 Mon Sep 17 00:00:00 2001
From: Ruibin Ma <ruibinma@meta.com>
Date: Tue, 19 Aug 2025 14:35:29 -0700
Subject: [PATCH 165/235] expose aspect_ratio_sd parameter

Summary:
It is questionable to assign the same std for focal length and aspect ratio, because aspect ratio, being the ratio of fu and fv, should be one order of magnitude smaller than fu and fv themselves.

In practice we have noticed problematic maps built from opensfm BA that have very wrong aspect ratio, causing the camera poses to be inaccurate.

Reviewed By: paulinus

Differential Revision: D78990090

fbshipit-source-id: 65334567a693ab8872e91746942ef011f2e62de6
---
 annotation_gui_gcp/run_ba.py              |  1 +
 opensfm/config.py                         |  2 +
 opensfm/src/bundle/bundle_adjuster.h      |  8 +--
 opensfm/src/bundle/pybundle.pyi           | 65 ++++++++++++++---------
 opensfm/src/bundle/python/pybind.cc       |  5 +-
 opensfm/src/bundle/src/bundle_adjuster.cc | 11 ++--
 opensfm/src/sfm/src/ba_helpers.cc         |  3 ++
 7 files changed, 60 insertions(+), 35 deletions(-)

diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index cf65c6c5e..ba6bc3dea 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -301,6 +301,7 @@ def bundle_with_fixed_images(
     )
     ba.set_internal_parameters_prior_sd(
         config["exif_focal_sd"],
+        config["aspect_ratio_sd"],
         config["principal_point_sd"],
         config["radial_distortion_k1_sd"],
         config["radial_distortion_k2_sd"],
diff --git a/opensfm/config.py b/opensfm/config.py
index cd1cb4d91..513575b7f 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -239,6 +239,8 @@ class OpenSfMConfig:
     reprojection_error_sd: float = 0.004
     # The standard deviation of the exif focal length in log-scale
     exif_focal_sd: float = 0.01
+    # The standard deviation of aspect ratio, i.e. fu/fv, in log-scale
+    aspect_ratio_sd: float = 0.01
     # The standard deviation of the principal point coordinates
     principal_point_sd: float = 0.01
     # The standard deviation of the first radial distortion parameter
diff --git a/opensfm/src/bundle/bundle_adjuster.h b/opensfm/src/bundle/bundle_adjuster.h
index 06a959b1e..a9e74f90e 100644
--- a/opensfm/src/bundle/bundle_adjuster.h
+++ b/opensfm/src/bundle/bundle_adjuster.h
@@ -252,9 +252,10 @@ class BundleAdjuster {
   void SetLinearSolverType(std::string t);
   void SetCovarianceAlgorithmType(std::string t);
 
-  void SetInternalParametersPriorSD(double focal_sd, double c_sd, double k1_sd,
-                                    double k2_sd, double p1_sd, double p2_sd,
-                                    double k3_sd, double k4_sd);
+  void SetInternalParametersPriorSD(double focal_sd, double aspect_ratio_sd,
+                                    double c_sd, double k1_sd, double k2_sd,
+                                    double p1_sd, double p2_sd, double k3_sd,
+                                    double k4_sd);
   void SetRigParametersPriorSD(double rig_translation_sd,
                                double rig_rotation_sd);
 
@@ -324,6 +325,7 @@ class BundleAdjuster {
 
   // Camera parameters prior
   double focal_prior_sd_;
+  double aspect_ratio_prior_sd_;
   double c_prior_sd_;
   double k1_sd_;
   double k2_sd_;
diff --git a/opensfm/src/bundle/pybundle.pyi b/opensfm/src/bundle/pybundle.pyi
index 3f5cff7e7..53b40a4ab 100644
--- a/opensfm/src/bundle/pybundle.pyi
+++ b/opensfm/src/bundle/pybundle.pyi
@@ -25,6 +25,7 @@ __all__ = [
     "ReconstructionAlignment",
     "RelativeMotion",
     "RelativeRotation",
+    "StaticExtensionLoader",
 ]
 
 class BundleAdjuster:
@@ -36,7 +37,7 @@ class BundleAdjuster:
     def add_absolute_roll(self, arg0: str, arg1: float, arg2: float) -> None: ...
     def add_absolute_tilt(self, arg0: str, arg1: float, arg2: float) -> None: ...
     def add_absolute_up_vector(
-        self, arg0: str, arg1: numpy.ndarray, arg2: float
+        self, arg0: str, arg1: numpy.typing.NDArray, arg2: float
     ) -> None: ...
     def add_camera(
         self,
@@ -49,20 +50,24 @@ class BundleAdjuster:
         self, arg0: str, arg1: str, arg2: float, arg3: float
     ) -> None: ...
     def add_heatmap(
-        self, arg0: str, arg1: List[float], arg2: int, arg3: float
+        self, arg0: str, arg1: list[float], arg2: int, arg3: float
     ) -> None: ...
     def add_linear_motion(
         self, arg0: str, arg1: str, arg2: str, arg3: float, arg4: float, arg5: float
     ) -> None: ...
-    def add_point(self, arg0: str, arg1: numpy.ndarray, arg2: bool) -> None: ...
+    def add_point(self, arg0: str, arg1: numpy.typing.NDArray, arg2: bool) -> None: ...
     def add_point_prior(
-        self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: bool
+        self,
+        arg0: str,
+        arg1: numpy.typing.NDArray,
+        arg2: numpy.typing.NDArray,
+        arg3: bool,
     ) -> None: ...
     def add_point_projection_observation(
         self,
         shot: str,
         point: str,
-        observation: numpy.ndarray,
+        observation: numpy.typing.NDArray,
         std_deviation: float,
         depth_prior: Optional[opensfm.pymap.Depth] = None,
     ) -> None: ...
@@ -83,12 +88,16 @@ class BundleAdjuster:
         self,
         arg0: str,
         arg1: opensfm.pygeometry.Pose,
-        arg2: Dict[str, str],
-        arg3: Dict[str, str],
+        arg2: dict[str, str],
+        arg3: dict[str, str],
         arg4: bool,
     ) -> None: ...
     def add_rig_instance_position_prior(
-        self, arg0: str, arg1: numpy.ndarray, arg2: numpy.ndarray, arg3: str
+        self,
+        arg0: str,
+        arg1: numpy.typing.NDArray,
+        arg2: numpy.typing.NDArray,
+        arg3: str,
     ) -> None: ...
     def brief_report(self) -> str: ...
     def full_report(self) -> str: ...
@@ -106,14 +115,15 @@ class BundleAdjuster:
     def set_gauge_fix_shots(self, arg0: str, arg1: str) -> None: ...
     def set_internal_parameters_prior_sd(
         self,
-        arg0: float,
-        arg1: float,
-        arg2: float,
-        arg3: float,
-        arg4: float,
-        arg5: float,
-        arg6: float,
-        arg7: float,
+        focal_sd: float,
+        aspect_ratio_sd: float,
+        c_sd: float,
+        k1_sd: float,
+        k2_sd: float,
+        p1_sd: float,
+        p2_sd: float,
+        k3_sd: float,
+        k4_sd: float,
     ) -> None: ...
     def set_linear_solver_type(self, arg0: str) -> None: ...
     def set_max_num_iterations(self, arg0: int) -> None: ...
@@ -127,11 +137,11 @@ class Point:
     @property
     def id(self) -> str: ...
     @property
-    def p(self) -> numpy.ndarray: ...
+    def p(self) -> numpy.typing.NDArray: ...
     @property
-    def reprojection_errors(self) -> Dict[str, numpy.ndarray]: ...
+    def reprojection_errors(self) -> dict[str, numpy.typing.NDArray]: ...
     @reprojection_errors.setter
-    def reprojection_errors(self, arg0: Dict[str, numpy.ndarray]) -> None: ...
+    def reprojection_errors(self, arg0: dict[str, numpy.typing.NDArray]) -> None: ...
 
 class RAReconstruction:
     def __init__(self) -> None: ...
@@ -314,13 +324,13 @@ class RelativeMotion:
         self,
         arg0: str,
         arg1: str,
-        arg2: numpy.ndarray,
-        arg3: numpy.ndarray,
+        arg2: numpy.typing.NDArray,
+        arg3: numpy.typing.NDArray,
         arg4: float,
         arg5: float,
         arg6: bool,
     ) -> None: ...
-    def set_scale_matrix(self, arg0: numpy.ndarray) -> None: ...
+    def set_scale_matrix(self, arg0: numpy.typing.NDArray) -> None: ...
     @property
     def rig_instance_i(self) -> str: ...
     @rig_instance_i.setter
@@ -331,12 +341,12 @@ class RelativeMotion:
     def rig_instance_j(self, arg0: str) -> None: ...
 
 class RelativeRotation:
-    def __init__(self, arg0: str, arg1: str, arg2: numpy.ndarray) -> None: ...
-    def set_scale_matrix(self, arg0: numpy.ndarray) -> None: ...
+    def __init__(self, arg0: str, arg1: str, arg2: numpy.typing.NDArray) -> None: ...
+    def set_scale_matrix(self, arg0: numpy.typing.NDArray) -> None: ...
     @property
-    def r(self) -> numpy.ndarray: ...
+    def r(self) -> numpy.typing.NDArray: ...
     @r.setter
-    def r(self, arg1: numpy.ndarray) -> None: ...
+    def r(self, arg1: numpy.typing.NDArray) -> None: ...
     @property
     def shot_i(self) -> str: ...
     @shot_i.setter
@@ -345,3 +355,6 @@ class RelativeRotation:
     def shot_j(self) -> str: ...
     @shot_j.setter
     def shot_j(self, arg0: str) -> None: ...
+
+class StaticExtensionLoader:
+    pass
diff --git a/opensfm/src/bundle/python/pybind.cc b/opensfm/src/bundle/python/pybind.cc
index 3dd4a02b3..e4c802724 100644
--- a/opensfm/src/bundle/python/pybind.cc
+++ b/opensfm/src/bundle/python/pybind.cc
@@ -94,7 +94,10 @@ PYBIND11_MODULE(pybundle, m) {
       .def("add_linear_motion", &bundle::BundleAdjuster::AddLinearMotion)
       .def("set_gauge_fix_shots", &bundle::BundleAdjuster::SetGaugeFixShots)
       .def("set_internal_parameters_prior_sd",
-           &bundle::BundleAdjuster::SetInternalParametersPriorSD)
+           &bundle::BundleAdjuster::SetInternalParametersPriorSD,
+           py::arg("focal_sd"), py::arg("aspect_ratio_sd"), py::arg("c_sd"),
+           py::arg("k1_sd"), py::arg("k2_sd"), py::arg("p1_sd"),
+           py::arg("p2_sd"), py::arg("k3_sd"), py::arg("k4_sd"))
       .def("set_compute_covariances",
            &bundle::BundleAdjuster::SetComputeCovariances)
       .def("get_covariance_estimation_valid",
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index c066a394a..3c5f97f8b 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -25,6 +25,7 @@ BundleAdjuster::BundleAdjuster() {
   SetPointProjectionLossFunction("CauchyLoss", 1.0);
   SetRelativeMotionLossFunction("CauchyLoss", 1.0);
   focal_prior_sd_ = 1;
+  aspect_ratio_prior_sd_ = 1;
   c_prior_sd_ = 1;
   k1_sd_ = 1;
   k2_sd_ = 1;
@@ -48,7 +49,7 @@ geometry::Camera BundleAdjuster::GetDefaultCameraSigma(
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::Focal)] =
       focal_prior_sd_;
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::AspectRatio)] =
-      focal_prior_sd_;
+      aspect_ratio_prior_sd_;
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::Cx)] = c_prior_sd_;
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::Cy)] = c_prior_sd_;
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::K1)] = k1_sd_;
@@ -376,11 +377,11 @@ void BundleAdjuster::SetCovarianceAlgorithmType(std::string t) {
   covariance_algorithm_type_ = t;
 }
 
-void BundleAdjuster::SetInternalParametersPriorSD(double focal_sd, double c_sd,
-                                                  double k1_sd, double k2_sd,
-                                                  double p1_sd, double p2_sd,
-                                                  double k3_sd, double k4_sd) {
+void BundleAdjuster::SetInternalParametersPriorSD(
+    double focal_sd, double aspect_ratio_sd, double c_sd, double k1_sd,
+    double k2_sd, double p1_sd, double p2_sd, double k3_sd, double k4_sd) {
   focal_prior_sd_ = focal_sd;
+  aspect_ratio_prior_sd_ = aspect_ratio_sd;
   c_prior_sd_ = c_sd;
   k1_sd_ = k1_sd;
   k2_sd_ = k2_sd;
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 85ed5747a..1f1d55e95 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -255,6 +255,7 @@ py::tuple BAHelpers::BundleLocal(
       config["loss_function_threshold"].cast<double>());
   ba.SetInternalParametersPriorSD(
       config["exif_focal_sd"].cast<double>(),
+      config["aspect_ratio_sd"].cast<double>(),
       config["principal_point_sd"].cast<double>(),
       config["radial_distortion_k1_sd"].cast<double>(),
       config["radial_distortion_k2_sd"].cast<double>(),
@@ -536,6 +537,7 @@ py::dict BAHelpers::BundleShotPoses(
       config["loss_function_threshold"].cast<double>());
   ba.SetInternalParametersPriorSD(
       config["exif_focal_sd"].cast<double>(),
+      config["aspect_ratio_sd"].cast<double>(),
       config["principal_point_sd"].cast<double>(),
       config["radial_distortion_k1_sd"].cast<double>(),
       config["radial_distortion_k2_sd"].cast<double>(),
@@ -728,6 +730,7 @@ py::dict BAHelpers::Bundle(
       config["loss_function_threshold"].cast<double>());
   ba.SetInternalParametersPriorSD(
       config["exif_focal_sd"].cast<double>(),
+      config["aspect_ratio_sd"].cast<double>(),
       config["principal_point_sd"].cast<double>(),
       config["radial_distortion_k1_sd"].cast<double>(),
       config["radial_distortion_k2_sd"].cast<double>(),

From 8074f9fbc67ddcfc0f1726f69db288365a83ad95 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Mon, 25 Aug 2025 02:54:59 -0700
Subject: [PATCH 166/235] Use old style typing to keep supporting python 3.8.
 (#1104)

Summary:
Fixes github CI

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1104

Differential Revision: D80844236

Pulled By: paulinus

fbshipit-source-id: d5ab888d2d4f472246dc606b6909d132391d6694
---
 opensfm/reconstruction.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 37adf068c..3acd262eb 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -13,7 +13,6 @@
 
 import cv2
 import numpy as np
-from numpy import typing as npt
 from numpy.typing import NDArray
 from opensfm import (
     log,
@@ -1614,7 +1613,7 @@ def _get_common_feature_arrays(
     tracks_manager: pymap.TracksManager,
     im1: str,
     im2: str,
-) -> tuple[npt.NDArray, npt.NDArray]:
+) -> Tuple[NDArray, NDArray]:
     """Return the feature arrays of common tracks between two images."""
     features1 = []
     features2 = []
@@ -1630,7 +1629,7 @@ def compute_image_pairs_sequential(
     data: DataSetBase,
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
-) -> list[tuple[str, str]]:
+) -> List[Tuple[str, str]]:
     """Compute all possible pairs of images that share at least `min_common` points.
     The pairs are sorted by "reconstructability" which is estimated by the
     pairwise_reconstructability function.

From c7847d9f541d0baebe8199f3b028f218e0a219d6 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Fri, 29 Aug 2025 09:44:15 -0700
Subject: [PATCH 167/235] fbcode/mapillary/opensfm/opensfm/stats.py

Differential Revision: D81228161

fbshipit-source-id: cc1a5f43bd15343af99b55c37998fc3f6b44f179
---
 opensfm/stats.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/opensfm/stats.py b/opensfm/stats.py
index 389737441..754553eeb 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -515,11 +515,7 @@ def save_matchgraph(
             continue
         o1 = reconstructions[comp1].shots[node1].pose.get_origin()
         o2 = reconstructions[comp2].shots[node2].pose.get_origin()
-        # pyre-fixme[58]: `-` is not supported for operand types `int` and
-        #  `floating[Any]`.
-        # pyre-fixme[58]: `/` is not supported for operand types `int` and
-        #  `floating[Any]`.
-        c = max(0, min(1.0, 1 - (edge - lowest) / (highest - lowest)))
+        c = max(0, min(1.0, 1 - (float(edge) - lowest) / (highest - lowest)))
         plt.plot([o1[0], o2[0]], [o1[1], o2[1]], linestyle="-", color=cmap(c))
 
     for i, rec in enumerate(reconstructions):

From e7aa0b0712569fa60bf0eb548cefdab8ba10757c Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Fri, 29 Aug 2025 09:54:05 -0700
Subject: [PATCH 168/235] fbcode/mapillary/opensfm/opensfm/align.py

Differential Revision: D81223929

fbshipit-source-id: 03612c6150dc26d8b28c283e89b9bb67bbc437dc
---
 opensfm/align.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index 5b020e36e..b28af8e77 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -277,14 +277,10 @@ def compute_orientation_prior_similarity(
 
         # Clamp shots pair scale to 1km, so the
         # optimizer can still catch-up acceptable error
-        max_scale = 1000
+        max_scale = 1000.0
         current_scale = np.linalg.norm(b)
         if two_shots and current_scale > max_scale:
-            # pyre-fixme[58]: `/` is not supported for operand types `int` and
-            #  `floating[typing.Any]`.
             b = max_scale * b / current_scale
-            # pyre-fixme[58]: `/` is not supported for operand types `int` and
-            #  `floating[typing.Any]`.
             s = max_scale / current_scale
     else:
         try:

From de97cd21d161d5928301793e56de5ed10f1d24a7 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Tue, 2 Sep 2025 05:41:54 -0700
Subject: [PATCH 169/235] fbcode/mapillary/opensfm/opensfm/video.py

Reviewed By: d99m

Differential Revision: D81439436

fbshipit-source-id: 0be3d849cd7bb41910d2e64779d37403e7400b9a
---
 opensfm/video.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/opensfm/video.py b/opensfm/video.py
index 45028b6e3..0fab6ccec 100644
--- a/opensfm/video.py
+++ b/opensfm/video.py
@@ -11,10 +11,11 @@
 
 def video_orientation(video_file: str) -> int:
     # Rotation
-    # pyre-fixme[16]: Optional type has no attribute `read`.
-    rotation = Popen(
-        ["exiftool", "-Rotation", "-b", video_file], stdout=PIPE
-    ).stdout.read()
+    process = Popen(["exiftool", "-Rotation", "-b", video_file], stdout=PIPE)
+    assert (
+        process.stdout is not None
+    ), "stdout should not be None when stdout=PIPE is specified"
+    rotation = process.stdout.read().decode("utf-8").strip()
     if rotation:
         rotation = float(rotation)
         if rotation == 0:
@@ -49,10 +50,11 @@ def import_video_with_gpx(
         video_start_time = dateutil.parser.parse(start_time)
     else:
         try:
-            # pyre-fixme[16]: Optional type has no attribute `read`.
-            exifdate = Popen(
-                ["exiftool", "-CreateDate", "-b", video_file], stdout=PIPE
-            ).stdout.read()
+            process = Popen(["exiftool", "-CreateDate", "-b", video_file], stdout=PIPE)
+            assert (
+                process.stdout is not None
+            ), "stdout should not be None when stdout=PIPE is specified"
+            exifdate = process.stdout.read().decode("utf-8").strip()
             video_start_time = datetime.datetime.strptime(exifdate, "%Y:%m:%d %H:%M:%S")
         except Exception:
             print("Video recording timestamp not found. Using first GPS point time.")

From 7eb66cfa0d2f1fedfa9f4b03bb684696540a1db0 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Tue, 2 Sep 2025 05:47:18 -0700
Subject: [PATCH 170/235] 
 fbcode/mapillary/opensfm/opensfm/test/data_generation.py

Reviewed By: d99m

Differential Revision: D81430562

fbshipit-source-id: 55d75c506cc4bde2bbc75aa93cbaba9dcd7ee2b0
---
 opensfm/test/data_generation.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/opensfm/test/data_generation.py b/opensfm/test/data_generation.py
index 8e48845a9..4f59d520e 100644
--- a/opensfm/test/data_generation.py
+++ b/opensfm/test/data_generation.py
@@ -15,8 +15,7 @@
     DATA_PATH = os.path.abspath("data")
 
 
-# pyre-fixme[2]: switch from tmpdir to tmp_path
-def create_berlin_test_folder(tmpdir) -> opensfm.dataset.DataSet:
+def create_berlin_test_folder(tmpdir: Any) -> opensfm.dataset.DataSet:
     src = os.path.join(DATA_PATH, "berlin")
     dst = str(tmpdir.mkdir("berlin"))
     files = ["images", "masks", "config.yaml", "ground_control_points.json"]

From 6efcb2e2722b06ea9f31ed92aa824de7da6e599b Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Tue, 2 Sep 2025 05:49:09 -0700
Subject: [PATCH 171/235] 
 fbcode/mapillary/opensfm/opensfm/synthetic_data/synthetic_generator.py

Reviewed By: d99m

Differential Revision: D81225044

fbshipit-source-id: 4079c94fc2e4b23b34a459308f70c8337edab60b
---
 opensfm/synthetic_data/synthetic_generator.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/opensfm/synthetic_data/synthetic_generator.py b/opensfm/synthetic_data/synthetic_generator.py
index b0d72bd61..136fcabdd 100644
--- a/opensfm/synthetic_data/synthetic_generator.py
+++ b/opensfm/synthetic_data/synthetic_generator.py
@@ -196,14 +196,12 @@ def _gps_dop(shot: pymap.Shot) -> float:
 
     speed_ms = 10.0
     previous_pose = None
-    previous_time = 0
+    previous_time = 0.0
     for rig_instance in sorted(
         reconstruction.rig_instances.values(), key=lambda x: x.id
     ):
         pose = rig_instance.pose.get_origin()
         if previous_pose is not None:
-            # pyre-fixme[58]: `+` is not supported for operand types `int` and
-            #  `floating[typing.Any]`.
             previous_time += np.linalg.norm(pose - previous_pose) / speed_ms
         previous_pose = pose
         for shot_id in rig_instance.shots:

From 9acae6f5b625fca47c541adcd8710fb8a3eb4a13 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Tue, 2 Sep 2025 06:06:14 -0700
Subject: [PATCH 172/235] 
 fbcode/mapillary/opensfm/opensfm/test/test_commands.py

Reviewed By: d99m

Differential Revision: D81312747

fbshipit-source-id: 2c54996e6cd1dd58ddaab5ffc5e8657fb1c1db52
---
 opensfm/test/test_commands.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/opensfm/test/test_commands.py b/opensfm/test/test_commands.py
index fc3cf5b13..649a7c2ad 100644
--- a/opensfm/test/test_commands.py
+++ b/opensfm/test/test_commands.py
@@ -2,7 +2,7 @@
 import argparse
 from os.path import join
 from types import ModuleType
-from typing import List
+from typing import Any, List
 
 from opensfm import commands, dataset
 from opensfm.test import data_generation, utils
@@ -15,8 +15,7 @@ def run_command(command: ModuleType, args: List[str]) -> None:
     command.run(dataset.DataSet(parsed_args.dataset), parsed_args)
 
 
-# pyre-fixme[2]: switch from tmpdir to tmp_path
-def test_run_all(tmpdir) -> None:
+def test_run_all(tmpdir: Any) -> None:
     data = data_generation.create_berlin_test_folder(tmpdir)
     run_all_commands = [
         commands.extract_metadata,

From 3e7b1db5c33408b279dd5698e7fa9d3aa6a1c5f0 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Wed, 3 Sep 2025 18:52:24 -0700
Subject: [PATCH 173/235] 
 fbcode/mapillary/opensfm/opensfm/test/test_pairs_selection.py

Differential Revision: D81573910

fbshipit-source-id: aeb66eb6e395909dd959874cbda296abe3dca829
---
 opensfm/test/test_pairs_selection.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index 6518b1385..dd8d0c5b8 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -27,8 +27,7 @@ def clear_cache() -> Iterator[None]:
 
 
 @pytest.fixture(scope="module", autouse=True)
-# pyre-fixme[2]: switch from tmpdir to tmp_path
-def lund_path(tmpdir_factory) -> str:
+def lund_path(tmpdir_factory: Any) -> str:
     """
     Precompute exif and features to avoid doing
     it for every test which is time consuming.

From 05eaa1ef83be5c35d479251fa71f9ee11d147cd3 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Thu, 4 Sep 2025 15:47:22 -0700
Subject: [PATCH 174/235] fbcode/mapillary/opensfm/opensfm/test/test_dataset.py

Differential Revision: D81670445

fbshipit-source-id: c42b6f330525a096e80a74ccf912c8153b0dcd78
---
 opensfm/test/test_dataset.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/opensfm/test/test_dataset.py b/opensfm/test/test_dataset.py
index 1a6b1acb9..4c3257f85 100644
--- a/opensfm/test/test_dataset.py
+++ b/opensfm/test/test_dataset.py
@@ -1,12 +1,13 @@
 # pyre-strict
+from typing import Any
+
 import numpy as np
 
 from opensfm import features
 from opensfm.test import data_generation
 
 
-# pyre-fixme[2]: switch from tmpdir to tmp_path
-def test_dataset_load_features_sift(tmpdir) -> None:
+def test_dataset_load_features_sift(tmpdir: Any) -> None:
     data = data_generation.create_berlin_test_folder(tmpdir)
 
     assert len(data.images()) == 3

From 8cc59856fdacfbf223225f7c0aba4ea73bcf5fda Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 10 Sep 2025 01:17:28 -0700
Subject: [PATCH 175/235] Improve final point cloud with filtering (#1108)

Summary:
This PR adds a point cloud cleaning step that removes points with high covariance ellipsoid, and isolated points. This greatly improves the final point cloud, especially if subsequent steps rely on it directly.

On a Mapillary dataset : CLEAN on LEFT, ORIGINAL on RIGHT
<img width="3135" height="1820" alt="Screenshot From 2025-08-21 16-48-08" src="https://github.com/user-attachments/assets/a5f94461-0ff1-4396-86b5-073c77e1defa" />
<img width="3135" height="1820" alt="Screenshot From 2025-08-21 16-47-30" src="https://github.com/user-attachments/assets/05160e57-1d88-4894-a805-697181ccaf54" />

On an aerial dataset  :
CLEAN
<img width="2583" height="1349" alt="Screenshot From 2025-08-21 12-43-55" src="https://github.com/user-attachments/assets/dc42ccaa-1c76-46e8-b652-519adbe52d6d" />
ORIGINAL
<img width="2583" height="1349" alt="Screenshot From 2025-08-21 12-34-06" src="https://github.com/user-attachments/assets/6c604806-8d2d-40fa-a06e-611837146675" />

This branch is on top fix-gcp-handling

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1108

Test Plan:
Imported from GitHub, without a `Test Plan:` line.

Rollback Plan:

Reviewed By: DodgySpaniard

Differential Revision: D81899119

Pulled By: paulinus

fbshipit-source-id: e1434ec894a8e66b853cd484e8d104dbbbbd3c9a
---
 opensfm/config.py                         |   3 +
 opensfm/reconstruction.py                 |   9 +
 opensfm/src/geometry/src/covariance.cc    |   2 +-
 opensfm/src/geometry/src/triangulation.cc |  17 +-
 opensfm/src/geometry/triangulation.h      |   2 +
 opensfm/src/sfm/CMakeLists.txt            |   1 +
 opensfm/src/sfm/pysfm.pyi                 |  91 +++++++--
 opensfm/src/sfm/python/pybind.cc          |   8 +
 opensfm/src/sfm/src/tracks_helpers.cc     | 235 +++++++++++++++++++++-
 opensfm/src/sfm/tracks_helpers.h          |   8 +
 10 files changed, 345 insertions(+), 31 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 513575b7f..4c3f7c238 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -293,6 +293,9 @@ class OpenSfMConfig:
     # Max number of shots to optimize during local bundle adjustment
     local_bundle_max_shots: int = 30
 
+    # Remove uncertain and isolated points from the final point cloud
+    filter_final_point_cloud: bool = False
+
     # Save reconstructions at every iteration
     save_partial_reconstructions: bool = False
 
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 3acd262eb..071e4a0f8 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1538,6 +1538,15 @@ def grow_reconstruction(
 
     bundle(reconstruction, camera_priors, rig_camera_priors, gcp, config)
     remove_outliers(reconstruction, config)
+
+    if config["filter_final_point_cloud"]:
+        bad_condition = pysfm.filter_badly_conditioned_points(
+            reconstruction.map, config["triangulation_min_ray_angle"]
+        )
+        logger.info("Removed bad-condition: {}".format(bad_condition))
+        isolated = pysfm.remove_isolated_points(reconstruction.map)
+        logger.info("Removed isolated: {}".format(isolated))
+
     paint_reconstruction(data, tracks_manager, reconstruction)
     return reconstruction, report
 
diff --git a/opensfm/src/geometry/src/covariance.cc b/opensfm/src/geometry/src/covariance.cc
index b7cbdd3d1..e50b9eb11 100644
--- a/opensfm/src/geometry/src/covariance.cc
+++ b/opensfm/src/geometry/src/covariance.cc
@@ -26,7 +26,7 @@ std::pair<Mat3d, double> ComputePointInverseCovariance(
     const std::vector<Vec2d>& observations, const Vec3d& point) {
   double sigma2 = 0;  // Assume centered errors
   Mat3d covariance = Mat3d::Zero();
-  for (int i = 0; i < cameras.size(); ++i) {
+  for (int i = 0; i < observations.size(); ++i) {
     const auto result = ComputeJacobianReprojectionError(
         cameras[i], poses[i], observations[i], point);
     const auto& jacobian = result.first;
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index e29272b8d..65a22ead9 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -10,15 +10,6 @@
 
 namespace {
 
-double AngleBetweenVectors(const Vec3d &u, const Vec3d &v) {
-  double c = (u.dot(v)) / sqrt(u.dot(u) * v.dot(v));
-  if (std::fabs(c) >= 1.0) {
-    return 0.0;
-  } else {
-    return acos(c);
-  }
-}
-
 struct BearingErrorCost : public ceres::CostFunction {
   constexpr static int Size = 3;
 
@@ -74,6 +65,14 @@ struct BearingErrorCost : public ceres::CostFunction {
 
 namespace geometry {
 
+double AngleBetweenVectors(const Vec3d &u, const Vec3d &v) {
+  double c = (u.dot(v)) / std::sqrt(u.dot(u) * v.dot(v));
+  if (std::fabs(c) >= 1.0) {
+    return 0.0;
+  } else {
+    return acos(c);
+  }
+}
 std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
                                               const MatX3d &bearings,
                                               double threshold,
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index 4685245e5..fcbbd2e9a 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -9,6 +9,8 @@
 
 namespace geometry {
 
+double AngleBetweenVectors(const Vec3d &u, const Vec3d &v);
+
 std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
                                               const MatX3d &bearings,
                                               double threshold,
diff --git a/opensfm/src/sfm/CMakeLists.txt b/opensfm/src/sfm/CMakeLists.txt
index 7f56b791b..7e99ec8cc 100644
--- a/opensfm/src/sfm/CMakeLists.txt
+++ b/opensfm/src/sfm/CMakeLists.txt
@@ -14,6 +14,7 @@ target_link_libraries(sfm
     foundation
     map
     bundle
+    vl
 )
 target_include_directories(sfm PUBLIC ${CMAKE_SOURCE_DIR})
 
diff --git a/opensfm/src/sfm/pysfm.pyi b/opensfm/src/sfm/pysfm.pyi
index 96df11d6e..71f66c3a2 100644
--- a/opensfm/src/sfm/pysfm.pyi
+++ b/opensfm/src/sfm/pysfm.pyi
@@ -7,36 +7,89 @@
 # Tip: Be sure to run this with the build mode you use for your project, e.g.,
 # @//arvr/mode/linux/opt (or dev) in arvr.
 #
-# Ignore errors for [5] global variable types and [24] untyped generics.
-# pyre-ignore-all-errors[5,24]
+# Ignore errors for [24] untyped generics.
+# pyre-ignore-all-errors[24]
 
 import opensfm.pybundle
 import opensfm.pygeometry
 import opensfm.pymap
 from typing import *
-__all__  = [
-"BAHelpers",
-"add_connections",
-"count_tracks_per_shot",
-"realign_maps",
-"remove_connections"
+
+__all__ = [
+    "BAHelpers",
+    "StaticExtensionLoader",
+    "add_connections",
+    "count_tracks_per_shot",
+    "filter_badly_conditioned_points",
+    "realign_maps",
+    "remove_connections",
+    "remove_isolated_points",
 ]
+
 class BAHelpers:
     @staticmethod
-    def add_gcp_to_bundle(arg0: opensfm.pybundle.BundleAdjuster, arg1: opensfm.pymap.Map, arg2: List[opensfm.pymap.GroundControlPoint], arg3: dict) -> int: ...
+    def add_gcp_to_bundle(
+        arg0: opensfm.pybundle.BundleAdjuster,
+        arg1: opensfm.pymap.Map,
+        arg2: list[opensfm.pymap.GroundControlPoint],
+        arg3: dict,
+    ) -> int: ...
     @staticmethod
-    def bundle(arg0: opensfm.pymap.Map, arg1: Dict[str, opensfm.pygeometry.Camera], arg2: Dict[str, opensfm.pymap.RigCamera], arg3: List[opensfm.pymap.GroundControlPoint], arg4: dict) -> dict: ...
+    def bundle(
+        arg0: opensfm.pymap.Map,
+        arg1: dict[str, opensfm.pygeometry.Camera],
+        arg2: dict[str, opensfm.pymap.RigCamera],
+        arg3: list[opensfm.pymap.GroundControlPoint],
+        arg4: dict,
+    ) -> dict: ...
     @staticmethod
-    def bundle_local(arg0: opensfm.pymap.Map, arg1: Dict[str, opensfm.pygeometry.Camera], arg2: Dict[str, opensfm.pymap.RigCamera], arg3: List[opensfm.pymap.GroundControlPoint], arg4: str, arg5: dict) -> tuple: ...
+    def bundle_local(
+        arg0: opensfm.pymap.Map,
+        arg1: dict[str, opensfm.pygeometry.Camera],
+        arg2: dict[str, opensfm.pymap.RigCamera],
+        arg3: list[opensfm.pymap.GroundControlPoint],
+        arg4: str,
+        arg5: dict,
+    ) -> tuple: ...
     @staticmethod
-    def bundle_shot_poses(arg0: opensfm.pymap.Map, arg1: Set[str], arg2: Dict[str, opensfm.pygeometry.Camera], arg3: Dict[str, opensfm.pymap.RigCamera], arg4: dict) -> dict: ...
+    def bundle_shot_poses(
+        arg0: opensfm.pymap.Map,
+        arg1: set[str],
+        arg2: dict[str, opensfm.pygeometry.Camera],
+        arg3: dict[str, opensfm.pymap.RigCamera],
+        arg4: dict,
+    ) -> dict: ...
     @staticmethod
-    def bundle_to_map(arg0: opensfm.pybundle.BundleAdjuster, arg1: opensfm.pymap.Map, arg2: bool) -> None: ...
+    def bundle_to_map(
+        arg0: opensfm.pybundle.BundleAdjuster, arg1: opensfm.pymap.Map, arg2: bool
+    ) -> None: ...
     @staticmethod
-    def detect_alignment_constraints(arg0: opensfm.pymap.Map, arg1: dict, arg2: List[opensfm.pymap.GroundControlPoint]) -> str: ...
+    def detect_alignment_constraints(
+        arg0: opensfm.pymap.Map,
+        arg1: dict,
+        arg2: list[opensfm.pymap.GroundControlPoint],
+    ) -> str: ...
     @staticmethod
-    def shot_neighborhood_ids(arg0: opensfm.pymap.Map, arg1: str, arg2: int, arg3: int, arg4: int) -> Tuple[Set[str], Set[str]]: ...
-def add_connections(arg0: opensfm.pymap.TracksManager, arg1: str, arg2: List[str]) -> None:...
-def count_tracks_per_shot(arg0: opensfm.pymap.TracksManager, arg1: List[str], arg2: List[str]) -> Dict[str, int]:...
-def realign_maps(arg0: opensfm.pymap.Map, arg1: opensfm.pymap.Map, arg2: bool) -> None:...
-def remove_connections(arg0: opensfm.pymap.TracksManager, arg1: str, arg2: List[str]) -> None:...
+    def shot_neighborhood_ids(
+        arg0: opensfm.pymap.Map, arg1: str, arg2: int, arg3: int, arg4: int
+    ) -> tuple[set[str], set[str]]: ...
+
+class StaticExtensionLoader:
+    pass
+
+def add_connections(
+    arg0: opensfm.pymap.TracksManager, arg1: str, arg2: list[str]
+) -> None: ...
+def count_tracks_per_shot(
+    arg0: opensfm.pymap.TracksManager, arg1: list[str], arg2: list[str]
+) -> dict[str, int]: ...
+def filter_badly_conditioned_points(
+    map: opensfm.pymap.Map, min_angle_deg: float = 1.0, min_abs_det: float = 1e-15
+) -> int: ...
+def realign_maps(
+    arg0: opensfm.pymap.Map, arg1: opensfm.pymap.Map, arg2: bool
+) -> None: ...
+def remove_connections(
+    arg0: opensfm.pymap.TracksManager, arg1: str, arg2: list[str]
+) -> None: ...
+def remove_isolated_points(map: opensfm.pymap.Map, k: int = 7) -> int: ...
diff --git a/opensfm/src/sfm/python/pybind.cc b/opensfm/src/sfm/python/pybind.cc
index 55e66686c..2cc7eea5d 100644
--- a/opensfm/src/sfm/python/pybind.cc
+++ b/opensfm/src/sfm/python/pybind.cc
@@ -18,6 +18,14 @@ PYBIND11_MODULE(pysfm, m) {
         py::call_guard<py::gil_scoped_release>());
   m.def("remove_connections", &sfm::tracks_helpers::RemoveConnections,
         py::call_guard<py::gil_scoped_release>());
+  m.def("filter_badly_conditioned_points",
+        &sfm::tracks_helpers::FilterBadlyConditionedPoints, py::arg("map"),
+        py::arg("min_angle_deg") = 1.0, py::arg("min_abs_det") = 1e-15,
+        py::call_guard<py::gil_scoped_release>());
+
+  m.def("remove_isolated_points", &sfm::tracks_helpers::RemoveIsolatedPoints,
+        py::arg("map"), py::arg("k") = 7,
+        py::call_guard<py::gil_scoped_release>());
 
   py::class_<sfm::BAHelpers>(m, "BAHelpers")
       .def_static("bundle", &sfm::BAHelpers::Bundle)
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index 8b8ffaab2..f43f62a76 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -1,7 +1,20 @@
-#include <sfm/tracks_helpers.h>
+#include "sfm/tracks_helpers.h"
 
-#include <unordered_map>
+#include <geometry/covariance.h>
+#include <geometry/triangulation.h>
+#include <map/landmark.h>
+#include <map/shot.h>
+
+#include <Eigen/Eigen>
+#include <algorithm>
+#include <cmath>
+#include <numeric>
 #include <unordered_set>
+#include <vector>
+
+extern "C" {
+#include <vl/kdtree.h>
+}
 
 namespace sfm::tracks_helpers {
 std::unordered_map<map::ShotId, int> CountTracksPerShot(
@@ -42,4 +55,222 @@ void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
     manager.RemoveObservation(shot_id, connection);
   }
 }
+
+int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg,
+                                 double min_abs_det) {
+  std::vector<map::LandmarkId> to_remove;
+
+  // Cull based on stats on covariance's condition number
+  constexpr double kMaxCond = 1000;
+  constexpr double kSigmaMultiplier = 1.0;
+  std::vector<std::pair<map::LandmarkId, double>> landmark_conds;
+  landmark_conds.reserve(map.GetLandmarks().size());
+
+  // Iterate over a snapshot of landmarks to decide removals.
+  for (const auto& kv : map.GetLandmarks()) {
+    const map::LandmarkId& lm_id = kv.first;
+    const map::Landmark& lm = kv.second;
+
+    const auto& observations = lm.GetObservations();
+
+    std::vector<geometry::Camera> cameras;
+    cameras.reserve(observations.size());
+    std::vector<geometry::Pose> poses;
+    poses.reserve(observations.size());
+    std::vector<Vec2d> obs_vec;
+    obs_vec.reserve(observations.size());
+
+    // Build camera/pose/observation vectors from observations.
+    for (const auto& obs_kv : observations) {
+      map::Shot* shot_ptr = obs_kv.first;
+      if (!shot_ptr) {
+        continue;
+      }
+
+      const geometry::Pose* pose_ptr = shot_ptr->GetPose();
+      const geometry::Camera* cam_ptr = shot_ptr->GetCamera();
+      if (!pose_ptr || !cam_ptr) {
+        continue;
+      }
+
+      // Get the shot's Observation for this landmark.
+      map::Observation* obs_ptr =
+          shot_ptr->GetLandmarkObservation(const_cast<map::Landmark*>(&lm));
+      if (!obs_ptr) {
+        continue;
+      }
+
+      cameras.push_back(*cam_ptr);
+      poses.push_back(*pose_ptr);
+      obs_vec.push_back(obs_ptr->point);
+    }
+
+    // First simple check based on angle between all pairs of raysmap
+    double rad_angle = min_angle_deg * M_PI / 180.0;
+    bool to_keep = false;
+    for (size_t i = 0; i < poses.size() && !to_keep; ++i) {
+      for (size_t j = i + 1; j < poses.size() && !to_keep; ++j) {
+        const auto ray1 =
+            (lm.GetGlobalPos() - poses[i].GetOrigin()).normalized();
+        const auto ray2 =
+            (lm.GetGlobalPos() - poses[j].GetOrigin()).normalized();
+        const double angle = geometry::AngleBetweenVectors(ray1, ray2);
+        if (angle > rad_angle) {
+          to_keep = true;
+        }
+      }
+    }
+    if (!to_keep) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Compute inverse covariance for the point.
+    auto invcov_and_score = geometry::covariance::ComputePointInverseCovariance(
+        cameras, poses, obs_vec, lm.GetGlobalPos());
+    const auto& invcov = invcov_and_score.first;
+
+    // Basic numerical checks.
+    if (!invcov.allFinite()) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Determinant-based test.
+    const double det = invcov.determinant();
+    if (!std::isfinite(det) || std::abs(det) < min_abs_det) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Eigenvalue-based test (condition number).
+    Eigen::SelfAdjointEigenSolver<Mat3d> es(invcov.inverse());
+    if (es.info() != Eigen::Success) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+    const auto& eigs = es.eigenvalues();
+    if (!(eigs.array().isFinite().all())) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    const double max_eig = eigs.maxCoeff();
+    const double min_eig = eigs.minCoeff();
+
+    // If any eigenvalue is non-positive or extremely small, mark removal.
+    if (min_eig <= 0.0 || !std::isfinite(min_eig)) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    const double cond = std::min(std::sqrt(max_eig / min_eig), kMaxCond);
+    if (!std::isfinite(cond)) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+    landmark_conds.emplace_back(lm_id, cond);
+  }
+
+  // Compute median and MAD of condition numbers.
+  if (!landmark_conds.empty()) {
+    const double avg_cond =
+        std::accumulate(
+            landmark_conds.begin(), landmark_conds.end(), 0.0,
+            [](double sum, const auto& pair) { return sum + pair.second; }) /
+        landmark_conds.size();
+    const double sigma = std::sqrt(
+        std::accumulate(landmark_conds.begin(), landmark_conds.end(), 0.0,
+                        [avg_cond](double sum, const auto& pair) {
+                          return sum + (pair.second - avg_cond) *
+                                           (pair.second - avg_cond);
+                        }) /
+        landmark_conds.size());
+    const double threshold = avg_cond + kSigmaMultiplier * sigma;
+    for (const auto& [lm_id, cond] : landmark_conds) {
+      if (cond > threshold) {
+        to_remove.push_back(lm_id);
+      }
+    }
+  }
+
+  // Remove collected landmarks from the map.
+  int removed = 0;
+  for (const auto& lm_id : to_remove) {
+    if (map.HasLandmark(lm_id)) {
+      map.RemoveLandmark(lm_id);
+      ++removed;
+    }
+  }
+
+  return removed;
+}
+
+int RemoveIsolatedPoints(map::Map& map, int k) {
+  const auto& landmarks = map.GetLandmarks();
+  if (landmarks.size() <= k) {
+    return 0;
+  }
+
+  // Gather all positions
+  std::vector<map::LandmarkId> lm_ids;
+  std::vector<float> positions;  // flattened for VLFeat (x0,y0,z0,x1,y1,z1,...)
+  lm_ids.reserve(landmarks.size());
+  positions.reserve(landmarks.size() * 3);
+  for (const auto& kv : landmarks) {
+    lm_ids.push_back(kv.first);
+    const Vec3d& pos = kv.second.GetGlobalPos();
+    positions.push_back(static_cast<float>(pos.x()));
+    positions.push_back(static_cast<float>(pos.y()));
+    positions.push_back(static_cast<float>(pos.z()));
+  }
+
+  // Build VLFeat KD-tree
+  VlKDForest* forest = vl_kdforest_new(VL_TYPE_FLOAT, 3, 1, VlDistanceL2);
+  vl_kdforest_build(forest, lm_ids.size(), positions.data());
+
+  // Query kNN for each point in parallel
+  std::vector<double> avg_dists(lm_ids.size(), 0.0);
+  std::vector<VlKDForestNeighbor> neighbors(k + 1);
+  for (vl_size i = 0; i < lm_ids.size(); ++i) {
+    const float* query = positions.data() + 3 * i;
+    vl_kdforest_query(forest, neighbors.data(), k + 1, query);
+
+    // neighbors[0] is always the query point itself (distance 0)
+    double sum = 0.0;
+    int found = 0;
+    for (int j = 1; j < k + 1; ++j) {
+      if (std::isfinite(neighbors[j].distance)) {
+        sum += neighbors[j].distance;
+        ++found;
+      }
+    }
+    avg_dists[i] = found > 0 ? sum / found : 0.0;
+  }
+  vl_kdforest_delete(forest);
+
+  // Compute mean and stddev of average neighbor distances
+  const double mean = std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0) /
+                      avg_dists.size();
+  const double std_dev =
+      std::sqrt(std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0,
+                                [mean](double sum, double val) {
+                                  return sum + (val - mean) * (val - mean);
+                                }) /
+                avg_dists.size());
+
+  // Remove points whose avg kNN distance > mean + stddev
+  constexpr double kSigmaMultiplier = 1.25;
+  int removed = 0;
+  for (size_t i = 0; i < lm_ids.size(); ++i) {
+    if (avg_dists[i] > mean + kSigmaMultiplier * std_dev) {
+      if (map.HasLandmark(lm_ids[i])) {
+        map.RemoveLandmark(lm_ids[i]);
+        ++removed;
+      }
+    }
+  }
+  return removed;
+}
+
 }  // namespace sfm::tracks_helpers
diff --git a/opensfm/src/sfm/tracks_helpers.h b/opensfm/src/sfm/tracks_helpers.h
index e715397f2..388b6dd7f 100644
--- a/opensfm/src/sfm/tracks_helpers.h
+++ b/opensfm/src/sfm/tracks_helpers.h
@@ -3,11 +3,14 @@
 #include <foundation/types.h>
 #include <geometry/camera.h>
 #include <map/defines.h>
+#include <map/map.h>
 #include <map/observation.h>
 #include <map/shot.h>
 #include <map/tracks_manager.h>
 
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 namespace sfm::tracks_helpers {
 std::unordered_map<map::ShotId, int> CountTracksPerShot(
@@ -17,4 +20,9 @@ void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                     const std::vector<map::TrackId>& connections);
 void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                        const std::vector<map::TrackId>& connections);
+
+int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg = 1.0,
+                                 double min_abs_det = 1e-15);
+int RemoveIsolatedPoints(map::Map& map, int k = 7);
+
 }  // namespace sfm::tracks_helpers

From 6dde847fe461a209b53381615c60ad73fa461311 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Thu, 11 Sep 2025 09:00:10 -0700
Subject: [PATCH 176/235] Move map helper functions from tracks_helpers to
 dedicated map_helpers

Summary:
AI: Move FilterBadlyConditionedPoints and RemoveIsolatedPoints functions from tracks_helpers to a new map_helpers module for better code organization.

The functions FilterBadlyConditionedPoints and RemoveIsolatedPoints operate on Map objects rather than tracks, so they are better suited to be in a dedicated map_helpers module alongside tracks_helpers. This refactoring:

1. Creates new map_helpers.h and map_helpers.cc files with the moved functions
2. Updates the namespace from sfm::tracks_helpers to sfm::map_helpers
3. Updates Python bindings to reference the new namespace
4. Removes the functions and their specific dependencies from tracks_helpers
5. Updates build files to include the new map_helpers module

The API remains unchanged - the same function signatures are available through the Python bindings, maintaining full backward compatibility.

Differential Revision: D82020656

fbshipit-source-id: 153a94fdc61c8f28554b49503558407f69189162
---
 opensfm/src/sfm/CMakeLists.txt        |   2 +
 opensfm/src/sfm/map_helpers.h         |  12 ++
 opensfm/src/sfm/python/pybind.cc      |   5 +-
 opensfm/src/sfm/src/map_helpers.cc    | 238 ++++++++++++++++++++++++++
 opensfm/src/sfm/src/tracks_helpers.cc | 227 ------------------------
 opensfm/src/sfm/tracks_helpers.h      |   6 -
 6 files changed, 255 insertions(+), 235 deletions(-)
 create mode 100644 opensfm/src/sfm/map_helpers.h
 create mode 100644 opensfm/src/sfm/src/map_helpers.cc

diff --git a/opensfm/src/sfm/CMakeLists.txt b/opensfm/src/sfm/CMakeLists.txt
index 7e99ec8cc..a5bfe6632 100644
--- a/opensfm/src/sfm/CMakeLists.txt
+++ b/opensfm/src/sfm/CMakeLists.txt
@@ -2,9 +2,11 @@ set(SFM_FILES
     retriangulation.h
     ba_helpers.h
     tracks_helpers.h
+    map_helpers.h
     src/retriangulation.cc
     src/ba_helpers.cc
     src/tracks_helpers.cc
+    src/map_helpers.cc
 )
 add_library(sfm ${SFM_FILES})
 target_link_libraries(sfm
diff --git a/opensfm/src/sfm/map_helpers.h b/opensfm/src/sfm/map_helpers.h
new file mode 100644
index 000000000..34e5fe9bb
--- /dev/null
+++ b/opensfm/src/sfm/map_helpers.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <foundation/types.h>
+#include <map/map.h>
+
+namespace sfm::map_helpers {
+
+int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg = 1.0,
+                                 double min_abs_det = 1e-15);
+int RemoveIsolatedPoints(map::Map& map, int k = 7);
+
+}  // namespace sfm::map_helpers
diff --git a/opensfm/src/sfm/python/pybind.cc b/opensfm/src/sfm/python/pybind.cc
index 2cc7eea5d..9a2ca7253 100644
--- a/opensfm/src/sfm/python/pybind.cc
+++ b/opensfm/src/sfm/python/pybind.cc
@@ -5,6 +5,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <sfm/ba_helpers.h>
+#include <sfm/map_helpers.h>
 #include <sfm/retriangulation.h>
 #include <sfm/tracks_helpers.h>
 
@@ -19,11 +20,11 @@ PYBIND11_MODULE(pysfm, m) {
   m.def("remove_connections", &sfm::tracks_helpers::RemoveConnections,
         py::call_guard<py::gil_scoped_release>());
   m.def("filter_badly_conditioned_points",
-        &sfm::tracks_helpers::FilterBadlyConditionedPoints, py::arg("map"),
+        &sfm::map_helpers::FilterBadlyConditionedPoints, py::arg("map"),
         py::arg("min_angle_deg") = 1.0, py::arg("min_abs_det") = 1e-15,
         py::call_guard<py::gil_scoped_release>());
 
-  m.def("remove_isolated_points", &sfm::tracks_helpers::RemoveIsolatedPoints,
+  m.def("remove_isolated_points", &sfm::map_helpers::RemoveIsolatedPoints,
         py::arg("map"), py::arg("k") = 7,
         py::call_guard<py::gil_scoped_release>());
 
diff --git a/opensfm/src/sfm/src/map_helpers.cc b/opensfm/src/sfm/src/map_helpers.cc
new file mode 100644
index 000000000..752c9d3c4
--- /dev/null
+++ b/opensfm/src/sfm/src/map_helpers.cc
@@ -0,0 +1,238 @@
+#include "sfm/map_helpers.h"
+
+#include <geometry/covariance.h>
+#include <geometry/triangulation.h>
+#include <map/landmark.h>
+#include <map/shot.h>
+
+#include <Eigen/Eigen>
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+#include <vector>
+
+extern "C" {
+#include <vl/kdtree.h>
+}
+
+namespace sfm::map_helpers {
+
+int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg,
+                                 double min_abs_det) {
+  std::vector<map::LandmarkId> to_remove;
+
+  // Cull based on stats on covariance's condition number
+  constexpr double kMaxCond = 1000;
+  constexpr double kSigmaMultiplier = 1.0;
+  std::vector<std::pair<map::LandmarkId, double>> landmark_conds;
+  landmark_conds.reserve(map.GetLandmarks().size());
+
+  // Iterate over a snapshot of landmarks to decide removals.
+  for (const auto& kv : map.GetLandmarks()) {
+    const map::LandmarkId& lm_id = kv.first;
+    const map::Landmark& lm = kv.second;
+
+    const auto& observations = lm.GetObservations();
+
+    std::vector<geometry::Camera> cameras;
+    cameras.reserve(observations.size());
+    std::vector<geometry::Pose> poses;
+    poses.reserve(observations.size());
+    std::vector<Vec2d> obs_vec;
+    obs_vec.reserve(observations.size());
+
+    // Build camera/pose/observation vectors from observations.
+    for (const auto& obs_kv : observations) {
+      map::Shot* shot_ptr = obs_kv.first;
+      if (!shot_ptr) {
+        continue;
+      }
+
+      const geometry::Pose* pose_ptr = shot_ptr->GetPose();
+      const geometry::Camera* cam_ptr = shot_ptr->GetCamera();
+      if (!pose_ptr || !cam_ptr) {
+        continue;
+      }
+
+      // Get the shot's Observation for this landmark.
+      map::Observation* obs_ptr =
+          shot_ptr->GetLandmarkObservation(const_cast<map::Landmark*>(&lm));
+      if (!obs_ptr) {
+        continue;
+      }
+
+      cameras.push_back(*cam_ptr);
+      poses.push_back(*pose_ptr);
+      obs_vec.push_back(obs_ptr->point);
+    }
+
+    // First simple check based on angle between all pairs of raysmap
+    double rad_angle = min_angle_deg * M_PI / 180.0;
+    bool to_keep = false;
+    for (size_t i = 0; i < poses.size() && !to_keep; ++i) {
+      for (size_t j = i + 1; j < poses.size() && !to_keep; ++j) {
+        const auto ray1 =
+            (lm.GetGlobalPos() - poses[i].GetOrigin()).normalized();
+        const auto ray2 =
+            (lm.GetGlobalPos() - poses[j].GetOrigin()).normalized();
+        const double angle = geometry::AngleBetweenVectors(ray1, ray2);
+        if (angle > rad_angle) {
+          to_keep = true;
+          break;
+        }
+      }
+    }
+    if (!to_keep) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Compute inverse covariance for the point.
+    auto invcov_and_score = geometry::covariance::ComputePointInverseCovariance(
+        cameras, poses, obs_vec, lm.GetGlobalPos());
+    const auto& invcov = invcov_and_score.first;
+
+    // Basic numerical checks.
+    if (!invcov.allFinite()) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Determinant-based test.
+    const double det = invcov.determinant();
+    if (!std::isfinite(det) || std::abs(det) < min_abs_det) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    // Eigenvalue-based test (condition number).
+    Eigen::SelfAdjointEigenSolver<Mat3d> es(invcov.inverse());
+    if (es.info() != Eigen::Success) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+    const auto& eigs = es.eigenvalues();
+    if (!(eigs.array().isFinite().all())) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    const double max_eig = eigs.maxCoeff();
+    const double min_eig = eigs.minCoeff();
+
+    // If any eigenvalue is non-positive or extremely small, mark removal.
+    if (min_eig <= 0.0 || !std::isfinite(min_eig)) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+
+    const double cond = std::min(std::sqrt(max_eig / min_eig), kMaxCond);
+    if (!std::isfinite(cond)) {
+      to_remove.push_back(lm_id);
+      continue;
+    }
+    landmark_conds.emplace_back(lm_id, cond);
+  }
+
+  // Compute median and MAD of condition numbers.
+  if (!landmark_conds.empty()) {
+    const double avg_cond =
+        std::accumulate(
+            landmark_conds.begin(), landmark_conds.end(), 0.0,
+            [](double sum, const auto& pair) { return sum + pair.second; }) /
+        landmark_conds.size();
+    const double sigma = std::sqrt(
+        std::accumulate(landmark_conds.begin(), landmark_conds.end(), 0.0,
+                        [avg_cond](double sum, const auto& pair) {
+                          return sum + (pair.second - avg_cond) *
+                                           (pair.second - avg_cond);
+                        }) /
+        landmark_conds.size());
+    const double threshold = avg_cond + kSigmaMultiplier * sigma;
+    for (const auto& [lm_id, cond] : landmark_conds) {
+      if (cond > threshold) {
+        to_remove.push_back(lm_id);
+      }
+    }
+  }
+
+  // Remove collected landmarks from the map.
+  int removed = 0;
+  for (const auto& lm_id : to_remove) {
+    if (map.HasLandmark(lm_id)) {
+      map.RemoveLandmark(lm_id);
+      ++removed;
+    }
+  }
+
+  return removed;
+}
+
+int RemoveIsolatedPoints(map::Map& map, int k) {
+  const auto& landmarks = map.GetLandmarks();
+  if (landmarks.size() <= k) {
+    return 0;
+  }
+
+  // Gather all positions
+  std::vector<map::LandmarkId> lm_ids;
+  std::vector<float> positions;  // flattened for VLFeat (x0,y0,z0,x1,y1,z1,...)
+  lm_ids.reserve(landmarks.size());
+  positions.reserve(landmarks.size() * 3);
+  for (const auto& kv : landmarks) {
+    lm_ids.push_back(kv.first);
+    const Vec3d& pos = kv.second.GetGlobalPos();
+    positions.push_back(static_cast<float>(pos.x()));
+    positions.push_back(static_cast<float>(pos.y()));
+    positions.push_back(static_cast<float>(pos.z()));
+  }
+
+  // Build VLFeat KD-tree
+  VlKDForest* forest = vl_kdforest_new(VL_TYPE_FLOAT, 3, 1, VlDistanceL2);
+  vl_kdforest_build(forest, lm_ids.size(), positions.data());
+
+  // Query kNN for each point in parallel
+  std::vector<double> avg_dists(lm_ids.size(), 0.0);
+  std::vector<VlKDForestNeighbor> neighbors(k + 1);
+  for (vl_size i = 0; i < lm_ids.size(); ++i) {
+    const float* query = positions.data() + 3 * i;
+    vl_kdforest_query(forest, neighbors.data(), k + 1, query);
+
+    // neighbors[0] is always the query point itself (distance 0)
+    double sum = 0.0;
+    int found = 0;
+    for (int j = 1; j < k + 1; ++j) {
+      if (std::isfinite(neighbors[j].distance)) {
+        sum += neighbors[j].distance;
+        ++found;
+      }
+    }
+    avg_dists[i] = found > 0 ? sum / found : 0.0;
+  }
+  vl_kdforest_delete(forest);
+
+  // Compute mean and stddev of average neighbor distances
+  const double mean = std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0) /
+                      avg_dists.size();
+  const double std_dev =
+      std::sqrt(std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0,
+                                [mean](double sum, double val) {
+                                  return sum + (val - mean) * (val - mean);
+                                }) /
+                avg_dists.size());
+
+  // Remove points whose avg kNN distance > mean + stddev
+  constexpr double kSigmaMultiplier = 1.25;
+  int removed = 0;
+  for (size_t i = 0; i < lm_ids.size(); ++i) {
+    if (avg_dists[i] > mean + kSigmaMultiplier * std_dev) {
+      if (map.HasLandmark(lm_ids[i])) {
+        map.RemoveLandmark(lm_ids[i]);
+        ++removed;
+      }
+    }
+  }
+  return removed;
+}
+
+}  // namespace sfm::map_helpers
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index f43f62a76..d5a5c27c9 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -1,21 +1,11 @@
 #include "sfm/tracks_helpers.h"
 
-#include <geometry/covariance.h>
-#include <geometry/triangulation.h>
 #include <map/landmark.h>
 #include <map/shot.h>
 
-#include <Eigen/Eigen>
-#include <algorithm>
-#include <cmath>
-#include <numeric>
 #include <unordered_set>
 #include <vector>
 
-extern "C" {
-#include <vl/kdtree.h>
-}
-
 namespace sfm::tracks_helpers {
 std::unordered_map<map::ShotId, int> CountTracksPerShot(
     const map::TracksManager& manager, const std::vector<map::ShotId>& shots,
@@ -56,221 +46,4 @@ void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
   }
 }
 
-int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg,
-                                 double min_abs_det) {
-  std::vector<map::LandmarkId> to_remove;
-
-  // Cull based on stats on covariance's condition number
-  constexpr double kMaxCond = 1000;
-  constexpr double kSigmaMultiplier = 1.0;
-  std::vector<std::pair<map::LandmarkId, double>> landmark_conds;
-  landmark_conds.reserve(map.GetLandmarks().size());
-
-  // Iterate over a snapshot of landmarks to decide removals.
-  for (const auto& kv : map.GetLandmarks()) {
-    const map::LandmarkId& lm_id = kv.first;
-    const map::Landmark& lm = kv.second;
-
-    const auto& observations = lm.GetObservations();
-
-    std::vector<geometry::Camera> cameras;
-    cameras.reserve(observations.size());
-    std::vector<geometry::Pose> poses;
-    poses.reserve(observations.size());
-    std::vector<Vec2d> obs_vec;
-    obs_vec.reserve(observations.size());
-
-    // Build camera/pose/observation vectors from observations.
-    for (const auto& obs_kv : observations) {
-      map::Shot* shot_ptr = obs_kv.first;
-      if (!shot_ptr) {
-        continue;
-      }
-
-      const geometry::Pose* pose_ptr = shot_ptr->GetPose();
-      const geometry::Camera* cam_ptr = shot_ptr->GetCamera();
-      if (!pose_ptr || !cam_ptr) {
-        continue;
-      }
-
-      // Get the shot's Observation for this landmark.
-      map::Observation* obs_ptr =
-          shot_ptr->GetLandmarkObservation(const_cast<map::Landmark*>(&lm));
-      if (!obs_ptr) {
-        continue;
-      }
-
-      cameras.push_back(*cam_ptr);
-      poses.push_back(*pose_ptr);
-      obs_vec.push_back(obs_ptr->point);
-    }
-
-    // First simple check based on angle between all pairs of raysmap
-    double rad_angle = min_angle_deg * M_PI / 180.0;
-    bool to_keep = false;
-    for (size_t i = 0; i < poses.size() && !to_keep; ++i) {
-      for (size_t j = i + 1; j < poses.size() && !to_keep; ++j) {
-        const auto ray1 =
-            (lm.GetGlobalPos() - poses[i].GetOrigin()).normalized();
-        const auto ray2 =
-            (lm.GetGlobalPos() - poses[j].GetOrigin()).normalized();
-        const double angle = geometry::AngleBetweenVectors(ray1, ray2);
-        if (angle > rad_angle) {
-          to_keep = true;
-        }
-      }
-    }
-    if (!to_keep) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-
-    // Compute inverse covariance for the point.
-    auto invcov_and_score = geometry::covariance::ComputePointInverseCovariance(
-        cameras, poses, obs_vec, lm.GetGlobalPos());
-    const auto& invcov = invcov_and_score.first;
-
-    // Basic numerical checks.
-    if (!invcov.allFinite()) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-
-    // Determinant-based test.
-    const double det = invcov.determinant();
-    if (!std::isfinite(det) || std::abs(det) < min_abs_det) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-
-    // Eigenvalue-based test (condition number).
-    Eigen::SelfAdjointEigenSolver<Mat3d> es(invcov.inverse());
-    if (es.info() != Eigen::Success) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-    const auto& eigs = es.eigenvalues();
-    if (!(eigs.array().isFinite().all())) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-
-    const double max_eig = eigs.maxCoeff();
-    const double min_eig = eigs.minCoeff();
-
-    // If any eigenvalue is non-positive or extremely small, mark removal.
-    if (min_eig <= 0.0 || !std::isfinite(min_eig)) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-
-    const double cond = std::min(std::sqrt(max_eig / min_eig), kMaxCond);
-    if (!std::isfinite(cond)) {
-      to_remove.push_back(lm_id);
-      continue;
-    }
-    landmark_conds.emplace_back(lm_id, cond);
-  }
-
-  // Compute median and MAD of condition numbers.
-  if (!landmark_conds.empty()) {
-    const double avg_cond =
-        std::accumulate(
-            landmark_conds.begin(), landmark_conds.end(), 0.0,
-            [](double sum, const auto& pair) { return sum + pair.second; }) /
-        landmark_conds.size();
-    const double sigma = std::sqrt(
-        std::accumulate(landmark_conds.begin(), landmark_conds.end(), 0.0,
-                        [avg_cond](double sum, const auto& pair) {
-                          return sum + (pair.second - avg_cond) *
-                                           (pair.second - avg_cond);
-                        }) /
-        landmark_conds.size());
-    const double threshold = avg_cond + kSigmaMultiplier * sigma;
-    for (const auto& [lm_id, cond] : landmark_conds) {
-      if (cond > threshold) {
-        to_remove.push_back(lm_id);
-      }
-    }
-  }
-
-  // Remove collected landmarks from the map.
-  int removed = 0;
-  for (const auto& lm_id : to_remove) {
-    if (map.HasLandmark(lm_id)) {
-      map.RemoveLandmark(lm_id);
-      ++removed;
-    }
-  }
-
-  return removed;
-}
-
-int RemoveIsolatedPoints(map::Map& map, int k) {
-  const auto& landmarks = map.GetLandmarks();
-  if (landmarks.size() <= k) {
-    return 0;
-  }
-
-  // Gather all positions
-  std::vector<map::LandmarkId> lm_ids;
-  std::vector<float> positions;  // flattened for VLFeat (x0,y0,z0,x1,y1,z1,...)
-  lm_ids.reserve(landmarks.size());
-  positions.reserve(landmarks.size() * 3);
-  for (const auto& kv : landmarks) {
-    lm_ids.push_back(kv.first);
-    const Vec3d& pos = kv.second.GetGlobalPos();
-    positions.push_back(static_cast<float>(pos.x()));
-    positions.push_back(static_cast<float>(pos.y()));
-    positions.push_back(static_cast<float>(pos.z()));
-  }
-
-  // Build VLFeat KD-tree
-  VlKDForest* forest = vl_kdforest_new(VL_TYPE_FLOAT, 3, 1, VlDistanceL2);
-  vl_kdforest_build(forest, lm_ids.size(), positions.data());
-
-  // Query kNN for each point in parallel
-  std::vector<double> avg_dists(lm_ids.size(), 0.0);
-  std::vector<VlKDForestNeighbor> neighbors(k + 1);
-  for (vl_size i = 0; i < lm_ids.size(); ++i) {
-    const float* query = positions.data() + 3 * i;
-    vl_kdforest_query(forest, neighbors.data(), k + 1, query);
-
-    // neighbors[0] is always the query point itself (distance 0)
-    double sum = 0.0;
-    int found = 0;
-    for (int j = 1; j < k + 1; ++j) {
-      if (std::isfinite(neighbors[j].distance)) {
-        sum += neighbors[j].distance;
-        ++found;
-      }
-    }
-    avg_dists[i] = found > 0 ? sum / found : 0.0;
-  }
-  vl_kdforest_delete(forest);
-
-  // Compute mean and stddev of average neighbor distances
-  const double mean = std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0) /
-                      avg_dists.size();
-  const double std_dev =
-      std::sqrt(std::accumulate(avg_dists.begin(), avg_dists.end(), 0.0,
-                                [mean](double sum, double val) {
-                                  return sum + (val - mean) * (val - mean);
-                                }) /
-                avg_dists.size());
-
-  // Remove points whose avg kNN distance > mean + stddev
-  constexpr double kSigmaMultiplier = 1.25;
-  int removed = 0;
-  for (size_t i = 0; i < lm_ids.size(); ++i) {
-    if (avg_dists[i] > mean + kSigmaMultiplier * std_dev) {
-      if (map.HasLandmark(lm_ids[i])) {
-        map.RemoveLandmark(lm_ids[i]);
-        ++removed;
-      }
-    }
-  }
-  return removed;
-}
-
 }  // namespace sfm::tracks_helpers
diff --git a/opensfm/src/sfm/tracks_helpers.h b/opensfm/src/sfm/tracks_helpers.h
index 388b6dd7f..541c8a57d 100644
--- a/opensfm/src/sfm/tracks_helpers.h
+++ b/opensfm/src/sfm/tracks_helpers.h
@@ -3,12 +3,10 @@
 #include <foundation/types.h>
 #include <geometry/camera.h>
 #include <map/defines.h>
-#include <map/map.h>
 #include <map/observation.h>
 #include <map/shot.h>
 #include <map/tracks_manager.h>
 
-#include <string>
 #include <unordered_map>
 #include <vector>
 
@@ -21,8 +19,4 @@ void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
 void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                        const std::vector<map::TrackId>& connections);
 
-int FilterBadlyConditionedPoints(map::Map& map, double min_angle_deg = 1.0,
-                                 double min_abs_det = 1e-15);
-int RemoveIsolatedPoints(map::Map& map, int k = 7);
-
 }  // namespace sfm::tracks_helpers

From 32d6d73ef08c3788c83b2be414fd5e468cd51a28 Mon Sep 17 00:00:00 2001
From: Joel Ossher <ossher@meta.com>
Date: Fri, 19 Sep 2025 09:08:00 -0700
Subject: [PATCH 177/235] Support configurable memory usage for opensfm feature
 extraction

Summary: Follow up on a previous commit to expose feature's `mem_ceiling` and `mem_ratio`.

Reviewed By: DodgySpaniard

Differential Revision: D82730411

fbshipit-source-id: 7e4cf6d2d0e375c1e6fffa7ef0e65e9ace7795c3
---
 opensfm/config.py              | 4 ++++
 opensfm/features_processing.py | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 4c3f7c238..246fd27fb 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -34,6 +34,10 @@ class OpenSfMConfig:
     feature_use_adaptive_suppression: bool = False
     # Bake segmentation info (class and instance) in the feature data. Thus it is done once for all at extraction time.
     features_bake_segmentation: bool = False
+    # Maximum amount of memory to use for feature extraction (in MB). See default in features_processing.py.
+    mem_ceiling: int | None = None
+    # Ratio of the memory ceiling to use for feature extraction. See default in features_processing.py.
+    mem_ratio: float | None = None
 
     ##################################
     # Params for SIFT
diff --git a/opensfm/features_processing.py b/opensfm/features_processing.py
index 68b9aa0f5..5bd5e90fd 100644
--- a/opensfm/features_processing.py
+++ b/opensfm/features_processing.py
@@ -50,11 +50,11 @@ def run_features_processing(data: DataSetBase, images: List[str], force: bool) -
     default_queue_size = 10
     max_queue_size = 200
 
-    mem_ceiling = data.config.get("mem_ceiling", log.memory_available())
+    mem_ceiling = data.config.get("mem_ceiling") or log.memory_available()
 
     processes = data.config["processes"]
     if mem_ceiling:
-        ratio_use = data.config.get("mem_ratio", 0.9)
+        ratio_use = data.config.get("mem_ratio") or 0.9
         mem_available = mem_ceiling * ratio_use
         logger.info(
             f"Planning to use {mem_available} MB of RAM (out of {mem_ceiling} MB RAM available) for both processing queue and parallel processing. Memory ratio is {ratio_use}."

From 59c86f72e9af5ace8b813fea72276b9ff3f0d0a1 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Mon, 29 Sep 2025 02:47:59 -0700
Subject: [PATCH 178/235] import annotations to keep running on python <3.10

Differential Revision: D83461395

fbshipit-source-id: 169bd0e7e69b235a6282eb97cfc789a4a2541687
---
 opensfm/config.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/opensfm/config.py b/opensfm/config.py
index 246fd27fb..4eb19c200 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -1,4 +1,7 @@
 # pyre-strict
+
+from __future__ import annotations
+
 import os
 from dataclasses import asdict, dataclass
 from typing import Any, Dict, IO, Union

From 2c25da54c5197caacf8ebf6a2bb3dd9262338a33 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Fri, 3 Oct 2025 01:56:44 -0700
Subject: [PATCH 179/235] Add CI for Docker with Ubuntu 24.04 (#1109)

Summary:
- Add new docker file and GH action
- Remove the Ubuntu 20.04 + Ceres 2 CI
- Fix some deprecation warnings that showed up when using newer versions of the dependencies

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1109

Reviewed By: bal-a

Differential Revision: D83745229

Pulled By: paulinus

fbshipit-source-id: 48d731510e90f700d2ac7adfab1bd6b893ab6c75
---
 .github/workflows/conda.yml                   |  2 +-
 .github/workflows/docker.yml                  | 23 --------
 .github/workflows/docker_ceres2.yml           | 23 --------
 .github/workflows/docker_ubuntu20.yml         | 23 ++++++++
 .github/workflows/docker_ubuntu24.yml         | 23 ++++++++
 Dockerfile.ceres2                             | 43 ---------------
 Dockerfile => Dockerfile.ubuntu20             | 23 +++++++-
 Dockerfile.ubuntu24                           | 55 +++++++++++++++++++
 conda.yml                                     |  1 +
 licenses.csv                                  |  1 -
 opensfm/report.py                             |  2 +-
 .../src/bundle/error/autodiff_ceres_compat.h  | 27 +++++++++
 opensfm/src/bundle/error/error_utils.h        |  1 +
 opensfm/stats.py                              | 10 ++--
 opensfm/test/test_datastructures.py           | 28 +++++-----
 requirements.txt                              |  1 -
 16 files changed, 172 insertions(+), 114 deletions(-)
 delete mode 100644 .github/workflows/docker.yml
 delete mode 100644 .github/workflows/docker_ceres2.yml
 create mode 100644 .github/workflows/docker_ubuntu20.yml
 create mode 100644 .github/workflows/docker_ubuntu24.yml
 delete mode 100644 Dockerfile.ceres2
 rename Dockerfile => Dockerfile.ubuntu20 (52%)
 create mode 100644 Dockerfile.ubuntu24
 create mode 100644 opensfm/src/bundle/error/autodiff_ceres_compat.h

diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
index c4e502624..1f9161e21 100644
--- a/.github/workflows/conda.yml
+++ b/.github/workflows/conda.yml
@@ -1,4 +1,4 @@
-name: Conda CI
+name: Conda
 
 on: [push, pull_request]
 
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
deleted file mode 100644
index 4a35eab12..000000000
--- a/.github/workflows/docker.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: Docker CI
-
-on: [push, pull_request]
-
-jobs:
-
-  build-test:
-    name: Build docker and run tests
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-
-      - name: Build the Docker image
-        run: docker build . --file Dockerfile --tag mapillary/opensfm:$GITHUB_SHA
-
-      - name: Run C++ tests
-        run: docker run mapillary/opensfm:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
-
-      - name: Run Python tests
-        run: docker run mapillary/opensfm:$GITHUB_SHA python3 -m pytest
diff --git a/.github/workflows/docker_ceres2.yml b/.github/workflows/docker_ceres2.yml
deleted file mode 100644
index 54908c9df..000000000
--- a/.github/workflows/docker_ceres2.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: Docker CI
-
-on: [push, pull_request]
-
-jobs:
-
-  build-test:
-    name: Build docker installing CeresSolver 2 and run tests
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-
-      - name: Build the Docker image
-        run: docker build . --file Dockerfile.ceres2 --tag mapillary/opensfm.ceres2:$GITHUB_SHA
-
-      - name: Run C++ tests
-        run: docker run mapillary/opensfm.ceres2:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
-
-      - name: Run Python tests
-        run: docker run mapillary/opensfm.ceres2:$GITHUB_SHA python3 -m pytest
diff --git a/.github/workflows/docker_ubuntu20.yml b/.github/workflows/docker_ubuntu20.yml
new file mode 100644
index 000000000..6b39fdf22
--- /dev/null
+++ b/.github/workflows/docker_ubuntu20.yml
@@ -0,0 +1,23 @@
+name: Docker Ubuntu 20.04
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build docker and run tests on Ubuntu 20.04
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Build the Docker image
+        run: docker build . --file Dockerfile.ubuntu20 --tag mapillary/opensfm.ubuntu20:$GITHUB_SHA
+
+      - name: Run C++ tests
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
+
+      - name: Run Python tests
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA python3 -m pytest
diff --git a/.github/workflows/docker_ubuntu24.yml b/.github/workflows/docker_ubuntu24.yml
new file mode 100644
index 000000000..85cbf5ba4
--- /dev/null
+++ b/.github/workflows/docker_ubuntu24.yml
@@ -0,0 +1,23 @@
+name: Docker Ubuntu 24.04
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build docker and run tests on Ubuntu 24.04
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Build the Docker image
+        run: docker build . --file Dockerfile.ubuntu24 --tag mapillary/opensfm.ubuntu24:$GITHUB_SHA
+
+      - name: Run C++ tests
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
+
+      - name: Run Python tests
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA python3 -m pytest
diff --git a/Dockerfile.ceres2 b/Dockerfile.ceres2
deleted file mode 100644
index f839a7cc5..000000000
--- a/Dockerfile.ceres2
+++ /dev/null
@@ -1,43 +0,0 @@
-FROM ubuntu:20.04
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-# Install apt-getable dependencies
-RUN apt-get update \
-    && apt-get install -y \
-        build-essential \
-        cmake \
-        git \
-        libeigen3-dev \
-        libgoogle-glog-dev \
-        libopencv-dev \
-        libsuitesparse-dev \
-        python3-dev \
-        python3-numpy \
-        python3-opencv \
-        python3-pip \
-        python3-pyproj \
-        python3-scipy \
-        python3-yaml \
-        curl \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-
-# Install Ceres 2
-RUN \
-    mkdir -p /source && cd /source && \
-    curl -L http://ceres-solver.org/ceres-solver-2.0.0.tar.gz | tar xz && \
-    cd /source/ceres-solver-2.0.0 && \
-    mkdir -p build && cd build && \
-    cmake .. -DCMAKE_C_FLAGS=-fPIC -DCMAKE_CXX_FLAGS=-fPIC -DBUILD_EXAMPLES=OFF -DBUILD_TESTING=OFF && \
-    make -j4 install && \
-    cd / && rm -rf /source/ceres-solver-2.0.0
-
-
-COPY . /source/OpenSfM
-
-WORKDIR /source/OpenSfM
-
-RUN pip3 install -r requirements.txt && \
-    python3 setup.py build
diff --git a/Dockerfile b/Dockerfile.ubuntu20
similarity index 52%
rename from Dockerfile
rename to Dockerfile.ubuntu20
index 75de8b3cf..bc4e7ffea 100644
--- a/Dockerfile
+++ b/Dockerfile.ubuntu20
@@ -2,7 +2,6 @@ FROM ubuntu:20.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
-# Install apt-getable dependencies
 RUN apt-get update \
     && apt-get install -y \
         build-essential \
@@ -22,10 +21,28 @@ RUN apt-get update \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
+RUN pip3 install \
+        cloudpickle==0.4.0 \
+        ExifRead==2.1.2 \
+        Flask==2.3.2 \
+        fpdf2==2.4.6 \
+        joblib==0.14.1 \
+        matplotlib==3.7.5 \
+        networkx==2.5 \
+        numpy==1.24.4 \
+        opencv-python==4.12.0.88 \
+        pillow==10.4.0 \
+        pyproj==2.5.0 \
+        pytest==3.0.7 \
+        python-dateutil==2.9.0.post0 \
+        PyYAML==6.0.3 \
+        scipy==1.10.1 \
+        Sphinx==4.2.0 \
+        xmltodict==0.10.2
+
 
 COPY . /source/OpenSfM
 
 WORKDIR /source/OpenSfM
 
-RUN pip3 install -r requirements.txt && \
-    python3 setup.py build
+RUN python3 setup.py build
diff --git a/Dockerfile.ubuntu24 b/Dockerfile.ubuntu24
new file mode 100644
index 000000000..91d7fd7ff
--- /dev/null
+++ b/Dockerfile.ubuntu24
@@ -0,0 +1,55 @@
+FROM ubuntu:24.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+    && apt-get install -y \
+        build-essential \
+        cmake \
+        git \
+        libeigen3-dev \
+        libopencv-dev \
+        libceres-dev \
+        python3-dev \
+        python3-numpy \
+        python3-opencv \
+        python3-pip \
+        python3-venv \
+        python3-pyproj \
+        python3-scipy \
+        python3-yaml \
+        curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Create and activate virtual environment
+RUN python3 -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Install Python packages in the virtual environment
+RUN pip install \
+        cloudpickle==3.1.1 \
+        ExifRead==3.5.1 \
+        Flask==3.1.2 \
+        fpdf2==2.8.4 \
+        joblib==1.5.2 \
+        matplotlib==3.10.6 \
+        networkx==3.5 \
+        numpy==1.26.4 \
+        opencv-python==4.11.0.86 \
+        pillow==11.3.0 \
+        pyproj==3.7.2 \
+        pytest==8.4.2 \
+        python-dateutil==2.9.0.post0 \
+        PyYAML==6.0.3 \
+        scipy==1.16.2 \
+        setuptools==80.9.0 \
+        Sphinx==6.2.1 \
+        wheel==0.45.1 \
+        xmltodict==1.0.2
+
+COPY . /source/OpenSfM
+
+WORKDIR /source/OpenSfM
+
+RUN python3 setup.py build
diff --git a/conda.yml b/conda.yml
index ca5e0533d..828bcf01c 100644
--- a/conda.yml
+++ b/conda.yml
@@ -6,6 +6,7 @@ dependencies:
     - libxcrypt
     - libopencv *=headless*
     - py-opencv
+    - conda-forge::libvorbis
     - ceres-solver=2.1
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
diff --git a/licenses.csv b/licenses.csv
index 7bba7efa6..4754aa52f 100644
--- a/licenses.csv
+++ b/licenses.csv
@@ -11,5 +11,4 @@ pyproj, 2.5.0, "OSI Approved"
 pytest, 3.0.7, MIT
 python-dateutil, 2.6.0, "Simplified BSD"
 scipy, 1.4.1, BSD
-six, 1.14.0, MIT
 xmltodict, 0.10.2, MIT
diff --git a/opensfm/report.py b/opensfm/report.py
index 4ce77f00b..68f67540a 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -40,7 +40,7 @@ def __init__(self, data: DataSet) -> None:
         self.stats: Dict[str, Any] = self._read_stats_file("stats.json")
 
     def save_report(self, filename: str) -> None:
-        bytestring = self.pdf.output(dest="S")
+        bytestring = self.pdf.output()
         if isinstance(bytestring, str):
             bytestring = bytestring.encode("utf8")
 
diff --git a/opensfm/src/bundle/error/autodiff_ceres_compat.h b/opensfm/src/bundle/error/autodiff_ceres_compat.h
new file mode 100644
index 000000000..3df4c13c3
--- /dev/null
+++ b/opensfm/src/bundle/error/autodiff_ceres_compat.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <Eigen/Core>
+#include <cmath>
+#include <unsupported/Eigen/AutoDiff>
+
+// Compatibility overloads for Eigen::AutoDiffScalar with Ceres 2.2+
+// These are needed because Ceres rotation.h uses std::hypot and std::fpclassify
+// which don't have overloads for AutoDiffScalar types
+
+namespace Eigen {
+// 3-argument hypot for AutoDiffScalar (used in ceres/rotation.h)
+template <typename DerType>
+inline AutoDiffScalar<DerType> hypot(const AutoDiffScalar<DerType>& x,
+                                     const AutoDiffScalar<DerType>& y,
+                                     const AutoDiffScalar<DerType>& z) {
+  return sqrt(x * x + y * y + z * z);
+}
+}  // namespace Eigen
+
+namespace std {
+// fpclassify for AutoDiffScalar (used in ceres/rotation.h)
+template <typename DerType>
+inline int fpclassify(const Eigen::AutoDiffScalar<DerType>& x) {
+  return std::fpclassify(x.value());
+}
+}  // namespace std
diff --git a/opensfm/src/bundle/error/error_utils.h b/opensfm/src/bundle/error/error_utils.h
index 2ff7619a1..f54387cb2 100644
--- a/opensfm/src/bundle/error/error_utils.h
+++ b/opensfm/src/bundle/error/error_utils.h
@@ -5,6 +5,7 @@
 
 #include <initializer_list>
 
+#include "autodiff_ceres_compat.h"
 #include "ceres/ceres.h"
 #include "ceres/rotation.h"
 
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 754553eeb..a1166ba25 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -505,7 +505,7 @@ def save_matchgraph(
     highest = np.percentile(list(all_values), 95)
 
     plt.clf()
-    cmap = cm.get_cmap("viridis")
+    cmap = cm.viridis
     for (node1, node2), edge in sorted(connectivity.items(), key=lambda x: x[1]):
         if edge < 2 * data.config["resection_min_inliers"]:
             continue
@@ -538,6 +538,7 @@ def save_matchgraph(
         orientation="horizontal",
         label="Number of matches between images",
         pad=0.0,
+        ax=plt.gca(),
     )
 
     with io_handler.open_wb(os.path.join(output_path, "matchgraph.png")) as fwb:
@@ -700,8 +701,8 @@ def save_topview(
         sorted_shots = sorted(
             rec.shots.values(), key=lambda x: x.metadata.capture_time.value
         )
-        c_camera = cm.get_cmap("cool")(0 / len(reconstructions))
-        c_gps = cm.get_cmap("autumn")(0 / len(reconstructions))
+        c_camera = cm.cool(0 / len(reconstructions))
+        c_gps = cm.autumn(0 / len(reconstructions))
         for j, shot in enumerate(sorted_shots):
             o = shot.pose.get_origin()
             x, y = (
@@ -964,7 +965,7 @@ def save_residual_grids(
         )
 
         norm = colors.Normalize(vmin=lowest, vmax=highest)
-        cmap = cm.get_cmap("viridis_r")
+        cmap = cm.viridis_r
         sm = cm.ScalarMappable(norm=norm, cmap=cmap)
         sm.set_array([])
         plt.colorbar(
@@ -973,6 +974,7 @@ def save_residual_grids(
             label="Residual Norm",
             pad=0.08,
             aspect=40,
+            ax=plt.gca(),
         )
 
         plt.xticks(
diff --git a/opensfm/test/test_datastructures.py b/opensfm/test/test_datastructures.py
index dc86ddd00..ae7072a02 100644
--- a/opensfm/test/test_datastructures.py
+++ b/opensfm/test/test_datastructures.py
@@ -127,7 +127,7 @@ def test_camera_iterators() -> None:
     visited_cams = set()
     for cam in rec.cameras.values():
         visited_cams.add(cam.id)
-        focal = np.random.rand(1)
+        focal = np.random.rand(1).item()
         cam.focal = focal
         assert rec.cameras[cam.id].focal == focal
         assert cam is rec.cameras[cam.id]
@@ -140,7 +140,7 @@ def test_camera_iterators() -> None:
 
     for cam_id, cam in rec.cameras.items():
         assert cam_id == cam.id
-        focal = np.random.rand(1)
+        focal = np.random.rand(1).item()
         cam.focal = focal
         assert rec.cameras[cam.id].focal == focal
         assert cam is rec.cameras[cam.id]
@@ -349,12 +349,12 @@ def _help_measurement_test(
 def test_shot_measurement_setter_and_getter() -> None:
     m1 = pymap.ShotMeasurements()
     # Test basic functionality
-    _help_measurement_test(m1, "capture_time", np.random.rand(1))
+    _help_measurement_test(m1, "capture_time", np.random.rand(1).item())
     _help_measurement_test(m1, "gps_position", np.random.rand(3))
-    _help_measurement_test(m1, "gps_accuracy", np.random.rand(1))
-    _help_measurement_test(m1, "compass_accuracy", np.random.rand(1))
-    _help_measurement_test(m1, "compass_angle", np.random.rand(1))
-    _help_measurement_test(m1, "opk_accuracy", np.random.rand(1))
+    _help_measurement_test(m1, "gps_accuracy", np.random.rand(1).item())
+    _help_measurement_test(m1, "compass_accuracy", np.random.rand(1).item())
+    _help_measurement_test(m1, "compass_angle", np.random.rand(1).item())
+    _help_measurement_test(m1, "opk_accuracy", np.random.rand(1).item())
     _help_measurement_test(m1, "opk_angles", np.random.rand(3))
     _help_measurement_test(m1, "gravity_down", np.random.rand(3))
     _help_measurement_test(m1, "orientation", random.randint(0, 100))
@@ -362,12 +362,12 @@ def test_shot_measurement_setter_and_getter() -> None:
 
 
 def _helper_populate_metadata(m: pymap.ShotMeasurements) -> None:
-    m.capture_time.value = np.random.rand(1)
+    m.capture_time.value = np.random.rand(1).item()
     m.gps_position.value = np.random.rand(3)
-    m.gps_accuracy.value = np.random.rand(1)
-    m.compass_accuracy.value = np.random.rand(1)
-    m.compass_angle.value = np.random.rand(1)
-    m.opk_accuracy.value = np.random.rand(1)
+    m.gps_accuracy.value = np.random.rand(1).item()
+    m.compass_accuracy.value = np.random.rand(1).item()
+    m.compass_angle.value = np.random.rand(1).item()
+    m.opk_accuracy.value = np.random.rand(1).item()
     m.opk_angles.value = np.random.rand(3)
     m.gravity_down.value = np.random.rand(3)
     m.orientation.value = random.randint(0, 100)
@@ -973,7 +973,7 @@ def test_many_observations_delete() -> None:
         m.create_rig_camera(pymap.RigCamera(pygeometry.Pose(), cam.id))
 
     for shot_id in range(n_shots):
-        cam_id = "cam" + str(int(np.random.rand(1) * 10 % n_cams))
+        cam_id = "cam" + str(int(np.random.rand(1).item() * 10 % n_cams))
         shot_id = str(shot_id)
         m.create_rig_instance(shot_id)
         m.create_shot(shot_id, cam_id, cam_id, shot_id, pygeometry.Pose())
@@ -1013,7 +1013,7 @@ def test_clean_landmarks_with_min_observations() -> None:
         m.create_rig_camera(pymap.RigCamera(pygeometry.Pose(), cam.id))
 
     for shot_id in range(n_shots):
-        cam_id = "cam" + str(int(np.random.rand(1) * 10 % n_cams))
+        cam_id = "cam" + str(int(np.random.rand(1).item() * 10 % n_cams))
         m.create_rig_instance(str(shot_id))
         m.create_shot(str(shot_id), cam_id, cam_id, str(shot_id), pygeometry.Pose())
 
diff --git a/requirements.txt b/requirements.txt
index 608fcb746..86e1b1767 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -13,7 +13,6 @@ python-dateutil>=2.7
 pyyaml>=5.4
 scipy>=1.10.0
 Sphinx==4.2.0
-six
 xmltodict==0.10.2
 wheel
 opencv-python==4.5.1.48 ; sys_platform == "win32"

From bc27a2ce6d81db2f107fbf6c7181062a8e31996a Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Wed, 8 Oct 2025 05:48:30 -0700
Subject: [PATCH 180/235] fbcode/mapillary/opensfm/opensfm

Differential Revision: D83965186

fbshipit-source-id: b0579f689cb7b8e97490b353f0d8b052d4957375
---
 opensfm/align.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index b28af8e77..b949445d6 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -24,7 +24,7 @@ def align_reconstruction(
 ) -> Optional[Tuple[float, NDArray, NDArray]]:
     """Align a reconstruction with GPS and GCP data."""
     has_scaled_rigs = any(
-        [True for ri in reconstruction.rig_instances.values() if len(ri.shots) > 1]
+        True for ri in reconstruction.rig_instances.values() if len(ri.shots) > 1
     )
     use_scale = not has_scaled_rigs
     if bias_override and config["bundle_compensate_gps_bias"]:
@@ -343,7 +343,7 @@ def set_gps_bias(
             subrec, [], config, True, use_scale
         )
 
-    if any([True for x in per_camera_transform.values() if not x]):
+    if any(True for x in per_camera_transform.values() if not x):
         logger.warning("Cannot compensate some shots, GPS bias won't be compensated.")
     else:
         for camera_id, transform in per_camera_transform.items():

From b573141bbace40be8478ddc929545bdd665896aa Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Tue, 14 Oct 2025 02:47:44 -0700
Subject: [PATCH 181/235] Fix status badge to show new actions (#1110)

Summary:
The badge in the readme was pointing to an old unused action.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1110

Reviewed By: fabianschenk

Differential Revision: D84590543

Pulled By: paulinus

fbshipit-source-id: 6cdf1ffca70a5abcdc0b89976c3f44bd16027522
---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 727f3af23..5d74bbc6f 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
-OpenSfM ![Docker workflow](https://github.com/mapillary/opensfm/workflows/Docker%20CI/badge.svg)
+OpenSfM
 =======
+[![Conda](https://github.com/mapillary/OpenSfM/actions/workflows/conda.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/conda.yml) [![Docker Ubuntu 20.04](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu20.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu20.yml) [![Docker Ubuntu 24.04](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu24.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu24.yml)
 
 ## Overview
 OpenSfM is a Structure from Motion library written in Python. The library serves as a processing pipeline for reconstructing camera poses and 3D scenes from multiple images. It consists of basic modules for Structure from Motion (feature detection/matching, minimal solvers) with a focus on building a robust and scalable reconstruction pipeline. It also integrates external sensor (e.g. GPS, accelerometer) measurements for geographical alignment and robustness. A JavaScript viewer is provided to preview the models and debug the pipeline.

From 391f8d1767e8e7d1793ede84d9e2519ee1d67cef Mon Sep 17 00:00:00 2001
From: generatedunixname89002005287564
 <generatedunixname89002005287564@meta.com>
Date: Wed, 15 Oct 2025 12:07:14 -0700
Subject: [PATCH 182/235] Fix CQS signal facebook-unused-include-check in
 fbcode/mapillary/opensfm

Reviewed By: dmannemela

Differential Revision: D84694889

fbshipit-source-id: 915019616a10c2c9708645b868c9b81b425ebbc0
---
 opensfm/src/sfm/src/tracks_helpers.cc | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index d5a5c27c9..d3aa710dd 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -1,8 +1,5 @@
 #include "sfm/tracks_helpers.h"
 
-#include <map/landmark.h>
-#include <map/shot.h>
-
 #include <unordered_set>
 #include <vector>
 

From a885073eb48629798102ca37e98ad123e3950b0a Mon Sep 17 00:00:00 2001
From: Nikita Lutsenko <nlutsenko@meta.com>
Date: Sun, 26 Oct 2025 23:40:59 -0700
Subject: [PATCH 183/235] clang-format | Format fbsource with clang-format 21.

Reviewed By: ChristianK275

Differential Revision: D85317706

fbshipit-source-id: b399c5c4b75252999442b7d7d2778e7a241b0025
---
 opensfm/src/bundle/bundle_adjuster.h          | 126 +++----
 opensfm/src/bundle/data/bias.h                |  12 +-
 opensfm/src/bundle/data/camera.h              |   8 +-
 opensfm/src/bundle/data/data.h                |  32 +-
 opensfm/src/bundle/data/point.h               |  10 +-
 opensfm/src/bundle/data/pose.h                |  14 +-
 opensfm/src/bundle/data/shot.h                |  20 +-
 opensfm/src/bundle/error/parameters_errors.h  |   4 +-
 opensfm/src/bundle/python/pybind.cc           |  22 +-
 opensfm/src/bundle/reconstruction_alignment.h | 160 ++++-----
 opensfm/src/bundle/src/bundle_adjuster.cc     | 334 +++++++++---------
 opensfm/src/debug_c_extension.cc              |   2 +-
 opensfm/src/dense/depthmap.h                  | 104 +++---
 opensfm/src/dense/openmvs_exporter.h          |  12 +-
 opensfm/src/dense/src/depthmap.cc             | 127 ++++---
 opensfm/src/features/matching.h               |   6 +-
 opensfm/src/features/src/akaze_bind.cc        |   3 +-
 opensfm/src/features/src/hahog.cc             |  28 +-
 opensfm/src/features/src/matching.cc          |  30 +-
 opensfm/src/foundation/python_types.h         |  24 +-
 opensfm/src/foundation/src/types.cc           |   8 +-
 opensfm/src/geo/python/pybind.cc              |  32 +-
 opensfm/src/geometry/absolute_pose.h          |  18 +-
 opensfm/src/geometry/essential.h              |  22 +-
 opensfm/src/geometry/python/pybind.cc         |  74 ++--
 opensfm/src/geometry/src/absolute_pose.cc     |  14 +-
 opensfm/src/geometry/src/essential.cc         |  22 +-
 opensfm/src/geometry/src/relative_pose.cc     |  14 +-
 opensfm/src/geometry/src/triangulation.cc     |  56 +--
 .../src/geometry/test/triangulation_test.cc   |  12 +-
 opensfm/src/geometry/triangulation.h          |  46 +--
 opensfm/src/map/pybind_utils.h                |  21 +-
 opensfm/src/map/python/pybind.cc              | 208 +++++------
 opensfm/src/testing_main.cc                   |   2 +-
 34 files changed, 819 insertions(+), 808 deletions(-)

diff --git a/opensfm/src/bundle/bundle_adjuster.h b/opensfm/src/bundle/bundle_adjuster.h
index a9e74f90e..64c89ce10 100644
--- a/opensfm/src/bundle/bundle_adjuster.h
+++ b/opensfm/src/bundle/bundle_adjuster.h
@@ -36,20 +36,20 @@ struct Reconstruction {
   bool constant;
   bool shared;
 
-  double *GetScalePtr(const std::string &shot) {
+  double* GetScalePtr(const std::string& shot) {
     if (shared) {
       return &(scales.begin()->second);
     }
     return &(scales.at(shot));
   }
 
-  double GetScale(const std::string &shot) const {
+  double GetScale(const std::string& shot) const {
     if (shared) {
       return scales.begin()->second;
     }
     return scales.at(shot);
   }
-  void SetScale(const std::string &shot, double v) {
+  void SetScale(const std::string& shot, double v) {
     if (shared) {
       scales.begin()->second = v;
     }
@@ -59,17 +59,17 @@ struct Reconstruction {
 
 struct PointProjectionObservation {
   Vec2d coordinates;
-  Point *point;
-  Shot *shot;
-  Camera *camera;
+  Point* point;
+  Shot* shot;
+  Camera* camera;
   double std_deviation;
   std::optional<map::Depth> depth_prior;
 };
 
 struct RelativeMotion {
-  RelativeMotion(const std::string &rig_instance_i,
-                 const std::string &rig_instance_j, const Vec3d &rotation,
-                 const Vec3d &translation, double scale,
+  RelativeMotion(const std::string& rig_instance_i,
+                 const std::string& rig_instance_j, const Vec3d& rotation,
+                 const Vec3d& translation, double scale,
                  double robust_multiplier, bool observed_scale) {
     rig_instance_id_i = rig_instance_i;
     rig_instance_id_j = rig_instance_j;
@@ -86,7 +86,7 @@ struct RelativeMotion {
     this->observed_scale = observed_scale;
   }
 
-  void SetScaleMatrix(const MatXd &s) { scale_matrix = s; }
+  void SetScaleMatrix(const MatXd& s) { scale_matrix = s; }
 
   std::string rig_instance_id_i;
   std::string rig_instance_id_j;
@@ -98,16 +98,16 @@ struct RelativeMotion {
 };
 
 struct RelativeRotation {
-  RelativeRotation(const std::string &shot_i, const std::string &shot_j,
-                   const Vec3d &r) {
+  RelativeRotation(const std::string& shot_i, const std::string& shot_j,
+                   const Vec3d& r) {
     shot_id_i = shot_i;
     shot_id_j = shot_j;
     rotation = r;
     scale_matrix.setIdentity();
   }
   Vec3d GetRotation() const { return rotation; }
-  void SetRotation(const Vec3d &r) { rotation = r; }
-  void SetScaleMatrix(const Mat3d &s) { scale_matrix = s; }
+  void SetRotation(const Vec3d& r) { rotation = r; }
+  void SetScaleMatrix(const Mat3d& s) { scale_matrix = s; }
 
   std::string shot_id_i;
   std::string shot_id_j;
@@ -123,7 +123,7 @@ struct CommonPosition {
 };
 
 struct HeatmapInterpolator {
-  HeatmapInterpolator(const std::vector<double> &flatten_heatmap, size_t width,
+  HeatmapInterpolator(const std::vector<double>& flatten_heatmap, size_t width,
                       double resolution);
   std::vector<double> heatmap;
   size_t width;
@@ -172,74 +172,74 @@ class BundleAdjuster {
   // Bundle variables
 
   // Basic
-  void AddCamera(const std::string &id, const geometry::Camera &camera,
-                 const geometry::Camera &prior, bool constant);
-  void AddPoint(const std::string &id, const Vec3d &position, bool constant);
-  void AddPointPrior(const std::string &id, const Vec3d &position,
-                     const Vec3d &std_deviation, bool has_altitude_prior);
-  void SetCameraBias(const std::string &id, const geometry::Similarity &bias);
+  void AddCamera(const std::string& id, const geometry::Camera& camera,
+                 const geometry::Camera& prior, bool constant);
+  void AddPoint(const std::string& id, const Vec3d& position, bool constant);
+  void AddPointPrior(const std::string& id, const Vec3d& position,
+                     const Vec3d& std_deviation, bool has_altitude_prior);
+  void SetCameraBias(const std::string& id, const geometry::Similarity& bias);
 
   // Rigs
   void AddRigInstance(
-      const std::string &rig_instance_id,
-      const geometry::Pose &rig_instance_pose,
-      const std::unordered_map<std::string, std::string> &shot_cameras,
-      const std::unordered_map<std::string, std::string> &shot_rig_cameras,
+      const std::string& rig_instance_id,
+      const geometry::Pose& rig_instance_pose,
+      const std::unordered_map<std::string, std::string>& shot_cameras,
+      const std::unordered_map<std::string, std::string>& shot_rig_cameras,
       bool fixed);
-  void AddRigCamera(const std::string &rig_camera, const geometry::Pose &pose,
-                    const geometry::Pose &pose_prior, bool fixed);
-  void AddRigInstancePositionPrior(const std::string &instance_id,
-                                   const Vec3d &position,
-                                   const Vec3d &std_deviation,
-                                   const std::string &scale_group);
+  void AddRigCamera(const std::string& rig_camera, const geometry::Pose& pose,
+                    const geometry::Pose& pose_prior, bool fixed);
+  void AddRigInstancePositionPrior(const std::string& instance_id,
+                                   const Vec3d& position,
+                                   const Vec3d& std_deviation,
+                                   const std::string& scale_group);
 
   // Cluster-SfM related
-  void AddReconstruction(const std::string &id, bool constant);
-  void AddReconstructionInstance(const std::string &reconstruction_id,
-                                 double scale, const std::string &instance_id);
-  void SetScaleSharing(const std::string &id, bool share);
+  void AddReconstruction(const std::string& id, bool constant);
+  void AddReconstructionInstance(const std::string& reconstruction_id,
+                                 double scale, const std::string& instance_id);
+  void SetScaleSharing(const std::string& id, bool share);
 
   // Real bundle adjustment : point projections
   void AddPointProjectionObservation(
-      const std::string &shot, const std::string &point,
-      const Vec2d &observation, double std_deviation,
-      const std::optional<map::Depth> &depth_prior = std::nullopt);
+      const std::string& shot, const std::string& point,
+      const Vec2d& observation, double std_deviation,
+      const std::optional<map::Depth>& depth_prior = std::nullopt);
 
   // Relative motion constraints
-  void AddRelativeMotion(const RelativeMotion &rm);
-  void AddRelativeRotation(const RelativeRotation &rr);
+  void AddRelativeMotion(const RelativeMotion& rm);
+  void AddRelativeRotation(const RelativeRotation& rr);
 
   // Absolute motion constraints
-  void AddCommonPosition(const std::string &shot_id1,
-                         const std::string &shot_id2, double margin,
+  void AddCommonPosition(const std::string& shot_id1,
+                         const std::string& shot_id2, double margin,
                          double std_deviation);
-  void AddHeatmap(const std::string &heatmap_id,
-                  const std::vector<double> &in_heatmap, size_t in_width,
+  void AddHeatmap(const std::string& heatmap_id,
+                  const std::vector<double>& in_heatmap, size_t in_width,
                   double resolution);
 
-  void AddAbsolutePositionHeatmap(const std::string &shot_id,
-                                  const std::string &heatmap_id,
+  void AddAbsolutePositionHeatmap(const std::string& shot_id,
+                                  const std::string& heatmap_id,
                                   double x_offset, double y_offset,
                                   double std_deviation);
 
-  void AddAbsoluteUpVector(const std::string &shot_id, const Vec3d &up_vector,
+  void AddAbsoluteUpVector(const std::string& shot_id, const Vec3d& up_vector,
                            double std_deviation);
-  void AddAbsolutePan(const std::string &shot_id, double angle,
+  void AddAbsolutePan(const std::string& shot_id, double angle,
                       double std_deviation);
-  void AddAbsoluteTilt(const std::string &shot_id, double angle,
+  void AddAbsoluteTilt(const std::string& shot_id, double angle,
                        double std_deviation);
-  void AddAbsoluteRoll(const std::string &shot_id, double angle,
+  void AddAbsoluteRoll(const std::string& shot_id, double angle,
                        double std_deviation);
 
   // Motion priors
-  void AddLinearMotion(const std::string &shot0_id, const std::string &shot1_id,
-                       const std::string &shot2_id, double alpha,
+  void AddLinearMotion(const std::string& shot0_id, const std::string& shot1_id,
+                       const std::string& shot2_id, double alpha,
                        double position_std_deviation,
                        double orientation_std_deviation);
 
   // Gauge fixing
-  void SetGaugeFixShots(const std::string &shot_origin,
-                        const std::string &shot_scale);
+  void SetGaugeFixShots(const std::string& shot_origin,
+                        const std::string& shot_scale);
 
   // Minimization setup
   void SetPointProjectionLossFunction(std::string name, double threshold);
@@ -265,19 +265,19 @@ class BundleAdjuster {
 
   // Minimization
   void Run();
-  void ComputeCovariances(ceres::Problem *problem);
+  void ComputeCovariances(ceres::Problem* problem);
   void ComputeReprojectionErrors();
 
   // Getters
   int GetProjectionsCount() const;
   int GetRelativeMotionsCount() const;
-  geometry::Camera GetCamera(const std::string &id) const;
-  geometry::Similarity GetBias(const std::string &id) const;
-  Reconstruction GetReconstruction(const std::string &reconstruction_id) const;
-  Point GetPoint(const std::string &id) const;
-  bool HasPoint(const std::string &id) const;
-  RigCamera GetRigCamera(const std::string &rig_camera_id) const;
-  RigInstance GetRigInstance(const std::string &instance_id) const;
+  geometry::Camera GetCamera(const std::string& id) const;
+  geometry::Similarity GetBias(const std::string& id) const;
+  Reconstruction GetReconstruction(const std::string& reconstruction_id) const;
+  Point GetPoint(const std::string& id) const;
+  bool HasPoint(const std::string& id) const;
+  RigCamera GetRigCamera(const std::string& rig_camera_id) const;
+  RigInstance GetRigInstance(const std::string& instance_id) const;
   std::map<std::string, RigCamera> GetRigCameras() const;
   std::map<std::string, RigInstance> GetRigInstances() const;
 
@@ -287,7 +287,7 @@ class BundleAdjuster {
 
  private:
   // default sigmas
-  geometry::Camera GetDefaultCameraSigma(const geometry::Camera &camera) const;
+  geometry::Camera GetDefaultCameraSigma(const geometry::Camera& camera) const;
   geometry::Pose GetDefaultRigPoseSigma() const;
 
   // minimized data
diff --git a/opensfm/src/bundle/data/bias.h b/opensfm/src/bundle/data/bias.h
index 8c27633a7..38b272635 100644
--- a/opensfm/src/bundle/data/bias.h
+++ b/opensfm/src/bundle/data/bias.h
@@ -10,20 +10,20 @@ namespace bundle {
 struct Similarity : public Data<geometry::Similarity> {
   enum Parameter { RX, RY, RZ, TX, TY, TZ, SCALE, NUM_PARAMS };
 
-  Similarity(const std::string &id, const geometry::Similarity &value)
+  Similarity(const std::string& id, const geometry::Similarity& value)
       : Data<geometry::Similarity>(id, value) {
     Init();
   }
 
  private:
-  void ValueToData(const geometry::Similarity &value, VecXd &data) const final {
+  void ValueToData(const geometry::Similarity& value, VecXd& data) const final {
     data.resize(NUM_PARAMS);
     data.segment<3>(TX) = value.Translation();
     data.segment<3>(RX) = value.Rotation();
     data(SCALE) = value.Scale();
   }
 
-  void DataToValue(const VecXd &data, geometry::Similarity &value) const final {
+  void DataToValue(const VecXd& data, geometry::Similarity& value) const final {
     value.SetTranslation(data.segment<3>(TX));
     value.SetRotation(data.segment<3>(RX));
     value.SetScale(data(SCALE));
@@ -34,11 +34,11 @@ struct SimilarityPriorTransform
     : public geometry::Functor<Pose::NUM_PARAMS, Similarity::NUM_PARAMS,
                                Pose::NUM_PARAMS> {
   template <typename T>
-  VecN<T, Pose::NUM_PARAMS> operator()(T const *parameters,
-                                       T const *data) const {
+  VecN<T, Pose::NUM_PARAMS> operator()(T const* parameters,
+                                       T const* data) const {
     Vec3<T> R = ShotRotationFunctor(0, FUNCTOR_NOT_SET)(&parameters);
     Vec3<T> t = ShotPositionFunctor(0, FUNCTOR_NOT_SET)(&parameters);
-    const T *const scale = parameters + Similarity::Parameter::SCALE;
+    const T* const scale = parameters + Similarity::Parameter::SCALE;
 
     VecN<T, Pose::NUM_PARAMS> transformed =
         Eigen::Map<const VecN<T, Pose::NUM_PARAMS>>(data).eval();
diff --git a/opensfm/src/bundle/data/camera.h b/opensfm/src/bundle/data/camera.h
index 0966117ce..f5ecc4388 100644
--- a/opensfm/src/bundle/data/camera.h
+++ b/opensfm/src/bundle/data/camera.h
@@ -6,18 +6,18 @@
 namespace bundle {
 
 struct Camera : public Data<geometry::Camera> {
-  Camera(const std::string &id, const geometry::Camera &value,
-         const geometry::Camera &prior, const geometry::Camera &sigma)
+  Camera(const std::string& id, const geometry::Camera& value,
+         const geometry::Camera& prior, const geometry::Camera& sigma)
       : Data<geometry::Camera>(id, value, prior, sigma) {
     Init();
   }
 
  private:
-  void ValueToData(const geometry::Camera &value, VecXd &data) const final {
+  void ValueToData(const geometry::Camera& value, VecXd& data) const final {
     data = value.GetParametersValues();
   }
 
-  void DataToValue(const VecXd &data, geometry::Camera &value) const final {
+  void DataToValue(const VecXd& data, geometry::Camera& value) const final {
     value.SetParametersValues(data);
   }
 };
diff --git a/opensfm/src/bundle/data/data.h b/opensfm/src/bundle/data/data.h
index d54fa7bb0..8e49feb60 100644
--- a/opensfm/src/bundle/data/data.h
+++ b/opensfm/src/bundle/data/data.h
@@ -10,7 +10,7 @@
 namespace bundle {
 
 struct DataNode {
-  explicit DataNode(const std::string &id) : id_(id) {}
+  explicit DataNode(const std::string& id) : id_(id) {}
   std::string GetID() const { return id_; }
 
  protected:
@@ -22,12 +22,12 @@ struct Data : public DataNode {
  public:
   using ValueType = T;
 
-  Data(const std::string &id, const T &value, const T &prior, const T &sigma)
+  Data(const std::string& id, const T& value, const T& prior, const T& sigma)
       : DataNode(id), value_(value), prior_(prior), sigma_(sigma) {}
-  Data(const std::string &id, const T &value) : DataNode(id), value_(value) {}
+  Data(const std::string& id, const T& value) : DataNode(id), value_(value) {}
   virtual ~Data() {}
 
-  VecXd &GetValueData() { return value_data_; }
+  VecXd& GetValueData() { return value_data_; }
   T GetValue() const {
     T v = value_;
     DataToValue(value_data_, v);
@@ -43,7 +43,7 @@ struct Data : public DataNode {
     ValueToData(prior_.Value(), prior_data);
     return prior_data;
   }
-  void SetPrior(const T &prior) { prior_.SetValue(prior); }
+  void SetPrior(const T& prior) { prior_.SetValue(prior); }
 
   VecXd GetSigmaData() const {
     if (!sigma_.HasValue()) {
@@ -53,9 +53,9 @@ struct Data : public DataNode {
     ValueToData(sigma_.Value(), sigma_data);
     return sigma_data;
   }
-  void SetSigma(const T &sigma) { sigma_.SetValue(sigma); }
+  void SetSigma(const T& sigma) { sigma_.SetValue(sigma); }
 
-  void SetCovariance(const MatXd &covariance) {
+  void SetCovariance(const MatXd& covariance) {
     covariance_.SetValue(covariance);
   }
   bool HasCovariance() const { return covariance_.HasValue(); }
@@ -66,15 +66,15 @@ struct Data : public DataNode {
     return covariance_.Value();
   }
 
-  const std::vector<int> &GetParametersToOptimize() const {
+  const std::vector<int>& GetParametersToOptimize() const {
     return parameters_to_optimize_;
   }
-  void SetParametersToOptimize(const std::vector<int> &parameters) {
+  void SetParametersToOptimize(const std::vector<int>& parameters) {
     parameters_to_optimize_ = parameters;
   }
 
-  virtual void ValueToData(const T &value, VecXd &data) const = 0;
-  virtual void DataToValue(const VecXd &data, T &value) const = 0;
+  virtual void ValueToData(const T& value, VecXd& data) const = 0;
+  virtual void DataToValue(const VecXd& data, T& value) const = 0;
 
  protected:
   VecXd value_data_;
@@ -94,13 +94,13 @@ struct Data : public DataNode {
 };
 
 struct DataContainer : public DataNode {
-  explicit DataContainer(const std::string &id) : DataNode(id) {}
+  explicit DataContainer(const std::string& id) : DataNode(id) {}
 
  protected:
-  void RegisterData(const std::string &id, DataNode *data) {
+  void RegisterData(const std::string& id, DataNode* data) {
     ba_nodes_[id] = data;
   }
-  DataNode *GetData(const std::string &id) {
+  DataNode* GetData(const std::string& id) {
     const auto find_data = ba_nodes_.find(id);
     if (find_data == ba_nodes_.end()) {
       throw std::runtime_error("Data " + id +
@@ -108,7 +108,7 @@ struct DataContainer : public DataNode {
     }
     return find_data->second;
   }
-  const DataNode *GetData(const std::string &id) const {
+  const DataNode* GetData(const std::string& id) const {
     const auto find_data = ba_nodes_.find(id);
     if (find_data == ba_nodes_.end()) {
       throw std::runtime_error("Data " + id +
@@ -118,6 +118,6 @@ struct DataContainer : public DataNode {
   }
 
  private:
-  std::unordered_map<std::string, DataNode *> ba_nodes_;
+  std::unordered_map<std::string, DataNode*> ba_nodes_;
 };
 }  // namespace bundle
diff --git a/opensfm/src/bundle/data/point.h b/opensfm/src/bundle/data/point.h
index 177ab978d..ad01d90a0 100644
--- a/opensfm/src/bundle/data/point.h
+++ b/opensfm/src/bundle/data/point.h
@@ -9,12 +9,12 @@ namespace bundle {
 struct Point : public Data<Vec3d> {
   enum Parameter { PX, PY, PZ, NUM_PARAMS };
 
-  Point(const std::string &id, const Vec3d &value) : Data<Vec3d>(id, value) {
+  Point(const std::string& id, const Vec3d& value) : Data<Vec3d>(id, value) {
     Init();
   }
 
-  Point(const std::string &id, const Vec3d &value, const Vec3d &prior,
-        const Vec3d &sigma)
+  Point(const std::string& id, const Vec3d& value, const Vec3d& prior,
+        const Vec3d& sigma)
       : Data<Vec3d>(id, value, prior, sigma) {
     Init();
   }
@@ -23,11 +23,11 @@ struct Point : public Data<Vec3d> {
   bool has_altitude_prior{true};
 
  private:
-  void ValueToData(const Vec3d &value, VecXd &data) const final {
+  void ValueToData(const Vec3d& value, VecXd& data) const final {
     data = value;
   }
 
-  void DataToValue(const VecXd &data, Vec3d &value) const final {
+  void DataToValue(const VecXd& data, Vec3d& value) const final {
     value = data;
   }
 };
diff --git a/opensfm/src/bundle/data/pose.h b/opensfm/src/bundle/data/pose.h
index 1b512ab00..5b39465b5 100644
--- a/opensfm/src/bundle/data/pose.h
+++ b/opensfm/src/bundle/data/pose.h
@@ -16,22 +16,22 @@ struct Pose : public Data<geometry::Pose> {
 
   enum Parameter { RX, RY, RZ, TX, TY, TZ, NUM_PARAMS };
 
-  Pose(const std::string &id, const geometry::Pose &value,
-       const Parametrization &parametrization = Parametrization::CAM_TO_WORLD)
+  Pose(const std::string& id, const geometry::Pose& value,
+       const Parametrization& parametrization = Parametrization::CAM_TO_WORLD)
       : Data<geometry::Pose>(id, value), parametrization_(parametrization) {
     Init();
   }
 
-  Pose(const std::string &id, const geometry::Pose &value,
-       const geometry::Pose &prior, const geometry::Pose &sigma,
-       const Parametrization &parametrization = Parametrization::CAM_TO_WORLD)
+  Pose(const std::string& id, const geometry::Pose& value,
+       const geometry::Pose& prior, const geometry::Pose& sigma,
+       const Parametrization& parametrization = Parametrization::CAM_TO_WORLD)
       : Data<geometry::Pose>(id, value, prior, sigma),
         parametrization_(parametrization) {
     Init();
   }
 
  private:
-  void ValueToData(const geometry::Pose &value, VecXd &data) const final {
+  void ValueToData(const geometry::Pose& value, VecXd& data) const final {
     data.resize(NUM_PARAMS);
     if (parametrization_ == Parametrization::CAM_TO_WORLD) {
       data.segment<3>(TX) = value.TranslationCameraToWorld();
@@ -42,7 +42,7 @@ struct Pose : public Data<geometry::Pose> {
     }
   }
 
-  void DataToValue(const VecXd &data, geometry::Pose &value) const final {
+  void DataToValue(const VecXd& data, geometry::Pose& value) const final {
     if (parametrization_ == Parametrization::CAM_TO_WORLD) {
       value.SetFromCameraToWorld(Vec3d(data.segment<3>(RX)),
                                  data.segment<3>(TX));
diff --git a/opensfm/src/bundle/data/shot.h b/opensfm/src/bundle/data/shot.h
index 582672db8..a882af7bc 100644
--- a/opensfm/src/bundle/data/shot.h
+++ b/opensfm/src/bundle/data/shot.h
@@ -11,8 +11,8 @@ namespace bundle {
 using RigCamera = Pose;
 
 struct RigInstance : public Pose {
-  RigInstance(const std::string &id, const geometry::Pose &value,
-              const std::unordered_map<std::string, std::string> &shot_cameras)
+  RigInstance(const std::string& id, const geometry::Pose& value,
+              const std::unordered_map<std::string, std::string>& shot_cameras)
       : Pose(id, value, Parametrization::CAM_TO_WORLD),
         shot_cameras(shot_cameras) {}
 
@@ -21,22 +21,22 @@ struct RigInstance : public Pose {
 };
 
 struct Shot : public DataContainer {
-  Shot(const std::string &id, bundle::Camera *camera, RigCamera *rig_camera,
-       RigInstance *rig_instance)
+  Shot(const std::string& id, bundle::Camera* camera, RigCamera* rig_camera,
+       RigInstance* rig_instance)
       : DataContainer(id) {
     RegisterData("camera", camera);
     RegisterData("rig_camera", rig_camera);
     RegisterData("rig_instance", rig_instance);
   }
 
-  bundle::Camera *GetCamera() {
-    return static_cast<bundle::Camera *>(GetData("camera"));
+  bundle::Camera* GetCamera() {
+    return static_cast<bundle::Camera*>(GetData("camera"));
   }
-  RigCamera *GetRigCamera() {
-    return static_cast<RigCamera *>(GetData("rig_camera"));
+  RigCamera* GetRigCamera() {
+    return static_cast<RigCamera*>(GetData("rig_camera"));
   }
-  RigInstance *GetRigInstance() {
-    return static_cast<RigInstance *>(GetData("rig_instance"));
+  RigInstance* GetRigInstance() {
+    return static_cast<RigInstance*>(GetData("rig_instance"));
   }
 };
 }  // namespace bundle
diff --git a/opensfm/src/bundle/error/parameters_errors.h b/opensfm/src/bundle/error/parameters_errors.h
index 394b52c04..969b58a5f 100644
--- a/opensfm/src/bundle/error/parameters_errors.h
+++ b/opensfm/src/bundle/error/parameters_errors.h
@@ -8,7 +8,7 @@ struct StdDeviationConstraint {
   StdDeviationConstraint() = default;
 
   template <typename T>
-  bool operator()(const T *const std_deviation, T *residuals) const {
+  bool operator()(const T* const std_deviation, T* residuals) const {
     T std = std_deviation[0];
     residuals[0] = ceres::log(T(1.0) / ceres::sqrt(T(2.0 * M_PI) * std * std));
     return true;
@@ -20,7 +20,7 @@ struct ParameterBarrier {
       : lower_bound_(lower_bound), upper_bound_(upper_bound), index_(index) {}
 
   template <typename T>
-  bool operator()(const T *const parameters, T *residuals) const {
+  bool operator()(const T* const parameters, T* residuals) const {
     T eps = T(1e-10);
     T value = parameters[index_];
     T zero = 2.0 * ceres::log((T(upper_bound_) - T(lower_bound_)) * 0.5);
diff --git a/opensfm/src/bundle/python/pybind.cc b/opensfm/src/bundle/python/pybind.cc
index e4c802724..27b662147 100644
--- a/opensfm/src/bundle/python/pybind.cc
+++ b/opensfm/src/bundle/python/pybind.cc
@@ -10,8 +10,8 @@ PYBIND11_MODULE(pybundle, m) {
   py::module::import("opensfm.pymap");
 
   py::class_<bundle::RelativeMotion>(m, "RelativeMotion")
-      .def(py::init<const std::string &, const std::string &,
-                    const Eigen::Vector3d &, const Eigen::Vector3d &, double,
+      .def(py::init<const std::string&, const std::string&,
+                    const Eigen::Vector3d&, const Eigen::Vector3d&, double,
                     double, bool>())
       .def_readwrite("rig_instance_i",
                      &bundle::RelativeMotion::rig_instance_id_i)
@@ -20,8 +20,8 @@ PYBIND11_MODULE(pybundle, m) {
       .def("set_scale_matrix", &bundle::RelativeMotion::SetScaleMatrix);
 
   py::class_<bundle::RelativeRotation>(m, "RelativeRotation")
-      .def(py::init<const std::string &, const std::string &,
-                    const Eigen::Vector3d &>())
+      .def(py::init<const std::string&, const std::string&,
+                    const Eigen::Vector3d&>())
       .def_readwrite("shot_i", &bundle::RelativeRotation::shot_id_i)
       .def_readwrite("shot_j", &bundle::RelativeRotation::shot_id_j)
       .def_property("r", &bundle::RelativeRotation::GetRotation,
@@ -36,9 +36,9 @@ PYBIND11_MODULE(pybundle, m) {
 
   py::class_<bundle::Point>(m, "Point")
       .def_property_readonly(
-          "p", [](const bundle::Point &p) { return p.GetValue(); })
+          "p", [](const bundle::Point& p) { return p.GetValue(); })
       .def_property_readonly("id",
-                             [](const bundle::Point &p) { return p.GetID(); })
+                             [](const bundle::Point& p) { return p.GetID(); })
       .def_readwrite("reprojection_errors",
                      &bundle::Point::reprojection_errors);
 
@@ -54,14 +54,14 @@ PYBIND11_MODULE(pybundle, m) {
       .def("get_camera", &bundle::BundleAdjuster::GetCamera)
       .def("add_rig_camera", &bundle::BundleAdjuster::AddRigCamera)
       .def("get_rig_camera_pose",
-           [](const bundle::BundleAdjuster &ba,
-              const std::string &rig_camera_id) {
+           [](const bundle::BundleAdjuster& ba,
+              const std::string& rig_camera_id) {
              return ba.GetRigCamera(rig_camera_id).GetValue();
            })
       .def("add_rig_instance", &bundle::BundleAdjuster::AddRigInstance)
       .def("get_rig_instance_pose",
-           [](const bundle::BundleAdjuster &ba,
-              const std::string &rig_instance_id) {
+           [](const bundle::BundleAdjuster& ba,
+              const std::string& rig_instance_id) {
              return ba.GetRigInstance(rig_instance_id).GetValue();
            })
       .def("add_rig_instance_position_prior",
@@ -162,7 +162,7 @@ PYBIND11_MODULE(pybundle, m) {
       .def_readwrite("id", &RAReconstruction::id);
 
   py::class_<RARelativeMotionConstraint>(m, "RARelativeMotionConstraint")
-      .def(py::init<const std::string &, const std::string &, double, double,
+      .def(py::init<const std::string&, const std::string&, double, double,
                     double, double, double, double>())
       .def_readwrite("reconstruction",
                      &RARelativeMotionConstraint::reconstruction_id)
diff --git a/opensfm/src/bundle/reconstruction_alignment.h b/opensfm/src/bundle/reconstruction_alignment.h
index a27073439..6cb01fadb 100644
--- a/opensfm/src/bundle/reconstruction_alignment.h
+++ b/opensfm/src/bundle/reconstruction_alignment.h
@@ -75,8 +75,8 @@ struct RAReconstruction {
 };
 
 struct RARelativeMotionConstraint {
-  RARelativeMotionConstraint(const std::string &reconstruction,
-                             const std::string &shot, double rx, double ry,
+  RARelativeMotionConstraint(const std::string& reconstruction,
+                             const std::string& shot, double rx, double ry,
                              double rz, double tx, double ty, double tz) {
     reconstruction_id = reconstruction;
     shot_id = shot;
@@ -115,51 +115,51 @@ struct RARelativeMotionConstraint {
 };
 
 struct RAAbsolutePositionConstraint {
-  RAShot *shot;
+  RAShot* shot;
   double position[3];
   double std_deviation;
 };
 
 struct RARelativeAbsolutePositionConstraint {
-  RAShot *shot;
-  RAReconstruction *reconstruction;
+  RAShot* shot;
+  RAReconstruction* reconstruction;
   double position[3];
   double std_deviation;
 };
 
 struct RACommonCameraConstraint {
-  RAReconstruction *reconstruction_a;
-  RAShot *shot_a;
-  RAReconstruction *reconstruction_b;
-  RAShot *shot_b;
+  RAReconstruction* reconstruction_a;
+  RAShot* shot_a;
+  RAReconstruction* reconstruction_b;
+  RAShot* shot_b;
   double std_deviation_center;
   double std_deviation_rotation;
 };
 
 struct RACommonPointConstraint {
-  RAReconstruction *reconstruction_a;
+  RAReconstruction* reconstruction_a;
   double point_a[3];
-  RAReconstruction *reconstruction_b;
+  RAReconstruction* reconstruction_b;
   double point_b[3];
   double std_deviation;
 };
 
 struct RARelativeMotionError {
-  RARelativeMotionError(double *Rtai, double *scale_matrix)
+  RARelativeMotionError(double* Rtai, double* scale_matrix)
       : Rtai_(Rtai), scale_matrix_(scale_matrix) {}
 
   template <typename T>
-  bool operator()(const T *const reconstruction_a, const T *const shot_i,
-                  T *residuals) const {
+  bool operator()(const T* const reconstruction_a, const T* const shot_i,
+                  T* residuals) const {
     T r[6];
 
     // Get rotation and translation values.
-    const T *const Ri = shot_i + RA_SHOT_RX;
-    const T *const Ra = reconstruction_a + RA_RECONSTRUCTION_RX;
+    const T* const Ri = shot_i + RA_SHOT_RX;
+    const T* const Ra = reconstruction_a + RA_RECONSTRUCTION_RX;
     T Rit[3] = {-Ri[0], -Ri[1], -Ri[2]};
-    const T *const ti = shot_i + RA_SHOT_TX;
-    const T *const ta = reconstruction_a + RA_RECONSTRUCTION_TX;
-    const T *const scale_a = reconstruction_a + RA_RECONSTRUCTION_SCALE;
+    const T* const ti = shot_i + RA_SHOT_TX;
+    const T* const ta = reconstruction_a + RA_RECONSTRUCTION_TX;
+    const T* const scale_a = reconstruction_a + RA_RECONSTRUCTION_SCALE;
     T Rai[3] = {T(Rtai_[RA_SHOT_RX]), T(Rtai_[RA_SHOT_RY]),
                 T(Rtai_[RA_SHOT_RZ])};
     T tai[3] = {T(Rtai_[RA_SHOT_TX]), T(Rtai_[RA_SHOT_TY]),
@@ -199,19 +199,19 @@ struct RARelativeMotionError {
     return true;
   }
 
-  double *Rtai_;
-  double *scale_matrix_;
+  double* Rtai_;
+  double* scale_matrix_;
 };
 
 struct RAAbsolutePositionError {
-  RAAbsolutePositionError(double *c_prior, double std_deviation)
+  RAAbsolutePositionError(double* c_prior, double std_deviation)
       : c_prior_(c_prior), scale_(1.0 / std_deviation) {}
 
   template <typename T>
-  bool operator()(const T *const shot_i, T *residuals) const {
+  bool operator()(const T* const shot_i, T* residuals) const {
     // error: c + R^t t
-    const T *const Ri = shot_i + RA_SHOT_RX;
-    const T *const ti = shot_i + RA_SHOT_TX;
+    const T* const Ri = shot_i + RA_SHOT_RX;
+    const T* const ti = shot_i + RA_SHOT_TX;
     T Rit[3] = {-Ri[0], -Ri[1], -Ri[2]};
 
     T Rit_ti[3];
@@ -224,16 +224,16 @@ struct RAAbsolutePositionError {
     return true;
   }
 
-  double *c_prior_;
+  double* c_prior_;
   double scale_;
 };
 
 template <typename T>
-void transform_point(const T *const reconstruction, double *point,
-                     T *transformed) {
-  const T *const R = reconstruction + RA_RECONSTRUCTION_RX;
-  const T *const t = reconstruction + RA_RECONSTRUCTION_TX;
-  const T &scale = reconstruction[RA_RECONSTRUCTION_SCALE];
+void transform_point(const T* const reconstruction, double* point,
+                     T* transformed) {
+  const T* const R = reconstruction + RA_RECONSTRUCTION_RX;
+  const T* const t = reconstruction + RA_RECONSTRUCTION_TX;
+  const T& scale = reconstruction[RA_RECONSTRUCTION_SCALE];
   T p_t_s[3] = {(T(point[0]) - t[0]) / scale, (T(point[1]) - t[1]) / scale,
                 (T(point[2]) - t[2]) / scale};
   T Rt[3] = {-R[0], -R[1], -R[2]};
@@ -241,15 +241,15 @@ void transform_point(const T *const reconstruction, double *point,
 }
 
 struct RARelativeAbsolutePositionError {
-  RARelativeAbsolutePositionError(double *c_prior, double *shot,
+  RARelativeAbsolutePositionError(double* c_prior, double* shot,
                                   double std_deviation)
       : c_prior_(c_prior), shot_(shot), scale_(1.0 / std_deviation) {}
 
   template <typename T>
-  bool operator()(const T *const reconstruction, T *residuals) const {
+  bool operator()(const T* const reconstruction, T* residuals) const {
     // error: c - transform(-R^t t)
-    const double *const Ri = shot_ + RA_SHOT_RX;
-    const double *const ti = shot_ + RA_SHOT_TX;
+    const double* const Ri = shot_ + RA_SHOT_RX;
+    const double* const ti = shot_ + RA_SHOT_TX;
     double Rit[3] = {-Ri[0], -Ri[1], -Ri[2]};
 
     double Rit_ti[3];
@@ -266,18 +266,18 @@ struct RARelativeAbsolutePositionError {
     return true;
   }
 
-  double *c_prior_;
-  double *shot_;
+  double* c_prior_;
+  double* shot_;
   double scale_;
 };
 
 struct RACommonPointError {
-  RACommonPointError(double *pai, double *pbi, double std_deviation)
+  RACommonPointError(double* pai, double* pbi, double std_deviation)
       : pai_(pai), pbi_(pbi), inv_std_(1.0 / std_deviation) {}
 
   template <typename T>
-  bool operator()(const T *const reconstruction_a,
-                  const T *const reconstruction_b, T *residuals) const {
+  bool operator()(const T* const reconstruction_a,
+                  const T* const reconstruction_b, T* residuals) const {
     T transformed_pai[3];
     transform_point(reconstruction_a, pai_, transformed_pai);
 
@@ -297,13 +297,13 @@ struct RACommonPointError {
     return true;
   }
 
-  double *pai_;
-  double *pbi_;
+  double* pai_;
+  double* pbi_;
   double inv_std_;
 };
 
 struct RACommonCameraError {
-  RACommonCameraError(double *shot_ai, double *shot_bi,
+  RACommonCameraError(double* shot_ai, double* shot_bi,
                       double std_deviation_center,
                       double std_deviation_rotation)
       : shot_ai_(shot_ai),
@@ -312,12 +312,12 @@ struct RACommonCameraError {
         inv_std_rotation_(1.0 / std_deviation_rotation) {}
 
   template <typename T>
-  bool operator()(const T *const reconstruction_a,
-                  const T *const reconstruction_b, T *residuals) const {
-    const double *const rotation_ai = shot_ai_ + RA_SHOT_RX;
-    const double *const rotation_bi = shot_bi_ + RA_SHOT_RX;
-    const double *const translation_ai = shot_ai_ + RA_SHOT_TX;
-    const double *const translation_bi = shot_bi_ + RA_SHOT_TX;
+  bool operator()(const T* const reconstruction_a,
+                  const T* const reconstruction_b, T* residuals) const {
+    const double* const rotation_ai = shot_ai_ + RA_SHOT_RX;
+    const double* const rotation_bi = shot_bi_ + RA_SHOT_RX;
+    const double* const translation_ai = shot_ai_ + RA_SHOT_TX;
+    const double* const translation_bi = shot_bi_ + RA_SHOT_TX;
 
     double pose_ai[3], pose_bi[3];
     const double rotation_ait[3] = {-rotation_ai[0], -rotation_ai[1],
@@ -339,8 +339,8 @@ struct RACommonCameraError {
 
     // rotation error in world coordinates :
     // (Ra^t Rai^t)(^T)(Rb^t Rbi^t) = (Rai Ra)(Rb^t Rbi^t)
-    const T *const Ra = reconstruction_a + RA_RECONSTRUCTION_RX;
-    const T *const Rb = reconstruction_b + RA_RECONSTRUCTION_RX;
+    const T* const Ra = reconstruction_a + RA_RECONSTRUCTION_RX;
+    const T* const Rb = reconstruction_b + RA_RECONSTRUCTION_RX;
     const T Rbt[3] = {-Rb[0], -Rb[1], -Rb[2]};
     const T Rbit[3] = {T(-rotation_bi[0]), T(-rotation_bi[1]),
                        T(-rotation_bi[2])};
@@ -367,8 +367,8 @@ struct RACommonCameraError {
     return true;
   }
 
-  double *shot_ai_;
-  double *shot_bi_;
+  double* shot_ai_;
+  double* shot_bi_;
   double inv_std_center_;
   double inv_std_rotation_;
 };
@@ -378,13 +378,13 @@ class ReconstructionAlignment {
   ReconstructionAlignment() = default;
   virtual ~ReconstructionAlignment() = default;
 
-  RAShot GetShot(const std::string &id) { return shots_[id]; }
+  RAShot GetShot(const std::string& id) { return shots_[id]; }
 
-  RAReconstruction GetReconstruction(const std::string &id) {
+  RAReconstruction GetReconstruction(const std::string& id) {
     return reconstructions_[id];
   }
 
-  void AddShot(const std::string &id, double rx, double ry, double rz,
+  void AddShot(const std::string& id, double rx, double ry, double rz,
                double tx, double ty, double tz, bool constant) {
     RAShot s;
     s.id = id;
@@ -398,7 +398,7 @@ class ReconstructionAlignment {
     shots_[id] = s;
   }
 
-  void AddReconstruction(const std::string &id, double rx, double ry, double rz,
+  void AddReconstruction(const std::string& id, double rx, double ry, double rz,
                          double tx, double ty, double tz, double scale,
                          bool constant) {
     RAReconstruction r;
@@ -414,11 +414,11 @@ class ReconstructionAlignment {
     reconstructions_[id] = r;
   }
 
-  void AddRelativeMotionConstraint(const RARelativeMotionConstraint &rm) {
+  void AddRelativeMotionConstraint(const RARelativeMotionConstraint& rm) {
     relative_motions_.push_back(rm);
   }
 
-  void AddAbsolutePositionConstraint(const std::string &shot_id, double x,
+  void AddAbsolutePositionConstraint(const std::string& shot_id, double x,
                                      double y, double z, double std_deviation) {
     RAAbsolutePositionConstraint a;
     a.shot = &shots_[shot_id];
@@ -430,7 +430,7 @@ class ReconstructionAlignment {
   }
 
   void AddRelativeAbsolutePositionConstraint(
-      const std::string &reconstruction_id, const std::string &shot_id,
+      const std::string& reconstruction_id, const std::string& shot_id,
       double x, double y, double z, double std_deviation) {
     RARelativeAbsolutePositionConstraint a;
     a.reconstruction = &reconstructions_[reconstruction_id];
@@ -442,9 +442,9 @@ class ReconstructionAlignment {
     relative_absolute_positions_.push_back(a);
   }
 
-  void AddCommonPointConstraint(const std::string &reconstruction_a_id,
+  void AddCommonPointConstraint(const std::string& reconstruction_a_id,
                                 double xa, double ya, double za,
-                                const std::string &reconstruction_b_id,
+                                const std::string& reconstruction_b_id,
                                 double xb, double yb, double zb,
                                 double std_deviation) {
     RACommonPointConstraint c;
@@ -460,10 +460,10 @@ class ReconstructionAlignment {
     common_points_.push_back(c);
   }
 
-  void AddCommonCameraConstraint(const std::string &reconstruction_a_id,
-                                 const std::string &shot_a_id,
-                                 const std::string &reconstruction_b_id,
-                                 const std::string &shot_b_id,
+  void AddCommonCameraConstraint(const std::string& reconstruction_a_id,
+                                 const std::string& shot_a_id,
+                                 const std::string& reconstruction_b_id,
+                                 const std::string& shot_b_id,
                                  double std_deviation_center,
                                  double std_deviation_rotation) {
     RACommonCameraConstraint c;
@@ -480,14 +480,14 @@ class ReconstructionAlignment {
     ceres::Problem problem;
 
     // Init parameter blocks.
-    for (auto &i : shots_) {
+    for (auto& i : shots_) {
       if (i.second.constant) {
         problem.AddParameterBlock(i.second.parameters, RA_SHOT_NUM_PARAMS);
         problem.SetParameterBlockConstant(i.second.parameters);
       }
     }
 
-    for (auto &i : reconstructions_) {
+    for (auto& i : reconstructions_) {
       problem.AddParameterBlock(i.second.parameters,
                                 RA_RECONSTRUCTION_NUM_PARAMS);
       if (i.second.constant) {
@@ -502,9 +502,9 @@ class ReconstructionAlignment {
     }
 
     // Add relative motion errors
-    ceres::LossFunction *loss = new ceres::CauchyLoss(1.0);
-    for (auto &rp : relative_motions_) {
-      ceres::CostFunction *cost_function =
+    ceres::LossFunction* loss = new ceres::CauchyLoss(1.0);
+    for (auto& rp : relative_motions_) {
+      ceres::CostFunction* cost_function =
           new ceres::AutoDiffCostFunction<RARelativeMotionError, 6, 7, 6>(
               new RARelativeMotionError(rp.parameters, rp.scale_matrix));
 
@@ -515,8 +515,8 @@ class ReconstructionAlignment {
     }
 
     // Add absolute position errors
-    for (auto &a : absolute_positions_) {
-      ceres::CostFunction *cost_function =
+    for (auto& a : absolute_positions_) {
+      ceres::CostFunction* cost_function =
           new ceres::AutoDiffCostFunction<RAAbsolutePositionError, 3, 6>(
               new RAAbsolutePositionError(a.position, a.std_deviation));
 
@@ -524,9 +524,9 @@ class ReconstructionAlignment {
     }
 
     // Add relative-absolute position errors
-    ceres::LossFunction *l1_loss = new ceres::SoftLOneLoss(1.0);
-    for (auto &a : relative_absolute_positions_) {
-      ceres::CostFunction *cost_function =
+    ceres::LossFunction* l1_loss = new ceres::SoftLOneLoss(1.0);
+    for (auto& a : relative_absolute_positions_) {
+      ceres::CostFunction* cost_function =
           new ceres::AutoDiffCostFunction<RARelativeAbsolutePositionError, 3,
                                           7>(
               new RARelativeAbsolutePositionError(
@@ -537,8 +537,8 @@ class ReconstructionAlignment {
     }
 
     // Add common cameras constraints
-    for (auto &a : common_cameras_) {
-      ceres::CostFunction *cost_function =
+    for (auto& a : common_cameras_) {
+      ceres::CostFunction* cost_function =
           new ceres::AutoDiffCostFunction<RACommonCameraError, 6, 7, 7>(
               new RACommonCameraError(
                   a.shot_a->parameters, a.shot_b->parameters,
@@ -550,8 +550,8 @@ class ReconstructionAlignment {
     }
 
     // Add common point errors
-    for (auto &a : common_points_) {
-      ceres::CostFunction *cost_function =
+    for (auto& a : common_points_) {
+      ceres::CostFunction* cost_function =
           new ceres::AutoDiffCostFunction<RACommonPointError, 3, 7, 7>(
               new RACommonPointError(a.point_a, a.point_b, a.std_deviation));
 
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 3c5f97f8b..a8185354d 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -14,7 +14,7 @@
 #include "bundle/data/bias.h"
 
 namespace {
-bool IsRigCameraUseful(bundle::RigCamera &rig_camera) {
+bool IsRigCameraUseful(bundle::RigCamera& rig_camera) {
   return !(rig_camera.GetParametersToOptimize().empty() &&
            rig_camera.GetValueData().isConstant(0.));
 }
@@ -44,7 +44,7 @@ BundleAdjuster::BundleAdjuster() {
 }
 
 geometry::Camera BundleAdjuster::GetDefaultCameraSigma(
-    const geometry::Camera &camera) const {
+    const geometry::Camera& camera) const {
   std::unordered_map<int, double> std_dev_map;
   std_dev_map[static_cast<int>(geometry::Camera::Parameters::Focal)] =
       focal_prior_sd_;
@@ -73,10 +73,10 @@ geometry::Pose BundleAdjuster::GetDefaultRigPoseSigma() const {
   return sigma;
 }
 
-void BundleAdjuster::AddCamera(const std::string &id,
-                               const geometry::Camera &camera,
-                               const geometry::Camera &prior, bool constant) {
-  auto &camera_data =
+void BundleAdjuster::AddCamera(const std::string& id,
+                               const geometry::Camera& camera,
+                               const geometry::Camera& prior, bool constant) {
+  auto& camera_data =
       cameras_
           .emplace(std::piecewise_construct, std::forward_as_tuple(id),
                    std::forward_as_tuple(id, camera, prior,
@@ -87,7 +87,7 @@ void BundleAdjuster::AddCamera(const std::string &id,
   }
 
   // identity bias by default
-  auto &bias_data =
+  auto& bias_data =
       bias_
           .emplace(std::piecewise_construct, std::forward_as_tuple(id),
                    std::forward_as_tuple(
@@ -97,8 +97,8 @@ void BundleAdjuster::AddCamera(const std::string &id,
   bias_data.SetParametersToOptimize({});
 }
 
-void BundleAdjuster::SetCameraBias(const std::string &camera_id,
-                                   const geometry::Similarity &bias) {
+void BundleAdjuster::SetCameraBias(const std::string& camera_id,
+                                   const geometry::Similarity& bias) {
   auto bias_exists = bias_.find(camera_id);
   if (bias_exists == bias_.end()) {
     throw std::runtime_error("Camera " + camera_id + " doesn't exist.");
@@ -107,11 +107,11 @@ void BundleAdjuster::SetCameraBias(const std::string &camera_id,
 }
 
 void BundleAdjuster::AddRigInstance(
-    const std::string &rig_instance_id, const geometry::Pose &rig_instance_pose,
-    const std::unordered_map<std::string, std::string> &shot_cameras,
-    const std::unordered_map<std::string, std::string> &shot_rig_cameras,
+    const std::string& rig_instance_id, const geometry::Pose& rig_instance_pose,
+    const std::unordered_map<std::string, std::string>& shot_cameras,
+    const std::unordered_map<std::string, std::string>& shot_rig_cameras,
     bool fixed) {
-  auto &rig_instance =
+  auto& rig_instance =
       rig_instances_
           .emplace(std::piecewise_construct,
                    std::forward_as_tuple(rig_instance_id),
@@ -122,7 +122,7 @@ void BundleAdjuster::AddRigInstance(
     rig_instance.SetParametersToOptimize({});
   }
 
-  for (const auto &shot_camera : shot_cameras) {
+  for (const auto& shot_camera : shot_cameras) {
     const auto shot_id = shot_camera.first;
     const auto camera_id = shot_camera.second;
     const auto rig_camera_id = shot_rig_cameras.at(shot_id);
@@ -143,16 +143,16 @@ void BundleAdjuster::AddRigInstance(
   }
 }
 
-void BundleAdjuster::AddRigCamera(const std::string &rig_camera_id,
-                                  const geometry::Pose &pose,
-                                  const geometry::Pose &pose_prior,
+void BundleAdjuster::AddRigCamera(const std::string& rig_camera_id,
+                                  const geometry::Pose& pose,
+                                  const geometry::Pose& pose_prior,
                                   bool fixed) {
   const auto rig_camera_exists = rig_cameras_.find(rig_camera_id);
   if (rig_camera_exists != rig_cameras_.end()) {
     throw std::runtime_error("Rig model " + rig_camera_id + " already exist.");
   }
 
-  auto &rig_camera =
+  auto& rig_camera =
       rig_cameras_
           .emplace(std::piecewise_construct,
                    std::forward_as_tuple(rig_camera_id),
@@ -165,8 +165,8 @@ void BundleAdjuster::AddRigCamera(const std::string &rig_camera_id,
 }
 
 void BundleAdjuster::AddRigInstancePositionPrior(
-    const std::string &instance_id, const Vec3d &position,
-    const Vec3d &std_deviation, const std::string &scale_group) {
+    const std::string& instance_id, const Vec3d& position,
+    const Vec3d& std_deviation, const std::string& scale_group) {
   auto rig_instance_exists = rig_instances_.find(instance_id);
   if (rig_instance_exists == rig_instances_.end()) {
     throw std::runtime_error("Rig instance " + instance_id + " doesn't exist.");
@@ -183,7 +183,7 @@ void BundleAdjuster::AddRigInstancePositionPrior(
   rig_instance_exists->second.scale_group.SetValue(scale_group);
 }
 
-void BundleAdjuster::SetScaleSharing(const std::string &id, bool share) {
+void BundleAdjuster::SetScaleSharing(const std::string& id, bool share) {
   const auto find = reconstructions_.find(id);
   if (find == reconstructions_.end()) {
     return;
@@ -191,7 +191,7 @@ void BundleAdjuster::SetScaleSharing(const std::string &id, bool share) {
   find->second.shared = share;
 }
 
-void BundleAdjuster::AddReconstruction(const std::string &id, bool constant) {
+void BundleAdjuster::AddReconstruction(const std::string& id, bool constant) {
   Reconstruction r;
   r.id = id;
   r.constant = constant;
@@ -200,8 +200,8 @@ void BundleAdjuster::AddReconstruction(const std::string &id, bool constant) {
 }
 
 void BundleAdjuster::AddReconstructionInstance(
-    const std::string &reconstruction_id, double scale,
-    const std::string &instance_id) {
+    const std::string& reconstruction_id, double scale,
+    const std::string& instance_id) {
   const auto find = reconstructions_.find(reconstruction_id);
   if (find == reconstructions_.end()) {
     return;
@@ -210,7 +210,7 @@ void BundleAdjuster::AddReconstructionInstance(
   reconstructions_assignments_[instance_id] = reconstruction_id;
 }
 
-void BundleAdjuster::AddPoint(const std::string &id, const Vec3d &position,
+void BundleAdjuster::AddPoint(const std::string& id, const Vec3d& position,
                               bool constant) {
   auto point =
       &points_
@@ -223,9 +223,9 @@ void BundleAdjuster::AddPoint(const std::string &id, const Vec3d &position,
   }
 }
 
-void BundleAdjuster::AddPointPrior(const std::string &point_id,
-                                   const Vec3d &position,
-                                   const Vec3d &std_deviation,
+void BundleAdjuster::AddPointPrior(const std::string& point_id,
+                                   const Vec3d& position,
+                                   const Vec3d& std_deviation,
                                    bool has_altitude_prior) {
   auto point_exist = points_.find(point_id);
   if (point_exist == points_.end()) {
@@ -238,8 +238,8 @@ void BundleAdjuster::AddPointPrior(const std::string &point_id,
 }
 
 void BundleAdjuster::AddPointProjectionObservation(
-    const std::string &shot, const std::string &point, const Vec2d &observation,
-    double std_deviation, const std::optional<map::Depth> &depth_prior) {
+    const std::string& shot, const std::string& point, const Vec2d& observation,
+    double std_deviation, const std::optional<map::Depth>& depth_prior) {
   PointProjectionObservation o;
   o.shot = &shots_.at(shot);
   o.camera = &cameras_.at(o.shot->GetCamera()->GetID());
@@ -250,16 +250,16 @@ void BundleAdjuster::AddPointProjectionObservation(
   point_projection_observations_.push_back(o);
 }
 
-void BundleAdjuster::AddRelativeMotion(const RelativeMotion &rm) {
+void BundleAdjuster::AddRelativeMotion(const RelativeMotion& rm) {
   relative_motions_.push_back(rm);
 }
 
-void BundleAdjuster::AddRelativeRotation(const RelativeRotation &rr) {
+void BundleAdjuster::AddRelativeRotation(const RelativeRotation& rr) {
   relative_rotations_.push_back(rr);
 }
 
-void BundleAdjuster::AddCommonPosition(const std::string &shot_i,
-                                       const std::string &shot_j, double margin,
+void BundleAdjuster::AddCommonPosition(const std::string& shot_i,
+                                       const std::string& shot_j, double margin,
                                        double std_deviation) {
   CommonPosition a;
   a.shot_i = shot_i;
@@ -269,7 +269,7 @@ void BundleAdjuster::AddCommonPosition(const std::string &shot_i,
   common_positions_.push_back(a);
 }
 
-HeatmapInterpolator::HeatmapInterpolator(const std::vector<double> &in_heatmap,
+HeatmapInterpolator::HeatmapInterpolator(const std::vector<double>& in_heatmap,
                                          size_t in_width, double in_resolution)
     : heatmap(in_heatmap),
       width(in_width),
@@ -278,15 +278,15 @@ HeatmapInterpolator::HeatmapInterpolator(const std::vector<double> &in_heatmap,
       interpolator(grid),
       resolution(in_resolution) {}
 
-void BundleAdjuster::AddHeatmap(const std::string &heatmap_id,
-                                const std::vector<double> &in_heatmap,
+void BundleAdjuster::AddHeatmap(const std::string& heatmap_id,
+                                const std::vector<double>& in_heatmap,
                                 size_t in_width, double resolution) {
   heatmaps_[heatmap_id] =
       std::make_shared<HeatmapInterpolator>(in_heatmap, in_width, resolution);
 }
 
-void BundleAdjuster::AddAbsolutePositionHeatmap(const std::string &shot_id,
-                                                const std::string &heatmap_id,
+void BundleAdjuster::AddAbsolutePositionHeatmap(const std::string& shot_id,
+                                                const std::string& heatmap_id,
                                                 double x_offset,
                                                 double y_offset,
                                                 double std_deviation) {
@@ -299,8 +299,8 @@ void BundleAdjuster::AddAbsolutePositionHeatmap(const std::string &shot_id,
   absolute_positions_heatmaps_.push_back(a);
 }
 
-void BundleAdjuster::AddAbsoluteUpVector(const std::string &shot_id,
-                                         const Vec3d &up_vector,
+void BundleAdjuster::AddAbsoluteUpVector(const std::string& shot_id,
+                                         const Vec3d& up_vector,
                                          double std_deviation) {
   AbsoluteUpVector a;
   a.shot_id = shot_id;
@@ -309,7 +309,7 @@ void BundleAdjuster::AddAbsoluteUpVector(const std::string &shot_id,
   absolute_up_vectors_.push_back(a);
 }
 
-void BundleAdjuster::AddAbsolutePan(const std::string &shot_id, double angle,
+void BundleAdjuster::AddAbsolutePan(const std::string& shot_id, double angle,
                                     double std_deviation) {
   AbsoluteAngle a;
   a.shot_id = shot_id;
@@ -318,7 +318,7 @@ void BundleAdjuster::AddAbsolutePan(const std::string &shot_id, double angle,
   absolute_pans_.push_back(a);
 }
 
-void BundleAdjuster::AddAbsoluteTilt(const std::string &shot_id, double angle,
+void BundleAdjuster::AddAbsoluteTilt(const std::string& shot_id, double angle,
                                      double std_deviation) {
   AbsoluteAngle a;
   a.shot_id = shot_id;
@@ -327,7 +327,7 @@ void BundleAdjuster::AddAbsoluteTilt(const std::string &shot_id, double angle,
   absolute_tilts_.push_back(a);
 }
 
-void BundleAdjuster::AddAbsoluteRoll(const std::string &shot_id, double angle,
+void BundleAdjuster::AddAbsoluteRoll(const std::string& shot_id, double angle,
                                      double std_deviation) {
   AbsoluteAngle a;
   a.shot_id = shot_id;
@@ -336,9 +336,9 @@ void BundleAdjuster::AddAbsoluteRoll(const std::string &shot_id, double angle,
   absolute_rolls_.push_back(a);
 }
 
-void BundleAdjuster::SetGaugeFixShots(const std::string &shot_origin,
-                                      const std::string &shot_scale) {
-  Shot *shot = &shots_.at(shot_origin);
+void BundleAdjuster::SetGaugeFixShots(const std::string& shot_origin,
+                                      const std::string& shot_scale) {
+  Shot* shot = &shots_.at(shot_origin);
   shot->GetRigInstance()->SetParametersToOptimize({});
   gauge_fix_shots_.SetValue(std::make_pair(shot_origin, shot_scale));
 }
@@ -389,7 +389,7 @@ void BundleAdjuster::SetInternalParametersPriorSD(
   p2_sd_ = p2_sd;
   k3_sd_ = k3_sd;
   k4_sd_ = k4_sd;
-  for (auto &camera : cameras_) {
+  for (auto& camera : cameras_) {
     camera.second.SetSigma(GetDefaultCameraSigma(camera.second.GetValue()));
   }
 }
@@ -398,7 +398,7 @@ void BundleAdjuster::SetRigParametersPriorSD(double rig_translation_sd,
                                              double rig_rotation_sd) {
   rig_translation_sd_ = rig_translation_sd;
   rig_rotation_sd_ = rig_rotation_sd;
-  for (auto &rig_camera : rig_cameras_) {
+  for (auto& rig_camera : rig_cameras_) {
     rig_camera.second.SetSigma(GetDefaultRigPoseSigma());
   }
 }
@@ -413,7 +413,7 @@ void BundleAdjuster::SetComputeReprojectionErrors(bool v) {
   compute_reprojection_errors_ = v;
 }
 
-ceres::LossFunction *CreateLossFunction(std::string name, double threshold) {
+ceres::LossFunction* CreateLossFunction(std::string name, double threshold) {
   if (name.compare("TrivialLoss") == 0) {
     return new ceres::TrivialLoss();
   } else if (name.compare("HuberLoss") == 0) {
@@ -429,9 +429,9 @@ ceres::LossFunction *CreateLossFunction(std::string name, double threshold) {
                            " not found.");
 }
 
-void BundleAdjuster::AddLinearMotion(const std::string &shot0_id,
-                                     const std::string &shot1_id,
-                                     const std::string &shot2_id, double alpha,
+void BundleAdjuster::AddLinearMotion(const std::string& shot0_id,
+                                     const std::string& shot1_id,
+                                     const std::string& shot2_id, double alpha,
                                      double position_std_deviation,
                                      double orientation_std_deviation) {
   LinearMotion a;
@@ -465,15 +465,15 @@ struct ErrorTraitsAnalytic<geometry::SphericalCamera, 1> {
 
 struct AddProjectionError {
   template <class T>
-  static void Apply(bool use_analytical, const PointProjectionObservation &obs,
-                    ceres::LossFunction *loss, ceres::Problem *problem) {
+  static void Apply(bool use_analytical, const PointProjectionObservation& obs,
+                    ceres::LossFunction* loss, ceres::Problem* problem) {
     constexpr static int ErrorSize = ErrorTraits<T>::Type::Size;
     constexpr static int CameraSize = T::Size;
     constexpr static int ShotSize = 6;
 
     const bool is_rig_camera_useful =
         IsRigCameraUseful(*obs.shot->GetRigCamera());
-    ceres::CostFunction *cost_function = nullptr;
+    ceres::CostFunction* cost_function = nullptr;
     if (use_analytical) {
       using ErrorType = typename ErrorTraitsAnalytic<T, CameraSize>::Type;
       cost_function = new ErrorType(obs.camera->GetValue().GetProjectionType(),
@@ -497,15 +497,15 @@ struct AddProjectionError {
 
 struct AddRelativeDepthError {
   template <class T>
-  static void Apply(const PointProjectionObservation &obs,
-                    ceres::LossFunction *loss, ceres::Problem *problem) {
+  static void Apply(const PointProjectionObservation& obs,
+                    ceres::LossFunction* loss, ceres::Problem* problem) {
     constexpr static int ShotSize = 6;
     constexpr static int PointSize = 3;
 
     if (!obs.depth_prior.has_value()) {
       return;
     }
-    const auto &depth = obs.depth_prior.value();
+    const auto& depth = obs.depth_prior.value();
     if (!std::isfinite(depth.value)) {
       throw std::runtime_error(obs.shot->GetID() +
                                " has non-finite depth prior");
@@ -513,7 +513,7 @@ struct AddRelativeDepthError {
 
     const bool is_rig_camera_useful =
         IsRigCameraUseful(*obs.shot->GetRigCamera());
-    ceres::CostFunction *cost_function = nullptr;
+    ceres::CostFunction* cost_function = nullptr;
 
     cost_function =
         new ceres::AutoDiffCostFunction<RelativeDepthError,
@@ -532,7 +532,7 @@ struct AddRelativeDepthError {
 struct ComputeResidualError {
   template <class T>
   static void Apply(bool use_analytical,
-                    const PointProjectionObservation &obs) {
+                    const PointProjectionObservation& obs) {
     const bool is_rig_camera_useful =
         IsRigCameraUseful(*obs.shot->GetRigCamera());
     if (use_analytical) {
@@ -543,7 +543,7 @@ struct ComputeResidualError {
       VecNd<ErrorSize> residuals;
       ErrorType error(obs.camera->GetValue().GetProjectionType(),
                       obs.coordinates, 1.0, is_rig_camera_useful);
-      const double *params[] = {
+      const double* params[] = {
           obs.camera->GetValueData().data(),
           obs.shot->GetRigInstance()->GetValueData().data(),
           obs.shot->GetRigCamera()->GetValueData().data(),
@@ -568,8 +568,8 @@ struct ComputeResidualError {
 
 struct AddCameraPriorError {
   template <class T>
-  static void Apply(Camera &camera, ceres::Problem *problem) {
-    auto *prior_function = new DataPriorError<geometry::Camera>(&camera);
+  static void Apply(Camera& camera, ceres::Problem* problem) {
+    auto* prior_function = new DataPriorError<geometry::Camera>(&camera);
 
     // Set some logarithmic prior for Focal and Aspect ratio (if any)
     const auto camera_object = camera.GetValue();
@@ -584,7 +584,7 @@ struct AddCameraPriorError {
     }
 
     constexpr static int CameraSize = T::Size;
-    auto *cost_function = new ceres::DynamicAutoDiffCostFunction<
+    auto* cost_function = new ceres::DynamicAutoDiffCostFunction<
         DataPriorError<geometry::Camera>>(prior_function);
     cost_function->SetNumResiduals(CameraSize);
     cost_function->AddParameterBlock(CameraSize);
@@ -597,8 +597,8 @@ void BundleAdjuster::Run() {
   ceres::Problem problem;
 
   // Add cameras
-  for (auto &[_, cam] : cameras_) {
-    auto &data = cam.GetValueData();
+  for (auto& [_, cam] : cameras_) {
+    auto& data = cam.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
@@ -617,7 +617,7 @@ void BundleAdjuster::Run() {
         }
       }
       if (index >= 0) {
-        ceres::CostFunction *transition_barrier =
+        ceres::CostFunction* transition_barrier =
             new ceres::AutoDiffCostFunction<ParameterBarrier, 1,
                                             geometry::DualCamera::Size>(
                 new ParameterBarrier(0.0, 1.0, index));
@@ -627,8 +627,8 @@ void BundleAdjuster::Run() {
   }
 
   // Add cameras biases
-  for (auto &b : bias_) {
-    auto &data = b.second.GetValueData();
+  for (auto& b : bias_) {
+    auto& data = b.second.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
@@ -638,8 +638,8 @@ void BundleAdjuster::Run() {
   }
 
   // Add rig cameras
-  for (auto &rc : rig_cameras_) {
-    auto &data = rc.second.GetValueData();
+  for (auto& rc : rig_cameras_) {
+    auto& data = rc.second.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
@@ -649,8 +649,8 @@ void BundleAdjuster::Run() {
   }
 
   // Add rig instances
-  for (auto &ri : rig_instances_) {
-    auto &data = ri.second.GetValueData();
+  for (auto& ri : rig_instances_) {
+    auto& data = ri.second.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
@@ -660,8 +660,8 @@ void BundleAdjuster::Run() {
   }
 
   // Add points
-  for (auto &p : points_) {
-    auto &data = p.second.GetValueData();
+  for (auto& p : points_) {
+    auto& data = p.second.GetValueData();
     problem.AddParameterBlock(data.data(), data.size());
 
     // Lock parameters based on bitmask of parameters : only constant for now
@@ -671,8 +671,8 @@ void BundleAdjuster::Run() {
   }
 
   // Reconstructions
-  for (auto &i : reconstructions_) {
-    for (auto &s : i.second.scales) {
+  for (auto& i : reconstructions_) {
+    for (auto& s : i.second.scales) {
       if (i.second.constant) {
         problem.AddParameterBlock(&s.second, 1);
         problem.SetParameterBlockConstant(&s.second);
@@ -686,11 +686,11 @@ void BundleAdjuster::Run() {
   }
 
   // New generic prior errors (only rig instances + rig models + points for now)
-  for (auto &i : points_) {
+  for (auto& i : points_) {
     if (!i.second.HasPrior()) {
       continue;
     }
-    auto *position_prior = new DataPriorError<Vec3d>(&i.second);
+    auto* position_prior = new DataPriorError<Vec3d>(&i.second);
     if (i.second.has_altitude_prior) {
       position_prior->SetConstrainedDataIndexes(
           {Point::Parameter::PX, Point::Parameter::PY, Point::Parameter::PZ});
@@ -698,7 +698,7 @@ void BundleAdjuster::Run() {
       position_prior->SetConstrainedDataIndexes(
           {Point::Parameter::PX, Point::Parameter::PY});
     }
-    auto *cost_function =
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<DataPriorError<Vec3d>>(
             position_prior);
     cost_function->SetNumResiduals(i.second.has_altitude_prior ? 3 : 2);
@@ -710,7 +710,7 @@ void BundleAdjuster::Run() {
 
   // Gather scale groups for rig instance priors
   std::map<std::string, int> std_dev_group_remap;
-  for (auto &i : rig_instances_) {
+  for (auto& i : rig_instances_) {
     if (!i.second.scale_group.HasValue()) {
       continue;
     }
@@ -728,7 +728,7 @@ void BundleAdjuster::Run() {
   // them up.
   if (adjust_absolute_position_std_) {
     for (int i = 0; i < std_deviations.size(); ++i) {
-      ceres::CostFunction *std_dev_cost_function =
+      ceres::CostFunction* std_dev_cost_function =
           new ceres::AutoDiffCostFunction<StdDeviationConstraint, 1, 1>(
               new StdDeviationConstraint());
       problem.AddResidualBlock(std_dev_cost_function, nullptr,
@@ -736,25 +736,25 @@ void BundleAdjuster::Run() {
     }
   } else {
     for (int i = 0; i < std_deviations.size(); ++i) {
-      auto *data = &std_deviations[i];
+      auto* data = &std_deviations[i];
       problem.AddParameterBlock(data, 1);
       problem.SetParameterBlockConstant(data);
     }
   }
 
-  for (auto &i : rig_instances_) {
+  for (auto& i : rig_instances_) {
     if (!i.second.HasPrior()) {
       continue;
     }
 
     using PriorType = DataPriorError<geometry::Pose, SimilarityPriorTransform>;
-    auto *position_prior =
+    auto* position_prior =
         new PriorType(&i.second, adjust_absolute_position_std_);
     position_prior->SetTransform(SimilarityPriorTransform());
     position_prior->SetConstrainedDataIndexes(
         {Pose::Parameter::TX, Pose::Parameter::TY, Pose::Parameter::TZ});
 
-    const auto &bias_reference_camera = i.second.shot_cameras.begin()->second;
+    const auto& bias_reference_camera = i.second.shot_cameras.begin()->second;
     const auto maybe_bias = bias_.find(bias_reference_camera);
     if (maybe_bias == bias_.end()) {
       throw std::runtime_error("Reference camera " + bias_reference_camera +
@@ -763,9 +763,9 @@ void BundleAdjuster::Run() {
     }
 
     const auto scale_group = i.second.scale_group.Value();
-    auto *scale_param = &std_deviations.at(std_dev_group_remap.at(scale_group));
+    auto* scale_param = &std_deviations.at(std_dev_group_remap.at(scale_group));
 
-    auto *cost_function =
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<PriorType>(position_prior);
     cost_function->SetNumResiduals(3);
     cost_function->AddParameterBlock(Pose::Parameter::NUM_PARAMS);
@@ -775,12 +775,12 @@ void BundleAdjuster::Run() {
         cost_function, nullptr, i.second.GetValueData().data(),
         maybe_bias->second.GetValueData().data(), scale_param);
   }
-  for (auto &rc : rig_cameras_) {
+  for (auto& rc : rig_cameras_) {
     if (!rc.second.HasPrior()) {
       continue;
     }
-    auto *pose_prior = new DataPriorError<geometry::Pose>(&rc.second);
-    auto *cost_function =
+    auto* pose_prior = new DataPriorError<geometry::Pose>(&rc.second);
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<DataPriorError<geometry::Pose>>(
             pose_prior);
     cost_function->SetNumResiduals(Pose::Parameter::NUM_PARAMS);
@@ -789,20 +789,20 @@ void BundleAdjuster::Run() {
                              rc.second.GetValueData().data());
   }
   // Add internal parameter priors blocks
-  for (auto &i : cameras_) {
+  for (auto& i : cameras_) {
     const auto projection_type = i.second.GetValue().GetProjectionType();
     geometry::Dispatch<AddCameraPriorError>(projection_type, i.second,
                                             &problem);
   }
 
   // Add reprojection error blocks
-  ceres::LossFunction *projection_loss =
+  ceres::LossFunction* projection_loss =
       point_projection_observations_.empty()
           ? nullptr
           : CreateLossFunction(point_projection_loss_name_,
                                point_projection_loss_threshold_);
 
-  for (auto &observation : point_projection_observations_) {
+  for (auto& observation : point_projection_observations_) {
     const auto projection_type =
         observation.camera->GetValue().GetProjectionType();
     geometry::Dispatch<AddProjectionError>(
@@ -814,15 +814,15 @@ void BundleAdjuster::Run() {
   }
 
   // Add relative motion errors
-  for (auto &rp : relative_motions_) {
+  for (auto& rp : relative_motions_) {
     double robust_threshold =
         relative_motion_loss_threshold_ * rp.robust_multiplier;
-    ceres::LossFunction *relative_motion_loss =
+    ceres::LossFunction* relative_motion_loss =
         CreateLossFunction(relative_motion_loss_name_, robust_threshold);
 
-    auto *relative_motion = new RelativeMotionError(
+    auto* relative_motion = new RelativeMotionError(
         rp.parameters, rp.scale_matrix, rp.observed_scale);
-    auto *cost_function =
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<RelativeMotionError>(
             relative_motion);
     cost_function->AddParameterBlock(6);
@@ -830,18 +830,18 @@ void BundleAdjuster::Run() {
     cost_function->AddParameterBlock(1);
     cost_function->SetNumResiduals(Similarity::Parameter::NUM_PARAMS);
 
-    auto &rig_instance_i = rig_instances_.at(rp.rig_instance_id_i);
-    auto &rig_instance_j = rig_instances_.at(rp.rig_instance_id_j);
+    auto& rig_instance_i = rig_instances_.at(rp.rig_instance_id_i);
+    auto& rig_instance_j = rig_instances_.at(rp.rig_instance_id_j);
 
-    auto *scale_i =
+    auto* scale_i =
         reconstructions_[reconstructions_assignments_.at(rp.rig_instance_id_i)]
             .GetScalePtr(rp.rig_instance_id_i);
-    auto *scale_j =
+    auto* scale_j =
         reconstructions_[reconstructions_assignments_.at(rp.rig_instance_id_j)]
             .GetScalePtr(rp.rig_instance_id_j);
     auto parameter_blocks =
-        std::vector<double *>({rig_instance_i.GetValueData().data(),
-                               rig_instance_j.GetValueData().data(), scale_i});
+        std::vector<double*>({rig_instance_i.GetValueData().data(),
+                              rig_instance_j.GetValueData().data(), scale_i});
 
     if (scale_i != scale_j) {
       cost_function->AddParameterBlock(1);
@@ -854,27 +854,27 @@ void BundleAdjuster::Run() {
   }
 
   // Add relative rotation errors
-  ceres::LossFunction *relative_rotation_loss =
+  ceres::LossFunction* relative_rotation_loss =
       relative_rotations_.empty()
           ? nullptr
           : CreateLossFunction(relative_motion_loss_name_,
                                relative_motion_loss_threshold_);
-  for (auto &rr : relative_rotations_) {
-    auto *relative_rotation =
+  for (auto& rr : relative_rotations_) {
+    auto* relative_rotation =
         new RelativeRotationError(rr.rotation, rr.scale_matrix);
-    auto *cost_function =
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<RelativeRotationError>(
             relative_rotation);
     cost_function->AddParameterBlock(6);
     cost_function->AddParameterBlock(6);
     cost_function->SetNumResiduals(3);
 
-    auto &shot_i = shots_.at(rr.shot_id_i);
-    auto &shot_j = shots_.at(rr.shot_id_j);
+    auto& shot_i = shots_.at(rr.shot_id_i);
+    auto& shot_j = shots_.at(rr.shot_id_j);
 
     auto parameter_blocks =
-        std::vector<double *>({shot_i.GetRigInstance()->GetValueData().data(),
-                               shot_j.GetRigInstance()->GetValueData().data()});
+        std::vector<double*>({shot_i.GetRigInstance()->GetValueData().data(),
+                              shot_j.GetRigInstance()->GetValueData().data()});
 
     auto shot_i_rig_camera = shot_i.GetRigCamera()->GetValueData().data();
     if (IsRigCameraUseful(*shot_i.GetRigCamera())) {
@@ -899,25 +899,25 @@ void BundleAdjuster::Run() {
   }
 
   // Add common position errors
-  ceres::LossFunction *common_position_loss = nullptr;
-  for (auto &c : common_positions_) {
+  ceres::LossFunction* common_position_loss = nullptr;
+  for (auto& c : common_positions_) {
     if (common_position_loss == nullptr) {
       common_position_loss = new ceres::TukeyLoss(1);
     }
-    auto *common_position = new CommonPositionError(c.margin, c.std_deviation);
-    auto *cost_function =
+    auto* common_position = new CommonPositionError(c.margin, c.std_deviation);
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<CommonPositionError>(
             common_position);
     cost_function->AddParameterBlock(6);
     cost_function->AddParameterBlock(6);
     cost_function->SetNumResiduals(3);
 
-    auto &shot_i = shots_.at(c.shot_i);
-    auto &shot_j = shots_.at(c.shot_j);
+    auto& shot_i = shots_.at(c.shot_i);
+    auto& shot_j = shots_.at(c.shot_j);
 
     auto parameter_blocks =
-        std::vector<double *>({shot_i.GetRigInstance()->GetValueData().data(),
-                               shot_j.GetRigInstance()->GetValueData().data()});
+        std::vector<double*>({shot_i.GetRigInstance()->GetValueData().data(),
+                              shot_j.GetRigInstance()->GetValueData().data()});
 
     auto shot_i_rig_camera = shot_i.GetRigCamera()->GetValueData().data();
     if (IsRigCameraUseful(*shot_i.GetRigCamera())) {
@@ -942,28 +942,28 @@ void BundleAdjuster::Run() {
   }
 
   // Add heatmap cost
-  for (const auto &a : absolute_positions_heatmaps_) {
-    auto *cost_function = HeatmapdCostFunctor::Create(
+  for (const auto& a : absolute_positions_heatmaps_) {
+    auto* cost_function = HeatmapdCostFunctor::Create(
         a.heatmap->interpolator, a.x_offset, a.y_offset, a.heatmap->height,
         a.heatmap->width, a.heatmap->resolution, a.std_deviation);
-    auto &shot = shots_.at(a.shot_id);
+    auto& shot = shots_.at(a.shot_id);
     problem.AddResidualBlock(cost_function, nullptr,
                              shot.GetRigInstance()->GetValueData().data(),
                              shot.GetRigCamera()->GetValueData().data());
   }
 
   // Add absolute up vector errors
-  ceres::LossFunction *up_vector_loss = nullptr;
-  for (auto &a : absolute_up_vectors_) {
+  ceres::LossFunction* up_vector_loss = nullptr;
+  for (auto& a : absolute_up_vectors_) {
     if (a.std_deviation > 0) {
       if (up_vector_loss == nullptr) {
         up_vector_loss = new ceres::CauchyLoss(1);
       }
 
-      ceres::CostFunction *up_cost_function =
+      ceres::CostFunction* up_cost_function =
           new ceres::AutoDiffCostFunction<UpVectorError, 3, 6, 6>(
               new UpVectorError(a.up_vector, a.std_deviation));
-      auto &shot = shots_.at(a.shot_id);
+      auto& shot = shots_.at(a.shot_id);
       problem.AddResidualBlock(up_cost_function, up_vector_loss,
                                shot.GetRigInstance()->GetValueData().data(),
                                shot.GetRigCamera()->GetValueData().data());
@@ -971,16 +971,16 @@ void BundleAdjuster::Run() {
   }
 
   // Add absolute pan (compass) errors
-  ceres::LossFunction *pan_loss = nullptr;
-  for (auto &a : absolute_pans_) {
+  ceres::LossFunction* pan_loss = nullptr;
+  for (auto& a : absolute_pans_) {
     if (a.std_deviation > 0) {
       if (pan_loss == nullptr) {
         pan_loss = new ceres::CauchyLoss(1);
       }
-      ceres::CostFunction *pan_cost_function =
+      ceres::CostFunction* pan_cost_function =
           new ceres::AutoDiffCostFunction<PanAngleError, 1, 6, 6>(
               new PanAngleError(a.angle, a.std_deviation));
-      auto &shot = shots_.at(a.shot_id);
+      auto& shot = shots_.at(a.shot_id);
       problem.AddResidualBlock(pan_cost_function, pan_loss,
                                shot.GetRigInstance()->GetValueData().data(),
                                shot.GetRigCamera()->GetValueData().data());
@@ -988,16 +988,16 @@ void BundleAdjuster::Run() {
   }
 
   // Add absolute tilt errors
-  ceres::LossFunction *tilt_loss = nullptr;
-  for (auto &a : absolute_tilts_) {
+  ceres::LossFunction* tilt_loss = nullptr;
+  for (auto& a : absolute_tilts_) {
     if (a.std_deviation > 0) {
       if (tilt_loss == nullptr) {
         tilt_loss = new ceres::CauchyLoss(1);
       }
-      ceres::CostFunction *tilt_cost_function =
+      ceres::CostFunction* tilt_cost_function =
           new ceres::AutoDiffCostFunction<TiltAngleError, 1, 6, 6>(
               new TiltAngleError(a.angle, a.std_deviation));
-      auto &shot = shots_.at(a.shot_id);
+      auto& shot = shots_.at(a.shot_id);
       problem.AddResidualBlock(tilt_cost_function, tilt_loss,
                                shot.GetRigInstance()->GetValueData().data(),
                                shot.GetRigCamera()->GetValueData().data());
@@ -1005,16 +1005,16 @@ void BundleAdjuster::Run() {
   }
 
   // Add absolute roll errors
-  ceres::LossFunction *roll_loss = nullptr;
-  for (auto &a : absolute_rolls_) {
+  ceres::LossFunction* roll_loss = nullptr;
+  for (auto& a : absolute_rolls_) {
     if (a.std_deviation > 0) {
       if (roll_loss == nullptr) {
         roll_loss = new ceres::CauchyLoss(1);
       }
-      ceres::CostFunction *roll_cost_function =
+      ceres::CostFunction* roll_cost_function =
           new ceres::AutoDiffCostFunction<RollAngleError, 1, 6, 6>(
               new RollAngleError(a.angle, a.std_deviation));
-      auto &shot = shots_.at(a.shot_id);
+      auto& shot = shots_.at(a.shot_id);
       problem.AddResidualBlock(roll_cost_function, roll_loss,
                                shot.GetRigInstance()->GetValueData().data(),
                                shot.GetRigCamera()->GetValueData().data());
@@ -1022,15 +1022,15 @@ void BundleAdjuster::Run() {
   }
 
   // Add linear motion priors
-  ceres::LossFunction *linear_motion_prior_loss_ = nullptr;
-  for (auto &a : linear_motion_prior_) {
+  ceres::LossFunction* linear_motion_prior_loss_ = nullptr;
+  for (auto& a : linear_motion_prior_) {
     if (linear_motion_prior_loss_ == nullptr) {
       linear_motion_prior_loss_ = new ceres::CauchyLoss(1);
     }
 
-    auto *linear_motion = new LinearMotionError(
+    auto* linear_motion = new LinearMotionError(
         a.alpha, a.position_std_deviation, a.orientation_std_deviation);
-    auto *cost_function =
+    auto* cost_function =
         new ceres::DynamicAutoDiffCostFunction<LinearMotionError>(
             linear_motion);
     cost_function->AddParameterBlock(6);
@@ -1038,14 +1038,14 @@ void BundleAdjuster::Run() {
     cost_function->AddParameterBlock(6);
     cost_function->SetNumResiduals(6);
 
-    auto &shot0 = shots_.at(a.shot0);
-    auto &shot1 = shots_.at(a.shot1);
-    auto &shot2 = shots_.at(a.shot2);
+    auto& shot0 = shots_.at(a.shot0);
+    auto& shot1 = shots_.at(a.shot1);
+    auto& shot2 = shots_.at(a.shot2);
 
     auto parameter_blocks =
-        std::vector<double *>({shot0.GetRigInstance()->GetValueData().data(),
-                               shot1.GetRigInstance()->GetValueData().data(),
-                               shot2.GetRigInstance()->GetValueData().data()});
+        std::vector<double*>({shot0.GetRigInstance()->GetValueData().data(),
+                              shot1.GetRigInstance()->GetValueData().data(),
+                              shot2.GetRigInstance()->GetValueData().data()});
 
     auto shot0_rig_camera = shot0.GetRigCamera()->GetValueData().data();
     if (IsRigCameraUseful(*shot0.GetRigCamera())) {
@@ -1084,14 +1084,14 @@ void BundleAdjuster::Run() {
 
   // Gauge fix
   if (gauge_fix_shots_.HasValue()) {
-    const auto &gauge_shots = gauge_fix_shots_.Value();
+    const auto& gauge_shots = gauge_fix_shots_.Value();
     auto instance1 = shots_.at(gauge_shots.first).GetRigInstance();
     auto instance2 = shots_.at(gauge_shots.second).GetRigInstance();
     const double norm =
         (instance1->GetValue().GetOrigin() - instance2->GetValue().GetOrigin())
             .norm();
 
-    ceres::CostFunction *cost_function =
+    ceres::CostFunction* cost_function =
         new ceres::AutoDiffCostFunction<TranslationPriorError, 1, 6, 6>(
             new TranslationPriorError(norm));
 
@@ -1120,7 +1120,7 @@ void BundleAdjuster::Run() {
   }
 }
 
-void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
+void BundleAdjuster::ComputeCovariances(ceres::Problem* problem) {
   bool computed = false;
 
   if (last_run_summary_.termination_type != ceres::FAILURE) {
@@ -1132,8 +1132,8 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
     }
     ceres::Covariance covariance(options);
 
-    std::vector<std::pair<const double *, const double *>> covariance_blocks;
-    for (auto &i : shots_) {
+    std::vector<std::pair<const double*, const double*>> covariance_blocks;
+    for (auto& i : shots_) {
       covariance_blocks.emplace_back(
           i.second.GetRigInstance()->GetValueData().data(),
           i.second.GetRigInstance()->GetValueData().data());
@@ -1142,7 +1142,7 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
     bool worked = covariance.Compute(covariance_blocks, problem);
 
     if (worked) {
-      for (auto &i : shots_) {
+      for (auto& i : shots_) {
         covariance_estimation_valid_ = true;
 
         MatXd covariance_matrix(6, 6);
@@ -1161,7 +1161,7 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
   //       So maybe we can find a better solution
   if (computed) {
     // Check for NaNs
-    for (auto &i : shots_) {
+    for (auto& i : shots_) {
       if (!i.second.GetRigInstance()->HasCovariance() ||
           !i.second.GetRigInstance()->GetCovariance().allFinite()) {
         covariance_estimation_valid_ = false;
@@ -1186,7 +1186,7 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
         default_rotation_variance);
     default_covariance_matrix.diagonal().segment<3>(3).setConstant(
         default_translation_variance);
-    for (auto &i : shots_) {
+    for (auto& i : shots_) {
       i.second.GetRigInstance()->SetCovariance(default_covariance_matrix);
     }
   }
@@ -1194,11 +1194,11 @@ void BundleAdjuster::ComputeCovariances(ceres::Problem *problem) {
 
 void BundleAdjuster::ComputeReprojectionErrors() {
   // Init errors
-  for (auto &i : points_) {
+  for (auto& i : points_) {
     i.second.reprojection_errors.clear();
   }
 
-  for (auto &observation : point_projection_observations_) {
+  for (auto& observation : point_projection_observations_) {
     const auto projection_type =
         observation.camera->GetValue().GetProjectionType();
     geometry::Dispatch<ComputeResidualError>(projection_type, use_analytic_,
@@ -1214,33 +1214,33 @@ int BundleAdjuster::GetRelativeMotionsCount() const {
   return relative_motions_.size();
 }
 
-geometry::Camera BundleAdjuster::GetCamera(const std::string &id) const {
+geometry::Camera BundleAdjuster::GetCamera(const std::string& id) const {
   if (cameras_.find(id) == cameras_.end()) {
     throw std::runtime_error("Camera " + id + " doesn't exists");
   }
   return cameras_.at(id).GetValue();
 }
 
-geometry::Similarity BundleAdjuster::GetBias(const std::string &id) const {
+geometry::Similarity BundleAdjuster::GetBias(const std::string& id) const {
   if (bias_.find(id) == bias_.end()) {
     throw std::runtime_error("Camera " + id + " doesn't exists");
   }
   return bias_.at(id).GetValue();
 }
 
-Point BundleAdjuster::GetPoint(const std::string &id) const {
+Point BundleAdjuster::GetPoint(const std::string& id) const {
   if (points_.find(id) == points_.end()) {
     throw std::runtime_error("Point " + id + " doesn't exists");
   }
   return points_.at(id);
 }
 
-bool BundleAdjuster::HasPoint(const std::string &id) const {
+bool BundleAdjuster::HasPoint(const std::string& id) const {
   return points_.find(id) != points_.end();
 }
 
 Reconstruction BundleAdjuster::GetReconstruction(
-    const std::string &reconstruction_id) const {
+    const std::string& reconstruction_id) const {
   const auto it = reconstructions_.find(reconstruction_id);
   if (it == reconstructions_.end()) {
     throw std::runtime_error("Reconstruction " + reconstruction_id +
@@ -1249,7 +1249,7 @@ Reconstruction BundleAdjuster::GetReconstruction(
   return it->second;
 }
 
-RigCamera BundleAdjuster::GetRigCamera(const std::string &rig_camera_id) const {
+RigCamera BundleAdjuster::GetRigCamera(const std::string& rig_camera_id) const {
   if (rig_cameras_.find(rig_camera_id) == rig_cameras_.end()) {
     throw std::runtime_error("Rig camera " + rig_camera_id + " doesn't exists");
   }
@@ -1257,7 +1257,7 @@ RigCamera BundleAdjuster::GetRigCamera(const std::string &rig_camera_id) const {
 }
 
 RigInstance BundleAdjuster::GetRigInstance(
-    const std::string &instance_id) const {
+    const std::string& instance_id) const {
   if (rig_instances_.find(instance_id) == rig_instances_.end()) {
     throw std::runtime_error("Rig instance " + instance_id + " doesn't exists");
   }
diff --git a/opensfm/src/debug_c_extension.cc b/opensfm/src/debug_c_extension.cc
index ba0138d57..b4599c785 100644
--- a/opensfm/src/debug_c_extension.cc
+++ b/opensfm/src/debug_c_extension.cc
@@ -18,7 +18,7 @@
 #include <iostream>
 namespace py = pybind11;
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   py::scoped_interpreter guard{};
 
   if (argc != 2) {
diff --git a/opensfm/src/dense/depthmap.h b/opensfm/src/dense/depthmap.h
index 940a868ba..973ba5993 100644
--- a/opensfm/src/dense/depthmap.h
+++ b/opensfm/src/dense/depthmap.h
@@ -5,7 +5,7 @@
 
 namespace dense {
 
-float Variance(float *x, int n);
+float Variance(float* x, int n);
 
 class NCCEstimator {
  public:
@@ -19,31 +19,31 @@ class NCCEstimator {
   float sumw_;
 };
 
-void ApplyHomography(const cv::Matx33f &H, float x1, float y1, float *x2,
-                     float *y2);
+void ApplyHomography(const cv::Matx33f& H, float x1, float y1, float* x2,
+                     float* y2);
 
-cv::Matx33d PlaneInducedHomography(const cv::Matx33d &K1, const cv::Matx33d &R1,
-                                   const cv::Vec3d &t1, const cv::Matx33d &K2,
-                                   const cv::Matx33d &R2, const cv::Vec3d &t2,
-                                   const cv::Vec3d &v);
+cv::Matx33d PlaneInducedHomography(const cv::Matx33d& K1, const cv::Matx33d& R1,
+                                   const cv::Vec3d& t1, const cv::Matx33d& K2,
+                                   const cv::Matx33d& R2, const cv::Vec3d& t2,
+                                   const cv::Vec3d& v);
 
-cv::Matx33f PlaneInducedHomographyBaked(const cv::Matx33d &K1inv,
-                                        const cv::Matx33d &Q2,
-                                        const cv::Vec3d &a2,
-                                        const cv::Matx33d &K2,
-                                        const cv::Vec3d &v);
+cv::Matx33f PlaneInducedHomographyBaked(const cv::Matx33d& K1inv,
+                                        const cv::Matx33d& Q2,
+                                        const cv::Vec3d& a2,
+                                        const cv::Matx33d& K2,
+                                        const cv::Vec3d& v);
 
-cv::Vec3d Project(const cv::Vec3d &x, const cv::Matx33d &K,
-                  const cv::Matx33d &R, const cv::Vec3d &t);
+cv::Vec3d Project(const cv::Vec3d& x, const cv::Matx33d& K,
+                  const cv::Matx33d& R, const cv::Vec3d& t);
 
-cv::Vec3d Backproject(double x, double y, double depth, const cv::Matx33d &K,
-                      const cv::Matx33d &R, const cv::Vec3d &t);
+cv::Vec3d Backproject(double x, double y, double depth, const cv::Matx33d& K,
+                      const cv::Matx33d& R, const cv::Vec3d& t);
 
-float DepthOfPlaneBackprojection(double x, double y, const cv::Matx33d &K,
-                                 const cv::Vec3d &plane);
+float DepthOfPlaneBackprojection(double x, double y, const cv::Matx33d& K,
+                                 const cv::Vec3d& plane);
 
-cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d &K,
-                                  float depth, const cv::Vec3f &normal);
+cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d& K,
+                                  float depth, const cv::Vec3f& normal);
 
 float UniformRand(float a, float b);
 
@@ -57,38 +57,38 @@ struct DepthmapEstimatorResult {
 class DepthmapEstimator {
  public:
   DepthmapEstimator();
-  void AddView(const double *pK, const double *pR, const double *pt,
-               const unsigned char *pimage, const unsigned char *pmask,
+  void AddView(const double* pK, const double* pR, const double* pt,
+               const unsigned char* pimage, const unsigned char* pmask,
                int width, int height);
   void SetDepthRange(double min_depth, double max_depth, int num_depth_planes);
   void SetPatchMatchIterations(int n);
   void SetPatchSize(int size);
   void SetMinPatchSD(float sd);
-  void ComputeBruteForce(DepthmapEstimatorResult *result);
-  void ComputePatchMatch(DepthmapEstimatorResult *result);
-  void ComputePatchMatchSample(DepthmapEstimatorResult *result);
-  void AssignMatrices(DepthmapEstimatorResult *result);
-  void RandomInitialization(DepthmapEstimatorResult *result, bool sample);
-  void ComputeIgnoreMask(DepthmapEstimatorResult *result);
+  void ComputeBruteForce(DepthmapEstimatorResult* result);
+  void ComputePatchMatch(DepthmapEstimatorResult* result);
+  void ComputePatchMatchSample(DepthmapEstimatorResult* result);
+  void AssignMatrices(DepthmapEstimatorResult* result);
+  void RandomInitialization(DepthmapEstimatorResult* result, bool sample);
+  void ComputeIgnoreMask(DepthmapEstimatorResult* result);
   float PatchVariance(int i, int j);
-  void PatchMatchForwardPass(DepthmapEstimatorResult *result, bool sample);
-  void PatchMatchBackwardPass(DepthmapEstimatorResult *result, bool sample);
-  void PatchMatchUpdatePixel(DepthmapEstimatorResult *result, int i, int j,
+  void PatchMatchForwardPass(DepthmapEstimatorResult* result, bool sample);
+  void PatchMatchBackwardPass(DepthmapEstimatorResult* result, bool sample);
+  void PatchMatchUpdatePixel(DepthmapEstimatorResult* result, int i, int j,
                              int adjacent[2][2], bool sample);
-  void CheckPlaneCandidate(DepthmapEstimatorResult *result, int i, int j,
-                           const cv::Vec3f &plane);
-  void CheckPlaneImageCandidate(DepthmapEstimatorResult *result, int i, int j,
-                                const cv::Vec3f &plane, int nghbr);
-  void AssignPixel(DepthmapEstimatorResult *result, int i, int j,
-                   const float depth, const cv::Vec3f &plane, const float score,
+  void CheckPlaneCandidate(DepthmapEstimatorResult* result, int i, int j,
+                           const cv::Vec3f& plane);
+  void CheckPlaneImageCandidate(DepthmapEstimatorResult* result, int i, int j,
+                                const cv::Vec3f& plane, int nghbr);
+  void AssignPixel(DepthmapEstimatorResult* result, int i, int j,
+                   const float depth, const cv::Vec3f& plane, const float score,
                    const int nghbr);
-  void ComputePlaneScore(int i, int j, const cv::Vec3f &plane, float *score,
-                         int *nghbr);
-  float ComputePlaneImageScoreUnoptimized(int i, int j, const cv::Vec3f &plane,
+  void ComputePlaneScore(int i, int j, const cv::Vec3f& plane, float* score,
+                         int* nghbr);
+  float ComputePlaneImageScoreUnoptimized(int i, int j, const cv::Vec3f& plane,
                                           int other);
-  float ComputePlaneImageScore(int i, int j, const cv::Vec3f &plane, int other);
+  float ComputePlaneImageScore(int i, int j, const cv::Vec3f& plane, int other);
   float BilateralWeight(float dcolor, float dx, float dy);
-  void PostProcess(DepthmapEstimatorResult *result);
+  void PostProcess(DepthmapEstimatorResult* result);
 
  private:
   std::vector<cv::Mat> images_;
@@ -115,9 +115,9 @@ class DepthmapCleaner {
   DepthmapCleaner();
   void SetSameDepthThreshold(float t);
   void SetMinConsistentViews(int n);
-  void AddView(const double *pK, const double *pR, const double *pt,
-               const float *pdepth, int width, int height);
-  void Clean(cv::Mat *clean_depth);
+  void AddView(const double* pK, const double* pR, const double* pt,
+               const float* pdepth, int width, int height);
+  void Clean(cv::Mat* clean_depth);
 
  private:
   std::vector<cv::Mat> depths_;
@@ -132,14 +132,14 @@ class DepthmapPruner {
  public:
   DepthmapPruner();
   void SetSameDepthThreshold(float t);
-  void AddView(const double *pK, const double *pR, const double *pt,
-               const float *pdepth, const float *pplane,
-               const unsigned char *pcolor, const unsigned char *plabel,
+  void AddView(const double* pK, const double* pR, const double* pt,
+               const float* pdepth, const float* pplane,
+               const unsigned char* pcolor, const unsigned char* plabel,
                int width, int height);
-  void Prune(std::vector<float> *merged_points,
-             std::vector<float> *merged_normals,
-             std::vector<unsigned char> *merged_colors,
-             std::vector<unsigned char> *merged_labels);
+  void Prune(std::vector<float>* merged_points,
+             std::vector<float>* merged_normals,
+             std::vector<unsigned char>* merged_colors,
+             std::vector<unsigned char>* merged_labels);
 
  private:
   std::vector<cv::Mat> depths_;
diff --git a/opensfm/src/dense/openmvs_exporter.h b/opensfm/src/dense/openmvs_exporter.h
index 2ee915bb3..cdd1ba6ff 100644
--- a/opensfm/src/dense/openmvs_exporter.h
+++ b/opensfm/src/dense/openmvs_exporter.h
@@ -6,7 +6,7 @@ namespace dense {
 
 class OpenMVSExporter {
  public:
-  void AddCamera(const std::string &camera_id, foundation::pyarray_d K,
+  void AddCamera(const std::string& camera_id, foundation::pyarray_d K,
                  uint32_t width, uint32_t height) {
     MVS::Interface::Platform platform;
     platform.name = camera_id;
@@ -22,13 +22,13 @@ class OpenMVSExporter {
     scene_.platforms.push_back(platform);
   }
 
-  void AddShot(const std::string &path, const std::string &maskPath,
-               const std::string &shot_id, const std::string &camera_id,
+  void AddShot(const std::string& path, const std::string& maskPath,
+               const std::string& shot_id, const std::string& camera_id,
                foundation::pyarray_d R, foundation::pyarray_d C) {
-    const double *C_data = C.data();
+    const double* C_data = C.data();
 
     int platform_id = platform_ids_[camera_id];
-    MVS::Interface::Platform &platform = scene_.platforms[platform_id];
+    MVS::Interface::Platform& platform = scene_.platforms[platform_id];
 
     MVS::Interface::Platform::Pose pose;
     pose.R = cv::Matx33d(R.data());
@@ -48,7 +48,7 @@ class OpenMVSExporter {
   }
 
   void AddPoint(foundation::pyarray_d coordinates, py::list shot_ids) {
-    const double *x = coordinates.data();
+    const double* x = coordinates.data();
 
     MVS::Interface::Vertex vertex;
     vertex.X = cv::Point3_<double>(x[0], x[1], x[2]);
diff --git a/opensfm/src/dense/src/depthmap.cc b/opensfm/src/dense/src/depthmap.cc
index d96cae68d..e9bd0718a 100644
--- a/opensfm/src/dense/src/depthmap.cc
+++ b/opensfm/src/dense/src/depthmap.cc
@@ -7,12 +7,12 @@ namespace dense {
 
 static const double z_epsilon = 1e-8;
 
-bool IsInsideImage(const cv::Mat &image, int i, int j) {
+bool IsInsideImage(const cv::Mat& image, int i, int j) {
   return i >= 0 && i < image.rows && j >= 0 && j < image.cols;
 }
 
 template <typename T>
-float LinearInterpolation(const cv::Mat &image, float y, float x) {
+float LinearInterpolation(const cv::Mat& image, float y, float x) {
   if (x < 0.0f || x >= image.cols - 1 || y < 0.0f || y >= image.rows - 1) {
     return 0.0f;
   }
@@ -29,7 +29,7 @@ float LinearInterpolation(const cv::Mat &image, float y, float x) {
   return (1 - dy) * im0 + dy * im1;
 }
 
-float Variance(float *x, int n) {
+float Variance(float* x, int n) {
   float sum = 0;
   for (int i = 0; i < n; ++i) {
     sum += x[i];
@@ -73,8 +73,8 @@ float NCCEstimator::Get() {
   }
 }
 
-void ApplyHomography(const cv::Matx33f &H, float x1, float y1, float *x2,
-                     float *y2) {
+void ApplyHomography(const cv::Matx33f& H, float x1, float y1, float* x2,
+                     float* y2) {
   float w = H(2, 0) * x1 + H(2, 1) * y1 + H(2, 2);
   if (w == 0.0) {
     *x2 = 0.0f;
@@ -85,40 +85,40 @@ void ApplyHomography(const cv::Matx33f &H, float x1, float y1, float *x2,
   *y2 = (H(1, 0) * x1 + H(1, 1) * y1 + H(1, 2)) / w;
 }
 
-cv::Matx33d PlaneInducedHomography(const cv::Matx33d &K1, const cv::Matx33d &R1,
-                                   const cv::Vec3d &t1, const cv::Matx33d &K2,
-                                   const cv::Matx33d &R2, const cv::Vec3d &t2,
-                                   const cv::Vec3d &v) {
+cv::Matx33d PlaneInducedHomography(const cv::Matx33d& K1, const cv::Matx33d& R1,
+                                   const cv::Vec3d& t1, const cv::Matx33d& K2,
+                                   const cv::Matx33d& R2, const cv::Vec3d& t2,
+                                   const cv::Vec3d& v) {
   cv::Matx33d R2R1 = R2 * R1.t();
   return K2 * (R2R1 + (R2R1 * t1 - t2) * v.t()) * K1.inv();
 }
 
-cv::Matx33f PlaneInducedHomographyBaked(const cv::Matx33d &K1inv,
-                                        const cv::Matx33d &Q2,
-                                        const cv::Vec3d &a2,
-                                        const cv::Matx33d &K2,
-                                        const cv::Vec3d &v) {
+cv::Matx33f PlaneInducedHomographyBaked(const cv::Matx33d& K1inv,
+                                        const cv::Matx33d& Q2,
+                                        const cv::Vec3d& a2,
+                                        const cv::Matx33d& K2,
+                                        const cv::Vec3d& v) {
   return K2 * (Q2 + a2 * v.t()) * K1inv;
 }
 
-cv::Vec3d Project(const cv::Vec3d &x, const cv::Matx33d &K,
-                  const cv::Matx33d &R, const cv::Vec3d &t) {
+cv::Vec3d Project(const cv::Vec3d& x, const cv::Matx33d& K,
+                  const cv::Matx33d& R, const cv::Vec3d& t) {
   return K * (R * x + t);
 }
 
-cv::Vec3d Backproject(double x, double y, double depth, const cv::Matx33d &K,
-                      const cv::Matx33d &R, const cv::Vec3d &t) {
+cv::Vec3d Backproject(double x, double y, double depth, const cv::Matx33d& K,
+                      const cv::Matx33d& R, const cv::Vec3d& t) {
   return R.t() * (depth * K.inv() * cv::Vec3d(x, y, 1) - t);
 }
 
-float DepthOfPlaneBackprojection(double x, double y, const cv::Matx33d &K,
-                                 const cv::Vec3d &plane) {
+float DepthOfPlaneBackprojection(double x, double y, const cv::Matx33d& K,
+                                 const cv::Vec3d& plane) {
   float denom = -(plane.t() * K.inv() * cv::Vec3d(x, y, 1))(0);
   return 1.0f / std::max(1e-6f, denom);
 }
 
-cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d &K,
-                                  float depth, const cv::Vec3f &normal) {
+cv::Vec3f PlaneFromDepthAndNormal(float x, float y, const cv::Matx33d& K,
+                                  float depth, const cv::Vec3f& normal) {
   cv::Vec3f point = depth * K.inv() * cv::Vec3d(x, y, 1);
   float denom = -normal.dot(point);
   return normal / std::max(1e-6f, denom);
@@ -143,9 +143,9 @@ DepthmapEstimator::DepthmapEstimator()
       unit_normal_(0, 1),
       patch_variance_buffer_(patch_size_ * patch_size_) {}
 
-void DepthmapEstimator::AddView(const double *pK, const double *pR,
-                                const double *pt, const unsigned char *pimage,
-                                const unsigned char *pmask, int width,
+void DepthmapEstimator::AddView(const double* pK, const double* pR,
+                                const double* pt, const unsigned char* pimage,
+                                const unsigned char* pmask, int width,
                                 int height) {
   Ks_.emplace_back(pK);
   Rs_.emplace_back(pR);
@@ -153,8 +153,8 @@ void DepthmapEstimator::AddView(const double *pK, const double *pR,
   Kinvs_.emplace_back(Ks_.back().inv());
   Qs_.emplace_back(Rs_.back() * Rs_.front().t());
   as_.emplace_back(Qs_.back() * ts_.front() - ts_.back());
-  images_.emplace_back(cv::Mat(height, width, CV_8U, (void *)pimage).clone());
-  masks_.emplace_back(cv::Mat(height, width, CV_8U, (void *)pmask).clone());
+  images_.emplace_back(cv::Mat(height, width, CV_8U, (void*)pimage).clone());
+  masks_.emplace_back(cv::Mat(height, width, CV_8U, (void*)pmask).clone());
   std::size_t size = images_.size();
   int a = (size > 1) ? 1 : 0;
   int b = (size > 1) ? size - 1 : 0;
@@ -181,7 +181,7 @@ void DepthmapEstimator::SetMinPatchSD(float sd) {
   min_patch_variance_ = sd * sd;
 }
 
-void DepthmapEstimator::ComputeBruteForce(DepthmapEstimatorResult *result) {
+void DepthmapEstimator::ComputeBruteForce(DepthmapEstimatorResult* result) {
   AssignMatrices(result);
 
   int hpz = (patch_size_ - 1) / 2;
@@ -199,7 +199,7 @@ void DepthmapEstimator::ComputeBruteForce(DepthmapEstimatorResult *result) {
   }
 }
 
-void DepthmapEstimator::ComputePatchMatch(DepthmapEstimatorResult *result) {
+void DepthmapEstimator::ComputePatchMatch(DepthmapEstimatorResult* result) {
   AssignMatrices(result);
   RandomInitialization(result, false);
   ComputeIgnoreMask(result);
@@ -213,7 +213,7 @@ void DepthmapEstimator::ComputePatchMatch(DepthmapEstimatorResult *result) {
 }
 
 void DepthmapEstimator::ComputePatchMatchSample(
-    DepthmapEstimatorResult *result) {
+    DepthmapEstimatorResult* result) {
   AssignMatrices(result);
   RandomInitialization(result, true);
   ComputeIgnoreMask(result);
@@ -226,7 +226,7 @@ void DepthmapEstimator::ComputePatchMatchSample(
   PostProcess(result);
 }
 
-void DepthmapEstimator::AssignMatrices(DepthmapEstimatorResult *result) {
+void DepthmapEstimator::AssignMatrices(DepthmapEstimatorResult* result) {
   result->depth = cv::Mat(images_[0].rows, images_[0].cols, CV_32F, 0.0f);
   result->plane = cv::Mat(images_[0].rows, images_[0].cols, CV_32FC3, 0.0f);
   result->score = cv::Mat(images_[0].rows, images_[0].cols, CV_32F, 0.0f);
@@ -234,7 +234,7 @@ void DepthmapEstimator::AssignMatrices(DepthmapEstimatorResult *result) {
       cv::Mat(images_[0].rows, images_[0].cols, CV_32S, cv::Scalar(0));
 }
 
-void DepthmapEstimator::RandomInitialization(DepthmapEstimatorResult *result,
+void DepthmapEstimator::RandomInitialization(DepthmapEstimatorResult* result,
                                              bool sample) {
   int hpz = (patch_size_ - 1) / 2;
   for (int i = hpz; i < result->depth.rows - hpz; ++i) {
@@ -255,7 +255,7 @@ void DepthmapEstimator::RandomInitialization(DepthmapEstimatorResult *result,
   }
 }
 
-void DepthmapEstimator::ComputeIgnoreMask(DepthmapEstimatorResult *result) {
+void DepthmapEstimator::ComputeIgnoreMask(DepthmapEstimatorResult* result) {
   int hpz = (patch_size_ - 1) / 2;
   for (int i = hpz; i < result->depth.rows - hpz; ++i) {
     for (int j = hpz; j < result->depth.cols - hpz; ++j) {
@@ -269,7 +269,7 @@ void DepthmapEstimator::ComputeIgnoreMask(DepthmapEstimatorResult *result) {
 }
 
 float DepthmapEstimator::PatchVariance(int i, int j) {
-  float *patch = patch_variance_buffer_.data();
+  float* patch = patch_variance_buffer_.data();
   int hpz = (patch_size_ - 1) / 2;
   int counter = 0;
   for (int u = -hpz; u <= hpz; ++u) {
@@ -280,7 +280,7 @@ float DepthmapEstimator::PatchVariance(int i, int j) {
   return Variance(patch, patch_size_ * patch_size_);
 }
 
-void DepthmapEstimator::PatchMatchForwardPass(DepthmapEstimatorResult *result,
+void DepthmapEstimator::PatchMatchForwardPass(DepthmapEstimatorResult* result,
                                               bool sample) {
   int adjacent[2][2] = {{-1, 0}, {0, -1}};
   int hpz = (patch_size_ - 1) / 2;
@@ -291,7 +291,7 @@ void DepthmapEstimator::PatchMatchForwardPass(DepthmapEstimatorResult *result,
   }
 }
 
-void DepthmapEstimator::PatchMatchBackwardPass(DepthmapEstimatorResult *result,
+void DepthmapEstimator::PatchMatchBackwardPass(DepthmapEstimatorResult* result,
                                                bool sample) {
   int adjacent[2][2] = {{0, 1}, {1, 0}};
   int hpz = (patch_size_ - 1) / 2;
@@ -302,7 +302,7 @@ void DepthmapEstimator::PatchMatchBackwardPass(DepthmapEstimatorResult *result,
   }
 }
 
-void DepthmapEstimator::PatchMatchUpdatePixel(DepthmapEstimatorResult *result,
+void DepthmapEstimator::PatchMatchUpdatePixel(DepthmapEstimatorResult* result,
                                               int i, int j, int adjacent[2][2],
                                               bool sample) {
   // Ignore pixels with depth == 0.
@@ -373,9 +373,9 @@ void DepthmapEstimator::PatchMatchUpdatePixel(DepthmapEstimatorResult *result,
   CheckPlaneImageCandidate(result, i, j, plane, other_nghbr);
 }
 
-void DepthmapEstimator::CheckPlaneCandidate(DepthmapEstimatorResult *result,
+void DepthmapEstimator::CheckPlaneCandidate(DepthmapEstimatorResult* result,
                                             int i, int j,
-                                            const cv::Vec3f &plane) {
+                                            const cv::Vec3f& plane) {
   float score;
   int nghbr;
   ComputePlaneScore(i, j, plane, &score, &nghbr);
@@ -386,7 +386,7 @@ void DepthmapEstimator::CheckPlaneCandidate(DepthmapEstimatorResult *result,
 }
 
 void DepthmapEstimator::CheckPlaneImageCandidate(
-    DepthmapEstimatorResult *result, int i, int j, const cv::Vec3f &plane,
+    DepthmapEstimatorResult* result, int i, int j, const cv::Vec3f& plane,
     int nghbr) {
   float score = ComputePlaneImageScore(i, j, plane, nghbr);
   if (score > result->score.at<float>(i, j)) {
@@ -395,9 +395,9 @@ void DepthmapEstimator::CheckPlaneImageCandidate(
   }
 }
 
-void DepthmapEstimator::AssignPixel(DepthmapEstimatorResult *result, int i,
+void DepthmapEstimator::AssignPixel(DepthmapEstimatorResult* result, int i,
                                     int j, const float depth,
-                                    const cv::Vec3f &plane, const float score,
+                                    const cv::Vec3f& plane, const float score,
                                     const int nghbr) {
   result->depth.at<float>(i, j) = depth;
   result->plane.at<cv::Vec3f>(i, j) = plane;
@@ -405,8 +405,8 @@ void DepthmapEstimator::AssignPixel(DepthmapEstimatorResult *result, int i,
   result->nghbr.at<int>(i, j) = nghbr;
 }
 
-void DepthmapEstimator::ComputePlaneScore(int i, int j, const cv::Vec3f &plane,
-                                          float *score, int *nghbr) {
+void DepthmapEstimator::ComputePlaneScore(int i, int j, const cv::Vec3f& plane,
+                                          float* score, int* nghbr) {
   *score = -1.0f;
   *nghbr = 0;
   for (int other = 1; other < images_.size(); ++other) {
@@ -419,7 +419,7 @@ void DepthmapEstimator::ComputePlaneScore(int i, int j, const cv::Vec3f &plane,
 }
 
 float DepthmapEstimator::ComputePlaneImageScoreUnoptimized(
-    int i, int j, const cv::Vec3f &plane, int other) {
+    int i, int j, const cv::Vec3f& plane, int other) {
   cv::Matx33f H = PlaneInducedHomographyBaked(Kinvs_[0], Qs_[other], as_[other],
                                               Ks_[other], plane);
   int hpz = (patch_size_ - 1) / 2;
@@ -439,7 +439,7 @@ float DepthmapEstimator::ComputePlaneImageScoreUnoptimized(
 }
 
 float DepthmapEstimator::ComputePlaneImageScore(int i, int j,
-                                                const cv::Vec3f &plane,
+                                                const cv::Vec3f& plane,
                                                 int other) {
   cv::Matx33f H = PlaneInducedHomographyBaked(Kinvs_[0], Qs_[other], as_[other],
                                               Ks_[other], plane);
@@ -486,7 +486,7 @@ float DepthmapEstimator::BilateralWeight(float dcolor, float dx, float dy) {
              (dx * dx + dy * dy) * dx_factor);
 }
 
-void DepthmapEstimator::PostProcess(DepthmapEstimatorResult *result) {
+void DepthmapEstimator::PostProcess(DepthmapEstimatorResult* result) {
   cv::Mat depth_filtered;
   cv::medianBlur(result->depth, depth_filtered, 5);
 
@@ -512,16 +512,16 @@ void DepthmapCleaner::SetMinConsistentViews(int n) {
   min_consistent_views_ = n;
 }
 
-void DepthmapCleaner::AddView(const double *pK, const double *pR,
-                              const double *pt, const float *pdepth, int width,
+void DepthmapCleaner::AddView(const double* pK, const double* pR,
+                              const double* pt, const float* pdepth, int width,
                               int height) {
   Ks_.emplace_back(pK);
   Rs_.emplace_back(pR);
   ts_.emplace_back(pt);
-  depths_.emplace_back(cv::Mat(height, width, CV_32F, (void *)pdepth).clone());
+  depths_.emplace_back(cv::Mat(height, width, CV_32F, (void*)pdepth).clone());
 }
 
-void DepthmapCleaner::Clean(cv::Mat *clean_depth) {
+void DepthmapCleaner::Clean(cv::Mat* clean_depth) {
   *clean_depth = cv::Mat(depths_[0].rows, depths_[0].cols, CV_32F, 0.0f);
 
   for (int i = 0; i < depths_[0].rows; ++i) {
@@ -560,25 +560,24 @@ void DepthmapPruner::SetSameDepthThreshold(float t) {
   same_depth_threshold_ = t;
 }
 
-void DepthmapPruner::AddView(const double *pK, const double *pR,
-                             const double *pt, const float *pdepth,
-                             const float *pplane, const unsigned char *pcolor,
-                             const unsigned char *plabel, int width,
+void DepthmapPruner::AddView(const double* pK, const double* pR,
+                             const double* pt, const float* pdepth,
+                             const float* pplane, const unsigned char* pcolor,
+                             const unsigned char* plabel, int width,
                              int height) {
   Ks_.emplace_back(pK);
   Rs_.emplace_back(pR);
   ts_.emplace_back(pt);
-  depths_.emplace_back(cv::Mat(height, width, CV_32F, (void *)pdepth).clone());
-  planes_.emplace_back(
-      cv::Mat(height, width, CV_32FC3, (void *)pplane).clone());
-  colors_.emplace_back(cv::Mat(height, width, CV_8UC3, (void *)pcolor).clone());
-  labels_.emplace_back(cv::Mat(height, width, CV_8U, (void *)plabel).clone());
+  depths_.emplace_back(cv::Mat(height, width, CV_32F, (void*)pdepth).clone());
+  planes_.emplace_back(cv::Mat(height, width, CV_32FC3, (void*)pplane).clone());
+  colors_.emplace_back(cv::Mat(height, width, CV_8UC3, (void*)pcolor).clone());
+  labels_.emplace_back(cv::Mat(height, width, CV_8U, (void*)plabel).clone());
 }
 
-void DepthmapPruner::Prune(std::vector<float> *merged_points,
-                           std::vector<float> *merged_normals,
-                           std::vector<unsigned char> *merged_colors,
-                           std::vector<unsigned char> *merged_labels) {
+void DepthmapPruner::Prune(std::vector<float>* merged_points,
+                           std::vector<float>* merged_normals,
+                           std::vector<unsigned char>* merged_colors,
+                           std::vector<unsigned char>* merged_labels) {
   cv::Matx33f Rinv = Rs_[0].t();
   for (int i = 0; i < depths_[0].rows; ++i) {
     for (int j = 0; j < depths_[0].cols; ++j) {
diff --git a/opensfm/src/features/matching.h b/opensfm/src/features/matching.h
index 65a2ddbcd..0903ee981 100644
--- a/opensfm/src/features/matching.h
+++ b/opensfm/src/features/matching.h
@@ -13,9 +13,9 @@ py::array_t<int> match_using_words(foundation::pyarray_f features1,
                                    foundation::pyarray_int words2,
                                    float lowes_ratio, int max_checks);
 
-VecXf compute_vlad_descriptor(const MatXf &features, const MatXf &vlad_centers);
+VecXf compute_vlad_descriptor(const MatXf& features, const MatXf& vlad_centers);
 
 std::pair<std::vector<double>, std::vector<std::string>> compute_vlad_distances(
-    const std::map<std::string, VecXf> &vlad_descriptors,
-    const std::string &image, std::set<std::string> &other_images);
+    const std::map<std::string, VecXf>& vlad_descriptors,
+    const std::string& image, std::set<std::string>& other_images);
 }  // namespace features
diff --git a/opensfm/src/features/src/akaze_bind.cc b/opensfm/src/features/src/akaze_bind.cc
index 8739d0639..4131d23d6 100644
--- a/opensfm/src/features/src/akaze_bind.cc
+++ b/opensfm/src/features/src/akaze_bind.cc
@@ -9,8 +9,7 @@ namespace features {
 py::tuple akaze(foundation::pyarray_uint8 image, AKAZEOptions options) {
   py::gil_scoped_release release;
 
-  const cv::Mat img(image.shape(0), image.shape(1), CV_8U,
-                    (void *)image.data());
+  const cv::Mat img(image.shape(0), image.shape(1), CV_8U, (void*)image.data());
 
   cv::Mat img_32;
   img.convertTo(img_32, CV_32F, 1.0 / 255.0, 0);
diff --git a/opensfm/src/features/src/hahog.cc b/opensfm/src/features/src/hahog.cc
index 691a898fb..5b398e9e5 100644
--- a/opensfm/src/features/src/hahog.cc
+++ b/opensfm/src/features/src/hahog.cc
@@ -12,14 +12,14 @@ extern "C" {
 namespace features {
 
 // from VLFeat implementation of _vl_compare_scores
-static int vlfeat_compare_scores(const void *a, const void *b) {
-  float fa = ((VlCovDetFeature *)a)->peakScore;
-  float fb = ((VlCovDetFeature *)b)->peakScore;
+static int vlfeat_compare_scores(const void* a, const void* b) {
+  float fa = ((VlCovDetFeature*)a)->peakScore;
+  float fb = ((VlCovDetFeature*)b)->peakScore;
   return (fb > fa) - (fb < fa);
 }
 
 // select 'target_num_features' for using feature's scores
-vl_size select_best_features(VlCovDet *covdet, vl_size num_features,
+vl_size select_best_features(VlCovDet* covdet, vl_size num_features,
                              vl_size target_num_features) {
   if (num_features > target_num_features) {
     qsort(vl_covdet_get_features(covdet), num_features, sizeof(VlCovDetFeature),
@@ -33,11 +33,11 @@ vl_size select_best_features(VlCovDet *covdet, vl_size num_features,
 // select 'target_num_features' that have a maximum score in their neighbhood.
 // The neighborhood is computing using the feature's scale and
 // 'non_extrema_suppression' as : neighborhood = non_extrema_suppression * scale
-vl_size run_non_maxima_suppression(VlCovDet *covdet, vl_size num_features,
+vl_size run_non_maxima_suppression(VlCovDet* covdet, vl_size num_features,
                                    double non_extrema_suppression) {
   vl_index i, j;
   double tol = non_extrema_suppression;
-  VlCovDetFeature *features = (VlCovDetFeature *)vl_covdet_get_features(covdet);
+  VlCovDetFeature* features = (VlCovDetFeature*)vl_covdet_get_features(covdet);
   for (i = 0; i < (signed)num_features; ++i) {
     double x = features[i].frame.x;
     double y = features[i].frame.y;
@@ -69,7 +69,7 @@ vl_size run_non_maxima_suppression(VlCovDet *covdet, vl_size num_features,
   return j;
 }
 
-vl_size run_features_selection(VlCovDet *covdet, vl_size target_num_features) {
+vl_size run_features_selection(VlCovDet* covdet, vl_size target_num_features) {
   vl_size numFeaturesKept = vl_covdet_get_num_features(covdet);
 
   // keep only 1.5 x targetNumFeatures for speeding-up duplicate detection
@@ -91,15 +91,15 @@ vl_size run_features_selection(VlCovDet *covdet, vl_size target_num_features) {
 }
 
 std::vector<VlCovDetFeature> vlfeat_covdet_extract_orientations(
-    VlCovDet *covdet, vl_size num_features) {
-  VlCovDetFeature *features = (VlCovDetFeature *)vl_covdet_get_features(covdet);
+    VlCovDet* covdet, vl_size num_features) {
+  VlCovDetFeature* features = (VlCovDetFeature*)vl_covdet_get_features(covdet);
   std::vector<VlCovDetFeature> vecFeatures;
   vecFeatures.reserve(num_features);
   vl_index i, j;
   for (i = 0; i < (signed)num_features; ++i) {
     vl_size numOrientations;
     VlCovDetFeature feature = features[i];
-    VlCovDetFeatureOrientation *orientations =
+    VlCovDetFeatureOrientation* orientations =
         vl_covdet_extract_orientations_for_frame(covdet, &numOrientations,
                                                  feature.frame);
 
@@ -110,7 +110,7 @@ std::vector<VlCovDetFeature> vlfeat_covdet_extract_orientations(
       double r2 = sin(orientations[j].angle);
 
       vecFeatures.emplace_back(features[i]);
-      VlCovDetFeature &oriented = vecFeatures.back();
+      VlCovDetFeature& oriented = vecFeatures.back();
 
       oriented.orientationScore = orientations[j].score;
       oriented.frame.a11 = +A[0] * r1 + A[2] * r2;
@@ -137,7 +137,7 @@ py::tuple hahog(foundation::pyarray_f image, float peak_threshold,
     py::gil_scoped_release release;
 
     // create a detector object
-    VlCovDet *covdet = vl_covdet_new(VL_COVDET_METHOD_HESSIAN);
+    VlCovDet* covdet = vl_covdet_new(VL_COVDET_METHOD_HESSIAN);
     // set various parameters (optional)
     vl_covdet_set_first_octave(covdet, 0);
     vl_covdet_set_peak_threshold(covdet, peak_threshold);
@@ -157,7 +157,7 @@ py::tuple hahog(foundation::pyarray_f image, float peak_threshold,
     numFeatures = vecFeatures.size();
 
     // get feature descriptors
-    VlSiftFilt *sift = vl_sift_new(16, 16, 1, 3, 0);
+    VlSiftFilt* sift = vl_sift_new(16, 16, 1, 3, 0);
     vl_index i;
     vl_index patchResolution = 15;
     double patchRelativeExtent = 7.5;
@@ -171,7 +171,7 @@ py::tuple hahog(foundation::pyarray_f image, float peak_threshold,
 
     vl_sift_set_magnif(sift, 3.0);
     for (i = 0; i < (signed)numFeatures; ++i) {
-      const VlFrameOrientedEllipse &frame = vecFeatures.at(i).frame;
+      const VlFrameOrientedEllipse& frame = vecFeatures.at(i).frame;
       float det = frame.a11 * frame.a22 - frame.a12 * frame.a21;
       float size = sqrt(fabs(det));
       float angle = atan2(frame.a21, frame.a11) * 180.0f / M_PI;
diff --git a/opensfm/src/features/src/matching.cc b/opensfm/src/features/src/matching.cc
index e2ff9735c..4b17b6900 100644
--- a/opensfm/src/features/src/matching.cc
+++ b/opensfm/src/features/src/matching.cc
@@ -15,7 +15,7 @@ namespace py = pybind11;
 
 namespace features {
 
-float DistanceL1(const float *pa, const float *pb, int n) {
+float DistanceL1(const float* pa, const float* pb, int n) {
   float distance = 0;
   for (int i = 0; i < n; ++i) {
     distance += fabs(pa[i] - pb[i]);
@@ -23,7 +23,7 @@ float DistanceL1(const float *pa, const float *pb, int n) {
   return distance;
 }
 
-float DistanceL2(const float *pa, const float *pb, int n) {
+float DistanceL2(const float* pa, const float* pb, int n) {
   float distance = 0;
   for (int i = 0; i < n; ++i) {
     distance += (pa[i] - pb[i]) * (pa[i] - pb[i]);
@@ -31,12 +31,12 @@ float DistanceL2(const float *pa, const float *pb, int n) {
   return sqrt(distance);
 }
 
-void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
-                     const cv::Mat &w2, float lowes_ratio, int max_checks,
-                     cv::Mat *matches) {
+void MatchUsingWords(const cv::Mat& f1, const cv::Mat& w1, const cv::Mat& f2,
+                     const cv::Mat& w2, float lowes_ratio, int max_checks,
+                     cv::Mat* matches) {
   // Index features on the second image.
   std::multimap<int, int> index2;
-  const int *pw2 = &w2.at<int>(0, 0);
+  const int* pw2 = &w2.at<int>(0, 0);
   for (unsigned int i = 0; i < w2.rows * w2.cols; ++i) {
     index2.insert(std::pair<int, int>(pw2[i], i));
   }
@@ -55,8 +55,8 @@ void MatchUsingWords(const cv::Mat &f1, const cv::Mat &w1, const cv::Mat &f2,
       auto range = index2.equal_range(word);
       for (auto it = range.first; it != range.second; ++it) {
         int match = it->second;
-        const float *pa = f1.ptr<float>(i);
-        const float *pb = f2.ptr<float>(match);
+        const float* pa = f1.ptr<float>(i);
+        const float* pb = f2.ptr<float>(match);
         float distance = DistanceL2(pa, pb, f1.cols);
         if (distance < best_distance[i]) {
           second_best_distance[i] = best_distance[i];
@@ -98,8 +98,8 @@ py::array_t<int> match_using_words(foundation::pyarray_f features1,
   return foundation::py_array_from_cvmat<int>(matches);
 }
 
-VecXf compute_vlad_descriptor(const MatXf &features,
-                              const MatXf &vlad_centers) {
+VecXf compute_vlad_descriptor(const MatXf& features,
+                              const MatXf& vlad_centers) {
   const auto vlad_center_size = vlad_centers.cols();
   const auto vlad_center_count = vlad_centers.rows();
 
@@ -111,7 +111,7 @@ VecXf compute_vlad_descriptor(const MatXf &features,
   vlad_descriptor.setZero();
 
   for (int i = 0; i < features.rows(); ++i) {
-    const auto &feature = features.row(i);
+    const auto& feature = features.row(i);
 
     float best_distance = std::numeric_limits<float>::max();
     int best_center = -1;
@@ -130,16 +130,16 @@ VecXf compute_vlad_descriptor(const MatXf &features,
 }
 
 std::pair<std::vector<double>, std::vector<std::string>> compute_vlad_distances(
-    const std::map<std::string, VecXf> &vlad_descriptors,
-    const std::string &image, std::set<std::string> &other_images) {
+    const std::map<std::string, VecXf>& vlad_descriptors,
+    const std::string& image, std::set<std::string>& other_images) {
   if (vlad_descriptors.find(image) == vlad_descriptors.end()) {
     return std::make_pair(std::vector<double>(), std::vector<std::string>());
   }
 
   std::vector<double> distances;
   std::vector<std::string> others;
-  const auto &reference = vlad_descriptors.at(image);
-  for (const auto &candidate : other_images) {
+  const auto& reference = vlad_descriptors.at(image);
+  for (const auto& candidate : other_images) {
     if (candidate == image) {
       continue;
     }
diff --git a/opensfm/src/foundation/python_types.h b/opensfm/src/foundation/python_types.h
index 8d45a532e..e8acc8fab 100644
--- a/opensfm/src/foundation/python_types.h
+++ b/opensfm/src/foundation/python_types.h
@@ -19,21 +19,21 @@ using pyarray_uint8 =
     py::array_t<unsigned char, py::array::c_style | py::array::forcecast>;
 
 template <typename T>
-py::array_t<T> py_array_from_data(const T *data, size_t shape0) {
+py::array_t<T> py_array_from_data(const T* data, size_t shape0) {
   py::array_t<T> res(shape0);
   std::copy(data, data + shape0, res.mutable_data());
   return res;
 }
 
 template <typename T>
-py::array_t<T> py_array_from_data(const T *data, size_t shape0, size_t shape1) {
+py::array_t<T> py_array_from_data(const T* data, size_t shape0, size_t shape1) {
   py::array_t<T> res({shape0, shape1});
   std::copy(data, data + shape0 * shape1, res.mutable_data());
   return res;
 }
 
 template <typename T>
-py::array_t<T> py_array_from_data(const T *data, size_t shape0, size_t shape1,
+py::array_t<T> py_array_from_data(const T* data, size_t shape0, size_t shape1,
                                   size_t shape2) {
   py::array_t<T> res({shape0, shape1, shape2});
   std::copy(data, data + shape0 * shape1 * shape2, res.mutable_data());
@@ -41,19 +41,19 @@ py::array_t<T> py_array_from_data(const T *data, size_t shape0, size_t shape1,
 }
 
 template <typename T>
-py::array_t<T> py_array_from_vector(const std::vector<T> &v) {
-  const T *data = v.size() ? v.data() : NULL;
+py::array_t<T> py_array_from_vector(const std::vector<T>& v) {
+  const T* data = v.size() ? v.data() : NULL;
   return py_array_from_data(data, v.size());
 }
 
 template <typename T>
-py::array_t<T> py_array_from_cvmat(const cv::Mat &m) {
-  const T *data = m.rows ? m.ptr<T>(0) : NULL;
+py::array_t<T> py_array_from_cvmat(const cv::Mat& m) {
+  const T* data = m.rows ? m.ptr<T>(0) : NULL;
   return py_array_from_data(data, m.rows, m.cols);
 }
 
 template <typename T>
-cv::Mat pyarray_cv_mat_view_typed(T &array, int type) {
+cv::Mat pyarray_cv_mat_view_typed(T& array, int type) {
   int height = 1;
   int width = 1;
 
@@ -67,8 +67,8 @@ cv::Mat pyarray_cv_mat_view_typed(T &array, int type) {
   return cv::Mat(height, width, type, array.mutable_data());
 }
 
-cv::Mat pyarray_cv_mat_view(pyarray_f &array);
-cv::Mat pyarray_cv_mat_view(pyarray_d &array);
-cv::Mat pyarray_cv_mat_view(pyarray_int &array);
-cv::Mat pyarray_cv_mat_view(pyarray_uint8 &array);
+cv::Mat pyarray_cv_mat_view(pyarray_f& array);
+cv::Mat pyarray_cv_mat_view(pyarray_d& array);
+cv::Mat pyarray_cv_mat_view(pyarray_int& array);
+cv::Mat pyarray_cv_mat_view(pyarray_uint8& array);
 }  // namespace foundation
diff --git a/opensfm/src/foundation/src/types.cc b/opensfm/src/foundation/src/types.cc
index fe4581566..dd7755a81 100644
--- a/opensfm/src/foundation/src/types.cc
+++ b/opensfm/src/foundation/src/types.cc
@@ -2,19 +2,19 @@
 
 namespace foundation {
 
-cv::Mat pyarray_cv_mat_view(pyarray_f &array) {
+cv::Mat pyarray_cv_mat_view(pyarray_f& array) {
   return pyarray_cv_mat_view_typed(array, CV_32F);
 }
 
-cv::Mat pyarray_cv_mat_view(pyarray_d &array) {
+cv::Mat pyarray_cv_mat_view(pyarray_d& array) {
   return pyarray_cv_mat_view_typed(array, CV_64F);
 }
 
-cv::Mat pyarray_cv_mat_view(pyarray_int &array) {
+cv::Mat pyarray_cv_mat_view(pyarray_int& array) {
   return pyarray_cv_mat_view_typed(array, CV_32S);
 }
 
-cv::Mat pyarray_cv_mat_view(pyarray_uint8 &array) {
+cv::Mat pyarray_cv_mat_view(pyarray_uint8& array) {
   return pyarray_cv_mat_view_typed(array, CV_8U);
 }
 
diff --git a/opensfm/src/geo/python/pybind.cc b/opensfm/src/geo/python/pybind.cc
index bd1703b37..9610ba8f6 100644
--- a/opensfm/src/geo/python/pybind.cc
+++ b/opensfm/src/geo/python/pybind.cc
@@ -5,35 +5,35 @@
 namespace py = pybind11;
 
 PYBIND11_MODULE(pygeo, m) {
-  m.def("ecef_from_lla", (Vec3d(*)(const Vec3d&))geo::EcefFromLla);
+  m.def("ecef_from_lla", (Vec3d (*)(const Vec3d&))geo::EcefFromLla);
   m.def("ecef_from_lla",
-        (Vec3d(*)(const double, const double, const double))geo::EcefFromLla);
-  m.def("lla_from_ecef", (Vec3d(*)(const Vec3d&))geo::LlaFromEcef);
+        (Vec3d (*)(const double, const double, const double))geo::EcefFromLla);
+  m.def("lla_from_ecef", (Vec3d (*)(const Vec3d&))geo::LlaFromEcef);
   m.def("lla_from_ecef",
-        (Vec3d(*)(const double, const double, const double))geo::LlaFromEcef);
+        (Vec3d (*)(const double, const double, const double))geo::LlaFromEcef);
 
   m.def("ecef_from_topocentric_transform",
-        (Mat4d(*)(const Vec3d&))geo::EcefFromTopocentricTransform);
+        (Mat4d (*)(const Vec3d&))geo::EcefFromTopocentricTransform);
   m.def("ecef_from_topocentric_transform",
-        (Mat4d(*)(const double, const double,
-                  const double))geo::EcefFromTopocentricTransform);
+        (Mat4d (*)(const double, const double,
+                   const double))geo::EcefFromTopocentricTransform);
 
   m.def("ecef_from_topocentric_transform_finite_diff",
-        (Mat4d(*)(const Vec3d&))geo::EcefFromTopocentricTransformFiniteDiff);
+        (Mat4d (*)(const Vec3d&))geo::EcefFromTopocentricTransformFiniteDiff);
   m.def("ecef_from_topocentric_transform_finite_diff",
-        (Mat4d(*)(const double, const double,
-                  const double))geo::EcefFromTopocentricTransformFiniteDiff);
+        (Mat4d (*)(const double, const double,
+                   const double))geo::EcefFromTopocentricTransformFiniteDiff);
 
   m.def("topocentric_from_lla",
-        (Vec3d(*)(const Vec3d&, const Vec3d&))geo::TopocentricFromLla);
+        (Vec3d (*)(const Vec3d&, const Vec3d&))geo::TopocentricFromLla);
   m.def("topocentric_from_lla",
-        (Vec3d(*)(const double, const double, const double, const double,
-                  const double, const double))geo::TopocentricFromLla);
+        (Vec3d (*)(const double, const double, const double, const double,
+                   const double, const double))geo::TopocentricFromLla);
   m.def("lla_from_topocentric",
-        (Vec3d(*)(const Vec3d&, const Vec3d&))geo::LlaFromTopocentric);
+        (Vec3d (*)(const Vec3d&, const Vec3d&))geo::LlaFromTopocentric);
   m.def("lla_from_topocentric",
-        (Vec3d(*)(const double, const double, const double, const double,
-                  const double, const double))geo::LlaFromTopocentric);
+        (Vec3d (*)(const double, const double, const double, const double,
+                   const double, const double))geo::LlaFromTopocentric);
   m.def("gps_distance", geo::GpsDistance);
 
   py::class_<geo::TopocentricConverter>(m, "TopocentricConverter")
diff --git a/opensfm/src/geometry/absolute_pose.h b/opensfm/src/geometry/absolute_pose.h
index f2ba829c1..72a0c9e82 100644
--- a/opensfm/src/geometry/absolute_pose.h
+++ b/opensfm/src/geometry/absolute_pose.h
@@ -9,7 +9,7 @@
 
 Eigen::Matrix3d RotationMatrixAroundAxis(const double cos_theta,
                                          const double sin_theta,
-                                         const Eigen::Vector3d &v);
+                                         const Eigen::Vector3d& v);
 
 // Implements "An Efficient Algebraic Solution to the
 // Perspective-Three-Point Problem" from Ke and al.
@@ -92,7 +92,7 @@ std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(IT begin,
   e1 << 1, 0, 0;
   e2 << 0, 1, 0;
 
-  for (const auto &root : roots) {
+  for (const auto& root : roots) {
     const auto cos_theta_1 = root;
     const auto sin_theta_1 =
         foundation::Sign(k3_b3) * std::sqrt(1.0 - SQUARE(cos_theta_1));
@@ -123,7 +123,7 @@ std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(IT begin,
 
 template <class IT>
 Eigen::Vector3d TranslationBetweenPoints(IT begin, IT end,
-                                         const Eigen::Matrix3d &rotation) {
+                                         const Eigen::Matrix3d& rotation) {
   Eigen::Matrix3d F1 = Eigen::Matrix3d::Zero();
   Eigen::Vector3d F2 = Eigen::Vector3d::Zero();
   const Eigen::Matrix3d identity = Eigen::Matrix3d::Identity();
@@ -193,14 +193,14 @@ Eigen::Vector3d AbsolutePoseNPointsKnownRotation(IT begin, IT end) {
 
 namespace geometry {
 std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points);
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points);
 
 Eigen::Matrix<double, 3, 4> AbsolutePoseNPoints(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points);
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points);
 
 Eigen::Vector3d AbsolutePoseNPointsKnownRotation(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points);
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points);
 }  // namespace geometry
diff --git a/opensfm/src/geometry/essential.h b/opensfm/src/geometry/essential.h
index f6f47c7f7..d8bcea6a1 100644
--- a/opensfm/src/geometry/essential.h
+++ b/opensfm/src/geometry/essential.h
@@ -62,7 +62,7 @@ enum {
 };
 
 template <class IT, class MAT>
-inline void EncodeEpipolarEquation(IT begin, IT end, MAT *A) {
+inline void EncodeEpipolarEquation(IT begin, IT end, MAT* A) {
   for (IT it = begin; it != end; ++it) {
     int i = (it - begin);
     const auto x1 = it->first;
@@ -83,18 +83,18 @@ Eigen::MatrixXd FivePointsNullspaceBasis(IT begin, IT end) {
 }
 
 // Multiply two polynomials of degree 1.
-Eigen::Matrix<double, -1, 1> o1(const Eigen::Matrix<double, -1, 1> &a,
-                                const Eigen::Matrix<double, -1, 1> &b);
+Eigen::Matrix<double, -1, 1> o1(const Eigen::Matrix<double, -1, 1>& a,
+                                const Eigen::Matrix<double, -1, 1>& b);
 
 // Multiply a polynomial of degree 2, a, by a polynomial of degree 1, b.
-Eigen::Matrix<double, -1, 1> o2(const Eigen::Matrix<double, -1, 1> &a,
-                                const Eigen::Matrix<double, -1, 1> &b);
+Eigen::Matrix<double, -1, 1> o2(const Eigen::Matrix<double, -1, 1>& a,
+                                const Eigen::Matrix<double, -1, 1>& b);
 
 // Builds the polynomial constraint matrix M.
-Eigen::MatrixXd FivePointsPolynomialConstraints(const Eigen::MatrixXd &E_basis);
+Eigen::MatrixXd FivePointsPolynomialConstraints(const Eigen::MatrixXd& E_basis);
 
 // Gauss--Jordan elimination for the constraint matrix.
-bool FivePointsGaussJordan(Eigen::MatrixXd *Mp);
+bool FivePointsGaussJordan(Eigen::MatrixXd* Mp);
 
 template <class IT>
 std::vector<Eigen::Matrix<double, 3, 3>> EssentialFivePoints(IT begin, IT end) {
@@ -193,10 +193,10 @@ std::vector<Eigen::Matrix<double, 3, 3>> EssentialNPoints(IT begin, IT end) {
 
 namespace geometry {
 std::vector<Eigen::Matrix<double, 3, 3>> EssentialFivePoints(
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2);
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2);
 
 std::vector<Eigen::Matrix<double, 3, 3>> EssentialNPoints(
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2);
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2);
 }  // namespace geometry
diff --git a/opensfm/src/geometry/python/pybind.cc b/opensfm/src/geometry/python/pybind.cc
index 86259546a..907e1bc11 100644
--- a/opensfm/src/geometry/python/pybind.cc
+++ b/opensfm/src/geometry/python/pybind.cc
@@ -77,29 +77,35 @@ PYBIND11_MODULE(pygeometry, m) {
       .def("get_parameters_values", &geometry::Camera::GetParametersValues)
       .def("get_parameters_types", &geometry::Camera::GetParametersTypes)
       .def("get_parameters_map", &geometry::Camera::GetParametersMap)
-      .def_static("pixel_to_normalized_coordinates_common",
-                  (Vec2d(*)(const Vec2d&, const int, const int)) &
-                      geometry::Camera::PixelToNormalizedCoordinates)
-      .def_static("pixel_to_normalized_coordinates_many_common",
-                  (MatX2d(*)(const MatX2d&, const int, const int)) &
-                      geometry::Camera::PixelToNormalizedCoordinatesMany)
+      .def_static(
+          "pixel_to_normalized_coordinates_common",
+          (Vec2d (*)(const Vec2d&, const int,
+                     const int))&geometry::Camera::PixelToNormalizedCoordinates)
+      .def_static(
+          "pixel_to_normalized_coordinates_many_common",
+          (MatX2d (*)(
+              const MatX2d&, const int,
+              const int))&geometry::Camera::PixelToNormalizedCoordinatesMany)
       .def("pixel_to_normalized_coordinates",
-           (Vec2d(geometry::Camera::*)(const Vec2d&) const) &
+           (Vec2d (geometry::Camera::*)(const Vec2d&) const) &
                geometry::Camera::PixelToNormalizedCoordinates)
       .def("pixel_to_normalized_coordinates_many",
-           (MatX2d(geometry::Camera::*)(const MatX2d&) const) &
+           (MatX2d (geometry::Camera::*)(const MatX2d&) const) &
                geometry::Camera::PixelToNormalizedCoordinatesMany)
-      .def_static("normalized_to_pixel_coordinates_common",
-                  (Vec2d(*)(const Vec2d&, const int, const int)) &
-                      geometry::Camera::NormalizedToPixelCoordinates)
-      .def_static("normalized_to_pixel_coordinates_many_common",
-                  (MatX2d(*)(const MatX2d&, const int, const int)) &
-                      geometry::Camera::NormalizedToPixelCoordinatesMany)
+      .def_static(
+          "normalized_to_pixel_coordinates_common",
+          (Vec2d (*)(const Vec2d&, const int,
+                     const int))&geometry::Camera::NormalizedToPixelCoordinates)
+      .def_static(
+          "normalized_to_pixel_coordinates_many_common",
+          (MatX2d (*)(
+              const MatX2d&, const int,
+              const int))&geometry::Camera::NormalizedToPixelCoordinatesMany)
       .def("normalized_to_pixel_coordinates",
-           (Vec2d(geometry::Camera::*)(const Vec2d&) const) &
+           (Vec2d (geometry::Camera::*)(const Vec2d&) const) &
                geometry::Camera::NormalizedToPixelCoordinates)
       .def("normalized_to_pixel_coordinates_many",
-           (MatX2d(geometry::Camera::*)(const MatX2d&) const) &
+           (MatX2d (geometry::Camera::*)(const MatX2d&) const) &
                geometry::Camera::NormalizedToPixelCoordinatesMany)
       .def_readwrite("width", &geometry::Camera::width)
       .def_readwrite("height", &geometry::Camera::height)
@@ -188,7 +194,7 @@ PYBIND11_MODULE(pygeometry, m) {
                                 principal_point[1]);
           })
       .def_property_readonly("projection_type",
-                             (std::string(geometry::Camera::*)() const) &
+                             (std::string (geometry::Camera::*)() const) &
                                  geometry::Camera::GetProjectionString)
       .def_static("is_panorama",
                   [](const std::string& s) {
@@ -322,22 +328,28 @@ PYBIND11_MODULE(pygeometry, m) {
       .def("get_cam_to_world", &geometry::Pose::CameraToWorld)
       .def("get_world_to_cam", &geometry::Pose::WorldToCamera)
       // C++11
-      .def("set_from_world_to_cam", (void(geometry::Pose::*)(const Mat4d&)) &
-                                        geometry::Pose::SetFromWorldToCamera)
       .def("set_from_world_to_cam",
-           (void(geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
-               geometry::Pose::SetFromWorldToCamera)
-      .def("set_from_world_to_cam",
-           (void(geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
-               geometry::Pose::SetFromWorldToCamera)
-      .def("set_from_cam_to_world", (void(geometry::Pose::*)(const Mat4d&)) &
-                                        geometry::Pose::SetFromCameraToWorld)
-      .def("set_from_cam_to_world",
-           (void(geometry::Pose::*)(const Mat3d&, const Vec3d&)) &
-               geometry::Pose::SetFromCameraToWorld)
+           (void (geometry::Pose::*)(
+               const Mat4d&))&geometry::Pose::SetFromWorldToCamera)
+      .def(
+          "set_from_world_to_cam",
+          (void (geometry::Pose::*)(
+              const Mat3d&, const Vec3d&))&geometry::Pose::SetFromWorldToCamera)
+      .def(
+          "set_from_world_to_cam",
+          (void (geometry::Pose::*)(
+              const Vec3d&, const Vec3d&))&geometry::Pose::SetFromWorldToCamera)
       .def("set_from_cam_to_world",
-           (void(geometry::Pose::*)(const Vec3d&, const Vec3d&)) &
-               geometry::Pose::SetFromCameraToWorld)
+           (void (geometry::Pose::*)(
+               const Mat4d&))&geometry::Pose::SetFromCameraToWorld)
+      .def(
+          "set_from_cam_to_world",
+          (void (geometry::Pose::*)(
+              const Mat3d&, const Vec3d&))&geometry::Pose::SetFromCameraToWorld)
+      .def(
+          "set_from_cam_to_world",
+          (void (geometry::Pose::*)(
+              const Vec3d&, const Vec3d&))&geometry::Pose::SetFromCameraToWorld)
       .def("get_origin", &geometry::Pose::GetOrigin)
       .def("set_origin", &geometry::Pose::SetOrigin)
       .def("get_R_cam_to_world", &geometry::Pose::RotationCameraToWorld)
diff --git a/opensfm/src/geometry/src/absolute_pose.cc b/opensfm/src/geometry/src/absolute_pose.cc
index 116cbd9ca..9041139c7 100644
--- a/opensfm/src/geometry/src/absolute_pose.cc
+++ b/opensfm/src/geometry/src/absolute_pose.cc
@@ -2,7 +2,7 @@
 
 Eigen::Matrix3d RotationMatrixAroundAxis(const double cos_theta,
                                          const double sin_theta,
-                                         const Eigen::Vector3d &v) {
+                                         const Eigen::Vector3d& v) {
   Eigen::Matrix3d R;
   const auto one_minus_cos_theta = 1.0 - cos_theta;
   R(0, 0) = cos_theta + v[0] * v[0] * one_minus_cos_theta;
@@ -19,8 +19,8 @@ Eigen::Matrix3d RotationMatrixAroundAxis(const double cos_theta,
 
 namespace geometry {
 std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points) {
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points) {
   std::vector<std::pair<Eigen::Vector3d, Eigen::Vector3d>> samples(
       bearings.rows());
   for (int i = 0; i < bearings.rows(); ++i) {
@@ -31,8 +31,8 @@ std::vector<Eigen::Matrix<double, 3, 4>> AbsolutePoseThreePoints(
 }
 
 Eigen::Matrix<double, 3, 4> AbsolutePoseNPoints(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points) {
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points) {
   std::vector<std::pair<Eigen::Vector3d, Eigen::Vector3d>> samples(
       bearings.rows());
   for (int i = 0; i < bearings.rows(); ++i) {
@@ -43,8 +43,8 @@ Eigen::Matrix<double, 3, 4> AbsolutePoseNPoints(
 }
 
 Eigen::Vector3d AbsolutePoseNPointsKnownRotation(
-    const Eigen::Matrix<double, -1, 3> &bearings,
-    const Eigen::Matrix<double, -1, 3> &points) {
+    const Eigen::Matrix<double, -1, 3>& bearings,
+    const Eigen::Matrix<double, -1, 3>& points) {
   std::vector<std::pair<Eigen::Vector3d, Eigen::Vector3d>> samples(
       bearings.rows());
   for (int i = 0; i < bearings.rows(); ++i) {
diff --git a/opensfm/src/geometry/src/essential.cc b/opensfm/src/geometry/src/essential.cc
index 52c336f14..50c2dfa7e 100644
--- a/opensfm/src/geometry/src/essential.cc
+++ b/opensfm/src/geometry/src/essential.cc
@@ -1,8 +1,8 @@
 #include "../essential.h"
 
 // Multiply two polynomials of degree 1.
-Eigen::Matrix<double, -1, 1> o1(const Eigen::Matrix<double, -1, 1> &a,
-                                const Eigen::Matrix<double, -1, 1> &b) {
+Eigen::Matrix<double, -1, 1> o1(const Eigen::Matrix<double, -1, 1>& a,
+                                const Eigen::Matrix<double, -1, 1>& b) {
   Eigen::Matrix<double, -1, 1> res = Eigen::Matrix<double, -1, 1>::Zero(20);
 
   res(coef_xx) = a(coef_x) * b(coef_x);
@@ -20,8 +20,8 @@ Eigen::Matrix<double, -1, 1> o1(const Eigen::Matrix<double, -1, 1> &a,
 }
 
 // Multiply a polynomial of degree 2, a, by a polynomial of degree 1, b.
-Eigen::Matrix<double, -1, 1> o2(const Eigen::Matrix<double, -1, 1> &a,
-                                const Eigen::Matrix<double, -1, 1> &b) {
+Eigen::Matrix<double, -1, 1> o2(const Eigen::Matrix<double, -1, 1>& a,
+                                const Eigen::Matrix<double, -1, 1>& b) {
   Eigen::Matrix<double, -1, 1> res(20);
 
   res(coef_xxx) = a(coef_xx) * b(coef_x);
@@ -54,7 +54,7 @@ Eigen::Matrix<double, -1, 1> o2(const Eigen::Matrix<double, -1, 1> &a,
 
 // Builds the polynomial constraint matrix M.
 Eigen::MatrixXd FivePointsPolynomialConstraints(
-    const Eigen::MatrixXd &E_basis) {
+    const Eigen::MatrixXd& E_basis) {
   // Build the polynomial form of E (equation (8) in Stewenius et al. [1])
   Eigen::Matrix<double, -1, 1> E[3][3];
   for (int i = 0; i < 3; ++i) {
@@ -111,8 +111,8 @@ Eigen::MatrixXd FivePointsPolynomialConstraints(
 }
 
 // Gauss--Jordan elimination for the constraint matrix.
-bool FivePointsGaussJordan(Eigen::MatrixXd *Mp) {
-  Eigen::MatrixXd &M = *Mp;
+bool FivePointsGaussJordan(Eigen::MatrixXd* Mp) {
+  Eigen::MatrixXd& M = *Mp;
 
   // Gauss Elimination.
   for (int i = 0; i < 10; ++i) {
@@ -141,8 +141,8 @@ bool FivePointsGaussJordan(Eigen::MatrixXd *Mp) {
 
 namespace geometry {
 std::vector<Eigen::Matrix<double, 3, 3>> EssentialFivePoints(
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2) {
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2) {
   if ((x1.cols() != x2.cols()) || (x1.rows() != x2.rows())) {
     throw std::runtime_error("Features matrices have different sizes.");
   }
@@ -155,8 +155,8 @@ std::vector<Eigen::Matrix<double, 3, 3>> EssentialFivePoints(
 }
 
 std::vector<Eigen::Matrix<double, 3, 3>> EssentialNPoints(
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2) {
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2) {
   if ((x1.cols() != x2.cols()) || (x1.rows() != x2.rows())) {
     throw std::runtime_error("Features matrices have different sizes.");
   }
diff --git a/opensfm/src/geometry/src/relative_pose.cc b/opensfm/src/geometry/src/relative_pose.cc
index 2a7cf5bbd..00a7ef5da 100644
--- a/opensfm/src/geometry/src/relative_pose.cc
+++ b/opensfm/src/geometry/src/relative_pose.cc
@@ -3,8 +3,8 @@
 
 namespace geometry {
 Eigen::Matrix<double, 3, 4> RelativePoseFromEssential(
-    const Eigen::Matrix3d &essential, const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2) {
+    const Eigen::Matrix3d& essential, const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2) {
   if ((x1.cols() != x2.cols()) || (x1.rows() != x2.rows())) {
     throw std::runtime_error("Features matrices have different sizes.");
   }
@@ -17,8 +17,8 @@ Eigen::Matrix<double, 3, 4> RelativePoseFromEssential(
 }
 
 Eigen::Matrix3d RelativeRotationNPoints(
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2) {
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2) {
   if ((x1.cols() != x2.cols()) || (x1.rows() != x2.rows())) {
     throw std::runtime_error("Features matrices have different sizes.");
   }
@@ -31,9 +31,9 @@ Eigen::Matrix3d RelativeRotationNPoints(
 }
 
 Eigen::Matrix<double, 3, 4> RelativePoseRefinement(
-    const Eigen::Matrix<double, 3, 4> &relative_pose,
-    const Eigen::Matrix<double, -1, 3> &x1,
-    const Eigen::Matrix<double, -1, 3> &x2, int iterations) {
+    const Eigen::Matrix<double, 3, 4>& relative_pose,
+    const Eigen::Matrix<double, -1, 3>& x1,
+    const Eigen::Matrix<double, -1, 3>& x2, int iterations) {
   if ((x1.cols() != x2.cols()) || (x1.rows() != x2.rows())) {
     throw std::runtime_error("Features matrices have different sizes.");
   }
diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 65a22ead9..25568eaa0 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -13,21 +13,21 @@ namespace {
 struct BearingErrorCost : public ceres::CostFunction {
   constexpr static int Size = 3;
 
-  BearingErrorCost(const MatX3d &centers, const MatX3d &bearings,
-                   const Vec3d &point)
+  BearingErrorCost(const MatX3d& centers, const MatX3d& bearings,
+                   const Vec3d& point)
       : centers_(centers), bearings_(bearings), point_(point) {
     mutable_parameter_block_sizes()->push_back(Size);
     set_num_residuals(bearings_.rows() * 3);
   }
-  bool Evaluate(double const *const *parameters, double *residuals,
-                double **jacobians) const override {
-    const double *point = parameters[0];
+  bool Evaluate(double const* const* parameters, double* residuals,
+                double** jacobians) const override {
+    const double* point = parameters[0];
     for (int i = 0; i < bearings_.rows(); ++i) {
-      const Vec3d &center = centers_.row(i);
-      const Vec3d &bearing = bearings_.row(i);
+      const Vec3d& center = centers_.row(i);
+      const Vec3d& bearing = bearings_.row(i);
 
       /* Error only */
-      double *dummy = nullptr;
+      double* dummy = nullptr;
       double projected[] = {point[0] - center(0), point[1] - center(1),
                             point[2] - center(2)};
       if (!jacobians) {
@@ -37,7 +37,7 @@ struct BearingErrorCost : public ceres::CostFunction {
         double jacobian[JacobianSize];
         geometry::Normalize::ForwardDerivatives<double, true>(
             &projected[0], dummy, &projected[0], &jacobian[0]);
-        double *jac_point = jacobians[0];
+        double* jac_point = jacobians[0];
         if (jac_point) {
           for (int j = 0; j < Size; ++j) {
             for (int k = 0; k < Size; ++k) {
@@ -56,16 +56,16 @@ struct BearingErrorCost : public ceres::CostFunction {
     return true;
   }
 
-  const MatX3d &centers_;
-  const MatX3d &bearings_;
-  const Vec3d &point_;
+  const MatX3d& centers_;
+  const MatX3d& bearings_;
+  const Vec3d& point_;
 };
 
 }  // namespace
 
 namespace geometry {
 
-double AngleBetweenVectors(const Vec3d &u, const Vec3d &v) {
+double AngleBetweenVectors(const Vec3d& u, const Vec3d& v) {
   double c = (u.dot(v)) / std::sqrt(u.dot(u) * v.dot(v));
   if (std::fabs(c) >= 1.0) {
     return 0.0;
@@ -73,8 +73,8 @@ double AngleBetweenVectors(const Vec3d &u, const Vec3d &v) {
     return acos(c);
   }
 }
-std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
-                                              const MatX3d &bearings,
+std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d>& Rts,
+                                              const MatX3d& bearings,
                                               double threshold,
                                               double min_angle,
                                               double min_depth) {
@@ -82,7 +82,7 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
   MatXd world_bearings(count, 3);
   bool angle_ok = false;
   for (int i = 0; i < count && !angle_ok; ++i) {
-    const Mat34d &Rt = Rts[i];
+    const Mat34d& Rt = Rts[i];
     world_bearings.row(i) =
         Rt.block<3, 3>(0, 0).transpose() * bearings.row(i).transpose();
     for (int j = 0; j < i && !angle_ok; ++j) {
@@ -115,8 +115,8 @@ std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
   return std::make_pair(true, X.head<3>());
 }
 
-Vec4d TriangulateBearingsDLTSolve(const MatX3d &bearings,
-                                  const std::vector<Mat34d> &Rts) {
+Vec4d TriangulateBearingsDLTSolve(const MatX3d& bearings,
+                                  const std::vector<Mat34d>& Rts) {
   const int nviews = bearings.rows();
   assert(nviews == Rts.size());
 
@@ -139,8 +139,8 @@ Vec4d TriangulateBearingsDLTSolve(const MatX3d &bearings,
 }
 
 std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
-    const MatX3d &centers, const MatX3d &bearings,
-    const std::vector<double> &threshold_list, double min_angle,
+    const MatX3d& centers, const MatX3d& bearings,
+    const std::vector<double>& threshold_list, double min_angle,
     double min_depth) {
   const int count = centers.rows();
 
@@ -177,8 +177,8 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
 }
 
 std::vector<std::pair<bool, Vec3d>> TriangulateTwoBearingsMidpointMany(
-    const MatX3d &bearings1, const MatX3d &bearings2, const Mat3d &rotation,
-    const Vec3d &translation) {
+    const MatX3d& bearings1, const MatX3d& bearings2, const Mat3d& rotation,
+    const Vec3d& translation) {
   std::vector<std::pair<bool, Vec3d>> triangulated(bearings1.rows());
   Eigen::Matrix<double, 2, 3> os, bs;
   os.row(0) = Vec3d::Zero();
@@ -191,10 +191,10 @@ std::vector<std::pair<bool, Vec3d>> TriangulateTwoBearingsMidpointMany(
   return triangulated;
 }
 
-MatXd EpipolarAngleTwoBearingsMany(const MatX3d &bearings1,
-                                   const MatX3d &bearings2,
-                                   const Mat3d &rotation,
-                                   const Vec3d &translation) {
+MatXd EpipolarAngleTwoBearingsMany(const MatX3d& bearings1,
+                                   const MatX3d& bearings2,
+                                   const Mat3d& rotation,
+                                   const Vec3d& translation) {
   const auto translation_normalized = translation.normalized();
   const auto bearings2_world = bearings2 * rotation.transpose();
 
@@ -217,8 +217,8 @@ MatXd EpipolarAngleTwoBearingsMany(const MatX3d &bearings1,
   return M_PI / 2.0 - symmetric_epi.array().acos();
 }
 
-Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
-                      const Vec3d &point, int iterations) {
+Vec3d PointRefinement(const MatX3d& centers, const MatX3d& bearings,
+                      const Vec3d& point, int iterations) {
   using BearingCostFunction =
       ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, 3>;
   BearingErrorCost cost(centers, bearings, point);
diff --git a/opensfm/src/geometry/test/triangulation_test.cc b/opensfm/src/geometry/test/triangulation_test.cc
index 24dac9df3..50a0da8f9 100644
--- a/opensfm/src/geometry/test/triangulation_test.cc
+++ b/opensfm/src/geometry/test/triangulation_test.cc
@@ -4,7 +4,7 @@
 
 #include <Eigen/Dense>
 
-MatX3d generateNoisyBearings(const MatX3d &bearings, double maxNoise) {
+MatX3d generateNoisyBearings(const MatX3d& bearings, double maxNoise) {
   MatX3d bearings_noisy = MatX3d::Zero(bearings.rows(), 3);
   for (int i = 0; i < bearings.rows(); ++i) {
     const Vec3d bearing = bearings.row(i);
@@ -14,7 +14,7 @@ MatX3d generateNoisyBearings(const MatX3d &bearings, double maxNoise) {
   return bearings_noisy;
 }
 
-std::vector<Mat34d> generateRts(const MatX3d &centers) {
+std::vector<Mat34d> generateRts(const MatX3d& centers) {
   const int num_cameras = centers.rows();
   std::vector<Mat34d> Rts(num_cameras);
   for (int i = 0; i < num_cameras; ++i) {
@@ -26,9 +26,9 @@ std::vector<Mat34d> generateRts(const MatX3d &centers) {
   return Rts;
 }
 
-void generate_triangulation_data(const MatX3d &centers, MatX3d &bearings,
-                                 MatX3d &bearings_noisy,
-                                 std::vector<Mat34d> &Rts, Vec3d &gt_point) {
+void generate_triangulation_data(const MatX3d& centers, MatX3d& bearings,
+                                 MatX3d& bearings_noisy,
+                                 std::vector<Mat34d>& Rts, Vec3d& gt_point) {
   const int num_cameras = centers.rows();
 
   gt_point = Vec3d(0.0, 0.0, 1.0);
@@ -166,7 +166,7 @@ class TwoCamsManyPointsFixture : public ::testing::Test {
     bearings1 = MatX3d(gt_points.size(), 3);
     bearings2 = MatX3d(gt_points.size(), 3);
     for (int i = 0; i < gt_points.size(); ++i) {
-      const Vec3d &gt_point = gt_points[i];
+      const Vec3d& gt_point = gt_points[i];
       bearings1.row(i) = gt_point.normalized();
       bearings2.row(i) =
           (rotation_1_2.transpose() * (gt_point - translation_1_2))
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index fcbbd2e9a..a97ae6a17 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -9,43 +9,43 @@
 
 namespace geometry {
 
-double AngleBetweenVectors(const Vec3d &u, const Vec3d &v);
+double AngleBetweenVectors(const Vec3d& u, const Vec3d& v);
 
-std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d> &Rts,
-                                              const MatX3d &bearings,
+std::pair<bool, Vec3d> TriangulateBearingsDLT(const std::vector<Mat34d>& Rts,
+                                              const MatX3d& bearings,
                                               double threshold,
                                               double min_angle,
                                               double min_depth);
 
-Vec4d TriangulateBearingsDLTSolve(const MatX3d &bs,
-                                  const std::vector<Mat34d> &Rts);
+Vec4d TriangulateBearingsDLTSolve(const MatX3d& bs,
+                                  const std::vector<Mat34d>& Rts);
 
 std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
-    const MatX3d &centers, const MatX3d &bearings,
-    const std::vector<double> &threshold_list, double min_angle,
+    const MatX3d& centers, const MatX3d& bearings,
+    const std::vector<double>& threshold_list, double min_angle,
     double min_depth);
 
 template <class T>
 Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
-    const Eigen::Matrix<T, Eigen::Dynamic, 3> &centers,
-    const Eigen::Matrix<T, Eigen::Dynamic, 3> &bearings);
+    const Eigen::Matrix<T, Eigen::Dynamic, 3>& centers,
+    const Eigen::Matrix<T, Eigen::Dynamic, 3>& bearings);
 
 std::vector<std::pair<bool, Vec3d>> TriangulateTwoBearingsMidpointMany(
-    const MatX3d &bearings1, const MatX3d &bearings2, const Mat3d &rotation,
-    const Vec3d &translation);
+    const MatX3d& bearings1, const MatX3d& bearings2, const Mat3d& rotation,
+    const Vec3d& translation);
 
 template <class T>
 std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
-    const Eigen::Matrix<T, 2, 3> &centers,
-    const Eigen::Matrix<T, 2, 3> &bearings);
+    const Eigen::Matrix<T, 2, 3>& centers,
+    const Eigen::Matrix<T, 2, 3>& bearings);
 
-MatXd EpipolarAngleTwoBearingsMany(const MatX3d &bearings1,
-                                   const MatX3d &bearings2,
-                                   const Mat3d &rotation,
-                                   const Vec3d &translation);
+MatXd EpipolarAngleTwoBearingsMany(const MatX3d& bearings1,
+                                   const MatX3d& bearings2,
+                                   const Mat3d& rotation,
+                                   const Vec3d& translation);
 
-Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
-                      const Vec3d &point, int iterations);
+Vec3d PointRefinement(const MatX3d& centers, const MatX3d& bearings,
+                      const Vec3d& point, int iterations);
 
 // Template implementations
 
@@ -56,8 +56,8 @@ Vec3d PointRefinement(const MatX3d &centers, const MatX3d &bearings,
 //   CVIU 2006
 template <class T>
 Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
-    const Eigen::Matrix<T, Eigen::Dynamic, 3> &centers,
-    const Eigen::Matrix<T, Eigen::Dynamic, 3> &bearings) {
+    const Eigen::Matrix<T, Eigen::Dynamic, 3>& centers,
+    const Eigen::Matrix<T, Eigen::Dynamic, 3>& bearings) {
   int nviews = bearings.rows();
   assert(nviews == centers.rows());
   assert(nviews >= 2);
@@ -82,8 +82,8 @@ Eigen::Matrix<T, 3, 1> TriangulateBearingsMidpointSolve(
 
 template <class T>
 std::pair<bool, Eigen::Matrix<T, 3, 1>> TriangulateTwoBearingsMidpointSolve(
-    const Eigen::Matrix<T, 2, 3> &centers,
-    const Eigen::Matrix<T, 2, 3> &bearings) {
+    const Eigen::Matrix<T, 2, 3>& centers,
+    const Eigen::Matrix<T, 2, 3>& bearings) {
   const auto translation = centers.row(1) - centers.row(0);
   Eigen::Matrix<T, 2, 1> b;
   b[0] = translation.dot(bearings.row(0));
diff --git a/opensfm/src/map/pybind_utils.h b/opensfm/src/map/pybind_utils.h
index 77a823df0..3667baa05 100644
--- a/opensfm/src/map/pybind_utils.h
+++ b/opensfm/src/map/pybind_utils.h
@@ -19,15 +19,14 @@ PYBIND11_NAMESPACE_BEGIN_(detail)
 // See https://github.com/pybind/pybind11/issues/637
 
 using ListCasterBase =
-    pybind11::detail::list_caster<std::vector<map::Landmark *>,
-                                  map::Landmark *>;
+    pybind11::detail::list_caster<std::vector<map::Landmark*>, map::Landmark*>;
 template <>
-struct type_caster<std::vector<map::Landmark *>> : ListCasterBase {
-  static handle cast(const std::vector<map::Landmark *> &src,
+struct type_caster<std::vector<map::Landmark*>> : ListCasterBase {
+  static handle cast(const std::vector<map::Landmark*>& src,
                      return_value_policy, handle parent) {
     return ListCasterBase::cast(src, return_value_policy::reference, parent);
   }
-  static handle cast(const std::vector<map::Landmark *> *src,
+  static handle cast(const std::vector<map::Landmark*>* src,
                      return_value_policy pol, handle parent) {
     return cast(*src, pol, parent);
   }
@@ -56,16 +55,16 @@ template <return_value_policy Policy = return_value_policy::reference_internal,
           typename KeyType = decltype(&((*std::declval<Iterator>()).second)),
           typename... Extra>
 iterator make_ref_value_iterator(Iterator first, Sentinel last,
-                                 Extra &&...extra) {
+                                 Extra&&... extra) {
   using state = detail::sfm_iterator_state<Iterator, Sentinel,
                                            detail::RefValueIterator, Policy>;
 
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_value_iterator", pybind11::module_local())
-        .def("__iter__", [](state &s) -> state & { return s; })
+        .def("__iter__", [](state& s) -> state& { return s; })
         .def(
             "__next__",
-            [](state &s) -> KeyType {
+            [](state& s) -> KeyType {
               if (!s.first_or_done) {
                 ++s.it;
               } else {
@@ -89,16 +88,16 @@ template <
     typename KeyType =
         pybind11::tuple,  // decltype(&((*std::declval<Iterator>()).second)),
     typename... Extra>
-iterator make_ref_iterator(Iterator first, Sentinel last, Extra &&...extra) {
+iterator make_ref_iterator(Iterator first, Sentinel last, Extra&&... extra) {
   using state = detail::sfm_iterator_state<Iterator, Sentinel,
                                            detail::ValueIterator, Policy>;
 
   if (!detail::get_type_info(typeid(state), false)) {
     class_<state>(handle(), "ref_iterator", pybind11::module_local())
-        .def("__iter__", [](state &s) -> state & { return s; })
+        .def("__iter__", [](state& s) -> state& { return s; })
         .def(
             "__next__",
-            [](state &s) -> KeyType {
+            [](state& s) -> KeyType {
               if (!s.first_or_done) {
                 ++s.it;
               } else {
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index 13ecad21c..8307b7001 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -20,7 +20,7 @@
 namespace py = pybind11;
 
 template <typename T>
-void DeclareShotMeasurement(py::module &m, const std::string &type_name) {
+void DeclareShotMeasurement(py::module& m, const std::string& type_name) {
   using SM = foundation::OptionalValue<T>;
 
   std::string class_name = std::string("ShotMeasurement") + type_name;
@@ -32,7 +32,7 @@ void DeclareShotMeasurement(py::module &m, const std::string &type_name) {
                     &SM::SetValue)
       .def("reset", &SM::Reset)
       .def(py::pickle(
-          [](const SM &sm) {
+          [](const SM& sm) {
             return py::make_tuple(sm.HasValue(), sm.Value());
           },
           [](py::tuple p) {
@@ -89,14 +89,14 @@ PYBIND11_MODULE(pymap, m) {
                            &map::Observation::NO_SEMANTIC_VALUE)
       .def(
           "copy",
-          [](const map::Observation &to_copy) {
+          [](const map::Observation& to_copy) {
             map::Observation copy = to_copy;
             return copy;
           },
           py::return_value_policy::copy);
 
   py::class_<map::Landmark>(m, "Landmark")
-      .def(py::init<const map::LandmarkId &, const Vec3d &>())
+      .def(py::init<const map::LandmarkId&, const Vec3d&>())
       .def_readonly("id", &map::Landmark::id_)
       .def_property("coordinates", &map::Landmark::GetGlobalPos,
                     &map::Landmark::SetGlobalPos)
@@ -125,7 +125,7 @@ PYBIND11_MODULE(pymap, m) {
       .def_property("attributes", &map::ShotMeasurements::GetAttributes,
                     &map::ShotMeasurements::SetAttributes)
       .def(py::pickle(
-          [](const map::ShotMeasurements &s) {
+          [](const map::ShotMeasurements& s) {
             return py::make_tuple(
                 s.gps_accuracy_, s.gps_position_, s.orientation_,
                 s.capture_time_, s.gravity_down_, s.compass_angle_,
@@ -149,7 +149,7 @@ PYBIND11_MODULE(pymap, m) {
           }))
       .def(
           "__copy__",
-          [](const map::ShotMeasurements &to_copy) {
+          [](const map::ShotMeasurements& to_copy) {
             map::ShotMeasurements copy;
             copy.Set(to_copy);
             return copy;
@@ -165,12 +165,12 @@ PYBIND11_MODULE(pymap, m) {
 
   py::class_<map::RigCamera>(m, "RigCamera")
       .def(py::init<>())
-      .def(py::init<const geometry::Pose &, const map::RigCameraId &>())
+      .def(py::init<const geometry::Pose&, const map::RigCameraId&>())
       .def_readwrite("id", &map::RigCamera::id)
       .def_readwrite("pose", &map::RigCamera::pose)
       // pickle support
       .def(py::pickle(
-          [](const map::RigCamera &rc) {
+          [](const map::RigCamera& rc) {
             return py::make_tuple(rc.pose, rc.id);
           },
           [](py::tuple s) {
@@ -189,17 +189,17 @@ PYBIND11_MODULE(pymap, m) {
           py::return_value_policy::reference_internal)
       .def_property_readonly(
           "rig_camera_ids",
-          [](const map::RigInstance &ri) {
+          [](const map::RigInstance& ri) {
             std::map<map::ShotId, map::RigCameraId> rig_camera_ids;
-            for (const auto &rig_camera : ri.GetRigCameras()) {
+            for (const auto& rig_camera : ri.GetRigCameras()) {
               rig_camera_ids[rig_camera.first] = rig_camera.second->id;
             }
             return rig_camera_ids;
           })
       .def_property_readonly("camera_ids",
-                             [](const map::RigInstance &ri) {
+                             [](const map::RigInstance& ri) {
                                std::map<map::ShotId, map::CameraId> camera_ids;
-                               for (const auto &shot : ri.GetShots()) {
+                               for (const auto& shot : ri.GetShots()) {
                                  camera_ids[shot.first] =
                                      shot.second->GetCamera()->id;
                                }
@@ -216,8 +216,8 @@ PYBIND11_MODULE(pymap, m) {
       .def("update_rig_camera_pose", &map::RigInstance::UpdateRigCameraPose);
 
   shotCls
-      .def(py::init<const map::ShotId &, const geometry::Camera &,
-                    const geometry::Pose &>())
+      .def(py::init<const map::ShotId&, const geometry::Camera&,
+                    const geometry::Pose&>())
       .def_readonly("id", &map::Shot::id_)
       .def_readwrite("mesh", &map::Shot::mesh)
       .def_property("covariance", &map::Shot::GetCovariance,
@@ -254,7 +254,7 @@ PYBIND11_MODULE(pymap, m) {
   py::class_<map::GroundControlPointObservation>(
       m, "GroundControlPointObservation")
       .def(py::init())
-      .def(py::init<const map::ShotId &, const Vec2d &>())
+      .def(py::init<const map::ShotId&, const Vec2d&>())
       .def_readwrite("shot_id", &map::GroundControlPointObservation::shot_id_)
       .def_readwrite("uid", &map::GroundControlPointObservation::uid_)
       .def_readwrite("projection",
@@ -312,34 +312,34 @@ PYBIND11_MODULE(pymap, m) {
            py::call_guard<py::gil_scoped_release>());
 
   py::class_<map::PanoShotView>(m, "PanoShotView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::PanoShotView::NumberOfShots)
       .def(
           "items",
-          [](const map::PanoShotView &sv) {
-            auto &shots = sv.GetShots();
+          [](const map::PanoShotView& sv) {
+            auto& shots = sv.GetShots();
             return py::make_ref_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](const map::PanoShotView &sv) {
-            auto &shots = sv.GetShots();
+          [](const map::PanoShotView& sv) {
+            auto& shots = sv.GetShots();
             return py::make_ref_value_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::PanoShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::PanoShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_key_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::PanoShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::PanoShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_key_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -350,34 +350,34 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::PanoShotView::HasShot);
 
   py::class_<map::ShotView>(m, "ShotView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::ShotView::NumberOfShots)
       .def(
           "items",
-          [](const map::ShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::ShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_ref_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](const map::ShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::ShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_ref_value_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::ShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::ShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_key_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::ShotView &sv) {
-            const auto &shots = sv.GetShots();
+          [](const map::ShotView& sv) {
+            const auto& shots = sv.GetShots();
             return py::make_key_iterator(shots.begin(), shots.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -388,34 +388,34 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::ShotView::HasShot);
 
   py::class_<map::LandmarkView>(m, "LandmarkView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::LandmarkView::NumberOfLandmarks)
       .def(
           "items",
-          [](const map::LandmarkView &sv) {
-            auto &lms = sv.GetLandmarks();
+          [](const map::LandmarkView& sv) {
+            auto& lms = sv.GetLandmarks();
             return py::make_ref_iterator(lms.begin(), lms.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](const map::LandmarkView &sv) {
-            auto &lms = sv.GetLandmarks();
+          [](const map::LandmarkView& sv) {
+            auto& lms = sv.GetLandmarks();
             return py::make_ref_value_iterator(lms.begin(), lms.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::LandmarkView &sv) {
-            const auto &lms = sv.GetLandmarks();
+          [](const map::LandmarkView& sv) {
+            const auto& lms = sv.GetLandmarks();
             return py::make_key_iterator(lms.begin(), lms.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::LandmarkView &sv) {
-            const auto &lms = sv.GetLandmarks();
+          [](const map::LandmarkView& sv) {
+            const auto& lms = sv.GetLandmarks();
             return py::make_key_iterator(lms.begin(), lms.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -426,34 +426,34 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::LandmarkView::HasLandmark);
 
   py::class_<map::CameraView>(m, "CameraView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::CameraView::NumberOfCameras)
       .def(
           "items",
-          [](const map::CameraView &sv) {
-            const auto &cams = sv.GetCameras();
+          [](const map::CameraView& sv) {
+            const auto& cams = sv.GetCameras();
             return py::make_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](map::CameraView &sv) {
-            auto &cams = sv.GetCameras();
+          [](map::CameraView& sv) {
+            auto& cams = sv.GetCameras();
             return py::make_ref_value_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::CameraView &sv) {
-            const auto &cams = sv.GetCameras();
+          [](const map::CameraView& sv) {
+            const auto& cams = sv.GetCameras();
             return py::make_key_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::CameraView &sv) {
-            const auto &cams = sv.GetCameras();
+          [](const map::CameraView& sv) {
+            const auto& cams = sv.GetCameras();
             return py::make_key_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -464,34 +464,34 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::CameraView::HasCamera);
 
   py::class_<map::BiasView>(m, "BiasView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::BiasView::NumberOfBiases)
       .def(
           "items",
-          [](const map::BiasView &sv) {
-            const auto &biases = sv.GetBiases();
+          [](const map::BiasView& sv) {
+            const auto& biases = sv.GetBiases();
             return py::make_iterator(biases.begin(), biases.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](map::BiasView &sv) {
-            auto &biases = sv.GetBiases();
+          [](map::BiasView& sv) {
+            auto& biases = sv.GetBiases();
             return py::make_ref_value_iterator(biases.begin(), biases.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::BiasView &sv) {
-            const auto &biases = sv.GetBiases();
+          [](const map::BiasView& sv) {
+            const auto& biases = sv.GetBiases();
             return py::make_key_iterator(biases.begin(), biases.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::BiasView &sv) {
-            const auto &biases = sv.GetBiases();
+          [](const map::BiasView& sv) {
+            const auto& biases = sv.GetBiases();
             return py::make_key_iterator(biases.begin(), biases.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -502,34 +502,34 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::BiasView::HasBias);
 
   py::class_<map::RigCameraView>(m, "RigCameraView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::RigCameraView::NumberOfRigCameras)
       .def(
           "items",
-          [](const map::RigCameraView &sv) {
-            const auto &cams = sv.GetRigCameras();
+          [](const map::RigCameraView& sv) {
+            const auto& cams = sv.GetRigCameras();
             return py::make_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](map::RigCameraView &sv) {
-            auto &cams = sv.GetRigCameras();
+          [](map::RigCameraView& sv) {
+            auto& cams = sv.GetRigCameras();
             return py::make_ref_value_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::RigCameraView &sv) {
-            const auto &cams = sv.GetRigCameras();
+          [](const map::RigCameraView& sv) {
+            const auto& cams = sv.GetRigCameras();
             return py::make_key_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::RigCameraView &sv) {
-            const auto &cams = sv.GetRigCameras();
+          [](const map::RigCameraView& sv) {
+            const auto& cams = sv.GetRigCameras();
             return py::make_key_iterator(cams.begin(), cams.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -540,35 +540,35 @@ PYBIND11_MODULE(pymap, m) {
       .def("__contains__", &map::RigCameraView::HasRigCamera);
 
   py::class_<map::RigInstanceView>(m, "RigInstanceView")
-      .def(py::init<map::Map &>(),
+      .def(py::init<map::Map&>(),
            py::keep_alive<1, 2>())  // Keep map alive while view is used
       .def("__len__", &map::RigInstanceView::NumberOfRigInstances)
       .def(
           "items",
-          [](const map::RigInstanceView &sv) {
-            const auto &instances = sv.GetRigInstances();
+          [](const map::RigInstanceView& sv) {
+            const auto& instances = sv.GetRigInstances();
             return py::make_iterator(instances.begin(), instances.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "values",
-          [](map::RigInstanceView &sv) {
-            auto &instances = sv.GetRigInstances();
+          [](map::RigInstanceView& sv) {
+            auto& instances = sv.GetRigInstances();
             return py::make_ref_value_iterator(instances.begin(),
                                                instances.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "__iter__",
-          [](const map::RigInstanceView &sv) {
-            const auto &instances = sv.GetRigInstances();
+          [](const map::RigInstanceView& sv) {
+            const auto& instances = sv.GetRigInstances();
             return py::make_iterator(instances.begin(), instances.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
       .def(
           "keys",
-          [](const map::RigInstanceView &sv) {
-            const auto &instances = sv.GetRigInstances();
+          [](const map::RigInstanceView& sv) {
+            const auto& instances = sv.GetRigInstances();
             return py::make_key_iterator(instances.begin(), instances.end());
           },
           py::keep_alive<0, 1>())  // Keep view alive while iterator is used
@@ -586,7 +586,7 @@ PYBIND11_MODULE(pymap, m) {
       .def("create_camera", &map::Map::CreateCamera, py::arg("camera"),
            py::return_value_policy::reference_internal)
       .def("get_camera",
-           py::overload_cast<const map::CameraId &>(&map::Map::GetCamera),
+           py::overload_cast<const map::CameraId&>(&map::Map::GetCamera),
            py::return_value_policy::reference_internal)
       // Bias
       .def("set_bias", &map::Map::SetBias,
@@ -605,34 +605,35 @@ PYBIND11_MODULE(pymap, m) {
       .def("create_landmark", &map::Map::CreateLandmark, py::arg("lm_id"),
            py::arg("global_position"),
            py::return_value_policy::reference_internal)
-      .def("remove_landmark", (void(map::Map::*)(const map::Landmark *const)) &
-                                  map::Map::RemoveLandmark)
-      .def("remove_landmark", (void(map::Map::*)(const map::LandmarkId &)) &
-                                  map::Map::RemoveLandmark)
+      .def("remove_landmark",
+           (void (map::Map::*)(
+               const map::Landmark* const))&map::Map::RemoveLandmark)
+      .def(
+          "remove_landmark",
+          (void (map::Map::*)(const map::LandmarkId&))&map::Map::RemoveLandmark)
       .def("has_landmark", &map::Map::HasLandmark)
       .def("get_landmark",
-           py::overload_cast<const map::LandmarkId &>(&map::Map::GetLandmark),
+           py::overload_cast<const map::LandmarkId&>(&map::Map::GetLandmark),
            py::return_value_policy::reference_internal)
       .def("clear_observations_and_landmarks",
            &map::Map::ClearObservationsAndLandmarks)
       .def("clean_landmarks_below_min_observations",
            &map::Map::CleanLandmarksBelowMinObservations)
       // Shot
+      .def("create_shot",
+           py::overload_cast<const map::ShotId&, const map::CameraId&,
+                             const map::RigCameraId&, const map::RigInstanceId&,
+                             const geometry::Pose&>(&map::Map::CreateShot),
+           py::return_value_policy::reference_internal)
       .def(
           "create_shot",
-          py::overload_cast<const map::ShotId &, const map::CameraId &,
-                            const map::RigCameraId &,
-                            const map::RigInstanceId &, const geometry::Pose &>(
+          py::overload_cast<const map::ShotId&, const map::CameraId&,
+                            const map::RigCameraId&, const map::RigInstanceId&>(
               &map::Map::CreateShot),
           py::return_value_policy::reference_internal)
-      .def("create_shot",
-           py::overload_cast<const map::ShotId &, const map::CameraId &,
-                             const map::RigCameraId &,
-                             const map::RigInstanceId &>(&map::Map::CreateShot),
-           py::return_value_policy::reference_internal)
       .def("remove_shot", &map::Map::RemoveShot)
       .def("get_shot",
-           py::overload_cast<const map::ShotId &>(&map::Map::GetShot),
+           py::overload_cast<const map::ShotId&>(&map::Map::GetShot),
            py::return_value_policy::reference_internal)
       .def("update_shot", &map::Map::UpdateShot,
            py::return_value_policy::reference_internal)
@@ -641,24 +642,25 @@ PYBIND11_MODULE(pymap, m) {
            py::return_value_policy::reference_internal)
       .def("remove_pano_shot", &map::Map::RemovePanoShot)
       .def("get_pano_shot",
-           py::overload_cast<const map::ShotId &>(&map::Map::GetPanoShot),
+           py::overload_cast<const map::ShotId&>(&map::Map::GetPanoShot),
            py::return_value_policy::reference_internal)
       .def("update_pano_shot", &map::Map::UpdatePanoShot,
            py::return_value_policy::reference_internal)
       // Observation
       .def("add_observation",
-           (void(map::Map::*)(map::Shot *const, map::Landmark *const,
-                              const map::Observation &)) &
-               map::Map::AddObservation,
+           (void (map::Map::*)(
+               map::Shot* const, map::Landmark* const,
+               const map::Observation&))&map::Map::AddObservation,
            py::arg("shot"), py::arg("landmark"), py::arg("observation"))
       .def("add_observation",
-           (void(map::Map::*)(const map::ShotId &, const map::LandmarkId &,
-                              const map::Observation &)) &
-               map::Map::AddObservation,
+           (void (map::Map::*)(
+               const map::ShotId&, const map::LandmarkId&,
+               const map::Observation&))&map::Map::AddObservation,
            py::arg("shot_Id"), py::arg("landmark_id"), py::arg("observation"))
       .def("remove_observation",
-           (void(map::Map::*)(const map::ShotId &, const map::LandmarkId &)) &
-               map::Map::RemoveObservation,
+           (void (map::Map::*)(
+               const map::ShotId&,
+               const map::LandmarkId&))&map::Map::RemoveObservation,
            py::arg("shot"), py::arg("landmark"))
       // Getters
       .def("get_shots", &map::Map::GetShotView)
@@ -671,7 +673,7 @@ PYBIND11_MODULE(pymap, m) {
       .def("set_reference", &map::Map::SetTopocentricConverter)
       // Reference
       .def("get_reference",
-           [](const map::Map &map) {
+           [](const map::Map& map) {
              py::module::import("opensfm.pygeo");
              return map.GetTopocentricConverter();
            })
diff --git a/opensfm/src/testing_main.cc b/opensfm/src/testing_main.cc
index c5bfdd004..33a5e122c 100644
--- a/opensfm/src/testing_main.cc
+++ b/opensfm/src/testing_main.cc
@@ -2,7 +2,7 @@
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
   google::InitGoogleLogging(argv[0]);

From 2ef1e0300f9848f3c9d2d9202a10663c5955f6fb Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Mon, 27 Oct 2025 11:35:02 -0700
Subject: [PATCH 184/235] fbcode/mapillary/opensfm/opensfm

Reviewed By: nlutsenko

Differential Revision: D85329203

fbshipit-source-id: 19238d9a2b8b85447401de296eccd918da88d91d
---
 opensfm/dataset_base.py    | 1 -
 opensfm/mesh.py            | 2 +-
 opensfm/transformations.py | 1 -
 3 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index e9c2adc9e..b95db70c3 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -3,7 +3,6 @@
 from abc import ABC, abstractmethod
 from typing import Any, BinaryIO, Dict, List, Optional, Tuple
 
-import numpy as np
 from numpy.typing import NDArray
 from opensfm import features, geo, io, pygeometry, pymap, types
 
diff --git a/opensfm/mesh.py b/opensfm/mesh.py
index 42f77f05f..52e6eb00d 100644
--- a/opensfm/mesh.py
+++ b/opensfm/mesh.py
@@ -1,7 +1,7 @@
 # pyre-strict
 import itertools
 import logging
-from typing import Any, List, Tuple
+from typing import List, Tuple
 
 import numpy as np
 import scipy.spatial
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index a1bf7b876..dfa59ed29 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -1927,7 +1927,6 @@ def _import_module(
 
 if __name__ == "__main__":
     import doctest
-    import random  # used in doctests
 
     numpy.set_printoptions(suppress=True, precision=5)
     doctest.testmod()

From 574c6f779de61c4e8a7da270f03278e14da8e04b Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Wed, 29 Oct 2025 12:52:07 -0700
Subject: [PATCH 185/235] fbcode/mapillary/opensfm/opensfm/test/large

Differential Revision: D85759019

fbshipit-source-id: 90a18bd5b61a1f9b161f2aa08ae7c7b681b8769d
---
 opensfm/test/large/test_tools.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/opensfm/test/large/test_tools.py b/opensfm/test/large/test_tools.py
index d7cc370b5..f5da01409 100644
--- a/opensfm/test/large/test_tools.py
+++ b/opensfm/test/large/test_tools.py
@@ -1,4 +1,3 @@
-import numpy as np
 from opensfm.large import tools
 
 

From faf1d46db00cdccb4beffc2cac4a45fc9c340feb Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Fri, 31 Oct 2025 05:24:41 -0700
Subject: [PATCH 186/235] Fix CQS signal clang-diagnostic-shadow in
 fbcode/mapillary/opensfm

Differential Revision: D85426041

fbshipit-source-id: 3f8f196049c2e98fd27fa5e5e86f223487601b01
---
 opensfm/src/geometry/test/covariance_test.cc | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/opensfm/src/geometry/test/covariance_test.cc b/opensfm/src/geometry/test/covariance_test.cc
index d551bcda0..95519b91b 100644
--- a/opensfm/src/geometry/test/covariance_test.cc
+++ b/opensfm/src/geometry/test/covariance_test.cc
@@ -22,23 +22,22 @@ class CovarianceFixture : public ::testing::Test {
     observation << 0.0, 0.0;
   }
 
-  void RunAutodiffEval(const geometry::Camera& camera,
-                       const geometry::Pose& pose) {
+  void RunAutodiffEval(const geometry::Camera& cam, const geometry::Pose& p) {
     // Prepare Eigen's Autodiff structures
     for (int i = 0; i < 3; ++i) {
       point_adiff[i].derivatives() = VecXd::Unit(3, i);
     }
 
     VecX<AScalar> pose_adiff(6);
-    pose_adiff.segment<3>(3) = pose.TranslationCameraToWorld();
-    pose_adiff.segment<3>(0) = pose.RotationCameraToWorldMin();
+    pose_adiff.segment<3>(3) = p.TranslationCameraToWorld();
+    pose_adiff.segment<3>(0) = p.RotationCameraToWorldMin();
     for (int i = 0; i < 6; ++i) {
       pose_adiff(i).derivatives().resize(3);
       pose_adiff(i).derivatives().setZero();
     }
 
     VecX<AScalar> camera_adiff(3);
-    const VecXd camera_params = camera.GetParametersValues();
+    const VecXd camera_params = cam.GetParametersValues();
     for (int i = 0; i < camera_params.size(); ++i) {
       camera_adiff(i).value() = camera_params(i);
       camera_adiff(i).derivatives().resize(3);
@@ -50,7 +49,7 @@ class CovarianceFixture : public ::testing::Test {
     geometry::PoseFunctor::Forward(point_adiff, pose_adiff.data(),
                                    &transformed[0]);
     geometry::Dispatch<geometry::ProjectFunction>(
-        camera.GetProjectionType(), transformed, camera_adiff.data(),
+        cam.GetProjectionType(), transformed, camera_adiff.data(),
         projection_expected);
   }
 

From 655d75c8723b677b26c7750f6f19c7b02973858a Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Mon, 3 Nov 2025 04:07:17 -0800
Subject: [PATCH 187/235] Use pyproject.toml for building (#1112)

Summary:
Add `pyproject.toml` making it possible to build the library via `pip install -e .`

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1112

Reviewed By: DodgySpaniard

Differential Revision: D86073943

Pulled By: paulinus

fbshipit-source-id: 351fb4971c9c40376a4c26c99f0559bcb06e6ee7
---
 .dockerignore                         |   2 +-
 .github/workflows/conda.yml           |   4 +-
 .github/workflows/docker_ubuntu24.yml |   4 +-
 .gitignore                            |   2 +
 Dockerfile.ubuntu24                   |  33 +-------
 conda.yml                             |  20 -----
 doc/Makefile                          |  33 ++++++++
 doc/source/annotation_tool.rst        |   8 +-
 doc/source/building.rst               |  67 +++++++++++-----
 doc/source/conf.py                    |   4 +-
 doc/source/gcp.rst                    |   2 -
 doc/source/quality_report.rst         |  10 +--
 doc/source/rig.rst                    |  22 +++---
 doc/source/sensor_database.rst        |   8 +-
 doc/source/using.rst                  |   4 +-
 export_pmvs.md                        | 106 -------------------------
 opensfm/dataset.py                    |  10 ++-
 opensfm/exif.py                       |   2 +-
 opensfm/src/CMakeLists.txt            |  47 ++++++++---
 opensfm/src/bundle/CMakeLists.txt     |   1 +
 opensfm/src/cmake/FindGlog.cmake      |  10 +++
 opensfm/src/dense/CMakeLists.txt      |   1 +
 opensfm/src/features/CMakeLists.txt   |   1 +
 opensfm/src/foundation/CMakeLists.txt |   2 +-
 opensfm/src/geo/CMakeLists.txt        |   1 +
 opensfm/src/geometry/CMakeLists.txt   |   1 +
 opensfm/src/geometry/triangulation.h  |   1 +
 opensfm/src/map/CMakeLists.txt        |   1 +
 opensfm/src/robust/CMakeLists.txt     |   1 +
 opensfm/src/sfm/CMakeLists.txt        |   1 +
 opensfm/transformations.py            |  34 ++++----
 pyproject.toml                        | 107 ++++++++++++++++++++++++++
 requirements.txt                      |  19 -----
 33 files changed, 311 insertions(+), 258 deletions(-)
 create mode 100644 doc/Makefile
 delete mode 100644 export_pmvs.md
 create mode 100644 pyproject.toml
 delete mode 100644 requirements.txt

diff --git a/.dockerignore b/.dockerignore
index 83f5d8131..f25ca6e52 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -11,8 +11,8 @@
 !doc
 !LICENSE
 !opensfm
+!pyproject.toml
 !README.md
-!requirements.txt
 !setup.cfg
 !setup.py
 !viewer
diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
index 1f9161e21..1dc394936 100644
--- a/.github/workflows/conda.yml
+++ b/.github/workflows/conda.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
@@ -26,7 +26,7 @@ jobs:
 
       - name: Build OpenSfM
         shell: bash -l {0}
-        run: python setup.py build
+        run: pip install -e .[test]
 
       - name: Run C++ tests
         shell: bash -l {0}
diff --git a/.github/workflows/docker_ubuntu24.yml b/.github/workflows/docker_ubuntu24.yml
index 85cbf5ba4..5ae9c70b0 100644
--- a/.github/workflows/docker_ubuntu24.yml
+++ b/.github/workflows/docker_ubuntu24.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu24 --tag mapillary/opensfm.ubuntu24:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "cd cmake_build && ctest --output-on-failure"
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA python3 -m pytest
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA python -m pytest -v
diff --git a/.gitignore b/.gitignore
index 8843455c0..ea19cfda8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,8 @@ xcode
 launch.json
 .vscode
 .idea
+.claude
+uv.lock
 
 # Ignore generated files
 /build
diff --git a/Dockerfile.ubuntu24 b/Dockerfile.ubuntu24
index 91d7fd7ff..6e4cb8ee2 100644
--- a/Dockerfile.ubuntu24
+++ b/Dockerfile.ubuntu24
@@ -11,14 +11,8 @@ RUN apt-get update \
         libopencv-dev \
         libceres-dev \
         python3-dev \
-        python3-numpy \
-        python3-opencv \
         python3-pip \
         python3-venv \
-        python3-pyproj \
-        python3-scipy \
-        python3-yaml \
-        curl \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
@@ -26,30 +20,11 @@ RUN apt-get update \
 RUN python3 -m venv /opt/venv
 ENV PATH="/opt/venv/bin:$PATH"
 
-# Install Python packages in the virtual environment
-RUN pip install \
-        cloudpickle==3.1.1 \
-        ExifRead==3.5.1 \
-        Flask==3.1.2 \
-        fpdf2==2.8.4 \
-        joblib==1.5.2 \
-        matplotlib==3.10.6 \
-        networkx==3.5 \
-        numpy==1.26.4 \
-        opencv-python==4.11.0.86 \
-        pillow==11.3.0 \
-        pyproj==3.7.2 \
-        pytest==8.4.2 \
-        python-dateutil==2.9.0.post0 \
-        PyYAML==6.0.3 \
-        scipy==1.16.2 \
-        setuptools==80.9.0 \
-        Sphinx==6.2.1 \
-        wheel==0.45.1 \
-        xmltodict==1.0.2
-
 COPY . /source/OpenSfM
 
 WORKDIR /source/OpenSfM
 
-RUN python3 setup.py build
+# Build and install OpenSfM using pip with pyproject.toml
+# C++ tests are built automatically (OPENSFM_BUILD_TESTS=ON in pyproject.toml)
+# and will be available in cmake_build/ directory for running with ctest
+RUN pip install --no-cache-dir -e .[test]
diff --git a/conda.yml b/conda.yml
index 828bcf01c..1e163ceff 100644
--- a/conda.yml
+++ b/conda.yml
@@ -10,23 +10,3 @@ dependencies:
     - ceres-solver=2.1
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
-    - pip
-    - pip:
-        - cloudpickle==3.1.1
-        - ExifRead==3.3.1
-        - Flask==3.1.1
-        - fpdf2==2.8.3
-        - joblib==1.5.1
-        - matplotlib==3.5.1
-        - networkx==3.4.2
-        - numpy==1.21.5
-        - Pillow==9.0.1
-        - pyproj>=3.3.0
-        - pytest==8.4.0
-        - python-dateutil==2.8.1
-        - PyYAML>=5.4.1
-        - scipy==1.8.0
-        - Sphinx==4.2.0
-        - xmltodict==0.14.2
-        - wheel
-        - sphinx_rtd_theme
diff --git a/doc/Makefile b/doc/Makefile
new file mode 100644
index 000000000..69ba4bb7d
--- /dev/null
+++ b/doc/Makefile
@@ -0,0 +1,33 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = ../build/doc
+PORT          ?= 8000
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile serve clean
+
+# Serve the documentation locally
+serve:
+	@echo "Serving documentation at http://localhost:$(PORT)/"
+	@echo "Press Ctrl+C to stop the server"
+	@python -m http.server --directory $(BUILDDIR)/html $(PORT)
+
+# Clean build artifacts
+clean:
+	@echo "Cleaning build directory: $(BUILDDIR)"
+	@rm -rf $(BUILDDIR)
+	@echo "Done"
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/doc/source/annotation_tool.rst b/doc/source/annotation_tool.rst
index 1813f6186..b86d9471c 100644
--- a/doc/source/annotation_tool.rst
+++ b/doc/source/annotation_tool.rst
@@ -49,9 +49,9 @@ Main toolbox
 ~~~~~~~~~~~~
 
 The main toolbox contains the list of existing control points as well as several controls.
-The basic controls are explained here. Scroll to :ref:`additional-controls` for information on the rest.
+The basic controls are explained here. Scroll to :ref:`advanced-features` for information on the rest.
 
-- The 'Load', 'Save' buttons save and load the ground control points into a ``ground_control_points.json`` file with :ref:`json-gcps`.
+- The 'Load', 'Save' buttons save and load the ground control points into a ``ground_control_points.json`` file (see the JSON file format section in the Ground Control Points documentation).
 - If there is a ``ground_control_points.json`` file in the dataset directory, it will be loaded upon launch.
 - Control points can be added or removed with the 'Add GCP' and 'Remove GCP' buttons. The active point can be selected from the dropdown.
 - By selecting a point in the list it becomes active and can be annotated on all images.
@@ -84,6 +84,7 @@ Assuming that you have a set of ground control points whose geodetic coordinates
    You can use ``data/berlin`` for this example.
 2. Generate a ``ground_control_points.json`` file with all your measured ground control points and place it in the root of the dataset
    See the example below. Note how the 'observations' is empty as we will generate those using the annotation tool.
+
 ::
 
     "points": [
@@ -93,6 +94,7 @@ Assuming that you have a set of ground control points whose geodetic coordinates
         "observations": []
       }
     ]
+
 3. Launch the annotation tool, note how the control points dropdown contains your ground control points.
 4. Scroll through all the images, annotating each GCP on all the locations where it is visible.
 5. Click on 'save' to overwrite the ``ground_control_points.json`` file with your annotations.
@@ -122,6 +124,8 @@ The 'Flex' and 'Full' buttons produce additional analysis results and
 are explained in :ref:`two-reconstruction-annotation`
 
 
+.. _advanced-features:
+
 Advanced features
 -----------------
 
diff --git a/doc/source/building.rst b/doc/source/building.rst
index dd1ad3cf0..061625a8b 100644
--- a/doc/source/building.rst
+++ b/doc/source/building.rst
@@ -4,6 +4,25 @@
 Building
 ========
 
+Quick start
+-----------
+
+To build OpenSfM, follow these steps:
+
+1. Download the OpenSfM code from Github::
+
+    git clone --recursive https://github.com/mapillary/OpenSfM
+
+2. Install the dependencies (we recommend using conda)::
+
+    conda env create --file conda.yml --yes
+    conda activate opensfm
+
+3. Build OpenSfM::
+
+    pip install -e .
+
+
 Download
 --------
 
@@ -20,14 +39,14 @@ If you already have the code or you downloaded a release_, make sure to update t
 Install dependencies
 --------------------
 
-OpenSfM depends on multiple libraries (OpenCV_, `Ceres Solver`_, ...) and python packages that need to be installed before building it.
+OpenSfM depends on multiple libraries (OpenCV_, `Ceres Solver`_, ...) that need to be installed before building it.
 
 The way to install these dependencies depends on your system. We recommend using a virtual environment manager such as anaconda or miniconda, not to mess up with your current setup. Anaconda will take care of installing both systems and python dependencies.
 
 Installing dependencies using Conda (recommended)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Creating a conda environment will take care of installing all dependencies. Make sure you have conda or miniconda installed.  From the project root directory, run::
+Creating a conda environment will take care of installing all dependencies. Make sure you have conda or miniconda installed. From the project root directory, run::
 
     conda env create --file conda.yml --yes
 
@@ -40,19 +59,19 @@ and you are ready to build OpenSfM.
 (Anaconda dependencies installation has been tested under MacOS (Sequoia), Ubuntu 24.04 and Fedora 42.)
 
 Installing dependencies on Ubuntu
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-If you are not using conda, see this `Dockerfile <https://github.com/mapillary/OpenSfM/blob/main/Dockerfile>`_ for the commands to install all dependencies on Ubuntu 20.04.
+If you are not using conda, see this `Dockerfile.ubuntu24 <https://github.com/mapillary/OpenSfM/blob/main/Dockerfile.ubuntu24>`_ for the commands to install all dependencies on Ubuntu 24.04.
 
 
 Installing dependencies on MacOSX
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 While it is possible to install all dependencies using brew, we recommend using the conda instructions above instead.
 
 
 Installing dependencies on Windows
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Install git_.
 
@@ -73,39 +92,47 @@ Then install OpenCV, Ceres, SuiteSparse and LAPACK (this will take a while)::
 
     vcpkg install opencv4 ceres ceres[suitesparse] lapack suitesparse --triplet x64-windows
 
-Finally install the PIP requirements::
-
-    pip install -r requirements.txt
-
 
 Building the library
 --------------------
 
 Once the dependencies have been installed, you can build OpenSfM by running the following command from the main folder::
 
-    python setup.py build
+    pip install -e .
+
+This will first install python dependencies on your current python environment, and then build OpenSfM and install it in editable mode.
+
 
 Building Docker images
 ----------------------
 
-Once dependencies have been installed, you can build OpenSfM Docker images by running the following command from the main folder::
-
-    docker build -t opensfm -f Dockerfile .
+You can also use OpenSfM inside docker. We provide example Dockerfiles for Ubuntu 20.04 and 24.04. Build it by running the following command from the main folder::
 
-To build an image using the Ceres 2 solver, use::
+    docker build -t opensfm.ubuntu24 -f Dockerfile.ubuntu24 .
 
-  docker build -t opensfm:ceres2 -f Dockerfile.ceres2 .
 
 Building the documentation
 --------------------------
-To build the documentation and browse it locally use::
 
-    pip install sphinx_rtd_theme
-    python setup.py build_doc
-    python -m http.server --directory build/doc/html/
+To build the documentation and browse it locally, first install Sphinx::
+
+    pip install -e .[docs]
+
+Then build the documentation using make::
+
+    cd doc
+    make html
+
+To browse the documentation locally::
+
+    make serve
 
 and browse `http://localhost:8000/ <http://localhost:8000/>`_
 
+To clean the build artifacts::
+
+    make clean
+
 
 .. _Github: https://github.com/mapillary/OpenSfM
 .. _release: https://github.com/mapillary/OpenSfM/releases
diff --git a/doc/source/conf.py b/doc/source/conf.py
index ce672b700..7b716341b 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -50,7 +50,7 @@
 
 # General information about the project.
 project = "OpenSfM"
-copyright = "2021, Mapillary"
+copyright = "2025, Mapillary"
 author = "Mapillary"
 
 # The version info for the project you're documenting, acts as replacement for
@@ -67,7 +67,7 @@
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = "en"
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
diff --git a/doc/source/gcp.rst b/doc/source/gcp.rst
index ad92fb99f..96d5dabf4 100644
--- a/doc/source/gcp.rst
+++ b/doc/source/gcp.rst
@@ -12,8 +12,6 @@ In the bundle adjustment step, GCP observations are used as a constraint to refi
 
 GPSs can be specified in two file formats.  If existing, both are loaded.
 
-.. _json-gcps:
-
 JSON file format
 ~~~~~~~~~~~~~~~~
 GCPs can be specified by adding a text file named ``ground_control_points.json`` at the root folder of the dataset. The format of the file should be as follows::
diff --git a/doc/source/quality_report.rst b/doc/source/quality_report.rst
index 5faebacc0..e910ef3cb 100644
--- a/doc/source/quality_report.rst
+++ b/doc/source/quality_report.rst
@@ -52,12 +52,12 @@ Reconstruction Details
 
 |rec|
 
- - Average reprojection error (normalized/pixels): normalized (by features uncertainty) average norm of reprojection errors and same, but pixel-wise,
- un-normalized, error. Errors bigger than 4 pixels are pruned out.
- - Average Track Length : average number of images in which a reconstructed points has been detected.
- - Average Track Length (> 2) : same as above but ignoring 2-images points.
+- Average reprojection error (normalized/pixels): normalized (by features uncertainty) average norm of reprojection errors and same, but pixel-wise,
+  un-normalized, error. Errors bigger than 4 pixels are pruned out.
+- Average Track Length : average number of images in which a reconstructed points has been detected.
+- Average Track Length (> 2) : same as above but ignoring 2-images points.
 
- |residual_histogram|
+|residual_histogram|
 
  The tables are the histogram of the certainty-normalized and un-normalized reprojection errors norm. Errors bigger than 4 pixels are pruned out.
 
diff --git a/doc/source/rig.rst b/doc/source/rig.rst
index c261ee906..11029d0d4 100644
--- a/doc/source/rig.rst
+++ b/doc/source/rig.rst
@@ -12,18 +12,19 @@ Coordinate Systems
 Rig are defined by a fixed assembly of cameras that are triggered at the same instant.
 The following terms define such assembly and capture in OpenSfM terminology :
 
- - A `RigCamera` is a camera of the rig assembly defined as a combination of an existing camera model (it refers only to its ID) and its pose wrt. the rig assembly coordinate frame. `RigCamera` are defined in the `rig_cameras.json` as the following::
+- A `RigCamera` is a camera of the rig assembly defined as a combination of an existing camera model (it refers only to its ID) and its pose wrt. the rig assembly coordinate frame. `RigCamera` are defined in the `rig_cameras.json` as the following::
 
- {
-    "RIG_CAMERA_ID":
     {
-        "translation": translation of the rig frame wrt. the RigCamera frame
-        "rotation": rotation bringing a point from rig frame to the RigCamera frame
-        "camera": camera model ID of this RigCamera
-    },
-    ...
+        "RIG_CAMERA_ID":
+        {
+            "translation": translation of the rig frame wrt. the RigCamera frame
+            "rotation": rotation bringing a point from rig frame to the RigCamera frame
+            "camera": camera model ID of this RigCamera
+        },
+        ...
+    }
 
- - A `RigInstance` is a list of `Shots`, each of which correspond to a `RigCamera` of the `RigModel` and the actual pose of the `RigModel` in the world : it's indeed an instantiation of the `RigModel` by combining `Shots`. These instances are defined in the `rig_assignments.json` file as follows::
+- A `RigInstance` is a list of `Shots`, each of which correspond to a `RigCamera` of the `RigModel` and the actual pose of the `RigModel` in the world : it's indeed an instantiation of the `RigModel` by combining `Shots`. These instances are defined in the `rig_assignments.json` file as follows::
 
     {
         "RIG_INSTANCE_ID1": {
@@ -57,8 +58,7 @@ The following terms define such assembly and capture in OpenSfM terminology :
             ]
         },
         ...
-
-
+    }
 
 A picture is often worth many words :
 |rig_frame|
diff --git a/doc/source/sensor_database.rst b/doc/source/sensor_database.rst
index 63fdc1eb4..400649a16 100644
--- a/doc/source/sensor_database.rst
+++ b/doc/source/sensor_database.rst
@@ -9,7 +9,7 @@ Calibration Database
 Overview
 --------
 
-In order to produce accurate geometry, structure-from-motion (SfM) needs to have correct estimates of the imaging sensor geometry, such as : lens type (fisheye, perspective, spherical), focal, distorsion, principal point. Please refer to the `Geometric Models`_ section for a comprehensive list of camera internal parameters (calibration).
+In order to produce accurate geometry, structure-from-motion (SfM) needs to have correct estimates of the imaging sensor geometry, such as : lens type (fisheye, perspective, spherical), focal, distorsion, principal point. Please refer to the :doc:`geometry` section for a comprehensive list of camera internal parameters (calibration).
 
 While reconstructing the scene (using incremental SfM), OpenSfM will adjust for the camera calibration values that best explain the seen geometry. However, in order to get optimal and failsafe results, it is recommended to have a first good guess of the calibration values. By default, OpenSfM will try to get these values by reading the image EXIFs, where the focal length can be red, and is one of the most important of the calibration values. However, sometimes, EXIFs does not contain such value, or it is erroneous, and/or it is better to have other values than just the focal length.
 
@@ -21,18 +21,18 @@ Here comes sensors databases to the rescue. These are files stored under ``opens
 sensor_data_detailed.json
 -------------------------
 
-This file contains physical sensor's width and height, in millimeters, for a given ``model make`` sensor (see `extract_metadata`_). It means that if only the focal length is available in the EXIFs, since we also have the sensor physical size, we know the full sensor geometry.
+This file contains physical sensor's width and height, in millimeters, for a given ``model make`` sensor (see ``extract_metadata`` command). It means that if only the focal length is available in the EXIFs, since we also have the sensor physical size, we know the full sensor geometry.
 
 
 sensor_data.json
 ----------------
 
-This file contains a multiplicative factor for a given ``model make`` sensor (see `extract_metadata`_). When applied to the EXIFs focal length, this factor gives the focal 35mm equivalent. Since we know the dimensions of 35mm equivalent (24x32 mm), we again know the full sensor geometry.
+This file contains a multiplicative factor for a given ``model make`` sensor (see ``extract_metadata`` command). When applied to the EXIFs focal length, this factor gives the focal 35mm equivalent. Since we know the dimensions of 35mm equivalent (24x32 mm), we again know the full sensor geometry.
 
 camera_calibration.json
 ------------------------
 
-This file contains the full definition (in OpenSfM format) of camera calibrations. Calibration are for a given ``make`` (see `extract_metadata`_), and then, they're further refined :
+This file contains the full definition (in OpenSfM format) of camera calibrations. Calibration are for a given ``make`` (see ``extract_metadata`` command), and then, they're further refined :
  - If ``ALL`` is specified, then the calibration is valid for all ``make model`` camera independant of their ``model`` value
  - If ``MODEL`` is specified, then calibrations are per actual ``model``
  - If ``FOCAL`` is specified, then calibrations are per focal length red from the EXIFs
diff --git a/doc/source/using.rst b/doc/source/using.rst
index 9cf364ead..3f83aa758 100644
--- a/doc/source/using.rst
+++ b/doc/source/using.rst
@@ -22,7 +22,7 @@ First, build the OpenSfM Docker image, as described under "building".
 
 Then, start a Docker container. The following command mounts the `data/` folder to `/data/` inside the Docker container::
 
-    docker run -it -p 8080:8080 -v ${PWD}/data/:/data/ opensfm:ceres2
+    docker run -it -p 8080:8080 -v ${PWD}/data/:/data/ opensfm.ubuntu24 /bin/bash
 
 Once inside the running Docker container, start the reconstruction process with the usual command::
 
@@ -316,4 +316,4 @@ Checkout `the default configuration <_modules/opensfm/config.html>`_ to see the
 
 
 .. include:: gcp.rst
-.. _fisheye https://docs.opencv.org/master/db/d58/group__calib3d__fisheye.html
+.. _fisheye: https://docs.opencv.org/master/db/d58/group__calib3d__fisheye.html
diff --git a/export_pmvs.md b/export_pmvs.md
deleted file mode 100644
index e748868da..000000000
--- a/export_pmvs.md
+++ /dev/null
@@ -1,106 +0,0 @@
-# OpenSfM to PMVS dense point cloud reconstruction
-
-Download CMVS: http://www.di.ens.fr/cmvs/
-
-- [Install PMVS/CMVS](#pmvs-installation-hints-ubuntu)
-- [PMVS Inputs](#pmvs-inputs)
-- [Usage](#usage)
-
-### PMVS Installation Hints (Linux/Ubuntu)
-- Installation pointers here: http://www.di.ens.fr/cmvs/documentation.html
-
-- Type `make` in `cmvs/program/main`. Should make three binaries:
-    + `pmvs2`
-    + `cmvs`
-    + `genOptions`
-
-- Most dependencies installed with apt-get:
-
-    `sudo apt-get install libgsl0-dev libblas-dev libatlas-dev liblapack-dev liblapacke-dev`
-
-- Updated Graclus link: http://www.cs.utexas.edu/users/dml/Software/graclus.html
-
-#### Lapack Errors:
-http://mdda.net/oss-blog/2014-06/building-VisualSFM-on-FC20/
-
-    ERROR : ../base/numeric/mylapack.cc:6:25: fatal error: clapack/f2c.h: No such file or directory
-
-Update `../base/numeric/mylapack.cc`
-From:
-
-    extern "C" {
-    #include <clapack/f2c.h>
-    #include <clapack/clapack.h>
-    };
-To:
-
-    extern "C" {
-    //#include <clapack/f2c.h>
-    //#include <clapack/clapack.h>
-    #include <lapacke.h>
-    };
-    #define integer int
-
-Update `../base/numeric/mylapack.h`
-From:
-
-    static void lls(std::vector<float>& A,
-                  std::vector<float>& b,
-                  long int width, long int height);
-
-    static void lls(std::vector<double>& A,
-                  std::vector<double>& b,
-                  long int width, long int height);
-To:
-
-    static void lls(std::vector<float>& A,
-                  std::vector<float>& b,
-                  int width, int height);
-
-    static void lls(std::vector<double>& A,
-                  std::vector<double>& b,
-                  int width, int height);
-
-#### Accumulate Error:
-
-    ../base/cmvs/bundle.cc: In member function ‘int CMVS::Cbundle::addImagesSub(const std::vector<std::map<int, float> >&)’:
-    ../base/cmvs/bundle.cc:1134:52: error: ‘accumulate’ was not declared in this scope
-       return accumulate(addnum.begin(), addnum.end(), 0);
-
-Add this to `../base/cmvs/bundle.cc`
-
-    #include <numeric>
-
-#### Stdlib Error:
-    genOption.cc: In function ‘int main(int, char**)’:
-    genOption.cc:17:12: error: ‘exit’ was not declared in this scope
-
-Add this to `genOption.cc`
-
-    #include <cstdlib>
-
-### PMVS Inputs
-
-These are the files that `export_pmvs` generates for PMVS from OpenSfM output. More info: http://www.di.ens.fr/pmvs/documentation.html
-
-- Images: `visualize/%08d.jpg` (radially undistorted)
-- Camera Parameters: `txt/%08d.txt`
-- Image Co-Visibility file: `vis.dat`
-- Options file: `options.txt` (includes mention of `vis.dat`)
-- Output directory: `models/`
-
-### Usage
-
-From the root OpenSfM directory, run:
-
-    bin/export_pmvs <path_to_dataset>
-
-There will be an individual pmvs directory for each separate reconstruction.
-
-To perform the PMVS point cloud reconstruction, run:
-
-    ./pmvs2 <path_to_dataset>/pmvs/recon0/ pmvs_options.txt
-
-This will generate files in `<path_to_dataset>/pmvs/recon0/models/` including a `pmvs_options.txt.ply`
-
-**Important:** note that the trailing `/` in `recon0/` is needed.  Otherwise PMVS will fail to find the options file and will give an `Unrecognizable option` warning.
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 529fa31d3..ccc160cc9 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -347,9 +347,15 @@ def load_matches(self, image: str) -> Dict[str, NDArray]:
         # as 'pickle.load' is RCE-prone. Will raise on any class other
         # than the numpy ones we allow.
         class MatchingUnpickler(pickle.Unpickler):
+            # Handle both numpy <2.0 (np.core) and numpy >=2.0 (np._core)
+            _multiarray = (
+                np._core.multiarray if hasattr(np, "_core") else np.core.multiarray
+            )
             modules_map = {
-                "numpy.core.multiarray._reconstruct": np.core.multiarray,
-                "numpy.core.multiarray.scalar": np.core.multiarray,
+                "numpy.core.multiarray._reconstruct": _multiarray,
+                "numpy.core.multiarray.scalar": _multiarray,
+                "numpy._core.multiarray._reconstruct": _multiarray,
+                "numpy._core.multiarray.scalar": _multiarray,
                 "numpy.ndarray": np,
                 "numpy.dtype": np,
             }
diff --git a/opensfm/exif.py b/opensfm/exif.py
index 7f5b6f75a..2205007a8 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -530,7 +530,7 @@ def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                     )
                 )
 
-            if np.all(ypr) is not None:
+            if not any(v is None for v in ypr):
                 ypr = np.radians(ypr)
 
                 # Convert YPR --> OPK
diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index d6b5ad80b..8723da4fc 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -1,10 +1,11 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.15)
 
 project(opensfm C CXX)
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING
-      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+      "Choose the type of build, options are: None Debug Release "
+      "RelWithDebInfo MinSizeRel."
       FORCE)
 endif()
 set(CMAKE_MODULE_PATH ${opensfm_SOURCE_DIR}/cmake)
@@ -63,7 +64,19 @@ find_package(SuiteSparse)
 find_package(Eigen3 REQUIRED)
 find_package(Ceres)
 find_package(Gflags REQUIRED)
-find_package(Glog REQUIRED)
+
+# Try to find glog using its native CMake config first (modern systems)
+# Fall back to custom FindGlog.cmake for older systems (e.g., Ubuntu 20.04)
+find_package(glog QUIET CONFIG)
+if(glog_FOUND)
+  message(STATUS "Using glog native CMake config (modern glog)")
+else()
+  message(STATUS
+    "glog CMake config not found, using FindGlog.cmake "
+    "(Ubuntu 20.04 compatibility)"
+  )
+  find_package(Glog REQUIRED)
+endif()
 
 # Ceres2 exposes Ceres::ceres target.
 # Ceres1 exposes just ceres.
@@ -75,14 +88,25 @@ else()
     set(CERES_LIBRARIES ceres)
 endif()
 
-find_package(OpenCV)
+# Only link against the OpenCV components we actually need
+# This avoids pulling in unnecessary dependencies like viz (which requires VTK)
 # OpenCV's OpenCVConfig will enforce imgcodecs for < 3.0
-# (even if OPTIONAL_COMPONENTS) so we remove it as we don't need it
+# (even if OPTIONAL_COMPONENTS) so we handle version detection carefully
 # Cause is imread/imwrite moved to imgcodecs on > 3.0
-if(${OpenCV_VERSION} LESS 3.0)
-    find_package(OpenCV REQUIRED core imgproc calib3d)
+find_package(OpenCV QUIET)
+if(OpenCV_FOUND AND ${OpenCV_VERSION} VERSION_LESS "3.0")
+    find_package(OpenCV REQUIRED COMPONENTS core imgproc calib3d)
 else()
-    find_package(OpenCV REQUIRED core imgproc calib3d OPTIONAL_COMPONENTS imgcodecs)
+    find_package(OpenCV REQUIRED COMPONENTS core imgproc calib3d
+                 OPTIONAL_COMPONENTS imgcodecs)
+endif()
+
+# Override OpenCV_LIBS to only include the components we explicitly requested
+# This prevents linking against all OpenCV modules
+# (especially viz which requires VTK)
+set(OpenCV_LIBS opencv_core opencv_imgproc opencv_calib3d)
+if(TARGET opencv_imgcodecs)
+    list(APPEND OpenCV_LIBS opencv_imgcodecs)
 endif()
 
 ####### Third party libraries #######
@@ -111,18 +135,21 @@ if (OPENSFM_BUILD_TESTS)
 
   # Gtest if old now and trigger these
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-field-initializers")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy-with-user-provided-copy")
+  set(CMAKE_CXX_FLAGS
+      "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy-with-user-provided-copy"
+  )
 
   add_library(gtest
               third_party/gtest/gmock_gtest_all.cc
               third_party/gtest/gmock_main.cc)
   target_include_directories(gtest PRIVATE ${GFLAGS_INCLUDE_DIR})
+  target_link_libraries(gtest PRIVATE glog::glog)
 
   set(TEST_MAIN test_main)
   add_library(${TEST_MAIN} testing_main.cc)
   target_link_libraries(${TEST_MAIN}
                         ${GFLAGS_LIBRARY}
-                        ${GLOG_LIBRARY}
+                        glog::glog
                         gtest)
 endif()
 
diff --git a/opensfm/src/bundle/CMakeLists.txt b/opensfm/src/bundle/CMakeLists.txt
index 87b6a9587..9aa7a0b9a 100644
--- a/opensfm/src/bundle/CMakeLists.txt
+++ b/opensfm/src/bundle/CMakeLists.txt
@@ -58,3 +58,4 @@ target_link_libraries(pybundle PRIVATE
 set_target_properties(pybundle PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pybundle LIBRARY DESTINATION .)
diff --git a/opensfm/src/cmake/FindGlog.cmake b/opensfm/src/cmake/FindGlog.cmake
index 0dde218ee..b1244c15d 100644
--- a/opensfm/src/cmake/FindGlog.cmake
+++ b/opensfm/src/cmake/FindGlog.cmake
@@ -157,6 +157,16 @@ ENDIF (GLOG_LIBRARY AND
 IF (GLOG_FOUND)
   SET(GLOG_INCLUDE_DIRS ${GLOG_INCLUDE_DIR})
   SET(GLOG_LIBRARIES ${GLOG_LIBRARY})
+
+  # Create imported target for modern CMake usage
+  # This provides compatibility with systems that don't have glog CMake config
+  IF (NOT TARGET glog::glog)
+    ADD_LIBRARY(glog::glog UNKNOWN IMPORTED)
+    SET_TARGET_PROPERTIES(glog::glog PROPERTIES
+      IMPORTED_LOCATION "${GLOG_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIR}"
+      INTERFACE_COMPILE_DEFINITIONS "GLOG_USE_GLOG_EXPORT")
+  ENDIF()
 ENDIF (GLOG_FOUND)
 
 # Handle REQUIRED / QUIET optional arguments.
diff --git a/opensfm/src/dense/CMakeLists.txt b/opensfm/src/dense/CMakeLists.txt
index 2728749df..da67193e8 100644
--- a/opensfm/src/dense/CMakeLists.txt
+++ b/opensfm/src/dense/CMakeLists.txt
@@ -27,3 +27,4 @@ target_link_libraries(pydense PRIVATE dense foundation)
 set_target_properties(pydense PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pydense LIBRARY DESTINATION .)
diff --git a/opensfm/src/features/CMakeLists.txt b/opensfm/src/features/CMakeLists.txt
index 6db5b3f10..430a6182b 100644
--- a/opensfm/src/features/CMakeLists.txt
+++ b/opensfm/src/features/CMakeLists.txt
@@ -27,3 +27,4 @@ target_link_libraries(pyfeatures
 set_target_properties(pyfeatures PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pyfeatures LIBRARY DESTINATION .)
diff --git a/opensfm/src/foundation/CMakeLists.txt b/opensfm/src/foundation/CMakeLists.txt
index f7737f327..9508d1882 100644
--- a/opensfm/src/foundation/CMakeLists.txt
+++ b/opensfm/src/foundation/CMakeLists.txt
@@ -17,7 +17,7 @@ target_link_libraries(foundation
     Eigen3::Eigen
   PRIVATE
     ${GFLAGS_LIBRARY}
-    ${GLOG_LIBRARY}
+    glog::glog
 )
 target_include_directories(foundation
   PUBLIC
diff --git a/opensfm/src/geo/CMakeLists.txt b/opensfm/src/geo/CMakeLists.txt
index 75620d069..ad62e5853 100644
--- a/opensfm/src/geo/CMakeLists.txt
+++ b/opensfm/src/geo/CMakeLists.txt
@@ -33,3 +33,4 @@ target_link_libraries(pygeo
 set_target_properties(pygeo PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pygeo LIBRARY DESTINATION .)
diff --git a/opensfm/src/geometry/CMakeLists.txt b/opensfm/src/geometry/CMakeLists.txt
index c8be4b9b7..8bdc5455a 100644
--- a/opensfm/src/geometry/CMakeLists.txt
+++ b/opensfm/src/geometry/CMakeLists.txt
@@ -53,3 +53,4 @@ target_link_libraries(pygeometry
 set_target_properties(pygeometry PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pygeometry LIBRARY DESTINATION .)
diff --git a/opensfm/src/geometry/triangulation.h b/opensfm/src/geometry/triangulation.h
index a97ae6a17..70447f7ad 100644
--- a/opensfm/src/geometry/triangulation.h
+++ b/opensfm/src/geometry/triangulation.h
@@ -6,6 +6,7 @@
 #include <Eigen/QR>
 #include <Eigen/SVD>
 #include <Eigen/StdVector>
+#include <cassert>
 
 namespace geometry {
 
diff --git a/opensfm/src/map/CMakeLists.txt b/opensfm/src/map/CMakeLists.txt
index 74eb67420..58f931fb2 100644
--- a/opensfm/src/map/CMakeLists.txt
+++ b/opensfm/src/map/CMakeLists.txt
@@ -62,3 +62,4 @@ endif()
 set_target_properties(pymap PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pymap LIBRARY DESTINATION .)
diff --git a/opensfm/src/robust/CMakeLists.txt b/opensfm/src/robust/CMakeLists.txt
index 40bdf7a46..a9eb0f2f9 100644
--- a/opensfm/src/robust/CMakeLists.txt
+++ b/opensfm/src/robust/CMakeLists.txt
@@ -33,3 +33,4 @@ target_link_libraries(pyrobust
 set_target_properties(pyrobust PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pyrobust LIBRARY DESTINATION .)
diff --git a/opensfm/src/sfm/CMakeLists.txt b/opensfm/src/sfm/CMakeLists.txt
index a5bfe6632..ffc8d6e56 100644
--- a/opensfm/src/sfm/CMakeLists.txt
+++ b/opensfm/src/sfm/CMakeLists.txt
@@ -43,3 +43,4 @@ target_link_libraries(pysfm
 set_target_properties(pysfm PROPERTIES
     LIBRARY_OUTPUT_DIRECTORY "${opensfm_SOURCE_DIR}/.."
 )
+install(TARGETS pysfm LIBRARY DESTINATION .)
diff --git a/opensfm/transformations.py b/opensfm/transformations.py
index dfa59ed29..209aafc6f 100644
--- a/opensfm/transformations.py
+++ b/opensfm/transformations.py
@@ -235,7 +235,7 @@ def translation_from_matrix(matrix: NDArray) -> NDArray:
     True
 
     """
-    return numpy.array(matrix, copy=False)[:3, 3].copy()
+    return numpy.asarray(matrix)[:3, 3].copy()
 
 
 def reflection_matrix(point: NDArray, normal: NDArray) -> NDArray:
@@ -278,7 +278,7 @@ def reflection_from_matrix(
     True
 
     """
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M = numpy.asarray(matrix, dtype=numpy.float64)
     # normal: unit eigenvector corresponding to eigenvalue -1
     w, V = numpy.linalg.eig(M[:3, :3])
     i = numpy.where(abs(numpy.real(w) + 1.0) < 1e-8)[0]
@@ -342,7 +342,7 @@ def rotation_matrix(
     M[:3, :3] = R
     if point is not None:
         # rotation not around origin
-        point = numpy.array(point[:3], dtype=numpy.float64, copy=False)
+        point = numpy.asarray(point[:3], dtype=numpy.float64)
         M[:3, 3] = point - numpy.dot(R, point)
     return M
 
@@ -362,7 +362,7 @@ def rotation_from_matrix(
     True
 
     """
-    R = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    R = numpy.asarray(matrix, dtype=numpy.float64)
     R33 = R[:3, :3]
     # direction: unit eigenvector of R33 corresponding to eigenvalue of 1
     w, W = numpy.linalg.eig(R33.T)
@@ -448,7 +448,7 @@ def scale_from_matrix(
     True
 
     """
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M = numpy.asarray(matrix, dtype=numpy.float64)
     M33 = M[:3, :3]
     factor = numpy.trace(M33) - 2.0
     try:
@@ -513,11 +513,11 @@ def projection_matrix(
 
     """
     M = numpy.identity(4)
-    point = numpy.array(point[:3], dtype=numpy.float64, copy=False)
+    point = numpy.asarray(point[:3], dtype=numpy.float64)
     normal = unit_vector(normal[:3])
     if perspective is not None:
         # perspective projection
-        perspective = numpy.array(perspective[:3], dtype=numpy.float64, copy=False)
+        perspective = numpy.asarray(perspective[:3], dtype=numpy.float64)
         M[0, 0] = M[1, 1] = M[2, 2] = numpy.dot(perspective - point, normal)
         M[:3, :3] -= numpy.outer(perspective, normal)
         if pseudo:
@@ -530,7 +530,7 @@ def projection_matrix(
         M[3, 3] = numpy.dot(perspective, normal)
     elif direction is not None:
         # parallel projection
-        direction = numpy.array(direction[:3], dtype=numpy.float64, copy=False)
+        direction = numpy.asarray(direction[:3], dtype=numpy.float64)
         scale = numpy.dot(direction, normal)
         M[:3, :3] -= numpy.outer(direction, normal) / scale
         M[:3, 3] = direction * (numpy.dot(point, normal) / scale)
@@ -575,7 +575,7 @@ def projection_from_matrix(
     True
 
     """
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M = numpy.asarray(matrix, dtype=numpy.float64)
     M33 = M[:3, :3]
     w, V = numpy.linalg.eig(M)
     i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
@@ -732,7 +732,7 @@ def shear_from_matrix(
     True
 
     """
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M = numpy.asarray(matrix, dtype=numpy.float64)
     M33 = M[:3, :3]
     # normal: cross independent eigenvectors corresponding to the eigenvalue 1
     w, V = numpy.linalg.eig(M33)
@@ -1103,8 +1103,8 @@ def superimposition_matrix(
     True
 
     """
-    v0 = numpy.array(v0, dtype=numpy.float64, copy=False)[:3]
-    v1 = numpy.array(v1, dtype=numpy.float64, copy=False)[:3]
+    v0 = numpy.asarray(v0, dtype=numpy.float64)[:3]
+    v1 = numpy.asarray(v1, dtype=numpy.float64)[:3]
     return affine_matrix_from_points(v0, v1, shear=False, scale=scale, usesvd=usesvd)
 
 
@@ -1210,7 +1210,7 @@ def euler_from_matrix(
     #  `Union[int, str]`.
     k = _NEXT_AXIS[i - parity + 1]
 
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:3, :3]
+    M = numpy.asarray(matrix, dtype=numpy.float64)[:3, :3]
     if repetition:
         # pyre-fixme[6]: For 1st argument expected `Union[ndarray[Any, dtype[Any]],
         #  tuple[ndarray[Any, dtype[Any]], ...]]` but got `Tuple[Union[int, str],
@@ -1429,7 +1429,7 @@ def quaternion_from_matrix(matrix: NDArray, isprecise: bool = False) -> NDArray:
     True
 
     """
-    M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:4, :4]
+    M = numpy.asarray(matrix, dtype=numpy.float64)[:4, :4]
     if isprecise:
         q = numpy.empty((4,))
         t = numpy.trace(M)
@@ -1755,7 +1755,7 @@ def unit_vector(
             return data
     else:
         if out is not data:
-            out[:] = numpy.array(data, copy=False)
+            out[:] = numpy.asarray(data)
         data = out
     length = numpy.atleast_1d(numpy.sum(data * data, axis))
     numpy.sqrt(length, length)
@@ -1827,8 +1827,8 @@ def angle_between_vectors(
     True
 
     """
-    v0 = numpy.array(v0, dtype=numpy.float64, copy=False)
-    v1 = numpy.array(v1, dtype=numpy.float64, copy=False)
+    v0 = numpy.asarray(v0, dtype=numpy.float64)
+    v1 = numpy.asarray(v1, dtype=numpy.float64)
     dot = numpy.sum(v0 * v1, axis=axis)
     dot /= vector_norm(v0, axis=axis) * vector_norm(v1, axis=axis)
     dot = numpy.clip(dot, -1.0, 1.0)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..5d67cf18a
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,107 @@
+[build-system]
+requires = ["scikit-build-core>=0.8.0", "pybind11>=2.10.0"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "opensfm"
+version = "0.5.2"
+description = "A Structure from Motion library"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "BSD"}
+authors = [
+    {name = "Mapillary"},
+]
+
+dependencies = [
+    "cloudpickle>=0.4.0",
+    "exifread>=2.1.2",
+    "flask>=2.3.2",
+    "fpdf2>=2.4.6",
+    "joblib>=1.0.0",
+    "matplotlib",
+    "networkx>=2.5",
+    "numpy>=1.19",
+    "Pillow>=8.1.1",
+    "pyproj>=1.9.5.1",
+    "python-dateutil>=2.7",
+    "pyyaml>=5.4",
+    "scipy>=1.10.0",
+    "xmltodict>=0.10.2",
+    "opencv-python>=4.8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "wheel",
+]
+docs = [
+    "Sphinx>=4.2.0",
+    "sphinx_rtd_theme>=1.0.0",
+]
+test = [
+    "pytest>=7.0.0",
+]
+
+# Note: The original bin/opensfm and bin/opensfm_run_all are bash scripts
+# For Phase 1, we'll install them as scripts using scikit-build's script handling
+# TODO Phase 2: Create proper Python entry points by moving bin/opensfm_main.py
+# into the opensfm package (e.g., opensfm/__main__.py or opensfm/cli.py)
+# [project.scripts]
+# opensfm = "opensfm.cli:main"
+# opensfm_run_all = "opensfm.cli:run_all"
+
+[project.urls]
+Homepage = "https://github.com/mapillary/OpenSfM"
+Documentation = "https://docs.opensfm.org/"
+
+[tool.scikit-build]
+# CMake source directory containing CMakeLists.txt
+cmake.source-dir = "opensfm/src"
+cmake.build-type = "Release"
+
+# Use a fixed build directory (useful for running C++ tests)
+build-dir = "cmake_build"
+
+# Minimum CMake version
+cmake.version = ">=3.15"
+
+# Specify where to install the Python package
+wheel.install-dir = "opensfm"
+
+# Package discovery - automatically find Python packages
+wheel.packages = ["opensfm"]
+
+# Package data (JSON, YAML, NPZ files in opensfm/data/) is automatically
+# included because it's inside the opensfm package directory
+# CMake only installs compiled .so files; Python packaging handles the rest
+
+# Note: Script installation
+# The bin/opensfm and bin/opensfm_run_all bash scripts need to be installed
+# This will be handled via CMake install() commands or Python entry points
+
+# Include files in the sdist (source distribution)
+sdist.include = [
+    "opensfm/data/**",          # sensor_data.json, camera_calibration.yaml, bow/*.npz
+    "opensfm/src/**",           # CMake source files
+    "bin/**",                   # All utility scripts
+]
+
+# Exclude unnecessary files from sdist
+sdist.exclude = [
+    ".git/**",
+    ".github/**",
+    "cmake_build/**",
+    "**/__pycache__/**",
+    "**/*.pyc",
+]
+
+# CMake configuration options
+[tool.scikit-build.cmake.define]
+# Build C++ tests (enabled for Docker/CI environments)
+OPENSFM_BUILD_TESTS = "ON"
+
+# Ensure we're using the correct Python executable
+# This will be automatically set by scikit-build-core
+# PYTHON_EXECUTABLE will be set automatically
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 86e1b1767..000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-cloudpickle==0.4.0
-exifread==2.1.2
-flask==2.3.2
-fpdf2==2.4.6
-joblib==0.14.1
-matplotlib
-networkx==2.5
-numpy>=1.19
-Pillow>=8.1.1
-pyproj>=1.9.5.1
-pytest==3.0.7
-python-dateutil>=2.7
-pyyaml>=5.4
-scipy>=1.10.0
-Sphinx==4.2.0
-xmltodict==0.10.2
-wheel
-opencv-python==4.5.1.48 ; sys_platform == "win32"
-opencv-python ; sys_platform == "linux"

From 971085a500651c6b9987d94c0ef521582951de78 Mon Sep 17 00:00:00 2001
From: Pau Gargallo <paugargallo@meta.com>
Date: Tue, 4 Nov 2025 01:16:35 -0800
Subject: [PATCH 188/235] fix cmake string format

Summary: A string was wrongly wrapped after a linter warning earlier

Differential Revision: D86135277

fbshipit-source-id: bb33c88364d8bf9471cda451da5c38345cd31f41
---
 opensfm/src/CMakeLists.txt | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index 8723da4fc..88a7dd84f 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -4,8 +4,7 @@ project(opensfm C CXX)
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING
-      "Choose the type of build, options are: None Debug Release "
-      "RelWithDebInfo MinSizeRel."
+      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
       FORCE)
 endif()
 set(CMAKE_MODULE_PATH ${opensfm_SOURCE_DIR}/cmake)

From 6f90a17ebf7c3cbf99d0df4f9c70f9bfbcff4cdd Mon Sep 17 00:00:00 2001
From: Pau Gargallo <pau.gargallo@gmail.com>
Date: Thu, 6 Nov 2025 02:48:51 -0800
Subject: [PATCH 189/235] fix: default to numpy.core if available (#1113)

Summary:
Not sure how to best handle access to `numpy.core` (in numpy 1) and `numpy._core` (in numpy 2). It seems the best would be not to access it at all.

In any case, there are situations in numpy 1 where `numpy._core` exists but does not contain any `multiarray` definition. So we default to use `numpy.core` if it exists and only use `numpy._core` otherwise.

Tested locally using `uv`. Failed before this fix.

Pull Request resolved: https://github.com/mapillary/OpenSfM/pull/1113

Differential Revision: D86282715

Pulled By: paulinus

fbshipit-source-id: eca406c318237fb18db19dd27611ddfd903eb1ef
---
 opensfm/dataset.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index ccc160cc9..719d1ab30 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -349,7 +349,7 @@ def load_matches(self, image: str) -> Dict[str, NDArray]:
         class MatchingUnpickler(pickle.Unpickler):
             # Handle both numpy <2.0 (np.core) and numpy >=2.0 (np._core)
             _multiarray = (
-                np._core.multiarray if hasattr(np, "_core") else np.core.multiarray
+                np.core.multiarray if hasattr(np, "core") else np._core.multiarray
             )
             modules_map = {
                 "numpy.core.multiarray._reconstruct": _multiarray,

From a7e674b0efd4856636a7eee5276f932fc56a2f8e Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Thu, 6 Nov 2025 15:07:31 -0800
Subject: [PATCH 190/235] fbcode/mapillary/opensfm/opensfm/src/map/src

Reviewed By: caglarpir

Differential Revision: D86286447

fbshipit-source-id: a9453a439fe4b21505cb1162116de888b80ed00d
---
 opensfm/src/map/src/tracks_manager.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/opensfm/src/map/src/tracks_manager.cc b/opensfm/src/map/src/tracks_manager.cc
index 89dc64aa4..b3ca2ed41 100644
--- a/opensfm/src/map/src/tracks_manager.cc
+++ b/opensfm/src/map/src/tracks_manager.cc
@@ -82,7 +82,7 @@ map::TracksManager InstanciateFromStreamV0(S& fstream) {
     SeparateLineByTabs(line, elems);
     if (elems.size() != N_ENTRIES)  // process only valid lines
     {
-      std::runtime_error(
+      throw std::runtime_error(
           "Encountered invalid line. A line must contain exactly " +
           std::to_string(N_ENTRIES) + " values!");
     }
@@ -112,7 +112,7 @@ map::TracksManager InstanciateFromStreamV1(S& fstream) {
     SeparateLineByTabs(line, elems);
     if (elems.size() != N_ENTRIES)  // process only valid lines
     {
-      std::runtime_error(
+      throw std::runtime_error(
           "Encountered invalid line. A line must contain exactly " +
           std::to_string(N_ENTRIES) + " values!");
     }
@@ -142,7 +142,7 @@ map::TracksManager InstanciateFromStreamV2(S& fstream) {
     SeparateLineByTabs(line, elems);
     if (elems.size() != N_ENTRIES)  // process only valid lines
     {
-      std::runtime_error(
+      throw std::runtime_error(
           "Encountered invalid line. A line must contain exactly " +
           std::to_string(N_ENTRIES) + " values!");
     }

From cff716cd8927965ad6b5ca55e41360d0c015d6d8 Mon Sep 17 00:00:00 2001
From: generatedunixname537391475639613 <noreply+537391475639613@fb.com>
Date: Mon, 10 Nov 2025 10:03:54 -0800
Subject: [PATCH 191/235] fbcode/mapillary/opensfm/opensfm/src/geometry/src

Differential Revision: D86404563

fbshipit-source-id: eb8c4b98542b4c459a38a6e9c7986c237a008d18
---
 opensfm/src/geometry/src/triangulation.cc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/opensfm/src/geometry/src/triangulation.cc b/opensfm/src/geometry/src/triangulation.cc
index 25568eaa0..3424a4e1b 100644
--- a/opensfm/src/geometry/src/triangulation.cc
+++ b/opensfm/src/geometry/src/triangulation.cc
@@ -143,6 +143,9 @@ std::pair<bool, Vec3d> TriangulateBearingsMidpoint(
     const std::vector<double>& threshold_list, double min_angle,
     double min_depth) {
   const int count = centers.rows();
+  if (threshold_list.size() < static_cast<size_t>(count)) {
+    return std::make_pair(false, Vec3d());
+  }
 
   // Check angle between rays
   bool angle_ok = false;

From 2e0acd49bf4832ccfd505cc6a9bbf432d7a9c8f6 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 18 Aug 2025 15:36:08 +0200
Subject: [PATCH 192/235] Proper focal 35mm conversion

---
 opensfm/exif.py | 46 +++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 43 insertions(+), 3 deletions(-)

diff --git a/opensfm/exif.py b/opensfm/exif.py
index 2205007a8..228caf229 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -3,6 +3,7 @@
 import datetime
 import logging
 from codecs import decode, encode
+import math
 from typing import Any, BinaryIO, Callable, Dict, List, Optional, Tuple, Union
 
 import exifread
@@ -60,14 +61,42 @@ def get_tag_as_float(tags: Dict[str, Any], key: str, index: int = 0) -> Optional
         return None
 
 
+def focal35_to_focal_ratio(
+    focal35_or_ratio: float, width: int, height: int, inverse=False
+) -> float:
+    """
+    Convert focal length in 35mm film equivalent to focal ratio (and vice versa).
+    We follow https://en.wikipedia.org/wiki/35_mm_equivalent_focal_length
+    """
+    image_ratio = float(max(width, height)) / min(width, height)
+    is_32 = math.fabs(image_ratio - 3.0 / 2.0)
+    is_43 = math.fabs(image_ratio - 4.0 / 3.0)
+    if is_32 < is_43:
+        # 3:2 aspect ratio : use 36mm for 35mm film
+        film_width = 36.0
+        if inverse:
+            return focal35_or_ratio * film_width
+        else:
+            return focal35_or_ratio / film_width
+    else:
+        # 4:3 aspect ratio : use 34mm for 35mm film
+        film_width = 34
+        if inverse:
+            return focal35_or_ratio * film_width
+        else:
+            return focal35_or_ratio / film_width
+
+
 def compute_focal(
+    pixel_width: int,
+    pixel_height: int,
     focal_35: Optional[float],
     focal: Optional[float],
     sensor_width: Optional[float],
     sensor_string: Optional[str],
 ) -> Tuple[float, float]:
     if focal_35 is not None and focal_35 > 0:
-        focal_ratio = focal_35 / 36.0  # 35mm film produces 36x24mm pictures.
+        focal_ratio = focal35_to_focal_ratio(focal_35, pixel_width, pixel_height)
     else:
         if not sensor_width:
             sensor_width = (
@@ -75,7 +104,9 @@ def compute_focal(
             )
         if sensor_width and focal:
             focal_ratio = focal / sensor_width
-            focal_35 = 36.0 * focal_ratio
+            focal_35 = focal35_to_focal_ratio(
+                focal, pixel_width, pixel_height, inverse=True
+            )
         else:
             focal_35 = 0.0
             focal_ratio = 0.0
@@ -248,7 +279,10 @@ def extract_projection_type(self) -> str:
 
     def extract_focal(self) -> Tuple[float, float]:
         make, model = self.extract_make(), self.extract_model()
+        width, height = self.extract_image_size()
         focal_35, focal_ratio = compute_focal(
+            width,
+            height,
             get_tag_as_float(self.tags, "EXIF FocalLengthIn35mmFilm"),
             get_tag_as_float(self.tags, "EXIF FocalLength"),
             self.extract_sensor_width(),
@@ -636,7 +670,13 @@ def extract_exif(self) -> Dict[str, Any]:
 
 def hard_coded_calibration(exif: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     focal = exif["focal_ratio"]
-    fmm35 = int(round(focal * 36.0))
+    fmm35 = int(
+        round(
+            focal35_to_focal_ratio(
+                focal, int(exif["width"]), int(exif["height"]), inverse=True
+            )
+        )
+    )
     make = exif["make"].strip().lower()
     model = exif["model"].strip().lower()
     raw_calibrations = camera_calibration()[0]

From bb73a7c25c57ebd99fef35c0db7e89d00633538b Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Fri, 15 Aug 2025 11:55:42 +0200
Subject: [PATCH 193/235] Update to ceres 2.2 + use SuiteSparse+Metis

---
 conda.yml                                      |  6 ++++--
 opensfm/src/CMakeLists.txt                     |  3 +++
 opensfm/src/bundle/src/bundle_adjuster.cc      |  1 +
 .../bundle/test/reprojection_errors_test.cc    | 18 +++++++++++++++++-
 4 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/conda.yml b/conda.yml
index 1e163ceff..39500686e 100644
--- a/conda.yml
+++ b/conda.yml
@@ -6,7 +6,9 @@ dependencies:
     - libxcrypt
     - libopencv *=headless*
     - py-opencv
-    - conda-forge::libvorbis
-    - ceres-solver=2.1
+    - anaconda::ceres-solver=2.2
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
+    - anaconda::suitesparse
+    - conda-forge::openblas
+    - anaconda::metis
\ No newline at end of file
diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index 88a7dd84f..3cf994f02 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -40,6 +40,9 @@ endif()
 # For compiling VLFeat
 add_definitions(-DVL_DISABLE_AVX)
 
+# We're not using an inplace Glog
+add_definitions(-DGLOG_USE_GLOG_EXPORT)
+
 # Use the version of vlfeat in ./src/third_party/vlfeat
 add_definitions(-DINPLACE_VLFEAT)
 if(NOT USE_SSE2)
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index a8185354d..5df2fa6ba 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -1109,6 +1109,7 @@ void BundleAdjuster::Run() {
   }
   options.num_threads = num_threads_;
   options.max_num_iterations = max_num_iterations_;
+  options.sparse_linear_algebra_library_type = ceres::SUITE_SPARSE;
 
   ceres::Solve(options, &problem, &last_run_summary_);
 
diff --git a/opensfm/src/bundle/test/reprojection_errors_test.cc b/opensfm/src/bundle/test/reprojection_errors_test.cc
index 3a920de0f..7c9093c19 100644
--- a/opensfm/src/bundle/test/reprojection_errors_test.cc
+++ b/opensfm/src/bundle/test/reprojection_errors_test.cc
@@ -1,8 +1,24 @@
-#include <bundle/error/projection_errors.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include <Eigen/Dense>
+#include <unsupported/Eigen/AutoDiff>
+
+using TEigenDiff = Eigen::AutoDiffScalar<Eigen::Matrix<double, -1, 1>>;
+
+namespace std {
+int fpclassify(const TEigenDiff& x) {
+  return std::fpclassify(x.value());
+}
+
+inline TEigenDiff hypot(const TEigenDiff& x, const TEigenDiff& y,
+                        const TEigenDiff& z) {
+  return sqrt(x * x + y * y + z * z);
+}
+}  // namespace std
+
+// Has to be included AFTER std:: maths overloads for Eigen Autodiff above
+#include <bundle/error/projection_errors.h>
 
 class ReprojectionError2DFixtureBase : public ::testing::Test {
  public:

From f6d3de4ae1cd83eee65aaac17b70c1aae314522f Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Fri, 15 Aug 2025 11:54:27 +0200
Subject: [PATCH 194/235] Speed track manager creation while decreasing memory
 usage

We read data in //, and return directly numpy array for pairs

BEFORE: peaked at 27 Gig, takes 7 minutes
66512 yann      20   0   33.8g  27.1g  85860 R 679.7  44.5  11:28.40 python3

2025-08-15 14:55:32,538 INFO: Starting incremental reconstruction
2025-08-15 14:55:32,595 INFO: Loaded 0 ground control points.
2025-08-15 15:02:37,038 INFO: Estimated reconstructability of 272092 image pairs.

AFTER: peaked at 24.5 Gig, takes 1.5 minutes
57925 yann      20   0   30.2g  24.5g  79620 S  1027  40.3   9:38.68 python3

2025-08-15 12:54:06,895 INFO: Starting incremental reconstruction
2025-08-15 12:54:07,361 INFO: Loaded 0 ground control points.
2025-08-15 12:54:07,361 DEBUG: Computing pairwise connectivity of images
2025-08-15 12:54:44,323 DEBUG: Gathering pairwise tracks with 24 processes
2025-08-15 12:55:34,110 INFO: Estimated reconstructability of 272106 image pairs.
---
 opensfm/actions/create_tracks.py      |   5 +-
 opensfm/actions/reconstruct.py        |   6 +-
 opensfm/dense.py                      |   5 +-
 opensfm/reconstruction.py             |   3 +-
 opensfm/src/map/python/pybind.cc      |   3 +
 opensfm/src/map/src/tracks_manager.cc |  18 ++++
 opensfm/src/map/tracks_manager.h      |   3 +
 opensfm/tracking.py                   | 147 +++++++++++++++++++-------
 8 files changed, 142 insertions(+), 48 deletions(-)

diff --git a/opensfm/actions/create_tracks.py b/opensfm/actions/create_tracks.py
index b57b810d4..ae7b456f8 100644
--- a/opensfm/actions/create_tracks.py
+++ b/opensfm/actions/create_tracks.py
@@ -13,9 +13,10 @@ def run_dataset(data: DataSetBase) -> None:
         data, data.images()
     )
     features_end = timer()
-    matches = tracking.load_matches(data, data.images())
+    matches = lambda: tracking.load_matches(data, data.images())
     matches_end = timer()
-    tracks_manager = tracking.create_tracks_manager(
+
+    tracks_manager = tracking.create_tracks_manager_from_matches_iter(
         features,
         colors,
         segmentations,
diff --git a/opensfm/actions/reconstruct.py b/opensfm/actions/reconstruct.py
index 0034b0355..0e03a182a 100644
--- a/opensfm/actions/reconstruct.py
+++ b/opensfm/actions/reconstruct.py
@@ -1,4 +1,5 @@
 # pyre-strict
+import gc
 from opensfm import io, reconstruction
 from opensfm.dataset_base import DataSetBase
 
@@ -21,5 +22,8 @@ def run_dataset(
     else:
         raise RuntimeError(f"Unsupported algorithm for reconstruction {algorithm}")
 
-    data.save_reconstruction(reconstructions)
+    del tracks_manager
+    gc.collect()
+
     data.save_report(io.json_dumps(report), "reconstruction.json")
+    data.save_reconstruction(reconstructions)
diff --git a/opensfm/dense.py b/opensfm/dense.py
index 9f4042cb4..0f4b69ec0 100644
--- a/opensfm/dense.py
+++ b/opensfm/dense.py
@@ -30,7 +30,7 @@ def compute_depthmaps(
     num_neighbors = config["depthmap_num_neighbors"]
 
     neighbors = {}
-    common_tracks = common_tracks_double_dict(graph)
+    common_tracks = common_tracks_double_dict(graph, processes)
     for shot in reconstruction.shots.values():
         neighbors[shot.id] = find_neighboring_images(
             shot, common_tracks, reconstruction, num_neighbors
@@ -394,13 +394,14 @@ def compute_depth_range(
 
 def common_tracks_double_dict(
     tracks_manager: pymap.TracksManager,
+    processes: int,
 ) -> Dict[str, Dict[str, List[str]]]:
     """List of track ids observed by each image pair.
 
     Return a dict, ``res``, such that ``res[im1][im2]`` is the list of
     common tracks between ``im1`` and ``im2``.
     """
-    common_tracks_per_pair = tracking.all_common_tracks_without_features(tracks_manager)
+    common_tracks_per_pair = tracking.all_common_tracks_without_features(tracks_manager, processes=processes)
     res = {image: {} for image in tracks_manager.get_shot_ids()}
     for (im1, im2), v in common_tracks_per_pair.items():
         res[im1][im2] = v
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 071e4a0f8..94dfcd718 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -235,7 +235,6 @@ def _pair_reconstructability_arguments(
 
 
 def _compute_pair_reconstructability(args: TPairArguments) -> Tuple[str, str, float]:
-    log.setup()
     im1, im2, p1, p2, camera1, camera2, threshold = args
     R, inliers = two_view_reconstruction_rotation_only(
         p1, p2, camera1, camera2, threshold
@@ -1684,7 +1683,7 @@ def incremental_reconstruction(
         # pairs of image. Features of an image can be stored
         # repeatedly in multiple image pairs.
         # Pros: fast; Cons: high memory usage
-        common_tracks = tracking.all_common_tracks_with_features(tracks_manager)
+        common_tracks = tracking.all_common_tracks_with_features(tracks_manager, processes=data.config["processes"])
         pairs = compute_image_pairs(common_tracks, data)
     else:
         # Get pairs sequentially, load features lazily.
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index 8307b7001..4a74b4ce8 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -305,6 +305,9 @@ PYBIND11_MODULE(pymap, m) {
       .def("get_all_common_observations",
            &map::TracksManager::GetAllCommonObservations,
            py::call_guard<py::gil_scoped_release>())
+      .def("get_all_common_observations_arrays",
+           &map::TracksManager::GetAllCommonObservationsArrays,
+           py::call_guard<py::gil_scoped_release>())     
       .def("get_all_pairs_connectivity",
            &map::TracksManager::GetAllPairsConnectivity,
            py::arg("shots") = std::vector<map::ShotId>(),
diff --git a/opensfm/src/map/src/tracks_manager.cc b/opensfm/src/map/src/tracks_manager.cc
index b3ca2ed41..881dfa2e0 100644
--- a/opensfm/src/map/src/tracks_manager.cc
+++ b/opensfm/src/map/src/tracks_manager.cc
@@ -1,4 +1,5 @@
 #include <foundation/union_find.h>
+#include <foundation/types.h>
 #include <map/tracks_manager.h>
 
 #include <optional>
@@ -305,6 +306,23 @@ TracksManager::GetAllCommonObservations(const ShotId& shot1,
   return tuples;
 }
 
+std::tuple<std::vector<map::TrackId>, MatX2f, MatX2f>
+TracksManager::GetAllCommonObservationsArrays(const ShotId& shot1,
+                                              const ShotId& shot2) const {
+  const auto tuples = GetAllCommonObservations(shot1, shot2);
+
+  std::vector<map::TrackId> track_ids(tuples.size());
+  MatX2f points1(tuples.size(), 2);
+  MatX2f points2(tuples.size(), 2);
+  for (int i = 0; i < tuples.size(); ++i) {
+    const auto& [track_id, obs1, obs2] = tuples[i];
+    track_ids[i] = track_id;
+    points1.row(i) = obs1.point.cast<float>();
+    points2.row(i) = obs2.point.cast<float>();
+  }
+  return {track_ids, points1, points2};
+}
+
 std::unordered_map<TracksManager::ShotPair, int, HashPair>
 TracksManager::GetAllPairsConnectivity(
     const std::vector<ShotId>& shots,
diff --git a/opensfm/src/map/tracks_manager.h b/opensfm/src/map/tracks_manager.h
index ab17d3189..6a9cfd446 100644
--- a/opensfm/src/map/tracks_manager.h
+++ b/opensfm/src/map/tracks_manager.h
@@ -33,6 +33,9 @@ class TracksManager {
   using KeyPointTuple = std::tuple<TrackId, Observation, Observation>;
   std::vector<KeyPointTuple> GetAllCommonObservations(
       const ShotId& shot1, const ShotId& shot2) const;
+  std::tuple<std::vector<map::TrackId>, MatX2f, MatX2f> GetAllCommonObservationsArrays(
+    const ShotId& shot1,
+    const ShotId& shot2) const;
 
   using ShotPair = std::pair<ShotId, ShotId>;
   std::unordered_map<ShotPair, int, HashPair> GetAllPairsConnectivity(
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index 04e5da48c..2fbc0e196 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -1,12 +1,12 @@
 # pyre-strict
 import logging
 import typing as t
-from typing import cast, Dict, List, Tuple
+from typing import Callable, cast, Dict, List, Tuple
 
 import networkx as nx
 import numpy as np
 from numpy.typing import NDArray
-from opensfm import pymap
+from opensfm import context, pymap
 from opensfm.dataset_base import DataSetBase
 from opensfm.pymap import TracksManager
 from opensfm.unionfind import UnionFind
@@ -24,38 +24,49 @@ def load_features(
     Dict[str, NDArray[np.int32]],
     Dict[str, NDArray[np.float64]],
 ]:
-    logging.info("reading features")
+    logging.info("Reading features")
+
+    def load_one(im):
+        features_data = dataset.load_features(im)
+        if not features_data:
+            return im, None, None, None, None, None
+        features = features_data.points[:, :3]
+        colors = features_data.colors
+        segmentations = None
+        instances = None
+        if features_data.semantic:
+            segmentations = features_data.semantic.segmentation
+            if features_data.semantic.has_instances():
+                instances = features_data.semantic.instances
+        depths = features_data.depths if features_data.depths is not None else None
+        return im, features, colors, segmentations, instances, depths
+
+    # Use context.parallel_map for parallel loading
+    results = context.parallel_map(load_one, images, dataset.config.get("processes", 1))
+
     features = {}
     colors = {}
     segmentations = {}
     instances = {}
     depths = {}
-    for im in images:
-        features_data = dataset.load_features(im)
-
-        if not features_data:
-            continue
-
-        features[im] = features_data.points[:, :3]
-        colors[im] = features_data.colors
-
-        semantic_data = features_data.semantic
-        if semantic_data:
-            segmentations[im] = semantic_data.segmentation
-            if semantic_data.has_instances():
-                instances[im] = semantic_data.instances
-
-        depth_data = features_data.depths
-        if depth_data is not None:
-            depths[im] = depth_data
+    for im, feat, color, seg, inst, depth in results:
+        if feat is not None:
+            features[im] = feat
+            colors[im] = color
+            if seg is not None:
+                segmentations[im] = seg
+            if inst is not None:
+                instances[im] = inst
+            if depth is not None:
+                depths[im] = depth
 
     return features, colors, segmentations, instances, depths
 
 
 def load_matches(
     dataset: DataSetBase, images: List[str]
-) -> Dict[Tuple[str, str], List[Tuple[int, int]]]:
-    matches = {}
+) -> t.Iterator[Tuple[Tuple[str, str], List[Tuple[int, int]]]]:
+    """Yield matches for each image pair"""
     for im1 in images:
         try:
             im1_matches = dataset.load_matches(im1)
@@ -63,16 +74,15 @@ def load_matches(
             continue
         for im2 in im1_matches:
             if im2 in images:
-                matches[im1, im2] = im1_matches[im2]
-    return matches
+                yield (im1, im2), im1_matches[im2]
 
 
-def create_tracks_manager(
+def create_tracks_manager_from_matches_iter(
     features: Dict[str, NDArray[np.float64]],
     colors: Dict[str, NDArray[np.int32]],
     segmentations: Dict[str, NDArray[np.int32]],
     instances: Dict[str, NDArray[np.int32]],
-    matches: Dict[Tuple[str, str], List[Tuple[int, int]]],
+    matches: Callable[[], t.Iterator[Tuple[Tuple[str, str], List[Tuple[int, int]]]]],
     min_length: int,
     depths: Dict[str, NDArray[np.float64]],
     depth_is_radial: bool = True,
@@ -80,9 +90,11 @@ def create_tracks_manager(
 ) -> TracksManager:
     """Link matches into tracks."""
     logger.debug("Merging features onto tracks")
+
+    logger.debug("Running union-find to find aggregated tracks")
     uf = UnionFind()
-    for im1, im2 in matches:
-        for f1, f2 in matches[im1, im2]:
+    for (im1, im2), pairs in matches():
+        for f1, f2 in pairs:
             uf.union((im1, f1), (im2, f2))
 
     sets = {}
@@ -95,6 +107,7 @@ def create_tracks_manager(
 
     tracks = [t for t in sets.values() if _good_track(t, min_length)]
 
+    logger.debug("Constructing TracksManager from tracks")
     NO_VALUE = pymap.Observation.NO_SEMANTIC_VALUE
     tracks_manager = pymap.TracksManager()
     num_observations = 0
@@ -147,6 +160,44 @@ def create_tracks_manager(
     return tracks_manager
 
 
+def create_tracks_manager(
+    features: Dict[str, NDArray[np.float64]],
+    colors: Dict[str, NDArray[np.int32]],
+    segmentations: Dict[str, NDArray[np.int32]],
+    instances: Dict[str, NDArray[np.int32]],
+    matches: t.Union[
+        Dict[Tuple[str, str], List[Tuple[int, int]]],
+        Callable[[], t.Iterator[Tuple[Tuple[str, str], List[Tuple[int, int]]]]]
+    ],
+    min_length: int,
+    depths: Dict[str, NDArray[np.float64]],
+    depth_is_radial: bool = True,
+    depth_std_deviation: float = 1.0,
+) -> TracksManager:
+    """
+    Link matches into tracks.
+
+    If matches is a dict, it will be wrapped as an iterator.
+    If matches is a callable, it will be used directly.
+    """
+    if callable(matches):
+        matches_iter = matches
+    else:
+        def matches_iter():
+            return iter(matches.items())
+    return create_tracks_manager_from_matches_iter(
+        features,
+        colors,
+        segmentations,
+        instances,
+        matches_iter,
+        min_length,
+        depths,
+        depth_is_radial,
+        depth_std_deviation,
+    )
+
+
 def common_tracks(
     tracks_manager: pymap.TracksManager, im1: str, im2: str
 ) -> Tuple[List[str], NDArray[np.float64], NDArray[np.float64]]:
@@ -179,9 +230,10 @@ def common_tracks(
 def all_common_tracks_with_features(
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
+    processes: int = 1,
 ) -> Dict[Tuple[str, str], TPairTracks]:
     tracks = all_common_tracks(
-        tracks_manager, include_features=True, min_common=min_common
+        tracks_manager, include_features=True, min_common=min_common, processes=processes
     )
     return cast(Dict[Tuple[str, str], TPairTracks], tracks)
 
@@ -189,9 +241,10 @@ def all_common_tracks_with_features(
 def all_common_tracks_without_features(
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
+    processes: int = 1,
 ) -> Dict[Tuple[str, str], List[str]]:
     tracks = all_common_tracks(
-        tracks_manager, include_features=False, min_common=min_common
+        tracks_manager, include_features=False, min_common=min_common, processes=processes
     )
     return cast(Dict[Tuple[str, str], List[str]], tracks)
 
@@ -200,6 +253,7 @@ def all_common_tracks(
     tracks_manager: pymap.TracksManager,
     include_features: bool = True,
     min_common: int = 50,
+    processes: int = 1,
 ) -> Dict[Tuple[str, str], t.Union[TPairTracks, List[str]]]:
     """List of tracks observed by each image pair.
 
@@ -213,20 +267,31 @@ def all_common_tracks(
         tuple: im1, im2 -> tuple: tracks, features from first image, features
         from second image
     """
-    common_tracks = {}
-    for (im1, im2), size in tracks_manager.get_all_pairs_connectivity().items():
+    def process_pair(pair):
+        im1, im2, size = pair
         if size < min_common:
-            continue
-
-        tuples = tracks_manager.get_all_common_observations(im1, im2)
+            return None
+        track_ids, points1, points2 = tracks_manager.get_all_common_observations_arrays(im1, im2)
         if include_features:
-            common_tracks[im1, im2] = (
-                [v for v, _, _ in tuples],
-                np.array([p.point for _, p, _ in tuples]),
-                np.array([p.point for _, _, p in tuples]),
+            return (
+                (im1, im2),
+                (track_ids, points1, points2),
             )
         else:
-            common_tracks[im1, im2] = [v for v, _, _ in tuples]
+            return ((im1, im2), track_ids,)
+
+    logger.debug("Computing pairwise connectivity of images")
+    pairs = [(k[0], k[1], v) for k, v in tracks_manager.get_all_pairs_connectivity().items()]
+
+    logger.debug(f"Gathering pairwise tracks with {processes} processes")
+    batch_size = max(1, len(pairs) // (2 * processes))
+    results = context.parallel_map(process_pair, pairs, processes, batch_size)
+
+    common_tracks = {}
+    for result in results:
+        if result is not None:
+            k, v = result
+            common_tracks[k] = v
     return common_tracks
 
 

From fbd98f890afdb4b2a480f85c03f78e14b4eb24b2 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sun, 3 Aug 2025 21:27:00 +0200
Subject: [PATCH 195/235] Add C++ // triangulation function

This will be used later for grid-decimation BA
---
 opensfm/src/map/shot.h                 |  1 +
 opensfm/src/map/src/shot.cc            |  9 +++
 opensfm/src/sfm/CMakeLists.txt         |  1 +
 opensfm/src/sfm/retriangulation.h      |  3 +
 opensfm/src/sfm/src/retriangulation.cc | 80 +++++++++++++++++++++++++-
 5 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/map/shot.h b/opensfm/src/map/shot.h
index 45846fca9..89ce77264 100644
--- a/opensfm/src/map/shot.h
+++ b/opensfm/src/map/shot.h
@@ -141,6 +141,7 @@ class Shot {
   MatX2d ProjectMany(const MatX3d& points) const;
   Vec3d Bearing(const Vec2d& point) const;
   MatX3d BearingMany(const MatX2d& points) const;
+  Vec3d LandmarkBearing(const Landmark* landmark) const;
 
   // Covariance
   MatXd GetCovariance() const { return covariance_.Value(); }
diff --git a/opensfm/src/map/src/shot.cc b/opensfm/src/map/src/shot.cc
index 2356d97b1..0b13520da 100644
--- a/opensfm/src/map/src/shot.cc
+++ b/opensfm/src/map/src/shot.cc
@@ -185,6 +185,15 @@ Vec3d Shot::Bearing(const Vec2d& point) const {
   return GetPose()->RotationCameraToWorld() * shot_camera_->Bearing(point);
 }
 
+Vec3d Shot::LandmarkBearing(const Landmark* landmark) const {
+  auto it = landmark_observations_.find(const_cast<Landmark*>(landmark));
+  if (it == landmark_observations_.end()) {
+    throw std::runtime_error("Landmark not observed in this shot");
+  }
+  const Observation& obs = it->second;
+  return Bearing(obs.point);
+}
+
 MatX3d Shot::BearingMany(const MatX2d& points) const {
   MatX3d bearings(points.rows(), 3);
   for (int i = 0; i < points.rows(); ++i) {
diff --git a/opensfm/src/sfm/CMakeLists.txt b/opensfm/src/sfm/CMakeLists.txt
index ffc8d6e56..e587f674d 100644
--- a/opensfm/src/sfm/CMakeLists.txt
+++ b/opensfm/src/sfm/CMakeLists.txt
@@ -15,6 +15,7 @@ target_link_libraries(sfm
   PRIVATE
     foundation
     map
+    geometry
     bundle
     vl
 )
diff --git a/opensfm/src/sfm/retriangulation.h b/opensfm/src/sfm/retriangulation.h
index ffa56bca0..58b39b436 100644
--- a/opensfm/src/sfm/retriangulation.h
+++ b/opensfm/src/sfm/retriangulation.h
@@ -1,8 +1,11 @@
 #pragma once
+#include <unordered_set>
+
 #include <map/map.h>
 #include <map/tracks_manager.h>
 
 namespace sfm::retriangulation {
 void RealignMaps(const map::Map& reference, map::Map& to_align,
                  bool update_points);
+int Triangulate(map::Map& map, const std::unordered_set<map::TrackId>& track_ids, float min_angle, float min_depth, int processing_threads);
 }  // namespace sfm::retriangulation
diff --git a/opensfm/src/sfm/src/retriangulation.cc b/opensfm/src/sfm/src/retriangulation.cc
index 65ff8073a..2173a5d39 100644
--- a/opensfm/src/sfm/src/retriangulation.cc
+++ b/opensfm/src/sfm/src/retriangulation.cc
@@ -2,8 +2,10 @@
 #include <map/tracks_manager.h>
 #include <sfm/retriangulation.h>
 
+#include <geometry/triangulation.h>
+#include <map/map.h>
+
 #include <limits>
-#include <unordered_set>
 
 namespace sfm::retriangulation {
 void RealignMaps(const map::Map& map_from, map::Map& map_to,
@@ -113,4 +115,80 @@ void RealignMaps(const map::Map& map_from, map::Map& map_to,
     map_to.RemoveShot(shot_id);
   }
 }
+
+int Triangulate(map::Map& map, const std::unordered_set<map::TrackId>& track_ids, float min_angle, float min_depth, int processing_threads) {
+    constexpr size_t kDefaultObservations = 10;
+    const float min_angle_rad = min_angle * M_PI / 180.0;
+
+    int count = 0;
+    std::vector<map::TrackId> track_ids_vec(track_ids.begin(), track_ids.end());
+    std::vector<map::TrackId> to_delete;
+#pragma omp parallel num_threads(processing_threads)
+    {
+      std::vector<map::TrackId> thread_to_delete;
+
+      std::vector<double> threshold_list(kDefaultObservations, 1.0);
+      MatX3d origins(kDefaultObservations, 3);
+      MatX3d bearings(kDefaultObservations, 3);
+#pragma omp for schedule(static)
+      for (int i = 0; i < static_cast<int>(track_ids_vec.size()); ++i) {
+          const auto& track_id = track_ids_vec.at(i);
+          if (!map.HasLandmark(track_id)) {
+              continue;
+          }
+          auto& landmark = map.GetLandmark(track_id);
+          const auto& observations = landmark.GetObservations();
+          const size_t num_observations = observations.size();
+          if (num_observations < 2) {
+              thread_to_delete.push_back(track_id);
+              continue;
+          }
+
+          if(threshold_list.size() != num_observations) {
+              threshold_list.resize(num_observations, 1.0);
+          }
+          if(origins.rows() !=  num_observations) {
+              origins.resize(num_observations, 3);
+          }
+          if(bearings.rows() !=  num_observations) {
+              bearings.resize(num_observations, 3);
+          }
+
+          int idx = 0;
+          for (const auto& obs_pair : observations) {
+              const map::Shot* shot = obs_pair.first;
+              origins.row(idx) = shot->GetPose()->GetOrigin();
+              bearings.row(idx) = shot->LandmarkBearing(&landmark);
+              ++idx;
+          }
+
+          // Triangulate using midpoint method
+          const auto ok_pos = geometry::TriangulateBearingsMidpoint(origins, bearings, threshold_list,
+                                                                    min_angle_rad, min_depth);
+          if (!ok_pos.first) {
+            thread_to_delete.push_back(track_id);
+          }
+          else  {
+            landmark.SetGlobalPos(ok_pos.second);
+
+            // Refine the triangulated point
+            const auto pos_refined = geometry::PointRefinement(origins, bearings, landmark.GetGlobalPos(), 20);
+            landmark.SetGlobalPos(pos_refined);
+          }
+      }
+#pragma omp critical
+      {
+        to_delete.insert(to_delete.end(), thread_to_delete.begin(), thread_to_delete.end());
+      }  
+    }
+
+    // Remove landmarks that were not triangulated
+    for (const auto& track_id : to_delete) {
+      if (map.HasLandmark(track_id)) {
+        map.RemoveLandmark(track_id);
+      }
+    }
+    return count;
+}
+
 }  // namespace sfm::retriangulation

From bf8f25a9a0571bbe3ece352a5715658862febeec Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sun, 3 Aug 2025 21:25:52 +0200
Subject: [PATCH 196/235] Parallelize track counting

TSIA. On a 24-cores i9 285K :

BEFORE : 1.2 seconds
2025-08-15 12:55:37,559 INFO: Reconstruction now has 3 shots.
2025-08-15 12:55:38,785 INFO: -------------------------------------------------------

2025-08-15 12:55:40,502 INFO: Reconstruction now has 4 shots.
2025-08-15 12:55:41,746 INFO: -------------------------------------------------------

2025-08-15 12:55:42,135 INFO: Reconstruction now has 5 shots.
2025-08-15 12:55:43,392 INFO: -------------------------------------------------------

AFTER : 0.2 seconds
2025-08-15 13:01:55,007 INFO: Reconstruction now has 3 shots.
2025-08-15 13:01:55,138 INFO: -------------------------------------------------------

2025-08-15 13:01:56,832 INFO: Reconstruction now has 4 shots.
2025-08-15 13:01:56,965 INFO: -------------------------------------------------------

2025-08-15 13:01:57,359 INFO: Reconstruction now has 5 shots.
2025-08-15 13:01:57,492 INFO: -------------------------------------------------------

Difference is even bigger on larger (7K images) datasets
---
 opensfm/src/sfm/src/tracks_helpers.cc | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index d3aa710dd..4b25cd84b 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -11,8 +11,18 @@ std::unordered_map<map::ShotId, int> CountTracksPerShot(
   for (const auto& track : tracks) {
     tracks_set.insert(track);
   }
+  
   std::unordered_map<map::ShotId, int> counts;
-  for (const auto& shot : shots) {
+  for (int i = 0; i < shots.size(); ++i) {
+    counts[shots[i]] = 0;
+  }
+
+#pragma omp parallel
+{
+  std::vector<int> thread_counts(shots.size(), 0);
+#pragma omp for
+  for (int i = 0; i < shots.size(); ++i) {
+    const auto& shot = shots[i];
     const auto& observations = manager.GetShotObservations(shot);
 
     int sum = 0;
@@ -23,8 +33,19 @@ std::unordered_map<map::ShotId, int> CountTracksPerShot(
       }
       ++sum;
     }
-    counts[shot] = sum;
+    thread_counts[i] = sum;
+  }
+
+#pragma omp critical
+  {
+    for (int i = 0; i < shots.size(); ++i) {
+      if (thread_counts[i] > 0) {
+        counts[shots[i]] = thread_counts[i];
+      }
+    }
   }
+}
+
   return counts;
 }
 

From 2cf29a7eff8c67d4f52fdac48be4ef951c4839d2 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sun, 3 Aug 2025 21:26:21 +0200
Subject: [PATCH 197/235] Speed up VLAD by passing small copies instead of a
 big chunk

This speed-up and makes processing actually maxing cores, while avoiding lookups in a big map for large datasets. On a 24-core i9 285K :

BEFORE : 5 minutes, occupancy at 1x
2025-08-15 14:23:51,914 INFO: Computing VLAD candidates with 24 processes
2025-08-15 14:28:21,323 INFO: Matching 72411 image pairs
2025-08-15 14:28:21,326 INFO: Computing pair matching with 24 processes

AFTER : 1 second, occupancy at 20x
2025-08-15 14:35:41,984 INFO: Computing VLAD candidates with 24 processes
2025-08-15 14:35:42,726 INFO: Matching 72378 image pairs
2025-08-15 14:35:42,728 INFO: Computing pair matching with 24 processes

There's a difference in the number of pairs due to the config using jitter-based triangulation
---
 opensfm/vlad.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/opensfm/vlad.py b/opensfm/vlad.py
index 64d7cd18c..d6de6b510 100644
--- a/opensfm/vlad.py
+++ b/opensfm/vlad.py
@@ -41,8 +41,14 @@ def vlad_distances(
     Returns the image, the order of the other images,
     and the other images.
     """
+
+    # avoid passing a gigantic VLAD dictionary in case of preemption : copy instead
+    ratio_copy = 0.5
+    need_copy = len(other_images) < ratio_copy*len(histograms)
+    candidates = {k: histograms[k] for k in other_images + [image]} if need_copy else histograms
+
     distances, others = pyfeatures.compute_vlad_distances(
-        histograms, image, set(other_images)
+        candidates, image, set(other_images)
     )
     return image, distances, others
 

From a6bab0024b15121325fb5f5e0b7fb7f4af7371af Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Fri, 15 Aug 2025 12:21:06 +0200
Subject: [PATCH 198/235] On-the-fly resection candidates

Instead of recomputing resection candidates from scratch, which has O(N2) for the entire processing (and takes up to 1-2 seconds on large projects), we instead keep track of candidates per images. This makes everything constant time instead.

On helenenschacht (https://github.com/OpenDroneMap/odm_data_helenenschacht/tree/main) :

BEFORE : around 120 ms
2025-08-15 13:01:55,007 INFO: Reconstruction now has 3 shots.
2025-08-15 13:01:55,138 INFO: -------------------------------------------------------

2025-08-15 13:01:56,832 INFO: Reconstruction now has 4 shots.
2025-08-15 13:01:56,965 INFO: -------------------------------------------------------

2025-08-15 13:01:57,359 INFO: Reconstruction now has 5 shots.
2025-08-15 13:01:57,492 INFO: -------------------------------------------------------

AFTER : constant < 1 ms
2025-08-15 13:10:39,368 INFO: Reconstruction now has 3 shots.
2025-08-15 13:10:39,368 INFO: -------------------------------------------------------

2025-08-15 13:10:41,195 INFO: Reconstruction now has 4 shots.
2025-08-15 13:10:41,195 INFO: -------------------------------------------------------

2025-08-15 13:10:41,706 INFO: Reconstruction now has 5 shots.
2025-08-15 13:10:41,706 INFO: -------------------------------------------------------

On 7K images datasets (https://github.com/zivillian/odm_ziegeleipark/tree/master), this takes up to 1-2 seconds after a few thousands images
---
 opensfm/reconstruction.py | 140 +++++++++++++++++++++++++++++++-------
 1 file changed, 116 insertions(+), 24 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 94dfcd718..7b605b49a 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -705,7 +705,7 @@ def resect(
     bs = np.array(bs)
     Xs = np.array(Xs)
     if len(bs) < 5:
-        return False, set(), {"num_common_points": len(bs)}
+        return False, set(), set(), {"num_common_points": len(bs)}
 
     T = multiview.absolute_pose_ransac(bs, Xs, threshold, 1000, 0.999)
 
@@ -736,15 +736,17 @@ def resect(
             triangulate_shot_features(
                 tracks_manager, reconstruction, new_shots, data.config
             )
+        tracks = set()
         for i, succeed in enumerate(inliers):
             if succeed:
                 add_observation_to_reconstruction(
                     tracks_manager, reconstruction, shot_id, ids[i]
                 )
+                tracks.add(ids[i])
         report["shots"] = list(new_shots)
-        return True, new_shots, report
+        return True, new_shots, tracks, report
     else:
-        return False, set(), report
+        return False, set(), set(), report
 
 
 def corresponding_tracks(
@@ -911,7 +913,7 @@ def triangulate_robust(
         min_ray_angle_degrees: float,
         min_depth: float,
         iterations: int,
-    ) -> None:
+    ) -> bool:
         """Triangulate track in a RANSAC way and add point to reconstruction."""
         os, bs, ids = [], [], []
         for shot_id, obs in self.tracks_handler.get_observations(track).items():
@@ -923,7 +925,7 @@ def triangulate_robust(
             ids.append(shot_id)
 
         if len(ids) < 2:
-            return
+            return False
 
         os = np.array(os)
         bs = np.array(bs)
@@ -1003,6 +1005,7 @@ def triangulate_robust(
             self.tracks_handler.store_track_coordinates(track, best_point)
             for i in best_inliers:
                 self.tracks_handler.store_inliers_observation(track, ids[i])
+        return len(best_inliers) > 1
 
     def triangulate(
         self,
@@ -1011,7 +1014,7 @@ def triangulate(
         min_ray_angle_degrees: float,
         min_depth: float,
         iterations: int,
-    ) -> None:
+    ) -> bool:
         """Triangulate track and add point to reconstruction."""
         os, bs, ids = [], [], []
         for shot_id, obs in self.tracks_handler.get_observations(track).items():
@@ -1039,6 +1042,9 @@ def triangulate(
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
                     self.tracks_handler.store_inliers_observation(track, shot_id)
+                return True
+
+        return False            
 
     def triangulate_dlt(
         self,
@@ -1047,7 +1053,7 @@ def triangulate_dlt(
         min_ray_angle_degrees: float,
         min_depth: float,
         iterations: int,
-    ) -> None:
+    ) -> bool:
         """Triangulate track using DLT and add point to reconstruction."""
         Rts, bs, os, ids = [], [], [], []
         for shot_id, obs in self.tracks_handler.get_observations(track).items():
@@ -1075,6 +1081,8 @@ def triangulate_dlt(
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
                     self.tracks_handler.store_inliers_observation(track, shot_id)
+                return True
+        return False
 
     def _shot_origin(self, shot: pymap.Shot) -> NDArray:
         if shot.id in self.origins:
@@ -1106,7 +1114,7 @@ def triangulate_shot_features(
     reconstruction: types.Reconstruction,
     shot_ids: Set[str],
     config: Dict[str, Any],
-) -> None:
+) -> List[str]:
     """Reconstruct as many tracks seen in shot_id as possible."""
     reproj_threshold = config["triangulation_threshold"]
     min_ray_angle = config["triangulation_min_ray_angle"]
@@ -1124,24 +1132,29 @@ def triangulate_shot_features(
         if s in all_shots_ids
         for t in tracks_manager.get_shot_observations(s)
     }
+
+    created_tracks = []
     for track in tracks_ids:
         if track not in reconstruction.points:
             if config["triangulation_type"] == "ROBUST":
-                triangulator.triangulate_robust(
+                if(triangulator.triangulate_robust(
                     track,
                     reproj_threshold,
                     min_ray_angle,
                     min_depth,
                     refinement_iterations,
-                )
+                )):
+                    created_tracks.append(track)
             elif config["triangulation_type"] == "FULL":
-                triangulator.triangulate(
+                if(triangulator.triangulate(
                     track,
                     reproj_threshold,
                     min_ray_angle,
                     min_depth,
                     refinement_iterations,
-                )
+                )):
+                    created_tracks.append(track)
+    return created_tracks
 
 
 def retriangulate(
@@ -1214,7 +1227,7 @@ def remove_outliers(
     reconstruction: types.Reconstruction,
     config: Dict[str, Any],
     points: Optional[Dict[str, pymap.Landmark]] = None,
-) -> int:
+) -> Tuple[List[Tuple[str, str]], Set[str]]:
     """Remove points with large reprojection error.
 
     A list of point ids to be processed can be given in ``points``.
@@ -1236,14 +1249,16 @@ def remove_outliers(
         reconstruction.map.remove_observation(shot_id, track)
         track_ids.add(track)
 
+    removed_tracks = set()
     for track in track_ids:
         if track in reconstruction.points:
             lm = reconstruction.points[track]
             if lm.number_of_observations() < 2:
                 reconstruction.map.remove_landmark(lm)
+                removed_tracks.add(track)
 
     logger.info("Removed outliers: {}".format(len(outliers)))
-    return len(outliers)
+    return outliers, removed_tracks
 
 
 def shot_lla_and_compass(
@@ -1407,6 +1422,75 @@ def should(self) -> bool:
     def done(self) -> None:
         self.num_points_last = len(self.reconstruction.points)
 
+class ResectionCandidates:
+    """Helper to keep track of resection candidates."""
+
+    def __init__(self, tracks_manager: pymap.TracksManager, reconstruction: types.Reconstruction) -> None:
+        self.tracks_manager = tracks_manager
+        self.reconstruction = reconstruction
+        self.candidates: Dict[str, Set[str]] = {}
+        self.tracks = set()
+
+    def update(self, reconstruction: types.Reconstruction) -> None:
+        """Update candidates based on a new reconstruction."""
+        self.reconstruction = reconstruction
+        rec_tracks = set(reconstruction.points.keys())
+
+        # add new tracks
+        for track_id in rec_tracks:
+            if track_id not in self.tracks:
+                self.tracks.add(track_id)
+                for shot_id in self.tracks_manager.get_track_observations(track_id):
+                    if shot_id not in self.candidates:
+                        self.candidates[shot_id] = set()
+                    self.candidates[shot_id].add(track_id)
+
+        # remove tracks that are not in the reconstruction
+        to_remove = set()
+        for track_id in self.tracks:
+            if track_id not in rec_tracks:
+                for shot_id, shot_candidates in self.candidates.items():
+                    if track_id in shot_candidates:
+                        shot_candidates.remove(track_id)
+                to_remove.add(track_id)
+
+        for track_id in to_remove:
+            self.tracks.remove(track_id)
+                
+    def add(self, shots: List[str], tracks: Set[str]) -> None:
+        """Add newly resected tracks and the shots they belong to."""
+        for shot_id in shots:
+            if shot_id in self.candidates:
+                del self.candidates[shot_id]
+
+        for track_id in tracks:
+            self.tracks.add(track_id)
+            for shot_id in self.tracks_manager.get_track_observations(track_id):
+                if shot_id in self.reconstruction.shots:
+                    continue
+                if shot_id not in self.candidates:
+                    self.candidates[shot_id] = set()
+                self.candidates[shot_id].add(track_id)
+
+    def remove(self, outliers: List[Tuple[str, str]], removed_tracks: List[str]) -> None:
+        """Remove outliers from candidates."""
+        for shot_id, track_id in outliers:
+            if shot_id in self.candidates and track_id in self.candidates[shot_id]:
+                self.candidates[shot_id].remove(track_id)
+                if not self.candidates[shot_id]:
+                    del self.candidates[shot_id]
+
+        for track_id in removed_tracks:
+            for shot_id, shot_candidates in self.candidates.items():
+                if track_id in shot_candidates:
+                    shot_candidates.remove(track_id)
+            self.tracks.remove(track_id)
+
+
+    def get_candidates(self, images: Set[str]) -> List[Tuple[str, int]]:
+        """Get sorted candidates for resection."""
+        return [(k, len(v)) for k,v in filter(lambda x: x[0] in images, sorted(self.candidates.items(), key=lambda x: -len(x[1])))]
+
 
 def grow_reconstruction(
     data: DataSetBase,
@@ -1429,8 +1513,15 @@ def grow_reconstruction(
     remove_outliers(reconstruction, config)
     paint_reconstruction(data, tracks_manager, reconstruction)
 
+    resection_candidates = ResectionCandidates(tracks_manager, reconstruction)
     should_bundle = ShouldBundle(data, reconstruction)
     should_retriangulate = ShouldRetriangulate(data, reconstruction)
+
+    resection_candidates.add(
+        list(reconstruction.shots.keys()),
+        list(reconstruction.points.keys()),
+    )
+    
     while True:
         if config["save_partial_reconstructions"]:
             paint_reconstruction(data, tracks_manager, reconstruction)
@@ -1441,9 +1532,7 @@ def grow_reconstruction(
                 ),
             )
 
-        candidates = reconstructed_points_for_images(
-            tracks_manager, reconstruction, images
-        )
+        candidates = resection_candidates.get_candidates(images)
         if not candidates:
             break
 
@@ -1451,7 +1540,7 @@ def grow_reconstruction(
         threshold = data.config["resection_threshold"]
         min_inliers = data.config["resection_min_inliers"]
         for image, _ in candidates:
-            ok, new_shots, resrep = resect(
+            ok, new_shots, resected_tracks, resrep = resect(
                 data,
                 tracks_manager,
                 reconstruction,
@@ -1470,6 +1559,7 @@ def grow_reconstruction(
                 rig_camera_priors,
                 data.config,
             )
+            resection_candidates.add(new_shots, resected_tracks)
 
             logger.info(f"Adding {' and '.join(new_shots)} to the reconstruction")
             step: Dict[str, Union[List[int], List[str], int, List[int], Any]] = {
@@ -1480,7 +1570,8 @@ def grow_reconstruction(
             report["steps"].append(step)
 
             np_before = len(reconstruction.points)
-            triangulate_shot_features(tracks_manager, reconstruction, new_shots, config)
+            new_tracks = triangulate_shot_features(tracks_manager, reconstruction, new_shots, config)
+            resection_candidates.add([], new_tracks)
             np_after = len(reconstruction.points)
             step["triangulated_points"] = np_after - np_before
 
@@ -1491,10 +1582,11 @@ def grow_reconstruction(
                     reconstruction, camera_priors, rig_camera_priors, None, config
                 )
                 rrep = retriangulate(tracks_manager, reconstruction, config)
+                resection_candidates.update(reconstruction)
                 b2rep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, config
                 )
-                remove_outliers(reconstruction, config)
+                resection_candidates.remove(*remove_outliers(reconstruction, config))
                 step["bundle"] = b1rep
                 step["retriangulation"] = rrep
                 step["bundle_after_retriangulation"] = b2rep
@@ -1505,7 +1597,7 @@ def grow_reconstruction(
                 brep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, config
                 )
-                remove_outliers(reconstruction, config)
+                resection_candidates.remove(*remove_outliers(reconstruction, config))
                 step["bundle"] = brep
                 should_bundle.done()
             elif config["local_bundle_radius"] > 0:
@@ -1517,7 +1609,7 @@ def grow_reconstruction(
                     image,
                     config,
                 )
-                remove_outliers(reconstruction, config, bundled_points)
+                resection_candidates.remove(*remove_outliers(reconstruction, config, bundled_points))
                 step["local_bundle"] = brep
 
             logger.info(f"Reconstruction now has {len(reconstruction.shots)} shots.")
@@ -1536,7 +1628,7 @@ def grow_reconstruction(
         config = overidden_config
 
     bundle(reconstruction, camera_priors, rig_camera_priors, gcp, config)
-    remove_outliers(reconstruction, config)
+    resection_candidates.remove(*remove_outliers(reconstruction, config))
 
     if config["filter_final_point_cloud"]:
         bad_condition = pysfm.filter_badly_conditioned_points(
@@ -1545,7 +1637,7 @@ def grow_reconstruction(
         logger.info("Removed bad-condition: {}".format(bad_condition))
         isolated = pysfm.remove_isolated_points(reconstruction.map)
         logger.info("Removed isolated: {}".format(isolated))
-
+    
     paint_reconstruction(data, tracks_manager, reconstruction)
     return reconstruction, report
 

From 56de1a7971c9ffed5ac99dccc8ec5a243d8f0429 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Fri, 15 Aug 2025 11:44:44 +0200
Subject: [PATCH 199/235] Add grid-based decimation followed by triangulation
 in BA

This greatly speeds-up BA, with no noticeable change in quality. Also reduces memory usage (smaller BAs)

On helenenschacht (https://github.com/OpenDroneMap/odm_data_helenenschacht/tree/main) :

BEFORE : 75 seconds

Average Reprojection Error (normalized / pixels / angular)0.22 / 0.74 / 0.00015
Average Track Length 2.62 images
Average Track Length (> 2)4.17 images

AFTER : 35 seconds

Average Reprojection Error (normalized / pixels / angular)0.22 / 0.74 / 0.00015
Average Track Length 2.62 images
Average Track Length (> 2) 4.17 images

On ziegeleipark (https://github.com/zivillian/odm_ziegeleipark/tree/master)

BEFORE : stopped after 12 hours

AFTER : 7575 seconds
---
 opensfm/config.py                 |   4 +
 opensfm/reconstruction.py         |  23 +++--
 opensfm/src/sfm/ba_helpers.h      |  10 +-
 opensfm/src/sfm/src/ba_helpers.cc | 154 +++++++++++++++++++++++++++---
 4 files changed, 170 insertions(+), 21 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 4eb19c200..35d5f09da 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -299,6 +299,10 @@ class OpenSfMConfig:
     local_bundle_min_common_points: int = 20
     # Max number of shots to optimize during local bundle adjustment
     local_bundle_max_shots: int = 30
+    # Number of grid division for seleccting tracks in local bundle adjustment
+    local_bundle_grid: int = 8
+    # Number of grid division for selecting tracks in final bundle adjustment
+    final_bundle_grid: int = 32
 
     # Remove uncertain and isolated points from the final point cloud
     filter_final_point_cloud: bool = False
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 7b605b49a..d44a3eade 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -51,7 +51,7 @@ def _get_camera_from_bundle(
 
 def log_bundle_stats(bundle_type: str, bundle_report: Dict[str, Any]) -> None:
     times = bundle_report["wall_times"]
-    time_secs = times["run"] + times["setup"] + times["teardown"]
+    time_secs = times["run"] + times["setup"] + times["teardown"] + times["triangulate"]
     num_images, num_points, num_reprojections = (
         bundle_report["num_images"],
         bundle_report["num_points"],
@@ -71,6 +71,7 @@ def bundle(
     camera_priors: Dict[str, pygeometry.Camera],
     rig_camera_priors: Dict[str, pymap.RigCamera],
     gcp: Optional[List[pymap.GroundControlPoint]],
+    grid_size: int,
     config: Dict[str, Any],
 ) -> Dict[str, Any]:
     """Bundle adjust a reconstruction."""
@@ -79,6 +80,7 @@ def bundle(
         dict(camera_priors),
         dict(rig_camera_priors),
         gcp if gcp is not None else [],
+        grid_size,
         config,
     )
     log_bundle_stats("GLOBAL", report)
@@ -109,6 +111,7 @@ def bundle_local(
     camera_priors: Dict[str, pygeometry.Camera],
     rig_camera_priors: Dict[str, pymap.RigCamera],
     gcp: Optional[List[pymap.GroundControlPoint]],
+    grid_size: int,
     central_shot_id: str,
     config: Dict[str, Any],
 ) -> Tuple[Dict[str, Any], List[int]]:
@@ -119,6 +122,7 @@ def bundle_local(
         dict(rig_camera_priors),
         gcp if gcp is not None else [],
         central_shot_id,
+        grid_size,
         config,
     )
     log_bundle_stats("LOCAL", report)
@@ -1509,7 +1513,7 @@ def grow_reconstruction(
     paint_reconstruction(data, tracks_manager, reconstruction)
     align_reconstruction(reconstruction, gcp, config)
 
-    bundle(reconstruction, camera_priors, rig_camera_priors, None, config)
+    bundle(reconstruction, camera_priors, rig_camera_priors, None, 0, config)
     remove_outliers(reconstruction, config)
     paint_reconstruction(data, tracks_manager, reconstruction)
 
@@ -1522,6 +1526,10 @@ def grow_reconstruction(
         list(reconstruction.points.keys()),
     )
     
+    local_ba_radius = config["local_bundle_radius"]
+    local_ba_grid = config["local_bundle_grid"]
+    final_bundle_grid = config["final_bundle_grid"]
+
     while True:
         if config["save_partial_reconstructions"]:
             paint_reconstruction(data, tracks_manager, reconstruction)
@@ -1579,12 +1587,12 @@ def grow_reconstruction(
                 logger.info("Re-triangulating")
                 align_reconstruction(reconstruction, gcp, config)
                 b1rep = bundle(
-                    reconstruction, camera_priors, rig_camera_priors, None, config
+                    reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
                 rrep = retriangulate(tracks_manager, reconstruction, config)
                 resection_candidates.update(reconstruction)
                 b2rep = bundle(
-                    reconstruction, camera_priors, rig_camera_priors, None, config
+                    reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
                 resection_candidates.remove(*remove_outliers(reconstruction, config))
                 step["bundle"] = b1rep
@@ -1595,17 +1603,18 @@ def grow_reconstruction(
             elif should_bundle.should():
                 align_reconstruction(reconstruction, gcp, config)
                 brep = bundle(
-                    reconstruction, camera_priors, rig_camera_priors, None, config
+                    reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
                 resection_candidates.remove(*remove_outliers(reconstruction, config))
                 step["bundle"] = brep
                 should_bundle.done()
-            elif config["local_bundle_radius"] > 0:
+            elif local_ba_radius > 0:
                 bundled_points, brep = bundle_local(
                     reconstruction,
                     camera_priors,
                     rig_camera_priors,
                     None,
+                    local_ba_grid,
                     image,
                     config,
                 )
@@ -1627,7 +1636,7 @@ def grow_reconstruction(
         overidden_config["bundle_compensate_gps_bias"] = False
         config = overidden_config
 
-    bundle(reconstruction, camera_priors, rig_camera_priors, gcp, config)
+    bundle(reconstruction, camera_priors, rig_camera_priors, gcp, final_bundle_grid, config)
     resection_candidates.remove(*remove_outliers(reconstruction, config))
 
     if config["filter_final_point_cloud"]:
diff --git a/opensfm/src/sfm/ba_helpers.h b/opensfm/src/sfm/ba_helpers.h
index e0c8552d1..4b0ad37a5 100644
--- a/opensfm/src/sfm/ba_helpers.h
+++ b/opensfm/src/sfm/ba_helpers.h
@@ -18,6 +18,7 @@ class BAHelpers {
       const std::unordered_map<map::RigCameraId, map::RigCamera>&
           rig_camera_priors,
       const AlignedVector<map::GroundControlPoint>& gcp,
+      int grid_size,
       const py::dict& config);
 
   static py::tuple BundleLocal(
@@ -26,7 +27,9 @@ class BAHelpers {
       const std::unordered_map<map::RigCameraId, map::RigCamera>&
           rig_camera_priors,
       const AlignedVector<map::GroundControlPoint>& gcp,
-      const map::ShotId& central_shot_id, const py::dict& config);
+      const map::ShotId& central_shot_id, 
+      int grid_size,
+      const py::dict& config);
 
   static py::dict BundleShotPoses(
       map::Map& map, const std::unordered_set<map::ShotId>& shot_ids,
@@ -57,6 +60,11 @@ class BAHelpers {
       const AlignedVector<map::GroundControlPoint>& gcp,
       const py::dict& config);
 
+  static std::unordered_set<map::TrackId> SelectTracksGrid(
+    map::Map& map,
+    const std::unordered_set<map::ShotId>& shot_ids,
+    size_t grid_size);
+
  private:
   static std::unordered_set<map::Shot*> DirectShotNeighbors(
       map::Map& map, const std::unordered_set<map::Shot*>& shot_ids,
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 1f1d55e95..264241aca 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -4,6 +4,7 @@
 #include <map/ground_control_points.h>
 #include <map/map.h>
 #include <sfm/ba_helpers.h>
+#include <sfm/retriangulation.h>
 
 #include <chrono>
 #include <cmath>
@@ -116,10 +117,11 @@ std::unordered_set<map::Shot*> BAHelpers::DirectShotNeighbors(
 py::tuple BAHelpers::BundleLocal(
     map::Map& map,
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
-    const std::unordered_map<map::RigCameraId, map::RigCamera>&
-        rig_camera_priors,
+    const std::unordered_map<map::RigCameraId, map::RigCamera>& rig_camera_priors,
     const AlignedVector<map::GroundControlPoint>& gcp,
-    const map::ShotId& central_shot_id, const py::dict& config) {
+    const map::ShotId& central_shot_id,
+    int grid_size,
+    const py::dict& config) {
   py::dict report;
   const auto start = std::chrono::high_resolution_clock::now();
   auto neighborhood = ShotNeighborhood(
@@ -129,6 +131,16 @@ py::tuple BAHelpers::BundleLocal(
   auto& interior = neighborhood.first;
   auto& boundary = neighborhood.second;
 
+  // Convert subset to set for fast lookup
+  std::unordered_set<map::ShotId> all_shots;
+  for (auto* shot : interior) {
+    all_shots.insert(shot->GetId());
+  }
+  for (auto* shot : boundary) {
+    all_shots.insert(shot->GetId());
+  }
+  const auto subset = SelectTracksGrid(map, all_shots, grid_size);
+
   // set up BA
   auto ba = bundle::BundleAdjuster();
   ba.SetUseAnalyticDerivatives(
@@ -141,8 +153,7 @@ py::tuple BAHelpers::BundleLocal(
     ba.AddCamera(cam.id, cam, cam_prior, fix_cameras);
   }
   // combine the sets
-  std::unordered_set<map::Shot*> int_and_bound(interior.cbegin(),
-                                               interior.cend());
+  std::unordered_set<map::Shot*> int_and_bound(interior.cbegin(), interior.cend());
   int_and_bound.insert(boundary.cbegin(), boundary.cend());
   std::unordered_set<map::Landmark*> points;
   py::list pt_ids;
@@ -179,7 +190,7 @@ py::tuple BAHelpers::BundleLocal(
     int gps_count = 0;
 
     // if any instance's shot is in boundary
-    // then the entire instance will be fixed
+    // then the entire instance will be fixed    
     bool fix_instance = false;
     for (const auto& shot_n_rig_camera : instance.GetRigCameras()) {
       const auto shot_id = shot_n_rig_camera.first;
@@ -216,12 +227,18 @@ py::tuple BAHelpers::BundleLocal(
     }
   }
 
+  std::unordered_set<map::TrackId> to_retriangulate;
   size_t added_landmarks = 0;
   size_t added_reprojections = 0;
   for (auto* shot : interior) {
     // Add all points of the shots that are in the interior
     for (const auto& lm_obs : shot->GetLandmarkObservations()) {
       auto* lm = lm_obs.first;
+      // Only add points in the subset
+      if (!subset.empty() && subset.count(lm->id_) == 0) {
+        to_retriangulate.insert(lm->id_);
+        continue;
+      }
       if (points.count(lm) == 0) {
         points.insert(lm);
         pt_ids.append(lm->id_);
@@ -237,6 +254,11 @@ py::tuple BAHelpers::BundleLocal(
   for (auto* shot : boundary) {
     for (const auto& lm_obs : shot->GetLandmarkObservations()) {
       auto* lm = lm_obs.first;
+      // Only add points in the subset
+      if (!subset.empty() && subset.count(lm->id_) == 0) {
+        to_retriangulate.insert(lm->id_);
+        continue;
+      }
       if (points.count(lm) > 0) {
         const auto& obs = lm_obs.second;
         ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_,
@@ -288,6 +310,12 @@ py::tuple BAHelpers::BundleLocal(
     point->SetGlobalPos(pt.GetValue());
     point->SetReprojectionErrors(pt.reprojection_errors);
   }
+
+  const auto timer_triangulate = std::chrono::high_resolution_clock::now();
+  sfm::retriangulation::Triangulate(map, to_retriangulate, 
+    config["triangulation_min_ray_angle"].cast<float>(),
+    config["triangulation_min_depth"].cast<float>(),
+    config["processes"].cast<int>());
   const auto timer_teardown = std::chrono::high_resolution_clock::now();
   report["brief_report"] = ba.BriefReport();
   report["wall_times"] = py::dict();
@@ -302,6 +330,11 @@ py::tuple BAHelpers::BundleLocal(
       1000000.0;
   report["wall_times"]["teardown"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_teardown -
+                                                            timer_triangulate)
+          .count() /
+      1000000.0;
+  report["wall_times"]["triangulate"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_triangulate -
                                                             timer_run)
           .count() /
       1000000.0;
@@ -410,11 +443,69 @@ size_t BAHelpers::AddGCPToBundle(
   return added_gcp_observations;
 }
 
+
+std::unordered_set<map::TrackId> BAHelpers::SelectTracksGrid(
+    map::Map& map,
+    const std::unordered_set<map::ShotId>& shot_ids,
+    size_t grid_size) {
+  std::unordered_set<map::TrackId> set_selected_tracks;
+  if (shot_ids.empty() || grid_size <= 1) {
+    return set_selected_tracks;
+  }
+
+  // For each shot (image)
+  for (const auto& shot_id : shot_ids) {
+    const auto& shot = map.GetShot(shot_id);
+    const int width = shot.GetCamera()->width;
+    const int height = shot.GetCamera()->height;
+    if (width <= 0 || height <= 0) {
+      continue;
+    }
+
+    // Prepare grid cells: each cell holds the longest track (by observation count)
+    std::vector<std::pair<map::TrackId, size_t>> grid(grid_size*grid_size, {"", 0});
+
+    // For each observation in the shot
+    for (const auto& lm_obs : shot.GetLandmarkObservations()) {
+      auto* lm = lm_obs.first;
+      const auto& obs = lm_obs.second;
+      // Get normalized coordinates [0,1]
+      const auto normalize = std::max(width, height);
+      double x = (obs.point(0) * normalize + width * 0.5) / width;
+      double y = (obs.point(1) * normalize + height * 0.5) / height;
+      // Clamp to [0,1]
+      x = std::max(0.0, std::min(1.0, x));
+      y = std::max(0.0, std::min(1.0, y));
+      // Compute grid cell
+      const int gx = std::min(static_cast<int>(x * grid_size), static_cast<int>(grid_size - 1));
+      const int gy = std::min(static_cast<int>(y * grid_size), static_cast<int>(grid_size - 1));
+      // Track length = number of observations
+      const size_t track_len = lm->GetObservations().size();
+      // Keep the longest track in this cell
+      if (set_selected_tracks.count(lm->id_) == 0 && track_len > grid[gx+gy*grid_size].second) {
+        grid[gx+gy*grid_size] = {lm->id_, track_len};
+      }
+    }
+
+    // Add selected tracks for this shot
+    for (int i = 0; i < static_cast<int>(grid_size*grid_size); ++i) {
+      const auto& track_id = grid[i].first;
+      if (!track_id.empty()) {
+        set_selected_tracks.insert(track_id);
+      }
+    }
+  }
+
+  return set_selected_tracks;
+}
+
+
+
 py::dict BAHelpers::BundleShotPoses(
     map::Map& map, const std::unordered_set<map::ShotId>& shot_ids,
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
     const std::unordered_map<map::RigCameraId, map::RigCamera>&
-        rig_camera_priors,
+        rig_camera_priors,    
     const py::dict& config) {
   py::dict report;
 
@@ -591,9 +682,19 @@ py::dict BAHelpers::Bundle(
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
     const std::unordered_map<map::RigCameraId, map::RigCamera>&
         rig_camera_priors,
-    const AlignedVector<map::GroundControlPoint>& gcp, const py::dict& config) {
+    const AlignedVector<map::GroundControlPoint>& gcp,
+    int grid_size,
+    const py::dict& config) {
   py::dict report;
 
+  // Get shot ids from the map
+  const auto& all_shots = map.GetShots();
+  std::unordered_set<map::ShotId> shot_ids;
+  for (const auto& shot_pair : all_shots) {
+      shot_ids.insert(shot_pair.first);
+  }
+  const auto subset = SelectTracksGrid(map, shot_ids, grid_size);
+
   auto ba = bundle::BundleAdjuster();
   const bool fix_cameras = !config["optimize_camera_parameters"].cast<bool>();
   ba.SetUseAnalyticDerivatives(
@@ -607,8 +708,14 @@ py::dict BAHelpers::Bundle(
     ba.AddCamera(cam.id, cam, cam_prior, fix_cameras);
   }
 
+  // Only add points in the subset
+  std::unordered_set<map::TrackId> to_retriangulate;
   for (const auto& pt_pair : map.GetLandmarks()) {
     const auto& pt = pt_pair.second;
+    if (!subset.empty() && subset.count(pt.id_) == 0) {
+      to_retriangulate.insert(pt.id_);
+      continue;
+    }
     ba.AddPoint(pt.id_, pt.GetGlobalPos(), false);
   }
 
@@ -707,6 +814,10 @@ py::dict BAHelpers::Bundle(
 
     // setup observations for any shot type
     for (const auto& lm_obs : shot.GetLandmarkObservations()) {
+      if (!subset.empty() && subset.count(lm_obs.first->id_) == 0) {
+        to_retriangulate.insert(lm_obs.first->id_);
+        continue;
+      }
       const auto& obs = lm_obs.second;
       ba.AddPointProjectionObservation(shot.id_, lm_obs.first->id_, obs.point,
                                        obs.scale, obs.depth_prior);
@@ -754,6 +865,13 @@ py::dict BAHelpers::Bundle(
   const auto timer_run = std::chrono::high_resolution_clock::now();
 
   BundleToMap(ba, map, !fix_cameras);
+  if(!subset.empty()){
+    sfm::retriangulation::Triangulate(map, to_retriangulate, 
+      config["triangulation_min_ray_angle"].cast<float>(),
+      config["triangulation_min_depth"].cast<float>(),
+      config["processes"].cast<int>());
+  }
+  const auto timer_triangulate = std::chrono::high_resolution_clock::now();
 
   const auto timer_teardown = std::chrono::high_resolution_clock::now();
   report["brief_report"] = ba.BriefReport();
@@ -767,13 +885,18 @@ py::dict BAHelpers::Bundle(
                                                             timer_setup)
           .count() /
       1000000.0;
+  report["wall_times"]["triangulate"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_triangulate -
+                                                            timer_run)
+          .count() /
+      1000000.0;
   report["wall_times"]["teardown"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_teardown -
-                                                            timer_run)
+                                                            timer_triangulate)
           .count() /
       1000000.0;
   report["num_images"] = map.GetShots().size();
-  report["num_points"] = map.GetLandmarks().size();
+  report["num_points"] = subset.empty() ? map.GetLandmarks().size() : subset.size();
   report["num_reprojections"] = added_reprojections;
   return report;
 }
@@ -824,10 +947,15 @@ void BAHelpers::BundleToMap(const bundle::BundleAdjuster& bundle_adjuster,
 
   // Update points
   for (auto& point : output_map.GetLandmarks()) {
-    const auto& pt = bundle_adjuster.GetPoint(point.first);
+    if(!bundle_adjuster.HasPoint(point.first)) {
+      continue;
+    }
+    auto pt = bundle_adjuster.GetPoint(point.first);
     if (!pt.GetValue().allFinite()) {
-      throw std::runtime_error("Point " + point.first +
-                               " has either NaN or INF values.");
+      // set large reprojection errors
+      for(auto& proj_error : pt.reprojection_errors) {
+        proj_error.second.setConstant(1.0);
+      }
     }
     point.second.SetGlobalPos(pt.GetValue());
     point.second.SetReprojectionErrors(pt.reprojection_errors);

From 1b30a0e44042b398e062ecbab7621c788a81c76b Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Fri, 15 Aug 2025 12:17:20 +0200
Subject: [PATCH 200/235] Preempt redundant images and resect them at the end

This conservative method greatly speeds-up project with long tracks and highly redundant images. This makes BA faster (smaller fill-in), and experiments shows no regression, even at aggressive thresholds.

Nevertheless, we use 0.7 as default, it likely not impact medium overlap dataset like zoo.

On ziegeleipark (https://github.com/zivillian/odm_ziegeleipark/tree/master) :

1.0 threshold (no redundancy cull) : 7575 seconds
Average Reprojection Error (normalized / pixels / angular)0.24 / 0.65 / 0.00022
Average Track Length 5.50 images
Average Track Length (> 2)8.61 images

0.8 threshold : 6843 seconds
Average Reprojection Error (normalized / pixels / angular)0.24 / 0.65 / 0.00022
Average Track Length 5.50 images
Average Track Length (> 2)8.61 images

0.4 threshold : 4262 seconds
Average Reprojection Error (normalized / pixels / angular)0.24 / 0.65 / 0.00023
Average Track Length 5.49 images
Average Track Length (> 2)8.60 images
---
 opensfm/config.py         |  2 ++
 opensfm/reconstruction.py | 33 ++++++++++++++++++++++++++-------
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 35d5f09da..4476f3abf 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -283,6 +283,8 @@ class OpenSfMConfig:
     # Maximum optimizer iterations.
     bundle_max_iterations: int = 100
 
+    # Ratio of (resection candidates / total tracks) of a given image so that it is culled at resection and resected later
+    resect_redundancy_threshold: float = 0.7
     # Retriangulate all points from time to time
     retriangulation: bool = True
     # Retriangulate when the number of points grows by this ratio
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index d44a3eade..382958435 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1521,14 +1521,16 @@ def grow_reconstruction(
     should_bundle = ShouldBundle(data, reconstruction)
     should_retriangulate = ShouldRetriangulate(data, reconstruction)
 
+    local_ba_radius = config["local_bundle_radius"]
+    local_ba_grid = config["local_bundle_grid"]
+    final_bundle_grid = config["final_bundle_grid"]
+
     resection_candidates.add(
         list(reconstruction.shots.keys()),
         list(reconstruction.points.keys()),
     )
-    
-    local_ba_radius = config["local_bundle_radius"]
-    local_ba_grid = config["local_bundle_grid"]
-    final_bundle_grid = config["final_bundle_grid"]
+    redundant_shots = set()
+    ratio_redundant = config["resect_redundancy_threshold"]
 
     while True:
         if config["save_partial_reconstructions"]:
@@ -1547,7 +1549,17 @@ def grow_reconstruction(
         logger.info("-------------------------------------------------------")
         threshold = data.config["resection_threshold"]
         min_inliers = data.config["resection_min_inliers"]
-        for image, _ in candidates:
+
+        for image, resect_points in candidates:
+
+            new_tracks = {t for t in tracks_manager.get_shot_observations(image)}
+            ratio_existing = resect_points / len(new_tracks) if new_tracks else 1.0
+            logger.info("Ratio of resected tracks in {}: {:.2f}".format(image, ratio_existing))
+            if ratio_existing > ratio_redundant:
+                redundant_shots.add(image)
+                images.remove(image)
+                continue
+
             ok, new_shots, resected_tracks, resrep = resect(
                 data,
                 tracks_manager,
@@ -1560,6 +1572,7 @@ def grow_reconstruction(
                 continue
 
             images -= new_shots
+            redundant_shots -= new_shots
             bundle_shot_poses(
                 reconstruction,
                 new_shots,
@@ -1625,8 +1638,14 @@ def grow_reconstruction(
 
             break
         else:
-            logger.info("Some images can not be added")
-            break
+            if redundant_shots:
+                images.update(redundant_shots)
+                redundant_shots.clear()
+                ratio_redundant = 1
+                local_ba_radius = 0
+            else:
+                logger.info("Some images can not be added")
+                break
 
     logger.info("-------------------------------------------------------")
 

From cd2452c7ad39b9730f2b9fb31c598038774de195 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sat, 16 Aug 2025 14:47:37 +0200
Subject: [PATCH 201/235] Better and unified GCP thresholds handling :  - Use a
 single threshold from triangulation to stats  - Only use  GCPs for linear
 alignment at the end since GPS and GCP have no garantee of consistency (bias)

---
 opensfm/align.py                              | 11 ++--
 opensfm/config.py                             |  6 ++-
 opensfm/multiview.py                          |  9 +++-
 opensfm/reconstruction.py                     |  8 +--
 opensfm/src/bundle/src/bundle_adjuster.cc     |  3 +-
 opensfm/src/sfm/ba_helpers.h                  |  1 +
 opensfm/src/sfm/src/ba_helpers.cc             | 52 +++++++++++--------
 opensfm/stats.py                              |  8 ++-
 .../test/test_reconstruction_incremental.py   |  6 +--
 .../test/test_reconstruction_triangulation.py |  2 +-
 10 files changed, 65 insertions(+), 41 deletions(-)

diff --git a/opensfm/align.py b/opensfm/align.py
index b949445d6..1b36c092c 100644
--- a/opensfm/align.py
+++ b/opensfm/align.py
@@ -127,11 +127,13 @@ def alignment_constraints(
     X, Xp = [], []
     # Get Ground Control Point correspondences
     if gcp and config["bundle_use_gcp"]:
-        triangulated, measured = triangulate_all_gcp(reconstruction, gcp)
+        triangulated, measured = triangulate_all_gcp(
+            reconstruction, gcp, config["gcp_reprojection_error_threshold"]
+        )
         X.extend(triangulated)
         Xp.extend(measured)
     # Get camera center correspondences
-    if use_gps and config["bundle_use_gps"]:
+    elif use_gps and config["bundle_use_gps"]:
         for rig_instance in reconstruction.rig_instances.values():
             gpses = [
                 shot.metadata.gps_position.value
@@ -433,7 +435,9 @@ def get_horizontal_and_vertical_directions(
 
 
 def triangulate_all_gcp(
-    reconstruction: types.Reconstruction, gcp: List[pymap.GroundControlPoint]
+    reconstruction: types.Reconstruction,
+    gcp: List[pymap.GroundControlPoint],
+    threshold: float,
 ) -> Tuple[List[NDArray], List[NDArray]]:
     """Group and triangulate Ground Control Points seen in 2+ images."""
     triangulated, measured = [], []
@@ -441,6 +445,7 @@ def triangulate_all_gcp(
         x = multiview.triangulate_gcp(
             point,
             reconstruction.shots,
+            threshold,
         )
         if x is not None and len(point.lla):
             point_enu = np.array(
diff --git a/opensfm/config.py b/opensfm/config.py
index 4476f3abf..9a1915d24 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -267,7 +267,7 @@ class OpenSfMConfig:
     # The default vertical standard deviation of the GCPs (in meters)
     gcp_vertical_sd: float = 0.1
     # Global weight for GCPs, expressed a ratio of the sum of (# projections) + (# shots) + (# relative motions)
-    gcp_global_weight: float = 0.01
+    gcp_global_weight: float = 0.1
     # The standard deviation of the rig translation
     rig_translation_sd: float = 0.1
     # The standard deviation of the rig rotation
@@ -313,7 +313,7 @@ class OpenSfMConfig:
     save_partial_reconstructions: bool = False
 
     ##################################
-    # Params for GPS alignment
+    # Params for GPS/GCP alignment
     ##################################
     # Use or ignore EXIF altitude tag
     use_altitude_tag: bool = True
@@ -327,6 +327,8 @@ class OpenSfMConfig:
     bundle_use_gcp: bool = True
     # Compensate GPS with a per-camera similarity transform
     bundle_compensate_gps_bias: bool = False
+    # Thrershold for the reprojection error of GCPs to be considered outliers
+    gcp_reprojection_error_threshold: float = 0.05
 
     ##################################
     # Params for rigs
diff --git a/opensfm/multiview.py b/opensfm/multiview.py
index 982204ee4..c74127812 100644
--- a/opensfm/multiview.py
+++ b/opensfm/multiview.py
@@ -533,6 +533,7 @@ def triangulate_gcp(
     reproj_threshold: float = 0.02,
     min_ray_angle_degrees: float = 1.0,
     min_depth: float = 0.001,
+    iterations: int = 10,
 ) -> Optional[NDArray]:
     """Compute the reconstructed position of a GCP from observations."""
 
@@ -550,13 +551,17 @@ def triangulate_gcp(
 
     if len(os) >= 2:
         thresholds = len(os) * [reproj_threshold]
+        os = np.asarray(os)
+        bs = np.asarray(bs)
         valid_triangulation, X = pygeometry.triangulate_bearings_midpoint(
-            np.asarray(os),
-            np.asarray(bs),
+            os,
+            bs,
             thresholds,
             np.radians(min_ray_angle_degrees),
             min_depth,
         )
+        
         if valid_triangulation:
+            X = pygeometry.point_refinement(os, bs, X, iterations)
             return X
     return None
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 382958435..733beabc0 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1511,7 +1511,7 @@ def grow_reconstruction(
     rig_camera_priors = data.load_rig_cameras()
 
     paint_reconstruction(data, tracks_manager, reconstruction)
-    align_reconstruction(reconstruction, gcp, config)
+    align_reconstruction(reconstruction, [], config)
 
     bundle(reconstruction, camera_priors, rig_camera_priors, None, 0, config)
     remove_outliers(reconstruction, config)
@@ -1598,7 +1598,7 @@ def grow_reconstruction(
 
             if should_retriangulate.should():
                 logger.info("Re-triangulating")
-                align_reconstruction(reconstruction, gcp, config)
+                align_reconstruction(reconstruction, [], config)
                 b1rep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
@@ -1614,7 +1614,7 @@ def grow_reconstruction(
                 should_retriangulate.done()
                 should_bundle.done()
             elif should_bundle.should():
-                align_reconstruction(reconstruction, gcp, config)
+                align_reconstruction(reconstruction, [], config)
                 brep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
@@ -1711,7 +1711,7 @@ def triangulation_reconstruction(
 
             step = {}
             logger.info(f"Triangulation SfM. Inner iteration {j}, running bundle ...")
-            align_reconstruction(reconstruction, gcp, config_override)
+            align_reconstruction(reconstruction, [], config_override)
             b1rep = bundle(
                 reconstruction, camera_priors, rig_camera_priors, None, config_override
             )
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 5df2fa6ba..8801ba326 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -809,8 +809,7 @@ void BundleAdjuster::Run() {
         projection_type, use_analytic_, observation, projection_loss, &problem);
 
     // Add relative depth error blocks
-    geometry::Dispatch<AddRelativeDepthError>(projection_type, observation,
-                                              projection_loss, &problem);
+    geometry::Dispatch<AddRelativeDepthError>(projection_type, observation, projection_loss, &problem);
   }
 
   // Add relative motion errors
diff --git a/opensfm/src/sfm/ba_helpers.h b/opensfm/src/sfm/ba_helpers.h
index 4b0ad37a5..61462540b 100644
--- a/opensfm/src/sfm/ba_helpers.h
+++ b/opensfm/src/sfm/ba_helpers.h
@@ -72,6 +72,7 @@ class BAHelpers {
   static bool TriangulateGCP(
       const map::GroundControlPoint& point,
       const std::unordered_map<map::ShotId, map::Shot>& shots,
+      float reproj_threshold,
       Vec3d& coordinates);
 
   static void AlignmentConstraints(
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 264241aca..06925b73b 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -351,8 +351,8 @@ py::tuple BAHelpers::BundleLocal(
 bool BAHelpers::TriangulateGCP(
     const map::GroundControlPoint& point,
     const std::unordered_map<map::ShotId, map::Shot>& shots,
+    float reproj_threshold,
     Vec3d& coordinates) {
-  constexpr auto reproj_threshold{1.0};
   constexpr auto min_ray_angle = 0.1 * M_PI / 180.0;
   constexpr auto min_depth = 1e-3;  // Assume GCPs 1mm+ away from the camera
   MatX3d os, bs;
@@ -390,35 +390,42 @@ size_t BAHelpers::AddGCPToBundle(
   const auto& reference = map.GetTopocentricConverter();
   const auto& shots = map.GetShots();
 
-  const auto dominant_terms = ba.GetRigInstances().size() +
-                              ba.GetProjectionsCount() +
-                              ba.GetRelativeMotionsCount();
 
-  size_t total_terms = 0;
-  for (const auto& point : gcp) {
-    Vec3d coordinates;
-    if (TriangulateGCP(point, shots, coordinates) || !point.lla_.empty()) {
-      ++total_terms;
-    }
-    for (const auto& obs : point.observations_) {
-      total_terms += (shots.count(obs.shot_id_) > 0);
-    }
-  }
-
-  double global_weight = config["gcp_global_weight"].cast<double>() *
-                         dominant_terms / std::max<size_t>(1, total_terms);
+  const float reproj_threshold =
+      config["gcp_reprojection_error_threshold"].cast<float>();
 
   size_t added_gcp_observations = 0;
   for (const auto& point : gcp) {
     const auto point_id = "gcp-" + point.id_;
     Vec3d coordinates;
-    if (!TriangulateGCP(point, shots, coordinates)) {
+    if (!TriangulateGCP(point, shots, reproj_threshold, coordinates)) {
       if (!point.lla_.empty()) {
         coordinates = reference.ToTopocentric(point.GetLlaVec3d());
       } else {
         continue;
       }
     }
+
+    double avg_observations = 0.;
+    int valid_shots = 0;
+    for (const auto& obs : point.observations_) {
+      const auto shot_it = shots.find(obs.shot_id_);
+      if (shot_it != shots.end()) {
+        const auto& shot = (shot_it->second);
+        avg_observations += shot.GetLandmarkObservations().size();
+        ++valid_shots;
+      }
+    }
+
+    if(!valid_shots) {
+      continue;
+    }
+    avg_observations /= valid_shots;
+    const double weight_factor =  std::sqrt(std::max(1.0, avg_observations));
+
+
+    const double prior_balance = std::sqrt(std::max(1.0, (double)valid_shots));
+    const double prior_weight = config["gcp_global_weight"].cast<double>() * weight_factor * prior_balance;
     constexpr auto point_constant{false};
     ba.AddPoint(point_id, coordinates, point_constant);
     if (!point.lla_.empty()) {
@@ -426,16 +433,17 @@ size_t BAHelpers::AddGCPToBundle(
                                    config["gcp_horizontal_sd"].cast<double>(),
                                    config["gcp_vertical_sd"].cast<double>());
       ba.AddPointPrior(point_id, reference.ToTopocentric(point.GetLlaVec3d()),
-                       point_std / global_weight, point.has_altitude_);
+                       point_std / prior_weight, point.has_altitude_);
     }
 
     // Now iterate through the observations
+    const double obs_weight = config["gcp_global_weight"].cast<double>() * weight_factor;
     for (const auto& obs : point.observations_) {
       const auto& shot_id = obs.shot_id_;
       if (shots.count(shot_id) > 0) {
         constexpr double scale{0.001};
         ba.AddPointProjectionObservation(shot_id, point_id, obs.projection_,
-                                         scale / global_weight);
+                                         scale  / obs_weight);
         ++added_gcp_observations;
       }
     }
@@ -829,7 +837,7 @@ py::dict BAHelpers::Bundle(
     AddGCPToBundle(ba, map, gcp, config);
   }
 
-  if (config["bundle_compensate_gps_bias"].cast<bool>()) {
+  if (config["bundle_compensate_gps_bias"].cast<bool>() && !gcp.empty()) {
     const auto& biases = map.GetBiases();
     for (const auto& camera : map.GetCameras()) {
       ba.SetCameraBias(camera.first, biases.at(camera.first));
@@ -989,7 +997,7 @@ void BAHelpers::AlignmentConstraints(
         continue;
       }
       Vec3d coordinates;
-      if (TriangulateGCP(point, shots, coordinates)) {
+      if (TriangulateGCP(point, shots, config["gcp_reprojection_error_threshold"].cast<float>(), coordinates)) {
         Xp.row(idx) = topocentricConverter.ToTopocentric(point.GetLlaVec3d());
         X.row(idx) = coordinates;
         ++idx;
diff --git a/opensfm/stats.py b/opensfm/stats.py
index a1166ba25..e6b39268c 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -94,7 +94,9 @@ def gcp_errors(
 
         triangulated = None
         for rec in reconstructions:
-            triangulated = multiview.triangulate_gcp(gcp, rec.shots, 1.0, 0.1)
+            triangulated = multiview.triangulate_gcp(
+                gcp, rec.shots, data.config["gcp_reprojection_error_threshold"]
+            )
             if triangulated is None:
                 continue
             else:
@@ -580,7 +582,9 @@ def save_residual_histogram(
         n,
         _,
         p_angular,
-    ) = axs[2].hist(b_angular[:-1], b_angular, weights=h_angular)
+    ) = axs[
+        2
+    ].hist(b_angular[:-1], b_angular, weights=h_angular)
     n = n.astype("int")
     for i in range(len(p_angular)):
         p_angular[i].set_facecolor(plt.cm.viridis(n[i] / max(n)))
diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index b5aaa8d74..21711ac07 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -34,15 +34,15 @@ def test_reconstruction_incremental(
     assert errors["ratio_cameras"] == 1.0
     assert 0.7 < errors["ratio_points"] < 1.0
 
-    assert 0 < errors["aligned_position_rmse"] < 0.03
-    assert 0 < errors["aligned_rotation_rmse"] < 0.003
+    assert 0 < errors["aligned_position_rmse"] < 0.035
+    assert 0 < errors["aligned_rotation_rmse"] < 0.0035
     assert 0 < errors["aligned_points_rmse"] < 0.1
 
     # Sanity check that GPS error is similar to the generated gps_noise
     assert 4.0 < errors["absolute_gps_rmse"] < 7.0
 
     # Sanity check that GCP error is similar to the generated gcp_noise
-    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.05
+    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.068
     assert 0.08 < errors["absolute_gcp_rmse_vertical"] < 0.18
 
     # Check that the GPS bias (only translation) is recovered
diff --git a/opensfm/test/test_reconstruction_triangulation.py b/opensfm/test/test_reconstruction_triangulation.py
index b41070072..bf86ec31e 100644
--- a/opensfm/test/test_reconstruction_triangulation.py
+++ b/opensfm/test/test_reconstruction_triangulation.py
@@ -40,7 +40,7 @@ def test_reconstruction_triangulation(
     assert 0.01 < errors["absolute_gps_rmse"] < 0.1
 
     # Sanity check that GCP error is similar to the generated gcp_noise
-    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.05
+    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.03
     assert 0.005 < errors["absolute_gcp_rmse_vertical"] < 0.04
 
     # Check that the GPS bias (only translation) is recovered

From 446a4b06624f38f7dc9922cf737fd3e806e75636 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 15 Dec 2025 21:21:02 +0100
Subject: [PATCH 202/235] Ensure consistent use of pyproj.Transform for
 Lat/Lon<->Proj CS conversions

---
 opensfm/actions/export_geocoords.py |  51 +----------
 opensfm/geo.py                      | 128 +++++++++++++++++++++++-----
 opensfm/io.py                       |  40 ++++++---
 3 files changed, 137 insertions(+), 82 deletions(-)

diff --git a/opensfm/actions/export_geocoords.py b/opensfm/actions/export_geocoords.py
index 966ef1445..34f6dc695 100644
--- a/opensfm/actions/export_geocoords.py
+++ b/opensfm/actions/export_geocoords.py
@@ -7,8 +7,8 @@
 import pyproj
 from numpy.typing import NDArray
 from opensfm import io, types
+from opensfm import geo
 from opensfm.dataset import DataSet, UndistortedDataSet
-from opensfm.geo import TopocentricConverter
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -40,8 +40,8 @@ def run_dataset(
 
     reference = data.load_reference()
 
-    projection = pyproj.Proj(proj)
-    t = _get_transformation(reference, projection)
+    projection = geo.construct_proj_transformer(proj, inverse=True)
+    t = geo.get_proj_transform_matrix(reference, projection)
 
     if transformation:
         output = output or "geocoords_transformation.txt"
@@ -57,7 +57,7 @@ def run_dataset(
     if reconstruction:
         reconstructions = data.load_reconstruction()
         for r in reconstructions:
-            _transform_reconstruction(r, t)
+            geo.transform_reconstruction_with_proj(r, projection)
         output = output or "reconstruction.geocoords.json"
         data.save_reconstruction(reconstructions, output)
 
@@ -68,24 +68,6 @@ def run_dataset(
         _transform_dense_point_cloud(udata, t, output_path)
 
 
-def _get_transformation(
-    reference: TopocentricConverter, projection: pyproj.Proj
-) -> NDArray:
-    """Get the linear transform from reconstruction coords to geocoords."""
-    p = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
-    q = [_transform(point, reference, projection) for point in p]
-
-    transformation = np.array(
-        [
-            [q[0][0] - q[3][0], q[1][0] - q[3][0], q[2][0] - q[3][0], q[3][0]],
-            [q[0][1] - q[3][1], q[1][1] - q[3][1], q[2][1] - q[3][1], q[3][1]],
-            [q[0][2] - q[3][2], q[1][2] - q[3][2], q[2][2] - q[3][2], q[3][2]],
-            [0, 0, 0, 1],
-        ]
-    )
-    return transformation
-
-
 def _write_transformation(transformation: NDArray, filename: str) -> None:
     """Write the 4x4 matrix transformation to a text file."""
     with io.open_wt(filename) as fout:
@@ -94,15 +76,6 @@ def _write_transformation(transformation: NDArray, filename: str) -> None:
             fout.write("\n")
 
 
-def _transform(
-    point: Sequence[float], reference: TopocentricConverter, projection: pyproj.Proj
-) -> List[float]:
-    """Transform on point from local coords to a proj4 projection."""
-    lat, lon, altitude = reference.to_lla(point[0], point[1], point[2])
-    easting, northing = projection(lon, lat)
-    return [easting, northing, altitude]
-
-
 def _transform_image_positions(
     reconstructions: List[types.Reconstruction], transformation: NDArray, output: str
 ) -> None:
@@ -121,22 +94,6 @@ def _transform_image_positions(
         fout.write(text)
 
 
-def _transform_reconstruction(
-    reconstruction: types.Reconstruction, transformation: NDArray
-) -> None:
-    """Apply a transformation to a reconstruction in-place."""
-    A, b = transformation[:3, :3], transformation[:3, 3]
-    A1 = np.linalg.inv(A)
-
-    for shot in reconstruction.shots.values():
-        R = shot.pose.get_rotation_matrix()
-        shot.pose.set_rotation_matrix(np.dot(R, A1))
-        shot.pose.set_origin(np.dot(A, shot.pose.get_origin()) + b)
-
-    for point in reconstruction.points.values():
-        point.coordinates = list(np.dot(A, point.coordinates) + b)
-
-
 def _transform_dense_point_cloud(
     udata: UndistortedDataSet, transformation: NDArray, output_path: str
 ) -> None:
diff --git a/opensfm/geo.py b/opensfm/geo.py
index 0d8229b8e..6c9cc7d82 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -1,7 +1,8 @@
 # pyre-strict
-from typing import overload, Sequence, Tuple, Union
+from typing import List, overload, Sequence, Tuple, Union
 
 import numpy as np
+import pyproj
 from numpy.typing import NDArray
 
 Scalars = Union[float, NDArray]
@@ -250,26 +251,6 @@ def gps_distance(
 def gps_distance(latlon_1: NDArray, latlon_2: NDArray) -> NDArray: ...
 
 
-def gps_distance(
-    latlon_1: Union[Sequence[Scalars], NDArray],
-    latlon_2: Union[Sequence[Scalars], NDArray],
-) -> Scalars:
-    """
-    Distance between two (lat,lon) pairs.
-
-    >>> p1 = (42.1, -11.1)
-    >>> p2 = (42.2, -11.3)
-    >>> 19000 < gps_distance(p1, p2) < 20000
-    True
-    """
-    x1, y1, z1 = ecef_from_lla(latlon_1[0], latlon_1[1], 0.0)
-    x2, y2, z2 = ecef_from_lla(latlon_2[0], latlon_2[1], 0.0)
-
-    dis = np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2 + (z1 - z2) ** 2)
-
-    return dis
-
-
 class TopocentricConverter:
     """Convert to and from a topocentric reference frame."""
 
@@ -311,3 +292,108 @@ def to_lla(
 
     def __eq__(self, o: "TopocentricConverter") -> bool:
         return np.allclose([self.lat, self.lon, self.alt], (o.lat, o.lon, o.alt))
+    
+
+def construct_proj_transformer(proj_str: str, inverse: bool = False) -> pyproj.Transformer:
+    """
+    Construct a pyproj Transformer object, converting between the given projection antod WGS84 (EPSG:4326).
+    If inverse is True, the transformation is from WGS84 to the given projection.
+    """
+    crs_4326 = pyproj.CRS.from_epsg(4326)
+    if inverse:
+        return pyproj.Transformer.from_proj(crs_4326, pyproj.CRS(proj_str))
+    else:
+        return pyproj.Transformer.from_proj(pyproj.CRS(proj_str), crs_4326)
+
+
+def transform_to_proj(
+    point: Sequence[float], reference: TopocentricConverter, projection: pyproj.Transformer
+) -> List[float]:
+    """
+    Transform a point defined wrt. the local topocentric frame to a projection
+    defined by the given Transformer. We assume the Transformer goes from
+    WGS84 to the desired projection.
+    """
+    assert projection.source_crs.to_epsg() == 4326, "Transformer source CRS must be WGS84 (EPSG:4326)"
+
+    lat, lon, altitude = reference.to_lla(point[0], point[1], point[2])
+    easting, northing = projection.transform(lat, lon)
+    return [easting, northing, altitude]
+
+
+def get_proj_transform_matrix(
+    reference: TopocentricConverter, projection: pyproj.Transformer
+) -> NDArray:
+    """Get the linear transform from reconstruction coords to geocoords."""
+    p = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
+    q = [transform_to_proj(point, reference, projection) for point in p]
+
+    transformation = np.array(
+        [
+            [q[0][0] - q[3][0], q[1][0] - q[3][0], q[2][0] - q[3][0], q[3][0]],
+            [q[0][1] - q[3][1], q[1][1] - q[3][1], q[2][1] - q[3][1], q[3][1]],
+            [q[0][2] - q[3][2], q[1][2] - q[3][2], q[2][2] - q[3][2], q[3][2]],
+            [0, 0, 0, 1],
+        ]
+    )
+    return transformation
+
+
+def transform_reconstruction_with_matrix(
+    reconstruction: "types.Reconstruction", transformation: NDArray
+) -> None:
+    """Apply a rigid transformation to a reconstruction in-place."""
+    A, b = transformation[:3, :3], transformation[:3, 3]
+    A1 = np.linalg.inv(A)
+
+    for shot in reconstruction.shots.values():
+        R = shot.pose.get_rotation_matrix()
+        shot.pose.set_rotation_matrix(np.dot(R, A1))
+        shot.pose.set_origin(np.dot(A, shot.pose.get_origin()) + b)
+
+    for point in reconstruction.points.values():
+        point.coordinates = list(np.dot(A, point.coordinates) + b)
+
+
+def transform_reconstruction_with_proj(
+    reconstruction: "types.Reconstruction", transformation: pyproj.Transformer
+) -> None:
+    """Apply a proj Transformer to a reconstruction in-place."""
+    eps = 1e-3
+    for shot in reconstruction.shots.values():
+        origin = shot.pose.get_origin()
+                    
+        # Jacobian for rotation update
+        p0 = np.array(transform_to_proj(origin, reconstruction.reference, transformation))
+        px = np.array(transform_to_proj(origin + [eps, 0, 0], reconstruction.reference, transformation))
+        py = np.array(transform_to_proj(origin + [0, eps, 0], reconstruction.reference, transformation))
+        pz = np.array(transform_to_proj(origin + [0, 0, eps], reconstruction.reference, transformation))
+        J = np.column_stack(((px - p0) / eps, (py - p0) / eps, (pz - p0) / eps))
+        
+        shot.pose.set_origin(p0)
+        shot.pose.set_rotation_matrix(shot.pose.get_rotation_matrix() @ np.linalg.inv(J))
+
+    for point in reconstruction.points.values():
+        point.coordinates = transform_to_proj(
+            point.coordinates, reconstruction.reference, transformation
+        )
+
+
+def gps_distance(
+    latlon_1: Union[Sequence[Scalars], NDArray],
+    latlon_2: Union[Sequence[Scalars], NDArray],
+) -> Scalars:
+    """
+    Distance between two (lat,lon) pairs.
+
+    >>> p1 = (42.1, -11.1)
+    >>> p2 = (42.2, -11.3)
+    >>> 19000 < gps_distance(p1, p2) < 20000
+    True
+    """
+    x1, y1, z1 = ecef_from_lla(latlon_1[0], latlon_1[1], 0.0)
+    x2, y2, z2 = ecef_from_lla(latlon_2[0], latlon_2[1], 0.0)
+
+    dis = np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2 + (z1 - z2) ** 2)
+
+    return dis
diff --git a/opensfm/io.py b/opensfm/io.py
index 3f4adc7e6..e82c6a765 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -903,25 +903,36 @@ def _parse_utm_projection_string(line: str) -> str:
     return s.format(zone_number, zone_hemisphere)
 
 
-def _parse_projection(line: str) -> Optional[pyproj.Transformer]:
-    """Build a proj4 from the GCP format line."""
-    crs_4326 = pyproj.CRS.from_epsg(4326)
-    if line.strip() == "WGS84":
+def _parse_projection_string(line: str) -> Optional[str]:
+    """Parse the projection string from the GCP format line."""
+    line = line.strip()
+    if line == "WGS84":
         return None
     elif line.upper().startswith("WGS84 UTM"):
-        return pyproj.Transformer.from_proj(
-            pyproj.CRS(_parse_utm_projection_string(line)), crs_4326
-        )
-    elif "+proj" in line:
-        return pyproj.Transformer.from_proj(pyproj.CRS(line), crs_4326)
-    elif line.upper().startswith("EPSG:"):
-        return pyproj.Transformer.from_proj(
-            pyproj.CRS.from_epsg(int(line.split(":")[1])), crs_4326
-        )
+        return _parse_utm_projection_string(line)
+    elif "+proj" in line or line.upper().startswith("EPSG:"):
+        return line
     else:
         raise ValueError("Un-supported geo system definition: {}".format(line))
 
 
+def read_gcp_projection_string(fileobj: IO[str]) -> Optional[str]:
+    """Read the projection string from a gcp_list.txt file."""
+    for line in fileobj:
+        if _valid_gcp_line(line):
+            return _parse_projection_string(line)
+    return None
+
+
+def read_gcp_projection(line: str) -> Optional[pyproj.Transformer]:
+    """Build a proj4 from the GCP format line."""
+    projection_string = _parse_projection_string(line)
+    if projection_string is None:
+        return None
+
+    return projection_string
+
+
 def _valid_gcp_line(line: str) -> bool:
     stripped = line.strip()
     return stripped != "" and stripped[0] != "#"
@@ -937,7 +948,8 @@ def read_gcp_list(
     """
     all_lines = fileobj.readlines()
     lines = iter(filter(_valid_gcp_line, all_lines))
-    projection = _parse_projection(next(lines))
+    projection_string = read_gcp_projection(next(lines))
+    projection = geo.construct_proj_transformer(projection_string) if projection_string else None
     points = _read_gcp_list_lines(lines, projection, exif)
     return points
 

From d1824b57c77d9365d9051350d6eb6d8987f8fc36 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 20:46:44 +0100
Subject: [PATCH 203/235] fix: support WGS84 as EPSG4326. And some formatting.

---
 opensfm/geo.py | 51 ++++++++++++++++++++++++++++++++++++--------------
 opensfm/io.py  | 22 ++++++++++++++--------
 2 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/opensfm/geo.py b/opensfm/geo.py
index 6c9cc7d82..c900dc9cc 100644
--- a/opensfm/geo.py
+++ b/opensfm/geo.py
@@ -12,7 +12,10 @@
 
 
 @overload
-def ecef_from_lla(lat: float, lon: float, alt: float) -> Tuple[float, float, float]: ...
+def ecef_from_lla(lat: float, lon: float,
+                  alt: float) -> Tuple[float, float, float]: ...
+
+
 @overload
 def ecef_from_lla(
     lat: NDArray, lon: NDArray, alt: NDArray
@@ -46,7 +49,10 @@ def ecef_from_lla(
 
 
 @overload
-def lla_from_ecef(x: float, y: float, z: float) -> Tuple[float, float, float]: ...
+def lla_from_ecef(x: float, y: float,
+                  z: float) -> Tuple[float, float, float]: ...
+
+
 @overload
 def lla_from_ecef(
     x: NDArray, y: NDArray, z: NDArray
@@ -163,6 +169,8 @@ def topocentric_from_lla(
     reflon: float,
     refalt: float,
 ) -> Tuple[float, float, float]: ...
+
+
 @overload
 def topocentric_from_lla(
     lat: NDArray,
@@ -212,6 +220,8 @@ def lla_from_topocentric(
     reflon: float,
     refalt: float,
 ) -> Tuple[float, float, float]: ...
+
+
 @overload
 def lla_from_topocentric(
     x: NDArray,
@@ -242,7 +252,10 @@ def lla_from_topocentric(
 
 
 @overload
-def gps_distance(latlon_1: Sequence[float], latlon_2: Sequence[float]) -> float: ...
+def gps_distance(latlon_1: Sequence[float],
+                 latlon_2: Sequence[float]) -> float: ...
+
+
 @overload
 def gps_distance(
     latlon_1: Sequence[NDArray], latlon_2: Sequence[NDArray]
@@ -264,6 +277,7 @@ def __init__(self, reflat: float, reflon: float, refalt: float) -> None:
     def to_topocentric(
         self, lat: float, lon: float, alt: float
     ) -> Tuple[float, float, float]: ...
+
     @overload
     def to_topocentric(
         self, lat: NDArray, lon: NDArray, alt: NDArray
@@ -277,7 +291,9 @@ def to_topocentric(
         return topocentric_from_lla(lat, lon, alt, self.lat, self.lon, self.alt)
 
     @overload
-    def to_lla(self, x: float, y: float, z: float) -> Tuple[float, float, float]: ...
+    def to_lla(self, x: float, y: float,
+               z: float) -> Tuple[float, float, float]: ...
+
     @overload
     def to_lla(
         self, x: NDArray, y: NDArray, z: NDArray
@@ -292,7 +308,7 @@ def to_lla(
 
     def __eq__(self, o: "TopocentricConverter") -> bool:
         return np.allclose([self.lat, self.lon, self.alt], (o.lat, o.lon, o.alt))
-    
+
 
 def construct_proj_transformer(proj_str: str, inverse: bool = False) -> pyproj.Transformer:
     """
@@ -314,7 +330,8 @@ def transform_to_proj(
     defined by the given Transformer. We assume the Transformer goes from
     WGS84 to the desired projection.
     """
-    assert projection.source_crs.to_epsg() == 4326, "Transformer source CRS must be WGS84 (EPSG:4326)"
+    assert projection.source_crs.to_epsg(
+    ) == 4326, "Transformer source CRS must be WGS84 (EPSG:4326)"
 
     lat, lon, altitude = reference.to_lla(point[0], point[1], point[2])
     easting, northing = projection.transform(lat, lon)
@@ -362,16 +379,22 @@ def transform_reconstruction_with_proj(
     eps = 1e-3
     for shot in reconstruction.shots.values():
         origin = shot.pose.get_origin()
-                    
+
         # Jacobian for rotation update
-        p0 = np.array(transform_to_proj(origin, reconstruction.reference, transformation))
-        px = np.array(transform_to_proj(origin + [eps, 0, 0], reconstruction.reference, transformation))
-        py = np.array(transform_to_proj(origin + [0, eps, 0], reconstruction.reference, transformation))
-        pz = np.array(transform_to_proj(origin + [0, 0, eps], reconstruction.reference, transformation))
-        J = np.column_stack(((px - p0) / eps, (py - p0) / eps, (pz - p0) / eps))
-        
+        p0 = np.array(transform_to_proj(
+            origin, reconstruction.reference, transformation))
+        px = np.array(transform_to_proj(
+            origin + [eps, 0, 0], reconstruction.reference, transformation))
+        py = np.array(transform_to_proj(
+            origin + [0, eps, 0], reconstruction.reference, transformation))
+        pz = np.array(transform_to_proj(
+            origin + [0, 0, eps], reconstruction.reference, transformation))
+        J = np.column_stack(
+            ((px - p0) / eps, (py - p0) / eps, (pz - p0) / eps))
+
         shot.pose.set_origin(p0)
-        shot.pose.set_rotation_matrix(shot.pose.get_rotation_matrix() @ np.linalg.inv(J))
+        shot.pose.set_rotation_matrix(
+            shot.pose.get_rotation_matrix() @ np.linalg.inv(J))
 
     for point in reconstruction.points.values():
         point.coordinates = transform_to_proj(
diff --git a/opensfm/io.py b/opensfm/io.py
index e82c6a765..0fd94dc77 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -611,7 +611,8 @@ def reconstruction_to_json(reconstruction: types.Reconstruction) -> Dict[str, An
     if len(reconstruction.rig_instances):
         obj["rig_instances"] = {}
     for rig_instance in reconstruction.rig_instances.values():
-        obj["rig_instances"][rig_instance.id] = rig_instance_to_json(rig_instance)
+        obj["rig_instances"][rig_instance.id] = rig_instance_to_json(
+            rig_instance)
 
     # Extract shots
     for shot in reconstruction.shots.values():
@@ -706,7 +707,8 @@ def camera_from_vector(
     elif projection_type == "fisheye62":
         fx, fy, cx, cy, k1, k2, k3, k4, k5, k6, p1, p2 = parameters
         camera = pygeometry.Camera.create_fisheye62(
-            fx, fy / fx, np.array([cx, cy]), np.array([k1, k2, k3, k4, k5, k6, p1, p2])
+            fx, fy / fx, np.array([cx, cy]), np.array([k1,
+                                                       k2, k3, k4, k5, k6, p1, p2])
         )
     elif projection_type == "fisheye624":
         fx, fy, cx, cy, k1, k2, k3, k4, k5, k6, p1, p2, s0, s1, s2, s3 = parameters
@@ -906,7 +908,7 @@ def _parse_utm_projection_string(line: str) -> str:
 def _parse_projection_string(line: str) -> Optional[str]:
     """Parse the projection string from the GCP format line."""
     line = line.strip()
-    if line == "WGS84":
+    if line in ["WGS84", "EPSG:4326"]:
         return None
     elif line.upper().startswith("WGS84 UTM"):
         return _parse_utm_projection_string(line)
@@ -948,8 +950,9 @@ def read_gcp_list(
     """
     all_lines = fileobj.readlines()
     lines = iter(filter(_valid_gcp_line, all_lines))
-    projection_string = read_gcp_projection(next(lines))
-    projection = geo.construct_proj_transformer(projection_string) if projection_string else None
+    projection_string = _parse_projection_string(next(lines))
+    projection = geo.construct_proj_transformer(
+        projection_string) if projection_string else None
     points = _read_gcp_list_lines(lines, projection, exif)
     return points
 
@@ -1112,7 +1115,8 @@ def reconstruction_to_ply(
             if point_num_views and tracks_manager:
                 obs_count = point.number_of_observations()
                 if obs_count == 0:
-                    obs_count = len(tracks_manager.get_track_observations(point.id))
+                    obs_count = len(
+                        tracks_manager.get_track_observations(point.id))
                 s += " {}".format(obs_count)
 
             vertices.append(s)
@@ -1272,7 +1276,8 @@ def imread_from_fileobject(
         raise IOError("Unable to load image")
 
     if len(image.shape) == 3:
-        image[:, :, :3] = image[:, :, [2, 1, 0]]  # Turn BGR to RGB (or BGRA to RGBA)
+        # Turn BGR to RGB (or BGRA to RGBA)
+        image[:, :, :3] = image[:, :, [2, 1, 0]]
     return image
 
 
@@ -1286,7 +1291,8 @@ def imwrite_from_fileobject(
 ) -> None:
     """Write an image to a file object"""
     if len(image.shape) == 3:
-        image[:, :, :3] = image[:, :, [2, 1, 0]]  # Turn RGB to BGR (or RGBA to BGRA)
+        # Turn RGB to BGR (or RGBA to BGRA)
+        image[:, :, :3] = image[:, :, [2, 1, 0]]
     _, im_buffer = cv2.imencode(ext, image)
     fwb.write(im_buffer)
 

From d88f3eb8ccabeeb6089990439b715b4678c4899d Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 7 Jan 2026 11:23:23 +0100
Subject: [PATCH 204/235] Fix test broken by GCP branch

---
 opensfm/test/test_geo.py | 15 +++++++++++++++
 opensfm/test/test_io.py  | 15 ++-------------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/opensfm/test/test_geo.py b/opensfm/test/test_geo.py
index 387e813bc..6ed172411 100644
--- a/opensfm/test/test_geo.py
+++ b/opensfm/test/test_geo.py
@@ -44,3 +44,18 @@ def test_ecef_lla_topocentric_consistency_pygeo() -> None:
 def test_eq_geo() -> None:
     assert geo.TopocentricConverter(40, 30, 0) == geo.TopocentricConverter(40, 30, 0)
     assert geo.TopocentricConverter(40, 32, 0) != geo.TopocentricConverter(40, 30, 0)
+
+
+def test_parse_projection() -> None:
+    from opensfm import io
+    proj_str = io._parse_projection_string("WGS84")
+    assert proj_str is None
+
+    proj_str = io._parse_projection_string("WGS84 UTM 31N")
+    assert proj_str is not None
+
+    proj = geo.construct_proj_transformer(proj_str)
+    easting, northing = 431760, 4582313.7
+    lat, lon = 41.38946, 2.18378
+    plat, plon = proj.transform(easting, northing)
+    assert np.allclose((lat, lon), (plat, plon))
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 30ce514c8..80ef37522 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -18,7 +18,8 @@
 def test_reconstructions_from_json_consistency() -> None:
     with open(filename) as fin:
         obj_before = json.loads(fin.read())
-    obj_after = io.reconstructions_to_json(io.reconstructions_from_json(obj_before))
+    obj_after = io.reconstructions_to_json(
+        io.reconstructions_from_json(obj_before))
 
     assert obj_before[0]["cameras"] == obj_after[0]["cameras"]
 
@@ -67,18 +68,6 @@ def test_reconstruction_to_ply() -> None:
     assert len(ply.splitlines()) > len(reconstructions[0].points)
 
 
-def test_parse_projection() -> None:
-    proj = io._parse_projection("WGS84")
-    assert proj is None
-
-    proj = io._parse_projection("WGS84 UTM 31N")
-    easting, northing = 431760, 4582313.7
-    lat, lon = 41.38946, 2.18378
-    assert proj
-    plat, plon = proj.transform(easting, northing)
-    assert np.allclose((lat, lon), (plat, plon))
-
-
 def test_read_gcp_list() -> None:
     text = """WGS84
 13.400740745 52.519134104 12.0792090446 2335.0 1416.7 01.jpg

From 66cbb0f038b1c3b8489b855fca6cc4f95bc6dbcc Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 7 Jan 2026 11:23:44 +0100
Subject: [PATCH 205/235] Fix test broken by bundle branch

---
 annotation_gui_gcp/run_ba.py                  |  79 ++++++----
 opensfm/actions/bundle.py                     |   2 +-
 opensfm/reconstruction.py                     | 147 +++++++++++-------
 opensfm/test/test_bundle.py                   |  14 +-
 .../test/test_reconstruction_triangulation.py |   2 +-
 5 files changed, 157 insertions(+), 87 deletions(-)

diff --git a/annotation_gui_gcp/run_ba.py b/annotation_gui_gcp/run_ba.py
index ba6bc3dea..2e5db05ee 100644
--- a/annotation_gui_gcp/run_ba.py
+++ b/annotation_gui_gcp/run_ba.py
@@ -43,7 +43,8 @@ def merge_reconstructions(reconstructions, tracks_manager):
             merged.add_camera(camera)
 
         for point in reconstruction.points.values():
-            new_point = merged.create_point(f"R{ix_r}_{point.id}", point.coordinates)
+            new_point = merged.create_point(
+                f"R{ix_r}_{point.id}", point.coordinates)
             new_point.color = point.color
 
         for shot in reconstruction.shots.values():
@@ -51,7 +52,8 @@ def merge_reconstructions(reconstructions, tracks_manager):
             try:
                 obsdict = tracks_manager.get_shot_observations(shot.id)
             except RuntimeError:
-                logger.warning(f"Shot id {shot.id} missing from tracks_manager!")
+                logger.warning(
+                    f"Shot id {shot.id} missing from tracks_manager!")
                 continue
             for track_id, obs in obsdict.items():
                 merged_track_id = f"R{ix_r}_{track_id}"
@@ -94,7 +96,8 @@ def gcp_geopositional_error(
     coords_reconstruction = triangulate_gcps(gcps, reconstruction)
     out = {}
     for ix, gcp in enumerate(gcps):
-        expected = reconstruction.reference.to_lla(*gcp.lla_vec) if gcp.lla else None
+        expected = reconstruction.reference.to_lla(
+            *gcp.lla_vec) if gcp.lla else None
         triangulated = (
             coords_reconstruction[ix] if coords_reconstruction[ix] is not None else None
         )
@@ -113,7 +116,8 @@ def gcp_geopositional_error(
             lat, lon, _alt = out[gcp.id]["expected_lla"]
             expected_xy = reconstruction.reference.to_topocentric(lat, lon, 0)
             lat, lon, _alt = out[gcp.id]["triangulated_lla"]
-            triangulated_xy = reconstruction.reference.to_topocentric(lat, lon, 0)
+            triangulated_xy = reconstruction.reference.to_topocentric(
+                lat, lon, 0)
             out[gcp.id]["error_planar"] = np.linalg.norm(
                 np.array(expected_xy) - np.array(triangulated_xy)
             )
@@ -154,11 +158,13 @@ def reproject_gcps(
         output[gcp.id] = {}
         n_obs = len(gcp.observations)
         if point is None:
-            logger.info(f"Could not triangulate {gcp.id} with {n_obs} annotations")
+            logger.info(
+                f"Could not triangulate {gcp.id} with {n_obs} annotations")
             continue
         for observation in gcp.observations:
             lat, lon, alt = reconstruction.reference.to_lla(*point)
-            output[gcp.id][observation.shot_id] = {"lla": [lat, lon, alt], "error": 0}
+            output[gcp.id][observation.shot_id] = {
+                "lla": [lat, lon, alt], "error": 0}
             if observation.shot_id not in reconstruction.shots:
                 continue
             shot = reconstruction.shots[observation.shot_id]
@@ -195,7 +201,8 @@ def compute_gcp_std(gcp_errors):
     all_errors = []
     for gcp_id in gcp_errors:
         errors = [e["error"] for e in gcp_errors[gcp_id].values()]
-        logger.info(f"gcp {gcp_id} mean reprojection error = {np.mean(errors)}")
+        logger.info(
+            f"gcp {gcp_id} mean reprojection error = {np.mean(errors)}")
         all_errors.extend(errors)
 
     all_errors = [e for e in all_errors if not np.isnan(e)]
@@ -248,7 +255,8 @@ def add_gcp_to_bundle(
                 coordinates = np.array(enu)
             else:
                 logger.warning(
-                    "Cannot initialize GCP '{}'." "  Ignoring it".format(point.id)
+                    "Cannot initialize GCP '{}'." "  Ignoring it".format(
+                        point.id)
                 )
                 continue
 
@@ -292,9 +300,11 @@ def bundle_with_fixed_images(
         shot = reconstruction.get_shot(shot_id)
         for point in shot.get_valid_landmarks():
             obs = shot.get_landmark_observation(point)
-            ba.add_point_projection_observation(shot.id, point.id, obs.point, obs.scale)
+            ba.add_point_projection_observation(
+                shot.id, point.id, obs.point, obs.scale)
 
-    add_gcp_to_bundle(ba, reconstruction.reference, gcp, gcp_std, reconstruction.shots)
+    add_gcp_to_bundle(ba, reconstruction.reference, gcp,
+                      gcp_std, reconstruction.shots)
 
     ba.set_point_projection_loss_function(
         config["loss_function"], config["loss_function_threshold"]
@@ -438,7 +448,8 @@ def resect_image(im, camera, gcps, reconstruction, data, dst_reconstruction=None
         R = T[:, :3].T
         t = -R.dot(T[:, 3])
         dst_reconstruction.add_camera(camera)
-        shot = dst_reconstruction.create_shot(im, camera.id, pygeometry.Pose(R, t))
+        shot = dst_reconstruction.create_shot(
+            im, camera.id, pygeometry.Pose(R, t))
         shot.metadata = helpers.get_image_metadata(data, im)
         return shot
     else:
@@ -505,7 +516,8 @@ def align_3d_annotations_to_reconstruction(
     model_id,
     reconstruction,
 ):
-    coords_triangulated_gcps = triangulate_gcps(gcps_this_model, reconstruction)
+    coords_triangulated_gcps = triangulate_gcps(
+        gcps_this_model, reconstruction)
     n_triangulated = sum(x is not None for x in coords_triangulated_gcps)
     if n_triangulated < 3:
         logger.info(f"{model_id} has {n_triangulated} gcps, not aligning")
@@ -522,7 +534,8 @@ def align_3d_annotations_to_reconstruction(
     # Move / "reproject" the triangulated GCPs to the reference frame of the CAD model for display/interaction
     gcp_reprojections = {}
     try:
-        s, A, b = find_alignment(coords_triangulated_gcps, coords_annotated_gcps)
+        s, A, b = find_alignment(
+            coords_triangulated_gcps, coords_annotated_gcps)
         for gcp, coords in zip(gcps_this_model, coords_triangulated_gcps):
             gcp_reprojections[gcp.id] = (
                 (s * A.dot(coords) + b).tolist() if coords is not None else None
@@ -634,24 +647,29 @@ def align(
                 reconstructions = data.load_reconstruction(fn_resplit)
             else:
                 reconstructions = data.load_reconstruction()
-                reconstructions = [reconstructions[rec_a], reconstructions[rec_b]]
+                reconstructions = [
+                    reconstructions[rec_a], reconstructions[rec_b]]
             coords0 = triangulate_gcps(gcps, reconstructions[0])
             coords1 = triangulate_gcps(gcps, reconstructions[1])
             n_valid_0 = sum(c is not None for c in coords0)
-            logger.debug(f"Triangulated {n_valid_0}/{len(gcps)} gcps for rec #{rec_a}")
+            logger.debug(
+                f"Triangulated {n_valid_0}/{len(gcps)} gcps for rec #{rec_a}")
             n_valid_1 = sum(c is not None for c in coords1)
-            logger.debug(f"Triangulated {n_valid_1}/{len(gcps)} gcps for rec #{rec_b}")
+            logger.debug(
+                f"Triangulated {n_valid_1}/{len(gcps)} gcps for rec #{rec_b}")
             try:
                 s, A, b = find_alignment(coords1, coords0)
                 apply_similarity(reconstructions[1], s, A, b)
             except ValueError:
-                logger.warning(f"Could not rigidly align rec #{rec_b} to rec #{rec_a}")
+                logger.warning(
+                    f"Could not rigidly align rec #{rec_b} to rec #{rec_a}")
                 return
             logger.info(f"Rigidly aligned rec #{rec_b} to rec #{rec_a}")
         else:  # Image - to - reconstruction annotation
             reconstructions = data.load_reconstruction()
             base = reconstructions[rec_a]
-            resected = resect_annotated_single_images(base, gcps, camera_models, data)
+            resected = resect_annotated_single_images(
+                base, gcps, camera_models, data)
             reconstructions = [base, resected]
     else:
         logger.debug(
@@ -663,7 +681,8 @@ def align(
         return
 
     logger.debug(f"Aligning annotations, if any, to rec #{rec_a}")
-    align_external_3d_models_to_reconstruction(data, gcps, reconstructions[0], rec_a)
+    align_external_3d_models_to_reconstruction(
+        data, gcps, reconstructions[0], rec_a)
 
     # Set the GPS constraint of the moved/resected shots to the manually-aligned position
     for shot in reconstructions[1].shots.values():
@@ -698,7 +717,8 @@ def align(
 
         logger.info("Running BA on merged reconstructions")
         # orec.align_reconstruction(merged, None, data.config)
-        orec.bundle(merged, camera_models, {}, gcp=gcps, config=data.config)
+        orec.bundle(merged, camera_models, {}, gcp=gcps,
+                    grid_size=0, config=data.config)
         data.save_reconstruction(
             [merged], f"reconstruction_gcp_ba_{rec_a}x{rec_b}.json"
         )
@@ -727,7 +747,8 @@ def align(
     with open(f"{data.data_path}/gcp_reprojections_{rec_a}x{rec_b}.json", "w") as f:
         json.dump(gcp_reprojections, f, indent=4, sort_keys=True)
 
-    n_bad_gcp_annotations = int(sum(t[2] > px_threshold for t in reprojection_errors))
+    n_bad_gcp_annotations = int(
+        sum(t[2] > px_threshold for t in reprojection_errors))
     if n_bad_gcp_annotations > 0:
         logger.info(f"{n_bad_gcp_annotations} large reprojection errors:")
         for t in reprojection_errors:
@@ -751,7 +772,7 @@ def align(
         data.config["triangulation_min_ray_angle"] = backup
         logger.info(
             f"Re-triangulated. Removed {n_points - len(merged.points)}."
-            f" Kept {int(100*len(merged.points)/n_points)}%"
+            f" Kept {int(100 * len(merged.points) / n_points)}%"
         )
         data.save_reconstruction(
             [merged],
@@ -763,7 +784,8 @@ def align(
         # If we have two reconstructions, we do this twice, fixing each one.
         _rec_ixs = [(0, 1), (1, 0)] if rec_b is not None else [(0, 1)]
         for rec_ixs in _rec_ixs:
-            logger.info(f"Running BA with fixed images. Fixing rec #{rec_ixs[0]}")
+            logger.info(
+                f"Running BA with fixed images. Fixing rec #{rec_ixs[0]}")
             fixed_images = set(reconstructions[rec_ixs[0]].shots.keys())
             covariance_estimation_valid = bundle_with_fixed_images(
                 merged,
@@ -787,7 +809,8 @@ def align(
                 shots_std_this_pair = []
                 for shot in merged.shots.values():
                     if shot.id in reconstructions[rec_ixs[1]].shots:
-                        u, std_v = decompose_covariance(shot.covariance[3:, 3:])
+                        u, std_v = decompose_covariance(
+                            shot.covariance[3:, 3:])
                         std = np.linalg.norm(std_v)
                         shots_std_this_pair.append((shot.id, std))
                         logger.debug(f"{shot.id} std: {std}")
@@ -851,7 +874,8 @@ def align(
         )
     if n_bad_std != 0 or n_bad_gcp_annotations != 0:
         if rigid:
-            logger.info("Positional uncertainty was not calculated. (--rigid was set).")
+            logger.info(
+                "Positional uncertainty was not calculated. (--rigid was set).")
         elif not covariance:
             logger.info(
                 "Positional uncertainty was not calculated (--covariance not set)."
@@ -873,12 +897,13 @@ def align(
                 gcp_reprojections, px_threshold
             )
             gcps_sorted = sorted(
-                stats_bad_reprojections, key=lambda k: -stats_bad_reprojections[k]
+                stats_bad_reprojections, key=lambda k: -
+                stats_bad_reprojections[k]
             )
             for ix, gcp_id in enumerate(gcps_sorted[:5]):
                 n = stats_bad_reprojections[gcp_id]
                 if n > 0:
-                    logger.info(f"#{ix+1} - {gcp_id}: {n} bad annotations")
+                    logger.info(f"#{ix + 1} - {gcp_id}: {n} bad annotations")
         else:
             logger.info("No annotations with large reprojection errors")
 
diff --git a/opensfm/actions/bundle.py b/opensfm/actions/bundle.py
index ef976f643..daa775f46 100644
--- a/opensfm/actions/bundle.py
+++ b/opensfm/actions/bundle.py
@@ -27,6 +27,6 @@ def run_dataset(
         reconstruction.add_correspondences_from_tracks_manager(tracks_manager)
         gcp = dataset.load_ground_control_points()
         orec.bundle(
-            reconstruction, camera_priors, rig_cameras_priors, gcp, dataset.config
+            reconstruction, camera_priors, rig_cameras_priors, gcp, 0, dataset.config
         )
     dataset.save_reconstruction(reconstructions, output)
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 733beabc0..04c8249b2 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -51,7 +51,8 @@ def _get_camera_from_bundle(
 
 def log_bundle_stats(bundle_type: str, bundle_report: Dict[str, Any]) -> None:
     times = bundle_report["wall_times"]
-    time_secs = times["run"] + times["setup"] + times["teardown"] + times["triangulate"]
+    time_secs = times["run"] + times["setup"] + \
+        times["teardown"] + times["triangulate"]
     num_images, num_points, num_reprojections = (
         bundle_report["num_images"],
         bundle_report["num_points"],
@@ -60,7 +61,7 @@ def log_bundle_stats(bundle_type: str, bundle_report: Dict[str, Any]) -> None:
 
     msg = f"Ran {bundle_type} bundle in {time_secs:.2f} secs."
     if num_points > 0:
-        msg += f"with {num_images}/{num_points}/{num_reprojections} ({num_reprojections/num_points:.2f}) "
+        msg += f"with {num_images}/{num_points}/{num_reprojections} ({num_reprojections / num_points:.2f}) "
         msg += "shots/points/proj. (avg. length)"
 
     logger.info(msg)
@@ -157,7 +158,8 @@ def shot_neighborhood(
             reconstruction, interior, min_common_points, remaining
         )
         interior.update(neighbors)
-    boundary = direct_shot_neighbors(reconstruction, interior, 1, max_boundary_size)
+    boundary = direct_shot_neighbors(
+        reconstruction, interior, 1, max_boundary_size)
     return interior, boundary
 
 
@@ -269,7 +271,8 @@ def add_shot(
         added_shots = {shot_id}
     else:
         instance_id, _, instance_shots = rig_assignments[shot_id]
-        rig_instance = reconstruction.add_rig_instance(pymap.RigInstance(instance_id))
+        rig_instance = reconstruction.add_rig_instance(
+            pymap.RigInstance(instance_id))
 
         for shot in instance_shots:
             _, rig_camera_id, _ = rig_assignments[shot]
@@ -326,7 +329,8 @@ def two_view_reconstruction_plane_based(
 
     motion_inliers = []
     for R, t, _, _ in motions:
-        inliers = _two_view_reconstruction_inliers(b1, b2, R.T, -R.T.dot(t), threshold)
+        inliers = _two_view_reconstruction_inliers(
+            b1, b2, R.T, -R.T.dot(t), threshold)
         motion_inliers.append(inliers)
 
     # pyre-fixme[6]: For 1st argument expected `Union[_SupportsArray[dtype[typing.Any...
@@ -364,7 +368,8 @@ def two_view_reconstruction_and_refinement(
         t_curr = t.copy()
         R_curr = R.copy()
 
-    inliers = _two_view_reconstruction_inliers(b1, b2, R_curr, t_curr, threshold)
+    inliers = _two_view_reconstruction_inliers(
+        b1, b2, R_curr, t_curr, threshold)
 
     if len(inliers) > 5:
         T = multiview.relative_pose_optimize_nonlinear(
@@ -372,7 +377,8 @@ def two_view_reconstruction_and_refinement(
         )
         R_curr = T[:, :3]
         t_curr = T[:, 3]
-        inliers = _two_view_reconstruction_inliers(b1, b2, R_curr, t_curr, threshold)
+        inliers = _two_view_reconstruction_inliers(
+            b1, b2, R_curr, t_curr, threshold)
 
     return cv2.Rodrigues(R_curr.T)[0].ravel(), -R_curr.T.dot(t_curr), inliers
 
@@ -407,7 +413,8 @@ def two_view_reconstruction_rotation_only(
     b1 = camera1.pixel_bearing_many(p1)
     b2 = camera2.pixel_bearing_many(p2)
 
-    R = multiview.relative_pose_ransac_rotation_only(b1, b2, threshold, 1000, 0.999)
+    R = multiview.relative_pose_ransac_rotation_only(
+        b1, b2, threshold, 1000, 0.999)
     inliers = _two_view_rotation_inliers(b1, b2, R, threshold)
 
     return cv2.Rodrigues(R.T)[0].ravel(), inliers
@@ -574,14 +581,16 @@ def reconstruction_from_relative_pose(
 
     camera_priors = data.load_camera_models()
     rig_camera_priors = data.load_rig_cameras()
-    rig_assignments = rig.rig_assignments_per_image(data.load_rig_assignments())
+    rig_assignments = rig.rig_assignments_per_image(
+        data.load_rig_assignments())
 
     reconstruction = types.Reconstruction()
     reconstruction.reference = data.load_reference()
     reconstruction.cameras = camera_priors
     reconstruction.rig_cameras = rig_camera_priors
 
-    new_shots = add_shot(data, reconstruction, rig_assignments, im1, pygeometry.Pose())
+    new_shots = add_shot(data, reconstruction,
+                         rig_assignments, im1, pygeometry.Pose())
 
     if im2 not in new_shots:
         new_shots |= add_shot(
@@ -589,7 +598,8 @@ def reconstruction_from_relative_pose(
         )
 
     align_reconstruction(reconstruction, [], data.config)
-    triangulate_shot_features(tracks_manager, reconstruction, new_shots, data.config)
+    triangulate_shot_features(
+        tracks_manager, reconstruction, new_shots, data.config)
 
     logger.info("Triangulated: {}".format(len(reconstruction.points)))
     report["triangulated_points"] = len(reconstruction.points)
@@ -696,7 +706,8 @@ def resect(
         True on success.
     """
 
-    rig_assignments = rig.rig_assignments_per_image(data.load_rig_assignments())
+    rig_assignments = rig.rig_assignments_per_image(
+        data.load_rig_assignments())
     camera = reconstruction.cameras[data.load_exif(shot_id)["camera"]]
 
     bs, Xs, ids = [], [], []
@@ -722,7 +733,8 @@ def resect(
     inliers = np.linalg.norm(reprojected_bs - bs, axis=1) < threshold
     ninliers = int(sum(inliers))
 
-    logger.info("{} resection inliers: {} / {}".format(shot_id, ninliers, len(bs)))
+    logger.info(
+        "{} resection inliers: {} / {}".format(shot_id, ninliers, len(bs)))
     report: Dict[str, Any] = {
         "num_common_points": len(bs),
         "num_inliers": ninliers,
@@ -733,7 +745,8 @@ def resect(
         assert shot_id not in reconstruction.shots
 
         new_shots = add_shot(
-            data, reconstruction, rig_assignments, shot_id, pygeometry.Pose(R, t)
+            data, reconstruction, rig_assignments, shot_id, pygeometry.Pose(
+                R, t)
         )
 
         if shot_id in rig_assignments:
@@ -964,9 +977,11 @@ def triangulate_robust(
 
             if valid_triangulation:
                 reprojected_bs = X - os
-                reprojected_bs /= np.linalg.norm(reprojected_bs, axis=1)[:, np.newaxis]
+                reprojected_bs /= np.linalg.norm(reprojected_bs,
+                                                 axis=1)[:, np.newaxis]
                 inliers = np.nonzero(
-                    np.linalg.norm(reprojected_bs - bs, axis=1) < reproj_threshold
+                    np.linalg.norm(reprojected_bs - bs,
+                                   axis=1) < reproj_threshold
                 )[0].tolist()
 
                 if len(inliers) > len(best_inliers):
@@ -986,7 +1001,8 @@ def triangulate_robust(
                         :, np.newaxis
                     ]
                     ls_inliers = np.nonzero(
-                        np.linalg.norm(reprojected_bs - bs, axis=1) < reproj_threshold
+                        np.linalg.norm(reprojected_bs - bs,
+                                       axis=1) < reproj_threshold
                     )[0]
                     if len(ls_inliers) > len(inliers):
                         best_inliers = ls_inliers
@@ -1045,10 +1061,11 @@ def triangulate(
                 )
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
-                    self.tracks_handler.store_inliers_observation(track, shot_id)
+                    self.tracks_handler.store_inliers_observation(
+                        track, shot_id)
                 return True
 
-        return False            
+        return False
 
     def triangulate_dlt(
         self,
@@ -1084,7 +1101,8 @@ def triangulate_dlt(
                 )
                 self.tracks_handler.store_track_coordinates(track, X.tolist())
                 for shot_id in ids:
-                    self.tracks_handler.store_inliers_observation(track, shot_id)
+                    self.tracks_handler.store_inliers_observation(
+                        track, shot_id)
                 return True
         return False
 
@@ -1126,7 +1144,8 @@ def triangulate_shot_features(
     refinement_iterations = config["triangulation_refinement_iterations"]
 
     triangulator = TrackTriangulator(
-        reconstruction, TrackHandlerTrackManager(tracks_manager, reconstruction)
+        reconstruction, TrackHandlerTrackManager(
+            tracks_manager, reconstruction)
     )
 
     all_shots_ids = set(tracks_manager.get_shot_ids())
@@ -1141,7 +1160,7 @@ def triangulate_shot_features(
     for track in tracks_ids:
         if track not in reconstruction.points:
             if config["triangulation_type"] == "ROBUST":
-                if(triangulator.triangulate_robust(
+                if (triangulator.triangulate_robust(
                     track,
                     reproj_threshold,
                     min_ray_angle,
@@ -1150,7 +1169,7 @@ def triangulate_shot_features(
                 )):
                     created_tracks.append(track)
             elif config["triangulation_type"] == "FULL":
-                if(triangulator.triangulate(
+                if (triangulator.triangulate(
                     track,
                     reproj_threshold,
                     min_ray_angle,
@@ -1181,7 +1200,8 @@ def retriangulate(
     all_shots_ids = set(tracks_manager.get_shot_ids())
 
     triangulator = TrackTriangulator(
-        reconstruction, TrackHandlerTrackManager(tracks_manager, reconstruction)
+        reconstruction, TrackHandlerTrackManager(
+            tracks_manager, reconstruction)
     )
     tracks = set()
     for image in reconstruction.shots.keys():
@@ -1311,7 +1331,8 @@ def merge_two_reconstructions(
 ) -> List[types.Reconstruction]:
     """Merge two reconstructions with common tracks IDs."""
     common_tracks = list(set(r1.points) & set(r2.points))
-    worked, T, inliers = align_two_reconstruction(r1, r2, common_tracks, threshold)
+    worked, T, inliers = align_two_reconstruction(
+        r1, r2, common_tracks, threshold)
 
     if T and worked and len(inliers) >= 10:
         s, A, b = multiview.decompose_similarity_transform(T)
@@ -1342,9 +1363,11 @@ def merge_reconstructions(
                 reconstructions[i], reconstructions[j], config
             )
             if len(r) == 1:
-                remaining_reconstruction = list(set(remaining_reconstruction) - {i, j})
+                remaining_reconstruction = list(
+                    set(remaining_reconstruction) - {i, j})
                 for k in remaining_reconstruction:
-                    rr = merge_two_reconstructions(r[0], reconstructions[k], config)
+                    rr = merge_two_reconstructions(
+                        r[0], reconstructions[k], config)
                     if len(r) == 2:
                         break
                     else:
@@ -1426,6 +1449,7 @@ def should(self) -> bool:
     def done(self) -> None:
         self.num_points_last = len(self.reconstruction.points)
 
+
 class ResectionCandidates:
     """Helper to keep track of resection candidates."""
 
@@ -1460,7 +1484,7 @@ def update(self, reconstruction: types.Reconstruction) -> None:
 
         for track_id in to_remove:
             self.tracks.remove(track_id)
-                
+
     def add(self, shots: List[str], tracks: Set[str]) -> None:
         """Add newly resected tracks and the shots they belong to."""
         for shot_id in shots:
@@ -1490,10 +1514,9 @@ def remove(self, outliers: List[Tuple[str, str]], removed_tracks: List[str]) ->
                     shot_candidates.remove(track_id)
             self.tracks.remove(track_id)
 
-
     def get_candidates(self, images: Set[str]) -> List[Tuple[str, int]]:
         """Get sorted candidates for resection."""
-        return [(k, len(v)) for k,v in filter(lambda x: x[0] in images, sorted(self.candidates.items(), key=lambda x: -len(x[1])))]
+        return [(k, len(v)) for k, v in filter(lambda x: x[0] in images, sorted(self.candidates.items(), key=lambda x: -len(x[1])))]
 
 
 def grow_reconstruction(
@@ -1552,9 +1575,12 @@ def grow_reconstruction(
 
         for image, resect_points in candidates:
 
-            new_tracks = {t for t in tracks_manager.get_shot_observations(image)}
-            ratio_existing = resect_points / len(new_tracks) if new_tracks else 1.0
-            logger.info("Ratio of resected tracks in {}: {:.2f}".format(image, ratio_existing))
+            new_tracks = {
+                t for t in tracks_manager.get_shot_observations(image)}
+            ratio_existing = resect_points / \
+                len(new_tracks) if new_tracks else 1.0
+            logger.info("Ratio of resected tracks in {}: {:.2f}".format(
+                image, ratio_existing))
             if ratio_existing > ratio_redundant:
                 redundant_shots.add(image)
                 images.remove(image)
@@ -1582,7 +1608,8 @@ def grow_reconstruction(
             )
             resection_candidates.add(new_shots, resected_tracks)
 
-            logger.info(f"Adding {' and '.join(new_shots)} to the reconstruction")
+            logger.info(
+                f"Adding {' and '.join(new_shots)} to the reconstruction")
             step: Dict[str, Union[List[int], List[str], int, List[int], Any]] = {
                 "images": list(new_shots),
                 "resection": resrep,
@@ -1591,7 +1618,8 @@ def grow_reconstruction(
             report["steps"].append(step)
 
             np_before = len(reconstruction.points)
-            new_tracks = triangulate_shot_features(tracks_manager, reconstruction, new_shots, config)
+            new_tracks = triangulate_shot_features(
+                tracks_manager, reconstruction, new_shots, config)
             resection_candidates.add([], new_tracks)
             np_after = len(reconstruction.points)
             step["triangulated_points"] = np_after - np_before
@@ -1607,7 +1635,8 @@ def grow_reconstruction(
                 b2rep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
-                resection_candidates.remove(*remove_outliers(reconstruction, config))
+                resection_candidates.remove(
+                    *remove_outliers(reconstruction, config))
                 step["bundle"] = b1rep
                 step["retriangulation"] = rrep
                 step["bundle_after_retriangulation"] = b2rep
@@ -1618,7 +1647,8 @@ def grow_reconstruction(
                 brep = bundle(
                     reconstruction, camera_priors, rig_camera_priors, None, local_ba_grid, config
                 )
-                resection_candidates.remove(*remove_outliers(reconstruction, config))
+                resection_candidates.remove(
+                    *remove_outliers(reconstruction, config))
                 step["bundle"] = brep
                 should_bundle.done()
             elif local_ba_radius > 0:
@@ -1631,10 +1661,12 @@ def grow_reconstruction(
                     image,
                     config,
                 )
-                resection_candidates.remove(*remove_outliers(reconstruction, config, bundled_points))
+                resection_candidates.remove(
+                    *remove_outliers(reconstruction, config, bundled_points))
                 step["local_bundle"] = brep
 
-            logger.info(f"Reconstruction now has {len(reconstruction.shots)} shots.")
+            logger.info(
+                f"Reconstruction now has {len(reconstruction.shots)} shots.")
 
             break
         else:
@@ -1649,13 +1681,15 @@ def grow_reconstruction(
 
     logger.info("-------------------------------------------------------")
 
-    align_result = align_reconstruction(reconstruction, gcp, config, bias_override=True)
+    align_result = align_reconstruction(
+        reconstruction, gcp, config, bias_override=True)
     if not align_result and config["bundle_compensate_gps_bias"]:
         overidden_config = config.copy()
         overidden_config["bundle_compensate_gps_bias"] = False
         config = overidden_config
 
-    bundle(reconstruction, camera_priors, rig_camera_priors, gcp, final_bundle_grid, config)
+    bundle(reconstruction, camera_priors, rig_camera_priors,
+           gcp, final_bundle_grid, config)
     resection_candidates.remove(*remove_outliers(reconstruction, config))
 
     if config["filter_final_point_cloud"]:
@@ -1665,7 +1699,7 @@ def grow_reconstruction(
         logger.info("Removed bad-condition: {}".format(bad_condition))
         isolated = pysfm.remove_isolated_points(reconstruction.map)
         logger.info("Removed isolated: {}".format(isolated))
-    
+
     paint_reconstruction(data, tracks_manager, reconstruction)
     return reconstruction, report
 
@@ -1691,6 +1725,7 @@ def triangulation_reconstruction(
     config_override = config.copy()
     config_override["triangulation_type"] = "ROBUST"
     config_override["bundle_max_iterations"] = 10
+    bundle_grid = config["final_bundle_grid"]
 
     report["steps"] = []
     outer_iterations = 3
@@ -1706,14 +1741,15 @@ def triangulation_reconstruction(
             if config_override["save_partial_reconstructions"]:
                 paint_reconstruction(data, tracks_manager, reconstruction)
                 data.save_reconstruction(
-                    [reconstruction], f"reconstruction.{i*inner_iterations+j}.json"
+                    [reconstruction], f"reconstruction.{i * inner_iterations + j}.json"
                 )
 
             step = {}
-            logger.info(f"Triangulation SfM. Inner iteration {j}, running bundle ...")
+            logger.info(
+                f"Triangulation SfM. Inner iteration {j}, running bundle ...")
             align_reconstruction(reconstruction, [], config_override)
             b1rep = bundle(
-                reconstruction, camera_priors, rig_camera_priors, None, config_override
+                reconstruction, camera_priors, rig_camera_priors, None, bundle_grid, config_override
             )
             remove_outliers(reconstruction, config_override)
             step["bundle"] = b1rep
@@ -1725,13 +1761,15 @@ def triangulation_reconstruction(
     chrono.lap("compute_reconstructions")
     report["wall_times"] = dict(chrono.lap_times())
 
-    align_result = align_reconstruction(reconstruction, gcp, config, bias_override=True)
+    align_result = align_reconstruction(
+        reconstruction, gcp, config, bias_override=True)
     if not align_result and config["bundle_compensate_gps_bias"]:
         overidden_bias_config = config.copy()
         overidden_bias_config["bundle_compensate_gps_bias"] = False
         config = overidden_bias_config
 
-    bundle(reconstruction, camera_priors, rig_camera_priors, gcp, config)
+    bundle(reconstruction, camera_priors,
+           rig_camera_priors, gcp, bundle_grid, config)
     remove_outliers(reconstruction, config_override)
     paint_reconstruction(data, tracks_manager, reconstruction)
     return report, [reconstruction]
@@ -1769,7 +1807,8 @@ def compute_image_pairs_sequential(
     for (im1, im2), size in connectivity.items():
         if size < min_common:
             continue
-        features1, features2 = _get_common_feature_arrays(tracks_manager, im1, im2)
+        features1, features2 = _get_common_feature_arrays(
+            tracks_manager, im1, im2)
         camera1 = cameras[data.load_exif(im1)["camera"]]
         camera2 = cameras[data.load_exif(im2)["camera"]]
         result = _compute_pair_reconstructability(
@@ -1803,7 +1842,8 @@ def incremental_reconstruction(
         # pairs of image. Features of an image can be stored
         # repeatedly in multiple image pairs.
         # Pros: fast; Cons: high memory usage
-        common_tracks = tracking.all_common_tracks_with_features(tracks_manager, processes=data.config["processes"])
+        common_tracks = tracking.all_common_tracks_with_features(
+            tracks_manager, processes=data.config["processes"])
         pairs = compute_image_pairs(common_tracks, data)
     else:
         # Get pairs sequentially, load features lazily.
@@ -1840,7 +1880,8 @@ def incremental_reconstruction(
                     gcp,
                 )
                 reconstructions.append(reconstruction)
-                reconstructions = sorted(reconstructions, key=lambda x: -len(x.shots))
+                reconstructions = sorted(
+                    reconstructions, key=lambda x: -len(x.shots))
 
     for k, r in enumerate(reconstructions):
         logger.info(
@@ -1848,7 +1889,8 @@ def incremental_reconstruction(
                 k, len(r.shots), len(r.points)
             )
         )
-    logger.info("{} partial reconstructions in total.".format(len(reconstructions)))
+    logger.info("{} partial reconstructions in total.".format(
+        len(reconstructions)))
     chrono.lap("compute_reconstructions")
     report["wall_times"] = dict(chrono.lap_times())
     report["not_reconstructed_images"] = list(remaining_images)
@@ -1879,7 +1921,8 @@ def reconstruct_from_prior(
     rec_report["num_remaining_images"] = len(remaining_images)
 
     # Start with the known poses
-    triangulate_shot_features(tracks_manager, reconstruction, prior_images, data.config)
+    triangulate_shot_features(
+        tracks_manager, reconstruction, prior_images, data.config)
     paint_reconstruction(data, tracks_manager, reconstruction)
     report["not_reconstructed_images"] = list(remaining_images)
     return report, reconstruction
diff --git a/opensfm/test/test_bundle.py b/opensfm/test/test_bundle.py
index b394fe0b6..8195b2944 100644
--- a/opensfm/test/test_bundle.py
+++ b/opensfm/test/test_bundle.py
@@ -142,7 +142,8 @@ def test_bundle_projection_fixed_internals(
     custom_config = config.default_config()
     custom_config["bundle_use_gps"] = False
     custom_config["optimize_camera_parameters"] = False
-    reconstruction.bundle(reference, camera_priors, rig_priors, [], custom_config)
+    reconstruction.bundle(reference, camera_priors,
+                          rig_priors, [], 0, custom_config)
 
     assert _projection_errors_std(reference.points) < 5e-3
     assert reference.cameras["1"].focal == orig_camera.focal
@@ -199,7 +200,8 @@ def test_pair_with_points_priors(bundle_adjuster: pybundle.BundleAdjuster) -> No
         instance_id = str(i + 1)
         sa.add_rig_instance(
             instance_id,
-            pygeometry.Pose(np.array([1e-3, 1e-3, 1e-3]), np.array([1e-3, 1e-3, 1e-3])),
+            pygeometry.Pose(np.array([1e-3, 1e-3, 1e-3]),
+                            np.array([1e-3, 1e-3, 1e-3])),
             {instance_id: "cam1"},
             {instance_id: "rig_cam1"},
             False,
@@ -607,7 +609,7 @@ def test_bundle_void_gps_ignored() -> None:
     shot.metadata.gps_accuracy.value = 1
     shot.metadata.gps_position.reset()
     shot.pose.set_origin(np.ones(3))
-    reconstruction.bundle(r, camera_priors, rig_priors, gcp, myconfig)
+    reconstruction.bundle(r, camera_priors, rig_priors, gcp, 0, myconfig)
     assert np.allclose(shot.pose.get_origin(), np.ones(3))
 
     # Missing accuracy
@@ -615,14 +617,14 @@ def test_bundle_void_gps_ignored() -> None:
     shot.metadata.gps_accuracy.value = 1
     shot.metadata.gps_accuracy.reset()
     shot.pose.set_origin(np.ones(3))
-    reconstruction.bundle(r, camera_priors, rig_priors, gcp, myconfig)
+    reconstruction.bundle(r, camera_priors, rig_priors, gcp, 0, myconfig)
     assert np.allclose(shot.pose.get_origin(), np.ones(3))
 
     # Valid gps position and accuracy
     shot.metadata.gps_position.value = np.zeros(3)
     shot.metadata.gps_accuracy.value = 1
     shot.pose.set_origin(np.ones(3))
-    reconstruction.bundle(r, camera_priors, rig_priors, gcp, myconfig)
+    reconstruction.bundle(r, camera_priors, rig_priors, gcp, 0, myconfig)
     assert np.allclose(shot.pose.get_origin(), np.zeros(3))
 
 
@@ -644,7 +646,7 @@ def test_bundle_alignment_prior() -> None:
     gcp = []
     myconfig = config.default_config()
 
-    reconstruction.bundle(r, camera_priors, rig_priors, gcp, myconfig)
+    reconstruction.bundle(r, camera_priors, rig_priors, gcp, 0, myconfig)
     shot = r.shots[shot.id]
 
     assert np.allclose(shot.pose.translation, np.zeros(3))
diff --git a/opensfm/test/test_reconstruction_triangulation.py b/opensfm/test/test_reconstruction_triangulation.py
index bf86ec31e..5b6a53718 100644
--- a/opensfm/test/test_reconstruction_triangulation.py
+++ b/opensfm/test/test_reconstruction_triangulation.py
@@ -40,7 +40,7 @@ def test_reconstruction_triangulation(
     assert 0.01 < errors["absolute_gps_rmse"] < 0.1
 
     # Sanity check that GCP error is similar to the generated gcp_noise
-    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.03
+    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.054
     assert 0.005 < errors["absolute_gcp_rmse_vertical"] < 0.04
 
     # Check that the GPS bias (only translation) is recovered

From dd18fe7bd53150aa736d5282dc8b37188c76f999 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 7 Jan 2026 11:37:40 +0100
Subject: [PATCH 206/235] FIx YPR to OPK conversion by staying in the
 tiopocenter frame Added proper unit test for EXIFs

---
 opensfm/exif.py           | 125 +++++++++-----
 opensfm/test/test_exif.py | 349 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 429 insertions(+), 45 deletions(-)
 create mode 100644 opensfm/test/test_exif.py

diff --git a/opensfm/exif.py b/opensfm/exif.py
index 228caf229..15743c185 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -9,11 +9,12 @@
 import exifread
 import numpy as np
 import xmltodict as x2d
-from opensfm import pygeometry
+from opensfm import geometry, pygeometry
 
 from opensfm.dataset_base import DataSetBase
 from opensfm.geo import ecef_from_lla
 from opensfm.sensors import camera_calibration, sensor_data
+from opensfm.geo import TopocentricConverter
 
 logger: logging.Logger = logging.getLogger(__name__)
 inch_in_mm: float = 25.4
@@ -96,7 +97,8 @@ def compute_focal(
     sensor_string: Optional[str],
 ) -> Tuple[float, float]:
     if focal_35 is not None and focal_35 > 0:
-        focal_ratio = focal35_to_focal_ratio(focal_35, pixel_width, pixel_height)
+        focal_ratio = focal35_to_focal_ratio(
+            focal_35, pixel_width, pixel_height)
     else:
         if not sensor_width:
             sensor_width = (
@@ -181,7 +183,7 @@ def get_xmp(fileobj: BinaryIO) -> List[Dict[str, Any]]:
     xmp_end = img_str.find("</x:xmpmeta")
 
     if xmp_start < xmp_end:
-        xmp_str = img_str[xmp_start : xmp_end + 12]
+        xmp_str = img_str[xmp_start: xmp_end + 12]
         xdict = parse_xmp_string(xmp_str)
         if xdict is None:
             return []
@@ -212,10 +214,12 @@ def __init__(
         use_exif_size: bool = True,
         name: Optional[str] = None,
     ) -> None:
-        self.image_size_loader: Callable[[], Tuple[int, int]] = image_size_loader
+        self.image_size_loader: Callable[[],
+                                         Tuple[int, int]] = image_size_loader
         self.use_exif_size: bool = use_exif_size
         self.fileobj: BinaryIO = fileobj
-        self.tags: Dict[str, Any] = exifread.process_file(fileobj, details=False)
+        self.tags: Dict[str, Any] = exifread.process_file(
+            fileobj, details=False)
         fileobj.seek(0)
         self.xmp: List[Dict[str, Any]] = get_xmp(fileobj)
         self.fileobj_name: str = self.fileobj.name if name is None else name
@@ -301,11 +305,13 @@ def extract_sensor_width(self) -> Optional[float]:
         mm_per_unit = self.get_mm_per_unit(resolution_unit)
         if not mm_per_unit:
             return None
-        pixels_per_unit = get_tag_as_float(self.tags, "EXIF FocalPlaneXResolution")
+        pixels_per_unit = get_tag_as_float(
+            self.tags, "EXIF FocalPlaneXResolution")
         if pixels_per_unit is None:
             return None
         if pixels_per_unit <= 0.0:
-            pixels_per_unit = get_tag_as_float(self.tags, "EXIF FocalPlaneYResolution")
+            pixels_per_unit = get_tag_as_float(
+                self.tags, "EXIF FocalPlaneYResolution")
             if pixels_per_unit is None or pixels_per_unit <= 0.0:
                 return None
         units_per_pixel = 1 / pixels_per_unit
@@ -332,7 +338,8 @@ def get_mm_per_unit(self, resolution_unit: int) -> Optional[float]:
             return um_in_mm
         else:
             logger.warning(
-                "Unknown EXIF resolution unit value: {}".format(resolution_unit)
+                "Unknown EXIF resolution unit value: {}".format(
+                    resolution_unit)
             )
             return None
 
@@ -513,13 +520,22 @@ def extract_capture_time(self) -> float:
                     )
                 return (d - datetime.datetime(1970, 1, 1)).total_seconds()
         logger.info(
-            'Image file "{0:s}" has no valid time stamp'.format(self.fileobj_name)
+            'Image file "{0:s}" has no valid time stamp'.format(
+                self.fileobj_name)
         )
         return 0.0
 
     def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         opk = None
 
+        # Can't convert from YPR to OPK without geo location
+        if "latitude" not in geo and "longitude" not in geo and "altitude" not in geo:
+            return opk
+
+        tc = TopocentricConverter(
+            geo["latitude"], geo["longitude"], geo["altitude"]
+        )
+
         if self.has_xmp() and geo and "latitude" in geo and "longitude" in geo:
             ypr = np.array([None, None, None])
 
@@ -532,31 +548,41 @@ def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                 # Pitch: 90 --> camera is looking forward
                 # Roll: 0 (assuming gimbal)
 
-                if (
-                    "@Camera:Yaw" in self.xmp[0]
-                    and "@Camera:Pitch" in self.xmp[0]
-                    and "@Camera:Roll" in self.xmp[0]
-                ):
-                    ypr = np.array(
-                        [
-                            float(self.xmp[0]["@Camera:Yaw"]),
-                            float(self.xmp[0]["@Camera:Pitch"]),
-                            float(self.xmp[0]["@Camera:Roll"]),
-                        ]
-                    )
-                elif (
-                    "@drone-dji:GimbalYawDegree" in self.xmp[0]
-                    and "@drone-dji:GimbalPitchDegree" in self.xmp[0]
-                    and "@drone-dji:GimbalRollDegree" in self.xmp[0]
-                ):
-                    ypr = np.array(
-                        [
-                            float(self.xmp[0]["@drone-dji:GimbalYawDegree"]),
-                            float(self.xmp[0]["@drone-dji:GimbalPitchDegree"]),
-                            float(self.xmp[0]["@drone-dji:GimbalRollDegree"]),
-                        ]
-                    )
-                    ypr[1] += 90  # DJI's values need to be offset
+                # Prioritize Gimbal, then Flight, then Camera
+                tag_sets = [
+                    (
+                        "@drone-dji:GimbalYawDegree",
+                        "@drone-dji:GimbalPitchDegree",
+                        "@drone-dji:GimbalRollDegree",
+                        True,
+                    ),
+                    (
+                        "@drone-dji:FlightYawDegree",
+                        "@drone-dji:FlightPitchDegree",
+                        "@drone-dji:FlightRollDegree",
+                        True,
+                    ),
+                    ("@Camera:Yaw", "@Camera:Pitch", "@Camera:Roll", False),
+                ]
+
+                for yaw_key, pitch_key, roll_key, offset_pitch in tag_sets:
+                    if (
+                        yaw_key in self.xmp[0]
+                        and pitch_key in self.xmp[0]
+                        and roll_key in self.xmp[0]
+                    ):
+                        ypr = np.array(
+                            [
+                                float(self.xmp[0][yaw_key]),
+                                float(self.xmp[0][pitch_key]),
+                                float(self.xmp[0][roll_key]),
+                            ]
+                        )
+                        if offset_pitch:
+                            ypr[1] += 90
+
+                        break
+
             except ValueError:
                 logger.debug(
                     'Invalid yaw/pitch/roll tag in image file "{0:s}"'.format(
@@ -579,18 +605,28 @@ def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                     [
                         [
                             np.cos(y) * np.cos(p),
-                            np.cos(y) * np.sin(p) * np.sin(r) - np.sin(y) * np.cos(r),
-                            np.cos(y) * np.sin(p) * np.cos(r) + np.sin(y) * np.sin(r),
+                            np.cos(y) * np.sin(p) * np.sin(r) -
+                            np.sin(y) * np.cos(r),
+                            np.cos(y) * np.sin(p) * np.cos(r) +
+                            np.sin(y) * np.sin(r),
                         ],
                         [
                             np.sin(y) * np.cos(p),
-                            np.sin(y) * np.sin(p) * np.sin(r) + np.cos(y) * np.cos(r),
-                            np.sin(y) * np.sin(p) * np.cos(r) - np.cos(y) * np.sin(r),
+                            np.sin(y) * np.sin(p) * np.sin(r) +
+                            np.cos(y) * np.cos(r),
+                            np.sin(y) * np.sin(p) * np.cos(r) -
+                            np.cos(y) * np.sin(r),
                         ],
-                        [-np.sin(p), np.cos(p) * np.sin(r), np.cos(p) * np.cos(r)],
+                        [-np.sin(p), np.cos(p) * np.sin(r),
+                         np.cos(p) * np.cos(r)],
                     ]
                 )
 
+                # Flip X and Z for 180 degree roll
+                if math.isclose(abs(ypr[2]), math.pi, abs_tol=1e-3):
+                    cnb[:, 0] *= -1
+                    cnb[:, 2] *= -1
+
                 # Convert between image and body coordinates
                 # Top of image pixels point to flying direction
                 # and camera is looking down.
@@ -600,17 +636,16 @@ def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                 # (Swap X/Y, flip Z)
                 cbb = np.array([[0, 1, 0], [1, 0, 0], [0, 0, -1]])
 
-                delta = 1e-7
-
+                delta = 1e-10
                 p1 = np.array(
-                    ecef_from_lla(
+                    tc.to_topocentric(
                         geo["latitude"] + delta,
                         geo["longitude"],
                         geo.get("altitude", 0),
                     )
                 )
                 p2 = np.array(
-                    ecef_from_lla(
+                    tc.to_topocentric(
                         geo["latitude"] - delta,
                         geo["longitude"],
                         geo.get("altitude", 0),
@@ -628,7 +663,6 @@ def extract_opk(self, geo: Dict[str, Any]) -> Optional[Dict[str, Any]]:
 
                 znp = np.array([0, 0, -1]).T
                 ynp = np.cross(znp, xnp)
-
                 cen = np.array([xnp, ynp, znp]).T
 
                 # OPK rotation matrix
@@ -807,7 +841,8 @@ def camera_from_exif_metadata(
             calib["focal_x"],
             calib["focal_y"] / calib["focal_x"],
             np.array([calib["c_x"], calib["c_y"]]),
-            np.array([calib["k1"], calib["k2"], calib["k3"], calib["p1"], calib["p2"]]),
+            np.array([calib["k1"], calib["k2"], calib["k3"],
+                     calib["p1"], calib["p2"]]),
         )
     elif calib_pt == "fisheye":
         camera = pygeometry.Camera.create_fisheye(
diff --git a/opensfm/test/test_exif.py b/opensfm/test/test_exif.py
new file mode 100644
index 000000000..0bf1766d8
--- /dev/null
+++ b/opensfm/test/test_exif.py
@@ -0,0 +1,349 @@
+
+import io
+import pytest
+import exifread
+import datetime
+import numpy as np
+from opensfm import exif
+
+
+@pytest.fixture
+def dji_xmp_data_gimbal():
+    return """
+    <x:xmpmeta xmlns:x="adobe:ns:meta/">
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description rdf:about="" xmlns:drone-dji="http://www.dji.com/drone-dji/1.0/"
+                drone-dji:GimbalYawDegree="+10.0"
+                drone-dji:GimbalPitchDegree="-20.0"
+                drone-dji:GimbalRollDegree="+30.0"
+                drone-dji:Longitude="+5.0"
+                drone-dji:Latitude="-6.0"
+                drone-dji:AbsoluteAltitude="+100.0">
+            </rdf:Description>
+        </rdf:RDF>
+    </x:xmpmeta>
+    """
+
+
+@pytest.fixture
+def dji_xmp_data_flight():
+    return """
+    <x:xmpmeta xmlns:x="adobe:ns:meta/">
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description rdf:about="" xmlns:drone-dji="http://www.dji.com/drone-dji/1.0/"
+                drone-dji:FlightYawDegree="+15.0"
+                drone-dji:FlightPitchDegree="-25.0"
+                drone-dji:FlightRollDegree="+35.0"
+                drone-dji:Longitude="-5.0"
+                drone-dji:Latitude="+6.0"
+                drone-dji:AbsoluteAltitude="50.0">
+            </rdf:Description>
+        </rdf:RDF>
+    </x:xmpmeta>
+    """
+
+
+@pytest.fixture
+def dji_xmp_data_camera():
+    return """
+    <x:xmpmeta xmlns:x="adobe:ns:meta/">
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description rdf:about="" xmlns:Camera="http://pix4d.com/camera/1.0/"
+                Camera:Yaw="12.0"
+                Camera:Pitch="22.0"
+                Camera:Roll="32.0"
+                drone-dji:Longitude="1.0"
+                drone-dji:Latitude="2.0"
+                drone-dji:AbsoluteAltitude="3.0">
+            </rdf:Description>
+        </rdf:RDF>
+    </x:xmpmeta>
+    """
+
+
+def create_exif_instance(xmp_content, monkeypatch):
+    content = xmp_content.encode('utf-8')
+    fileobj = io.BytesIO(content)
+    fileobj.name = "test.jpg"
+
+    monkeypatch.setattr("exifread.process_file", lambda f, details=False: {})
+
+    return exif.EXIF(fileobj, lambda: (100, 100))
+
+
+def test_dji_parsing_latlon(dji_xmp_data_gimbal, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_gimbal, monkeypatch)
+    assert e.has_dji_latlon()
+    lon, lat = e.extract_dji_lon_lat()
+    assert lon == 5.0
+    assert lat == -6.0
+
+
+def test_dji_parsing_altitude(dji_xmp_data_gimbal, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_gimbal, monkeypatch)
+    assert e.has_dji_altitude()
+    alt = e.extract_dji_altitude()
+    assert alt == 100.0
+
+
+def test_dji_parsing_public_geo(dji_xmp_data_gimbal, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_gimbal, monkeypatch)
+    lon, lat = e.extract_lon_lat()
+    assert lon == 5.0
+    assert lat == -6.0
+
+
+def test_dji_parsing_public_alt(dji_xmp_data_gimbal, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_gimbal, monkeypatch)
+    alt = e.extract_altitude()
+    assert alt == 100.0
+
+
+def test_dji_parsing_opk(dji_xmp_data_gimbal, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_gimbal, monkeypatch)
+    lon, lat = e.extract_lon_lat()
+    alt = e.extract_altitude()
+    geo_dict = {"latitude": lat, "longitude": lon, "altitude": alt}
+
+    opk = e.extract_opk(geo_dict)
+    assert opk is not None
+
+
+def test_dji_parsing_flight(dji_xmp_data_flight, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_flight, monkeypatch)
+
+    lon, lat = e.extract_dji_lon_lat()
+    assert lon == -5.0
+    assert lat == 6.0
+
+    alt = e.extract_dji_altitude()
+    assert alt == 50.0
+
+    geo_dict = {"latitude": lat, "longitude": lon, "altitude": alt}
+
+    opk = e.extract_opk(geo_dict)
+    assert opk is not None
+
+
+def test_dji_parsing_camera(dji_xmp_data_camera, monkeypatch):
+    e = create_exif_instance(dji_xmp_data_camera, monkeypatch)
+
+    geo_dict = {"latitude": 2.0, "longitude": 1.0, "altitude": 3.0}
+
+    opk = e.extract_opk(geo_dict)
+    assert opk is not None
+
+
+def test_dji_parsing_none(monkeypatch):
+    # No XMP data
+    content = b"dummy"
+    fileobj = io.BytesIO(content)
+    fileobj.name = "test.jpg"
+    monkeypatch.setattr("exifread.process_file", lambda f, details=False: {})
+
+    e = exif.EXIF(fileobj, lambda: (100, 100))
+
+    assert not e.has_dji_latlon()
+    assert not e.has_dji_altitude()
+
+    geo_dict = {"latitude": 0, "longitude": 0, "altitude": 0}
+    opk = e.extract_opk(geo_dict)
+    assert opk is None
+
+
+class MockTag:
+    def __init__(self, values):
+        self.values = values
+
+
+def create_exif_with_tags(tags, monkeypatch):
+    monkeypatch.setattr("exifread.process_file", lambda f, details=False: tags)
+    fileobj = io.BytesIO(b"")
+    fileobj.name = "test.jpg"
+
+    monkeypatch.setattr("opensfm.exif.get_xmp", lambda f: [])
+    return exif.EXIF(fileobj, lambda: (1000, 2000))
+
+
+def test_gps_parsing_standard(monkeypatch):
+    tags = {
+        "GPS GPSLatitude": MockTag([exifread.utils.Ratio(45, 1), exifread.utils.Ratio(30, 1), exifread.utils.Ratio(0, 1)]),
+        "GPS GPSLatitudeRef": MockTag("N"),
+        "GPS GPSLongitude": MockTag([exifread.utils.Ratio(10, 1), exifread.utils.Ratio(0, 1), exifread.utils.Ratio(0, 1)]),
+        "GPS GPSLongitudeRef": MockTag("W"),
+        "GPS GPSAltitude": MockTag([exifread.utils.Ratio(500, 1)]),
+        "GPS GPSAltitudeRef": MockTag([1]),
+    }
+
+    e = create_exif_with_tags(tags, monkeypatch)
+
+    lon, lat = e.extract_lon_lat()
+    assert lat == 45.5
+    assert lon == -10.0
+
+    alt = e.extract_altitude()
+    assert alt == -500.0
+
+
+def test_focal_length_parsing(monkeypatch):
+    tags = {
+        "EXIF FocalLength": MockTag([exifread.utils.Ratio(24, 1)]),
+        "EXIF FocalLengthIn35mmFilm": MockTag([exifread.utils.Ratio(35, 1)]),
+        "EXIF ExifImageWidth": MockTag([4000]),
+        "EXIF ExifImageLength": MockTag([3000]),
+    }
+
+    e = create_exif_with_tags(tags, monkeypatch)
+
+    focal_35, focal_ratio = e.extract_focal()
+    assert focal_35 == 35.0
+
+    # Image is 4:3 (4000x3000), so film width is assumed 34mm
+    assert abs(focal_ratio - (35.0 / 34.0)) < 0.01
+
+
+def test_sensor_width_calculation(monkeypatch):
+    tags = {
+        # Focal 50mm
+        "EXIF FocalLength": MockTag([exifread.utils.Ratio(50, 1)]),
+        # 100 pixels per unit
+        "EXIF FocalPlaneXResolution": MockTag([exifread.utils.Ratio(100, 1)]),
+        "EXIF FocalPlaneResolutionUnit": MockTag([2]),  # Inches
+        "EXIF ExifImageWidth": MockTag([1000]),  # 10 inches wide
+        "EXIF ExifImageLength": MockTag([1000]),
+    }
+
+    # Width in pixels = 1000
+    # Pixels per inch = 100
+    # Sensor width in inches = 10
+    # Sensor width in mm = 10 * 25.4 = 254.0
+
+    e = create_exif_with_tags(tags, monkeypatch)
+    sensor_width = e.extract_sensor_width()
+
+    assert abs(sensor_width - 254.0) < 0.01
+
+    _, focal_ratio = e.extract_focal()
+
+    # Sensor width 254mm
+    # Ratio = 50 / 254
+    assert abs(focal_ratio - (50.0 / 254.0)) < 0.001
+
+
+def test_orientation_parsing(monkeypatch):
+    tags = {"Image Orientation": MockTag([6])}
+    e = create_exif_with_tags(tags, monkeypatch)
+    assert e.extract_orientation() == 6
+
+    tags = {}
+    e = create_exif_with_tags(tags, monkeypatch)
+    assert e.extract_orientation() == 1
+
+
+def test_make_model_parsing_image_tags(monkeypatch):
+    tags = {
+        "Image Make": MockTag("TestMake"),
+        "Image Model": MockTag("TestModel"),
+    }
+    e = create_exif_with_tags(tags, monkeypatch)
+    assert e.extract_make() == "TestMake"
+    assert e.extract_model() == "TestModel"
+
+
+def test_make_model_parsing_lens_tags(monkeypatch):
+    tags = {
+        "EXIF LensMake": MockTag("LensMake"),
+        "EXIF LensModel": MockTag("LensModel"),
+    }
+    e = create_exif_with_tags(tags, monkeypatch)
+    assert e.extract_make() == "LensMake"
+    assert e.extract_model() == "LensModel"
+
+
+def test_capture_time_gps(monkeypatch):
+    tags = {
+        "GPS GPSDate": MockTag("2021:01:01"),
+        "GPS GPSTimeStamp": MockTag([exifread.utils.Ratio(12, 1), exifread.utils.Ratio(0, 1), exifread.utils.Ratio(0, 1)]),
+    }
+    e = create_exif_with_tags(tags, monkeypatch)
+
+    delta = datetime.datetime(2021, 1, 1, 12, 0, 0) - \
+        datetime.datetime(1970, 1, 1)
+    expected = delta.total_seconds()
+    assert e.extract_capture_time() == expected
+
+
+def test_capture_time_exif(monkeypatch):
+    tags = {
+        "EXIF DateTimeOriginal": MockTag("2022:02:02 10:00:00"),
+    }
+    e = create_exif_with_tags(tags, monkeypatch)
+
+    delta = datetime.datetime(2022, 2, 2, 10, 0, 0) - \
+        datetime.datetime(1970, 1, 1)
+    expected = delta.total_seconds()
+    assert e.extract_capture_time() == expected
+
+
+def test_focal35_to_focal_ratio_logic():
+    # 3:2 ratio
+    ratio = exif.focal35_to_focal_ratio(35.0, 300, 200)
+    assert abs(ratio - 35.0 / 36.0) < 0.01
+
+    # 4:3 ratio
+    ratio = exif.focal35_to_focal_ratio(34.0, 400, 300)
+    assert abs(ratio - 34.0 / 34.0) < 0.01
+
+    # Inverse
+    f35 = exif.focal35_to_focal_ratio(35.0 / 36.0, 300, 200, inverse=True)
+    assert abs(f35 - 35.0) < 0.01
+
+
+def test_extract_geo_structure_coord(monkeypatch):
+    tags = {
+        "GPS GPSLatitude": MockTag([exifread.utils.Ratio(10, 1), exifread.utils.Ratio(0, 1), exifread.utils.Ratio(0, 1)]),
+        "GPS GPSLatitudeRef": MockTag("N"),
+        "GPS GPSLongitude": MockTag([exifread.utils.Ratio(20, 1), exifread.utils.Ratio(0, 1), exifread.utils.Ratio(0, 1)]),
+        "GPS GPSLongitudeRef": MockTag("E"),
+    }
+
+    e = create_exif_with_tags(tags, monkeypatch)
+    geo = e.extract_geo()
+
+    assert geo["latitude"] == 10.0
+    assert geo["longitude"] == 20.0
+
+
+def test_extract_geo_structure_alt_dop(monkeypatch):
+    tags = {
+        "GPS GPSAltitude": MockTag([exifread.utils.Ratio(100, 1)]),
+        "GPS GPSDOP": MockTag([exifread.utils.Ratio(5, 10)]),  # 0.5
+    }
+
+    e = create_exif_with_tags(tags, monkeypatch)
+    geo = e.extract_geo()
+
+    assert geo["altitude"] == 100.0
+    assert geo["dop"] == 0.5
+
+
+def test_integration_extract_exif_from_file(monkeypatch):
+    # This tests the module level function that wraps EXIF class
+    tags = {
+        "Image Make": MockTag("TestMake"),
+        "Image Model": MockTag("TestModel"),
+        "EXIF ExifImageWidth": MockTag([100]),
+        "EXIF ExifImageLength": MockTag([100]),
+    }
+
+    monkeypatch.setattr("exifread.process_file", lambda f, details=False: tags)
+    monkeypatch.setattr("opensfm.exif.get_xmp", lambda f: [])
+
+    fileobj = io.BytesIO(b"")
+    fileobj.name = "test.jpg"
+
+    d = exif.extract_exif_from_file(fileobj, lambda: (100, 100), True)
+
+    assert d["make"] == "TestMake"
+    assert d["width"] == 100
+    assert "camera" in d

From fe09667f7cbc6a0e1222ef7676581e3f4633a2e0 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 7 Jan 2026 11:38:08 +0100
Subject: [PATCH 207/235] Added OPK IO

---
 opensfm/io.py           | 8 ++++++++
 opensfm/test/test_io.py | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/opensfm/io.py b/opensfm/io.py
index 0fd94dc77..7f2713ac6 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -553,6 +553,10 @@ def pymap_metadata_to_json(metadata: pymap.ShotMeasurements) -> Dict[str, Any]:
             obj["compass"] = {"accuracy": metadata.compass_accuracy.value}
     if metadata.sequence_key.has_value:
         obj["skey"] = metadata.sequence_key.value
+    if metadata.opk_angles.has_value:
+        obj["opk_angles"] = list(metadata.opk_angles.value)
+    if metadata.opk_accuracy.has_value:
+        obj["opk_accuracy"] = metadata.opk_accuracy.value
     return obj
 
 
@@ -576,6 +580,10 @@ def json_to_pymap_metadata(obj: Dict[str, Any]) -> pymap.ShotMeasurements:
             metadata.compass_angle.value = compass["angle"]
         if "accuracy" in compass:
             metadata.compass_accuracy.value = compass["accuracy"]
+    if obj.get("opk_angles") is not None:
+        metadata.opk_angles.value = obj.get("opk_angles")
+    if obj.get("opk_accuracy") is not None:
+        metadata.opk_accuracy.value = obj.get("opk_accuracy")
     return metadata
 
 
diff --git a/opensfm/test/test_io.py b/opensfm/test/test_io.py
index 80ef37522..2b1e8bca8 100644
--- a/opensfm/test/test_io.py
+++ b/opensfm/test/test_io.py
@@ -155,6 +155,8 @@ def test_json_to_and_from_metadata() -> None:
         "skey": "test",
         "gravity_down": [7, 8, 9],
         "compass": {"angle": 10, "accuracy": 45},
+        "opk_angles": [1.0, 2.0, 3.0],
+        "opk_accuracy": 0.1,
     }
     m = io.json_to_pymap_metadata(obj)
     assert m.orientation.value == 10
@@ -165,6 +167,8 @@ def test_json_to_and_from_metadata() -> None:
     assert np.allclose(m.gravity_down.value, [7, 8, 9])
     assert m.compass_angle.value == 10
     assert m.compass_accuracy.value == 45
+    assert np.allclose(m.opk_angles.value, [1.0, 2.0, 3.0])
+    assert m.opk_accuracy.value == 0.1
     assert obj == io.pymap_metadata_to_json(m)
 
 

From 2045631e2b329e6afc54f6390d96e69061a44483 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 7 Jan 2026 11:39:20 +0100
Subject: [PATCH 208/235] Added OPK errors in the report A bit for autoformat
 as well

---
 opensfm/report.py | 72 +++++++++++++++++++++++++++++++++---------
 opensfm/stats.py  | 79 +++++++++++++++++++++++++++++++++++------------
 2 files changed, 118 insertions(+), 33 deletions(-)

diff --git a/opensfm/report.py b/opensfm/report.py
index 68f67540a..274d13c73 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -115,7 +115,8 @@ def _make_subsection(self, title: str) -> None:
 
     def _make_centered_image(self, image_path: str, desired_height: float) -> None:
         with tempfile.TemporaryDirectory() as tmp_local_dir:
-            local_image_path = os.path.join(tmp_local_dir, os.path.basename(image_path))
+            local_image_path = os.path.join(
+                tmp_local_dir, os.path.basename(image_path))
             with self.io_handler.open_wb(local_image_path) as fwb:
                 with self.io_handler.open_rb(image_path) as f:
                     fwb.write(f.read())
@@ -152,7 +153,8 @@ def make_title(self) -> None:
             ).communicate()
             version = out.strip().decode()
         except BaseException as e:
-            logger.warning(f"Exception thrwon while extracting 'git' version, {e}")
+            logger.warning(
+                f"Exception thrwon while extracting 'git' version, {e}")
             version = ""
 
         # indicate we don't know the version
@@ -173,7 +175,7 @@ def make_dataset_summary(self) -> None:
             ["Date", self.stats["processing_statistics"]["date"]],
             [
                 "Area Covered",
-                f"{self.stats['processing_statistics']['area']/1e6:.6f} km²",
+                f"{self.stats['processing_statistics']['area'] / 1e6:.6f} km²",
             ],
             [
                 "Processing Time",
@@ -215,7 +217,7 @@ def make_processing_summary(self) -> None:
             ],
             [
                 "Reconstructed Points",
-                f"{rec_points} over {init_points} points ({rec_points/init_points*100:.1f}%)",
+                f"{rec_points} over {init_points} points ({rec_points / init_points * 100:.1f}%)",
             ],
             [
                 "Reconstructed Components",
@@ -235,9 +237,11 @@ def make_processing_summary(self) -> None:
         row_gps_gcp = [" / ".join(geo_string) + " errors"]
         geo_errors = []
         if self.stats["reconstruction_statistics"]["has_gps"]:
-            geo_errors.append(f"{self.stats['gps_errors']['average_error']:.2f}")
+            geo_errors.append(
+                f"{self.stats['gps_errors']['average_error']:.2f}")
         if self._has_meaningful_gcp():
-            geo_errors.append(f"{self.stats['gcp_errors']['average_error']:.2f}")
+            geo_errors.append(
+                f"{self.stats['gcp_errors']['average_error']:.2f}")
         row_gps_gcp.append(" / ".join(geo_errors) + " meters")
         rows.append(row_gps_gcp)
 
@@ -257,7 +261,8 @@ def make_processing_summary(self) -> None:
     def make_processing_time_details(self) -> None:
         self._make_section("Processing Time Details")
 
-        columns_names = list(self.stats["processing_statistics"]["steps_times"].keys())
+        columns_names = list(
+            self.stats["processing_statistics"]["steps_times"].keys())
         formatted_floats = []
         for v in self.stats["processing_statistics"]["steps_times"].values():
             formatted_floats.append(f"{v:.2f} sec.")
@@ -276,9 +281,12 @@ def make_gps_details(self) -> None:
                 continue
             for comp in ["x", "y", "z"]:
                 row = [comp.upper() + " Error (meters)"]
-                row.append(f"{self.stats[error_type + '_errors']['mean'][comp]:.3f}")
-                row.append(f"{self.stats[error_type +'_errors']['std'][comp]:.3f}")
-                row.append(f"{self.stats[error_type +'_errors']['error'][comp]:.3f}")
+                row.append(
+                    f"{self.stats[error_type + '_errors']['mean'][comp]:.3f}")
+                row.append(
+                    f"{self.stats[error_type + '_errors']['std'][comp]:.3f}")
+                row.append(
+                    f"{self.stats[error_type + '_errors']['error'][comp]:.3f}")
                 rows.append(row)
 
             rows.append(
@@ -286,7 +294,7 @@ def make_gps_details(self) -> None:
                     "Total",
                     "",
                     "",
-                    f"{self.stats[error_type +'_errors']['average_error']:.3f}",
+                    f"{self.stats[error_type + '_errors']['average_error']:.3f}",
                 ]
             )
             self._make_table(columns_names, rows)
@@ -310,8 +318,41 @@ def make_gps_details(self) -> None:
                     f"{R[0]:.2f}      {R[1]:.2f}      {R[2]:.2f}",
                 ]
             )
-        self._make_table(columns_names, rows)
+        if rows:
+            self._make_table(columns_names, rows)
+
+        self.pdf.set_xy(self.margin, self.pdf.get_y() + self.margin / 2)
+
+    def make_orientation_details(self) -> None:
+        if "opk_errors" not in self.stats:
+            return
+        if "average_error" not in self.stats["opk_errors"]:
+            return
+
+        self._make_section("Orientation Error Details")
+        columns_names = ["Component", "Mean", "Sigma", "RMS Error"]
+        error_name = "opk_errors"
+
+        rows = []
+        for comp in ["omega", "phi", "kappa"]:
+            row = [comp.capitalize() + " Error (degrees)"]
+            row.append(
+                f"{self.stats[error_name]['mean'][comp]:.3f}")
+            row.append(
+                f"{self.stats[error_name]['std'][comp]:.3f}")
+            row.append(
+                f"{self.stats[error_name]['error'][comp]:.3f}")
+            rows.append(row)
 
+        rows.append(
+            [
+                "Total",
+                "",
+                "",
+                f"{self.stats[error_name]['average_error']:.3f}",
+            ]
+        )
+        self._make_table(columns_names, rows)
         self.pdf.set_xy(self.margin, self.pdf.get_y() + self.margin / 2)
 
     def make_features_details(self) -> None:
@@ -394,7 +435,8 @@ def make_camera_models_details(self) -> None:
 
             rows = []
             rows.append(["Initial"] + [f"{x:.4f}" for x in initial.values()])
-            rows.append(["Optimized"] + [f"{x:.4f}" for x in optimized.values()])
+            rows.append(["Optimized"] +
+                        [f"{x:.4f}" for x in optimized.values()])
 
             self._make_subsection(camera)
             self._make_table(names, rows)
@@ -402,7 +444,8 @@ def make_camera_models_details(self) -> None:
 
             residual_grid_height = 100
             self._make_centered_image(
-                os.path.join(self.output_path, residual_grids[0]), residual_grid_height
+                os.path.join(self.output_path,
+                             residual_grids[0]), residual_grid_height
             )
 
     def make_rig_cameras_details(self) -> None:
@@ -499,4 +542,5 @@ def generate_report(self) -> None:
         self.add_page_break()
 
         self.make_gps_details()
+        self.make_orientation_details()
         self.make_processing_time_details()
diff --git a/opensfm/stats.py b/opensfm/stats.py
index e6b39268c..710bd27ac 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -3,6 +3,7 @@
 import math
 import os
 import random
+import cv2
 import statistics
 from collections import defaultdict
 from functools import lru_cache
@@ -14,7 +15,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 from numpy.typing import NDArray
-from opensfm import feature_loader, io, multiview, pygeometry, pymap, types
+from opensfm import feature_loader, geometry, io, multiview, pygeometry, pymap, types
 from opensfm.dataset import DataSet, DataSetBase
 
 RESIDUAL_PIXEL_CUTOFF = 4
@@ -48,7 +49,7 @@ def _gps_errors(reconstruction: types.Reconstruction) -> List[NDArray]:
     return errors
 
 
-def _gps_gcp_errors_stats(errors: Optional[NDArray]) -> Dict[str, Any]:
+def _gps_gcp_opk_errors_stats(errors: Optional[NDArray], names: List[str]) -> Dict[str, Any]:
     if errors is None or len(errors) == 0:
         return {}
 
@@ -59,12 +60,13 @@ def _gps_gcp_errors_stats(errors: Optional[NDArray]) -> Dict[str, Any]:
     std_dev = np.std(errors, 0)
     average = np.average(np.linalg.norm(errors, axis=1))
 
-    stats["mean"] = {"x": mean[0], "y": mean[1], "z": mean[2]}
-    stats["std"] = {"x": std_dev[0], "y": std_dev[1], "z": std_dev[2]}
+    stats["mean"] = {names[0]: mean[0], names[1]: mean[1], names[2]: mean[2]}
+    stats["std"] = {names[0]: std_dev[0], names[1]
+        : std_dev[1], names[2]: std_dev[2]}
     stats["error"] = {
-        "x": math.sqrt(m_squared[0]),
-        "y": math.sqrt(m_squared[1]),
-        "z": math.sqrt(m_squared[2]),
+        names[0]: math.sqrt(m_squared[0]),
+        names[1]: math.sqrt(m_squared[1]),
+        names[2]: math.sqrt(m_squared[2]),
     }
     stats["average_error"] = average
     return stats
@@ -74,7 +76,33 @@ def gps_errors(reconstructions: List[types.Reconstruction]) -> Dict[str, Any]:
     all_errors = []
     for rec in reconstructions:
         all_errors += _gps_errors(rec)
-    return _gps_gcp_errors_stats(np.array(all_errors))
+    return _gps_gcp_opk_errors_stats(np.array(all_errors), ["x", "y", "z"])
+
+
+def _opk_errors(reconstruction: types.Reconstruction) -> List[NDArray]:
+    errors = []
+    for shot in reconstruction.shots.values():
+        if shot.metadata.opk_angles.has_value:
+            opk_exif = np.array(shot.metadata.opk_angles.value)
+            rotation_computed = shot.pose.get_rotation_matrix()
+
+            # Extract OPK from computed rotation
+            opk_computed = np.degrees(
+                np.array(geometry.opk_from_rotation(rotation_computed))
+            )
+
+            # Compute difference per-angle and normalize to [-180, 180]
+            opk_diff = opk_computed - opk_exif
+            opk_diff = (opk_diff + 180) % 360 - 180
+            errors.append(opk_diff)
+    return errors
+
+
+def opk_errors(reconstructions: List[types.Reconstruction]) -> Dict[str, Any]:
+    all_errors = []
+    for rec in reconstructions:
+        all_errors += _opk_errors(rec)
+    return _gps_gcp_opk_errors_stats(np.array(all_errors), ["omega", "phi", "kappa"])
 
 
 def gcp_errors(
@@ -107,7 +135,7 @@ def gcp_errors(
         gcp_enu = reference.to_topocentric(*gcp.lla_vec)
         all_errors.append(triangulated - gcp_enu)
 
-    return _gps_gcp_errors_stats(np.array(all_errors))
+    return _gps_gcp_opk_errors_stats(np.array(all_errors), ["x", "y", "z"])
 
 
 def _compute_errors(
@@ -239,7 +267,8 @@ def reconstruction_statistics(
     points_count_over_two = sum(counts[1:])
     stats["observations_count"] = int(sum(lengths * counts))
     stats["average_track_length"] = (
-        (stats["observations_count"] / points_count) if points_count > 0 else -1
+        (stats["observations_count"] /
+         points_count) if points_count > 0 else -1
     )
     stats["average_track_length_over_two"] = (
         (int(sum(lengths[1:] * counts[1:])) / points_count_over_two)
@@ -322,7 +351,8 @@ def processing_statistics(
             min_y = min(min_y, o[1])
             max_x = max(max_x, o[0])
             max_y = max(max_y, o[1])
-    stats["area"] = (max_x - min_x) * (max_y - min_y) if min_x != default_max else -1
+    stats["area"] = (max_x - min_x) * \
+        (max_y - min_y) if min_x != default_max else -1
     return stats
 
 
@@ -335,7 +365,8 @@ def features_statistics(
     detected = []
     images = {s for r in reconstructions for s in r.shots}
     for im in images:
-        features_data = feature_loader.instance.load_all_data(data, im, False, False)
+        features_data = feature_loader.instance.load_all_data(
+            data, im, False, False)
         if not features_data:
             continue
         detected.append(len(features_data.points))
@@ -347,7 +378,8 @@ def features_statistics(
             "median": int(np.median(detected)),
         }
     else:
-        stats["detected_features"] = {"min": -1, "max": -1, "mean": -1, "median": -1}
+        stats["detected_features"] = {"min": -1,
+                                      "max": -1, "mean": -1, "median": -1}
 
     per_shots = defaultdict(int)
     for rec in reconstructions:
@@ -383,11 +415,14 @@ def cameras_statistics(
     stats = {}
     permutation = np.argsort([-len(r.shots) for r in reconstructions])
     for camera_id, camera_model in data.load_camera_models().items():
-        stats[camera_id] = {"initial_values": _cameras_statistics(camera_model)}
+        stats[camera_id] = {
+            "initial_values": _cameras_statistics(camera_model)}
 
     for idx in permutation:
         rec = reconstructions[idx]
         for camera in rec.cameras.values():
+            if camera.id not in stats:
+                continue
             if "optimized_values" in stats[camera.id]:
                 continue
             stats[camera.id]["optimized_values"] = _cameras_statistics(camera)
@@ -446,7 +481,8 @@ def compute_all_statistics(
 ) -> Dict[str, Any]:
     stats = {}
 
-    stats["processing_statistics"] = processing_statistics(data, reconstructions)
+    stats["processing_statistics"] = processing_statistics(
+        data, reconstructions)
     stats["features_statistics"] = features_statistics(
         data, tracks_manager, reconstructions
     )
@@ -457,6 +493,7 @@ def compute_all_statistics(
     stats["rig_errors"] = rig_statistics(data, reconstructions)
     stats["gps_errors"] = gps_errors(reconstructions)
     stats["gcp_errors"] = gcp_errors(data, reconstructions)
+    stats["opk_errors"] = opk_errors(reconstructions)
 
     return stats
 
@@ -501,7 +538,8 @@ def save_matchgraph(
         for shot in rec.shots:
             shot_component[shot] = i
 
-    connectivity = tracks_manager.get_all_pairs_connectivity(all_shots, all_points)
+    connectivity = tracks_manager.get_all_pairs_connectivity(
+        all_shots, all_points)
     all_values = connectivity.values()
     lowest = np.percentile(list(all_values), 5)
     highest = np.percentile(list(all_values), 95)
@@ -793,7 +831,8 @@ def save_heatmap(
             all_cameras[camera.id] = camera
 
     for i in range(len(reconstructions)):
-        valid_observations = _get_valid_observations(reconstructions, tracks_manager)(i)
+        valid_observations = _get_valid_observations(
+            reconstructions, tracks_manager)(i)
         for shot_id, observations in valid_observations.items():
             shot = reconstructions[i].get_shot(shot_id)
             w = shot.camera.width
@@ -884,7 +923,8 @@ def save_residual_grids(
             all_errors[camera_id] = []
 
     for i in range(len(reconstructions)):
-        valid_observations = _get_valid_observations(reconstructions, tracks_manager)(i)
+        valid_observations = _get_valid_observations(
+            reconstructions, tracks_manager)(i)
         errors_scaled = _compute_errors(reconstructions, tracks_manager)(
             i, pymap.ErrorType.Normalized
         )
@@ -990,7 +1030,8 @@ def save_residual_grids(
 
         with io_handler.open_wb(
             os.path.join(
-                output_path, "residuals_" + str(camera_id.replace("/", "_")) + ".png"
+                output_path, "residuals_" +
+                str(camera_id.replace("/", "_")) + ".png"
             )
         ) as fwb:
             plt.savefig(

From f90433c0b61c3280261ba9ad001135a09e519343 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sat, 13 Dec 2025 19:14:09 +0100
Subject: [PATCH 209/235] First stage of rerun export_rerun

---
 opensfm/actions/export_rerun.py  | 560 +++++++++++++++++++++++++++++++
 opensfm/commands/__init__.py     |   2 +
 opensfm/commands/export_rerun.py |  33 ++
 pyproject.toml                   |   1 +
 4 files changed, 596 insertions(+)
 create mode 100644 opensfm/actions/export_rerun.py
 create mode 100644 opensfm/commands/export_rerun.py

diff --git a/opensfm/actions/export_rerun.py b/opensfm/actions/export_rerun.py
new file mode 100644
index 000000000..40af6c4b2
--- /dev/null
+++ b/opensfm/actions/export_rerun.py
@@ -0,0 +1,560 @@
+# pyre-strict
+import logging
+from typing import List, Optional
+
+import numpy as np
+from opensfm import multiview, pymap, types
+from opensfm.dataset import DataSet
+from opensfm import pygeometry
+
+try:
+    import rerun as rr
+except ImportError:
+    raise ImportError(
+        "Rerun is not installed. Install it with: pip install rerun-sdk"
+    )
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+# Visualization constants
+GPS_COLOR = [0, 0, 255]
+GCP_OBSERVATION_COLOR = [255, 0, 0]
+GCP_COMPUTED_COLOR = [0, 255, 0]
+GCP_REFERENCE_COLOR = [255, 255, 255]
+GCP_ERROR_COLOR = [255, 0, 0]
+FEATURE_COLOR = [0, 255, 0]
+LABEL_COLOR = [255, 255, 255]
+
+SIZE_TIE_POINT = 0.1
+
+SIZE_GPS_ARROW = 1.0
+SIZE_GPS_RESIDUAL_LINE = 0.05
+
+SIZE_GCP_TARGET = 2.0
+SIZE_GCP_THICKNESS = 0.05
+SIZE_GCP_COMPUTED_ARROW = 0.1
+SIZE_GCP_RESIDUAL_LINE = 0.02
+
+SIZE_2D_POINT_GCP = 5.0
+SIZE_2D_POINT_FEATURE = 2.0
+
+SIZE_LABEL_SHIFT_SHOT = 0.5
+
+IMAGE_PLANE_DISTANCE = 2.0
+MAX_IMAGE_WIDTH = 1500
+
+
+def run_dataset(
+    data: DataSet,
+    output: Optional[str] = None,
+    reconstruction_index: int = 0,
+) -> None:
+    """Export reconstruction to Rerun format for 3D visualization.
+
+    Args:
+        data: OpenSfM dataset
+        output: Output .rrd file path (default: dataset_path/rerun.rrd)
+        reconstruction_index: Index of reconstruction to export (default: 0)
+    """
+
+    # Load reconstruction
+    reconstructions = data.load_reconstruction()
+    if not reconstructions:
+        logger.error("No reconstructions found in dataset")
+        return
+
+    if reconstruction_index >= len(reconstructions):
+        logger.error(
+            f"Reconstruction index {reconstruction_index} out of range "
+            f"(found {len(reconstructions)} reconstructions)"
+        )
+        return
+
+    reconstruction = reconstructions[reconstruction_index]
+    logger.info(
+        f"Exporting reconstruction {reconstruction_index} with "
+        f"{len(reconstruction.shots)} shots, "
+        f"{len(reconstruction.points)} points"
+    )
+
+    # Initialize Rerun
+    output_path = output or data.data_path + "/rerun.rrd"
+    rr.init("OpenSfM Reconstruction", spawn=False)
+    rr.save(output_path)
+    logger.info(f"Saving Rerun data to {output_path}")
+
+    # Set up coordinate system (OpenSfM uses East-North-Up)
+    rr.log("/", rr.ViewCoordinates.RIGHT_HAND_Z_UP)
+
+    # Center the view on the median of the reconstruction points
+    if reconstruction.points:
+        points = np.array([p.coordinates for p in reconstruction.points.values()])
+        median_center = np.median(points, axis=0)
+        rr.log("world", rr.Transform3D(translation=-median_center))
+
+    # Export reference coordinate system
+    if reconstruction.reference:
+        ref = reconstruction.reference
+        rr.log(
+            "world/reference",
+            rr.TextDocument(
+                f"Reference LLA:\n"
+                f"Latitude: {ref.lat:.6f}°\n"
+                f"Longitude: {ref.lon:.6f}°\n"
+                f"Altitude: {ref.alt:.2f}m",
+            ),
+        )
+
+    # Export cameras (intrinsics)
+    _export_cameras(reconstruction)
+
+    # Export camera poses (shots)
+    _export_shots(data, reconstruction)
+
+    # Export 3D points
+    _export_points(reconstruction)
+
+    # Export Ground Control Points
+    gcp = data.load_ground_control_points()
+    if gcp:
+        _export_gcp(data, reconstruction, gcp)
+
+    # Export tracks manager (optional, for visualizing observations)
+    # if data.tracks_exists():
+    #     tracks_manager = data.load_tracks_manager()
+    #     _export_observations(reconstruction, tracks_manager)
+
+    logger.info(f"Rerun export completed: {output_path}")
+    logger.info(f"Open with: rerun {output_path}")
+
+
+def _get_shot_sequence_id(shot_id: str) -> int:
+    """Extract integer ID from shot_id string (e.g., 'Shot 123' -> 123).
+    
+    If extraction fails, use hash of the shot_id to ensure uniqueness.
+    """
+    try:
+        # Try to extract number from strings like "Shot 123" or "DSC_0123.jpg"
+        import re
+        numbers = re.findall(r'\d+', shot_id)
+        if numbers:
+            return int(numbers[-1])  # Use the last number found
+    except:
+        pass
+    
+    # Fallback: use hash of shot_id
+    return hash(shot_id) & 0x7FFFFFFF  # Ensure positive integer
+
+
+def _get_scaled_dimensions(width: int, height: int) -> tuple[int, int]:
+    if width > MAX_IMAGE_WIDTH:
+        scale = MAX_IMAGE_WIDTH / width
+        return int(width * scale), int(height * scale)
+    return width, height
+
+
+def _get_camera_calibration(camera: pygeometry.Camera, width: int, height: int):
+    """Calculate camera intrinsic parameters."""
+    fx = fy = camera.focal * max(width, height)
+    if hasattr(camera, "focal_x") and hasattr(camera, "focal_y"):
+        fx = camera.focal_x * max(width, height)
+        fy = camera.focal_y * max(width, height)
+
+    cx = width / 2.0
+    cy = height / 2.0
+    if hasattr(camera, "c_x") and hasattr(camera, "c_y"):
+        cx = camera.c_x * max(width, height) + width / 2.0
+        cy = camera.c_y * max(width, height) + height / 2.0
+    return fx, fy, cx, cy
+
+
+def _export_cameras(reconstruction: types.Reconstruction) -> None:
+    """Export camera models (intrinsics)."""
+    for camera_id, camera in reconstruction.cameras.items():
+        # Get camera parameters
+        width = int(camera.width)
+        height = int(camera.height)
+        width, height = _get_scaled_dimensions(width, height)
+        fx, fy, cx, cy = _get_camera_calibration(camera, width, height)
+        focal_length_px = camera.focal * max(width, height)
+
+        # Log camera intrinsics (strip spaces from camera_id)
+        camera_id_clean = camera_id.replace(" ", "_")
+        rr.log(
+            f"world/cameras/{camera_id_clean}/info",
+            rr.TextDocument(
+                f"Camera: {camera_id}\n"
+                f"Type: {camera.projection_type}\n"
+                f"Resolution: {width}x{height}\n"
+                f"Focal: {focal_length_px:.1f}px\n"
+                f"Principal Point: ({cx:.1f}, {cy:.1f})"
+            ),
+        )
+
+
+def _export_shots(data: DataSet, reconstruction: types.Reconstruction) -> None:
+    """Export camera shots (poses and images)."""
+    reference = reconstruction.reference
+
+    for shot_id, shot in reconstruction.shots.items():
+        _export_shot_pose(shot, shot_id)
+
+        # Collect GPS position and error line if available
+        if reference and shot.metadata and shot.metadata.gps_position.has_value:
+            gps_topo = shot.metadata.gps_position.value
+            _export_shot_gps(shot, shot_id, gps_topo)
+
+        _export_shot_pinhole(data, shot, shot_id)
+
+
+def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
+    pose = shot.pose
+    R = pose.get_rotation_matrix()  # 3x3 rotation matrix
+    t = pose.get_origin()  # 3D position (camera center in world coords)
+
+    # Rerun expects rotation from world to camera
+    # OpenSfM GetRotationMatrix gives camera-to-world rotation
+    R_world_from_camera = R.T  # Transpose to get world-from-camera
+
+    # Strip spaces from camera_id for clean entity paths
+    camera_id_clean = shot.camera.id.replace(" ", "_")
+
+    # Log camera pose with integer sequence ID
+    sequence_id = _get_shot_sequence_id(shot_id)
+    rr.set_time_sequence("shot", sequence_id)
+    rr.log(
+        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose",
+        rr.Transform3D(
+            translation=t,
+            mat3x3=R_world_from_camera,
+            from_parent=False,
+        ),
+    )
+
+    labels_shift = np.array([0, 0, SIZE_LABEL_SHIFT_SHOT])  # Shift labels above targets
+    rr.log(
+        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose",
+        rr.Points3D(
+            positions=labels_shift,
+            labels=[shot_id],
+            radii=0.0,  # Invisible points, just for labels
+            colors=[LABEL_COLOR],  # White labels
+        ),
+        static=True,
+    )
+
+
+def _export_shot_pinhole(data: DataSet, shot: pymap.Shot, shot_id: str) -> None:
+    # Create pinhole camera for image projection
+    width = int(shot.camera.width)
+    height = int(shot.camera.height)
+    width, height = _get_scaled_dimensions(width, height)
+    fx, fy, cx, cy = _get_camera_calibration(shot.camera, width, height)
+
+    camera_id_clean = shot.camera.id.replace(" ", "_")
+    rr.log(
+        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose/pinhole",
+        rr.Pinhole(
+            resolution=[width, height],
+            focal_length=[fx, fy],
+            principal_point=[cx, cy],
+            image_plane_distance=IMAGE_PLANE_DISTANCE,
+        ),
+    )
+
+    # Load and log image if available
+    try:
+        image = data.load_image(shot_id)
+        
+        # Resize image if needed
+        if image.shape[1] != width or image.shape[0] != height:
+            import cv2
+            image = cv2.resize(image, (width, height), interpolation=cv2.INTER_AREA)
+
+        rr.log(
+            f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose/pinhole/image",
+            rr.Image(image).compress(jpeg_quality=50),
+        )
+    except Exception as e:
+        logger.warning(f"Could not load image for {shot_id}: {e}")
+
+
+def _export_shot_gps(
+    shot: pymap.Shot,
+    shot_id: str,
+    gps_topo: np.ndarray,
+) -> None:
+    camera_id_clean = shot.camera.id.replace(" ", "_")
+    base_path = f"world/cameras/{camera_id_clean}/shots/{shot_id}/gps"
+
+    arrow_size = SIZE_GPS_ARROW
+    arrow_radii = arrow_size / 8.0
+    arrow_length = arrow_size  # Length of arrows for GPS positions
+    
+    origin = gps_topo.copy()
+    origin[2] += arrow_length
+    vector = np.array([0, 0, -arrow_length])
+
+    rr.log(
+        f"{base_path}/position",
+        rr.Arrows3D(
+            origins=[origin],
+            vectors=[vector],
+            colors=[GPS_COLOR],  # Blue
+            radii=arrow_radii,
+        ),
+        static=True,
+    )
+
+    rr.log(
+        f"{base_path}/residual",
+        rr.LineStrips3D(
+            [[shot.pose.get_origin(), gps_topo]],
+            colors=[GPS_COLOR],  # Blue
+            radii=SIZE_GPS_RESIDUAL_LINE,
+        ),
+        static=True,
+    )
+
+
+def _export_points(reconstruction: types.Reconstruction) -> None:
+    """Export 3D points (structure)."""
+
+    if not reconstruction.points:
+        return
+
+    # Collect all points
+    positions = []
+    colors = []
+    point_ids = []
+
+    for point_id, point in reconstruction.points.items():
+        positions.append(point.coordinates)
+        # Convert color from 0-1 to 0-255 if needed
+        color = point.color
+        if all(c <= 1.0 for c in color):
+            color = [int(c * 255) for c in color]
+        colors.append(color)
+        point_ids.append(point_id)
+
+    # Log all points at once for efficiency
+    rr.log(
+        "world/points/automatic",
+        rr.Points3D(
+            positions=np.array(positions),
+            colors=np.array(colors, dtype=np.uint8),
+            radii=SIZE_TIE_POINT,  # Small radius for tie points
+        ),
+        static=True,
+    )
+
+    logger.info(f"Exported {len(positions)} automatic tie points")
+
+
+def _export_gcp(
+    data: DataSet,
+    reconstruction: types.Reconstruction,
+    gcp: List[pymap.GroundControlPoint],
+) -> None:
+    """Export Ground Control Points."""
+    if not gcp:
+        return
+
+    reference = reconstruction.reference
+
+    for point in gcp:
+        # Get 3D position
+        if point.lla:
+            # Convert from lat/lon/alt to topocentric coordinates
+            lla_vec = point.lla_vec
+            pos = reference.to_topocentric(*lla_vec)
+
+            # Try to triangulate GCP
+            triangulated = multiview.triangulate_gcp(
+                point, reconstruction.shots, data.config["gcp_reprojection_error_threshold"]
+            )
+
+            _export_single_gcp_geometry(point.id, pos, triangulated)
+            _export_gcp_observations(reconstruction, point)
+
+    logger.info(f"Exported {len(gcp)} Ground Control Points")
+
+
+def _export_gcp_observations(
+    reconstruction: types.Reconstruction, 
+    point: pymap.GroundControlPoint
+) -> None:
+    # Log GCP observations in images
+    for obs in point.observations:
+        shot_id = obs.shot_id
+        if shot_id in reconstruction.shots:
+            # Log 2D observation
+            shot = reconstruction.shots[shot_id]
+            width = int(shot.camera.width)
+            height = int(shot.camera.height)
+            width, height = _get_scaled_dimensions(width, height)
+            normalize = max(width, height)
+
+            # Convert from normalized to pixel coordinates
+            px = obs.projection[0] * normalize + width / 2.0
+            py = obs.projection[1] * normalize + height / 2.0
+
+            # Strip spaces from camera_id
+            camera_id_clean = shot.camera.id.replace(" ", "_")
+
+            # Set time sequence with integer ID
+            sequence_id = _get_shot_sequence_id(shot_id)
+            rr.set_time_sequence("shot", sequence_id)
+            rr.log(
+                f"world/cameras/{camera_id_clean}/shots/{shot_id}/pinhole/gcp/{point.id}",
+                rr.Points2D(
+                    [[px, py]],
+                    colors=[GCP_OBSERVATION_COLOR],
+                    radii=SIZE_2D_POINT_GCP,
+                    labels=[point.id],
+                ),
+            )
+
+
+def _export_single_gcp_geometry(
+    gcp_id: str,
+    reference_pos: np.ndarray,
+    computed_pos: Optional[np.ndarray],
+) -> None:
+    base_path = f"world/gcp/{gcp_id}"
+
+    # Target dimensions (1m x 1m target)
+    target_size = SIZE_GCP_TARGET
+    quad_r = target_size / 4.0  # Half-size of a quadrant
+    thickness = SIZE_GCP_THICKNESS
+
+    pos_np = np.array(reference_pos)
+    color = GCP_REFERENCE_COLOR if computed_pos is not None else GCP_ERROR_COLOR
+
+    # Checkerboard boxes
+    centers = [
+        pos_np + [-quad_r, quad_r, 0],
+        pos_np + [quad_r, -quad_r, 0]
+    ]
+    half_sizes = [[quad_r, quad_r, thickness]] * 2
+    colors = [color] * 2
+
+    rr.log(
+        f"{base_path}/marker",
+        rr.Boxes3D(
+            centers=centers,
+            half_sizes=half_sizes,
+            colors=colors,
+            fill_mode="solid",
+        ),
+        static=True,
+    )
+
+    # Outline
+    rr.log(
+        f"{base_path}/outline",
+        rr.Boxes3D(
+            centers=[pos_np],
+            half_sizes=[[target_size / 2.0, target_size / 2.0, thickness]],
+            colors=[color],
+            radii=thickness,
+            fill_mode="major_wireframe",
+        ),
+        static=True,
+    )
+
+    # Label
+    labels_shift = np.array([0, 0, target_size])
+    rr.log(
+        f"{base_path}/label",
+        rr.Points3D(
+            positions=[pos_np + labels_shift],
+            labels=[gcp_id],
+            radii=0.0,
+            colors=[LABEL_COLOR],
+        ),
+        static=True,
+    )
+
+    # Computed position
+    if computed_pos is not None:
+        arrow_length = 0.5
+        origin = computed_pos.copy()
+        origin[2] += arrow_length
+        vector = np.array([0, 0, -arrow_length])
+
+        rr.log(
+            f"{base_path}/computed",
+            rr.Arrows3D(
+                origins=[origin],
+                vectors=[vector],
+                colors=[GCP_COMPUTED_COLOR],
+                radii=SIZE_GCP_COMPUTED_ARROW,
+            ),
+            static=True,
+        )
+
+        # Residual line
+        rr.log(
+            f"{base_path}/residual",
+            rr.LineStrips3D(
+                [[computed_pos, reference_pos]],
+                colors=[GCP_COMPUTED_COLOR],
+                radii=SIZE_GCP_RESIDUAL_LINE,
+            ),
+            static=True,
+        )
+
+
+def _export_observations(
+    reconstruction: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+) -> None:
+    """Export feature observations (2D points in images)."""
+
+    logger.info("Exporting feature observations...")
+
+    # Sample some tracks to avoid overwhelming the viewer
+    max_tracks = 1000
+    track_ids = list(reconstruction.points.keys())
+    if len(track_ids) > max_tracks:
+        import random
+
+        track_ids = random.sample(track_ids, max_tracks)
+
+    for track_id in track_ids:
+        if track_id not in reconstruction.points:
+            continue
+
+        observations = tracks_manager.get_track_observations(track_id)
+
+        for shot_id, obs in observations.items():
+            if shot_id not in reconstruction.shots:
+                continue
+
+            shot = reconstruction.shots[shot_id]
+            width = int(shot.camera.width)
+            height = int(shot.camera.height)
+            width, height = _get_scaled_dimensions(width, height)
+            normalize = max(width, height)
+
+            # Convert from normalized to pixel coordinates
+            px = obs.point[0] * normalize + width / 2.0
+            py = obs.point[1] * normalize + height / 2.0
+
+            # Strip spaces from camera_id
+            camera_id_clean = shot.camera.id.replace(" ", "_")
+
+            # Set time sequence with integer ID
+            sequence_id = _get_shot_sequence_id(shot_id)
+            rr.set_time_sequence("shot", sequence_id)
+            rr.log(
+                f"world/cameras/{camera_id_clean}/shots/{shot_id}/pinhole/features",
+                rr.Points2D(
+                    [[px, py]],
+                    colors=[FEATURE_COLOR],  # Green for features
+                    radii=SIZE_2D_POINT_FEATURE,
+                ),
+            )
+
+    logger.info(f"Exported observations for {len(track_ids)} tracks")
\ No newline at end of file
diff --git a/opensfm/commands/__init__.py b/opensfm/commands/__init__.py
index 6d0aecffa..faf6eeff2 100644
--- a/opensfm/commands/__init__.py
+++ b/opensfm/commands/__init__.py
@@ -19,6 +19,7 @@
     export_ply,
     export_pmvs,
     export_report,
+    export_rerun,
     export_visualsfm,
     extend_reconstruction,
     extract_metadata,
@@ -52,6 +53,7 @@
     export_colmap,
     export_geocoords,
     export_report,
+    export_rerun,
     extend_reconstruction,
     create_submodels,
     align_submodels,
diff --git a/opensfm/commands/export_rerun.py b/opensfm/commands/export_rerun.py
new file mode 100644
index 000000000..3028c7b57
--- /dev/null
+++ b/opensfm/commands/export_rerun.py
@@ -0,0 +1,33 @@
+# pyre-strict
+import argparse
+
+from opensfm.actions import export_rerun
+from opensfm.dataset import DataSet
+
+from . import command
+
+
+class Command(command.CommandBase):
+    name = "export_rerun"
+    help = "Export reconstruction to Rerun format for 3D visualization"
+
+    def run_impl(self, dataset: DataSet, args: argparse.Namespace) -> None:
+        export_rerun.run_dataset(
+            dataset,
+            output=args.output,
+            reconstruction_index=args.reconstruction_index,
+        )
+
+    def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--output",
+            "-o",
+            type=str,
+            help="Output .rrd file path (default: dataset_path/rerun.rrd)",
+        )
+        parser.add_argument(
+            "--reconstruction-index",
+            type=int,
+            default=0,
+            help="Index of reconstruction to export (default: 0)",
+        )
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 5d67cf18a..a932c8131 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,6 +29,7 @@ dependencies = [
     "scipy>=1.10.0",
     "xmltodict>=0.10.2",
     "opencv-python>=4.8.0",
+    "rerun-sdk==0.27.2",
 ]
 
 [project.optional-dependencies]

From 0b3dc7c39ec1aa998f7e14d9c66d067f6a12ac0c Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sun, 14 Dec 2025 17:54:53 +0100
Subject: [PATCH 210/235] Unified colors, added matchgraph and coverage map

---
 opensfm/actions/export_rerun.py | 360 +++++++++++++++++++++++++++-----
 1 file changed, 311 insertions(+), 49 deletions(-)

diff --git a/opensfm/actions/export_rerun.py b/opensfm/actions/export_rerun.py
index 40af6c4b2..74f84a852 100644
--- a/opensfm/actions/export_rerun.py
+++ b/opensfm/actions/export_rerun.py
@@ -3,29 +3,26 @@
 from typing import List, Optional
 
 import numpy as np
-from opensfm import multiview, pymap, types
+from opensfm import features, multiview, pymap, types
 from opensfm.dataset import DataSet
 from opensfm import pygeometry
 
-try:
-    import rerun as rr
-except ImportError:
-    raise ImportError(
-        "Rerun is not installed. Install it with: pip install rerun-sdk"
-    )
+import matplotlib.cm as cm
+import rerun as rr
+import rerun.blueprint as rrb
 
 logger: logging.Logger = logging.getLogger(__name__)
 
 # Visualization constants
-GPS_COLOR = [0, 0, 255]
-GCP_OBSERVATION_COLOR = [255, 0, 0]
-GCP_COMPUTED_COLOR = [0, 255, 0]
-GCP_REFERENCE_COLOR = [255, 255, 255]
-GCP_ERROR_COLOR = [255, 0, 0]
-FEATURE_COLOR = [0, 255, 0]
-LABEL_COLOR = [255, 255, 255]
+GPS_COLOR = [100, 180, 255]
+GCP_OBSERVATION_COLOR = [255, 160, 120]
+GCP_COMPUTED_COLOR = [120, 255, 140]
+GCP_REFERENCE_COLOR = [255, 230, 100] 
+GCP_ERROR_COLOR = [255, 100, 100]
+FEATURE_COLOR = [100, 255, 220] 
+LABEL_COLOR = [220, 220, 220] 
 
-SIZE_TIE_POINT = 0.1
+SIZE_TIE_POINT = 0.2
 
 SIZE_GPS_ARROW = 1.0
 SIZE_GPS_RESIDUAL_LINE = 0.05
@@ -40,9 +37,13 @@
 
 SIZE_LABEL_SHIFT_SHOT = 0.5
 
-IMAGE_PLANE_DISTANCE = 2.0
+SIZE_MATCHGRAPH_LINE = 0.1
+SIZE_CAMERA_PATH_LINE = 0.5
+
 MAX_IMAGE_WIDTH = 1500
 
+MATCHGRAPH_CMAP = cm.get_cmap("plasma")
+COVERAGE_CMAP = cm.get_cmap("viridis")
 
 def run_dataset(
     data: DataSet,
@@ -86,11 +87,24 @@ def run_dataset(
     # Set up coordinate system (OpenSfM uses East-North-Up)
     rr.log("/", rr.ViewCoordinates.RIGHT_HAND_Z_UP)
 
-    # Center the view on the median of the reconstruction points
-    if reconstruction.points:
-        points = np.array([p.coordinates for p in reconstruction.points.values()])
-        median_center = np.median(points, axis=0)
-        rr.log("world", rr.Transform3D(translation=-median_center))
+    # Create a Spatial3D view to display the scene
+    blueprint = rrb.Blueprint(
+        rrb.Spatial3DView(
+            origin="/WORLD",
+            name="3D Scene",
+            background=[13, 17, 23], # Deep dark gray
+            line_grid=rrb.LineGrid3D(
+                visible=False,
+            ),
+            spatial_information=rrb.SpatialInformation(
+                show_axes=False,
+                show_bounding_box=False,
+            ),
+        ),
+        collapse_panels=False,
+        )
+
+    rr.send_blueprint(blueprint)
 
     # Export reference coordinate system
     if reconstruction.reference:
@@ -109,7 +123,8 @@ def run_dataset(
     _export_cameras(reconstruction)
 
     # Export camera poses (shots)
-    _export_shots(data, reconstruction)
+    _export_shots(data, reconstruction, _compute_image_plane_distance(reconstruction))
+    _export_camera_path(reconstruction)
 
     # Export 3D points
     _export_points(reconstruction)
@@ -120,9 +135,12 @@ def run_dataset(
         _export_gcp(data, reconstruction, gcp)
 
     # Export tracks manager (optional, for visualizing observations)
-    # if data.tracks_exists():
-    #     tracks_manager = data.load_tracks_manager()
-    #     _export_observations(reconstruction, tracks_manager)
+    if data.tracks_exists():
+        tracks_manager = data.load_tracks_manager()
+        # _export_observations(reconstruction, tracks_manager)
+        _export_matchgraph(data, reconstruction, tracks_manager)
+
+    _export_coverage_map(data, reconstruction)
 
     logger.info(f"Rerun export completed: {output_path}")
     logger.info(f"Open with: rerun {output_path}")
@@ -153,6 +171,22 @@ def _get_scaled_dimensions(width: int, height: int) -> tuple[int, int]:
     return width, height
 
 
+def _compute_image_plane_distance(reconstruction: types.Reconstruction) -> float:
+    positions = np.array([shot.pose.get_origin() for shot in reconstruction.shots.values()])
+    if len(positions) < 2:
+        return 2.0
+        
+    try:
+        from scipy.spatial import KDTree
+        tree = KDTree(positions)
+        dists, _ = tree.query(positions, k=5)
+        median_nn_dist = np.median(dists[:, 1])
+        return float(median_nn_dist)
+    except ImportError:
+        logger.warning("Scipy not found, using default image plane distance.")
+        return 2.0
+
+
 def _get_camera_calibration(camera: pygeometry.Camera, width: int, height: int):
     """Calculate camera intrinsic parameters."""
     fx = fy = camera.focal * max(width, height)
@@ -192,7 +226,7 @@ def _export_cameras(reconstruction: types.Reconstruction) -> None:
         )
 
 
-def _export_shots(data: DataSet, reconstruction: types.Reconstruction) -> None:
+def _export_shots(data: DataSet, reconstruction: types.Reconstruction, image_plane_distance: float) -> None:
     """Export camera shots (poses and images)."""
     reference = reconstruction.reference
 
@@ -204,7 +238,34 @@ def _export_shots(data: DataSet, reconstruction: types.Reconstruction) -> None:
             gps_topo = shot.metadata.gps_position.value
             _export_shot_gps(shot, shot_id, gps_topo)
 
-        _export_shot_pinhole(data, shot, shot_id)
+        _export_shot_pinhole(data, shot, shot_id, image_plane_distance)
+
+
+def _export_camera_path(reconstruction: types.Reconstruction) -> None:
+    """Export camera path based on capture time."""
+    shots_with_time = []
+    for shot in reconstruction.shots.values():
+        if shot.metadata and shot.metadata.capture_time.has_value:
+            shots_with_time.append(shot)
+    
+    if len(shots_with_time) < 2:
+        return
+
+    # Sort by capture time
+    shots_with_time.sort(key=lambda x: x.metadata.capture_time.value)
+    
+    points = [shot.pose.get_origin() for shot in shots_with_time]
+    
+    rr.log(
+        "WORLD/PATH",
+        rr.LineStrips3D(
+            [points],
+            colors=[[255, 255, 255]], # White
+            radii=SIZE_CAMERA_PATH_LINE,
+        ),
+        static=True,
+    )
+    logger.info(f"Exported camera path with {len(points)} points")
 
 
 def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
@@ -216,14 +277,11 @@ def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
     # OpenSfM GetRotationMatrix gives camera-to-world rotation
     R_world_from_camera = R.T  # Transpose to get world-from-camera
 
-    # Strip spaces from camera_id for clean entity paths
-    camera_id_clean = shot.camera.id.replace(" ", "_")
-
     # Log camera pose with integer sequence ID
     sequence_id = _get_shot_sequence_id(shot_id)
     rr.set_time_sequence("shot", sequence_id)
     rr.log(
-        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose",
+        f"WORLD/SHOTS/{shot_id}",
         rr.Transform3D(
             translation=t,
             mat3x3=R_world_from_camera,
@@ -233,7 +291,7 @@ def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
 
     labels_shift = np.array([0, 0, SIZE_LABEL_SHIFT_SHOT])  # Shift labels above targets
     rr.log(
-        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose",
+        f"WORLD/SHOTS/{shot_id}",
         rr.Points3D(
             positions=labels_shift,
             labels=[shot_id],
@@ -244,21 +302,20 @@ def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
     )
 
 
-def _export_shot_pinhole(data: DataSet, shot: pymap.Shot, shot_id: str) -> None:
+def _export_shot_pinhole(data: DataSet, shot: pymap.Shot, shot_id: str, image_plane_distance: float) -> None:
     # Create pinhole camera for image projection
     width = int(shot.camera.width)
     height = int(shot.camera.height)
     width, height = _get_scaled_dimensions(width, height)
     fx, fy, cx, cy = _get_camera_calibration(shot.camera, width, height)
 
-    camera_id_clean = shot.camera.id.replace(" ", "_")
     rr.log(
-        f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose/pinhole",
+        f"WORLD/SHOTS/{shot_id}/CAMERA",
         rr.Pinhole(
             resolution=[width, height],
             focal_length=[fx, fy],
             principal_point=[cx, cy],
-            image_plane_distance=IMAGE_PLANE_DISTANCE,
+            image_plane_distance=image_plane_distance,
         ),
     )
 
@@ -272,7 +329,7 @@ def _export_shot_pinhole(data: DataSet, shot: pymap.Shot, shot_id: str) -> None:
             image = cv2.resize(image, (width, height), interpolation=cv2.INTER_AREA)
 
         rr.log(
-            f"world/cameras/{camera_id_clean}/shots/{shot_id}/pose/pinhole/image",
+            f"WORLD/SHOTS/{shot_id}/CAMERA/IMAGE",
             rr.Image(image).compress(jpeg_quality=50),
         )
     except Exception as e:
@@ -284,8 +341,8 @@ def _export_shot_gps(
     shot_id: str,
     gps_topo: np.ndarray,
 ) -> None:
-    camera_id_clean = shot.camera.id.replace(" ", "_")
-    base_path = f"world/cameras/{camera_id_clean}/shots/{shot_id}/gps"
+
+    base_path = f"WORLD/GPS/{shot_id}/"
 
     arrow_size = SIZE_GPS_ARROW
     arrow_radii = arrow_size / 8.0
@@ -296,7 +353,7 @@ def _export_shot_gps(
     vector = np.array([0, 0, -arrow_length])
 
     rr.log(
-        f"{base_path}/position",
+        f"{base_path}/POSITION",
         rr.Arrows3D(
             origins=[origin],
             vectors=[vector],
@@ -307,7 +364,7 @@ def _export_shot_gps(
     )
 
     rr.log(
-        f"{base_path}/residual",
+        f"{base_path}/RESIDUAL",
         rr.LineStrips3D(
             [[shot.pose.get_origin(), gps_topo]],
             colors=[GPS_COLOR],  # Blue
@@ -339,7 +396,7 @@ def _export_points(reconstruction: types.Reconstruction) -> None:
 
     # Log all points at once for efficiency
     rr.log(
-        "world/points/automatic",
+        "WORLD/POINTS",
         rr.Points3D(
             positions=np.array(positions),
             colors=np.array(colors, dtype=np.uint8),
@@ -421,7 +478,7 @@ def _export_single_gcp_geometry(
     reference_pos: np.ndarray,
     computed_pos: Optional[np.ndarray],
 ) -> None:
-    base_path = f"world/gcp/{gcp_id}"
+    base_path = f"WORLD/GCP/{gcp_id}"
 
     # Target dimensions (1m x 1m target)
     target_size = SIZE_GCP_TARGET
@@ -440,7 +497,7 @@ def _export_single_gcp_geometry(
     colors = [color] * 2
 
     rr.log(
-        f"{base_path}/marker",
+        f"{base_path}/TARGET",
         rr.Boxes3D(
             centers=centers,
             half_sizes=half_sizes,
@@ -452,7 +509,7 @@ def _export_single_gcp_geometry(
 
     # Outline
     rr.log(
-        f"{base_path}/outline",
+        f"{base_path}/OUTLINE",
         rr.Boxes3D(
             centers=[pos_np],
             half_sizes=[[target_size / 2.0, target_size / 2.0, thickness]],
@@ -466,7 +523,7 @@ def _export_single_gcp_geometry(
     # Label
     labels_shift = np.array([0, 0, target_size])
     rr.log(
-        f"{base_path}/label",
+        f"{base_path}",
         rr.Points3D(
             positions=[pos_np + labels_shift],
             labels=[gcp_id],
@@ -484,7 +541,7 @@ def _export_single_gcp_geometry(
         vector = np.array([0, 0, -arrow_length])
 
         rr.log(
-            f"{base_path}/computed",
+            f"{base_path}/COMPUTED",
             rr.Arrows3D(
                 origins=[origin],
                 vectors=[vector],
@@ -496,7 +553,7 @@ def _export_single_gcp_geometry(
 
         # Residual line
         rr.log(
-            f"{base_path}/residual",
+            f"{base_path}/RESIDUAL",
             rr.LineStrips3D(
                 [[computed_pos, reference_pos]],
                 colors=[GCP_COMPUTED_COLOR],
@@ -557,4 +614,209 @@ def _export_observations(
                 ),
             )
 
-    logger.info(f"Exported observations for {len(track_ids)} tracks")
\ No newline at end of file
+    logger.info(f"Exported observations for {len(track_ids)} tracks")
+
+
+def _export_matchgraph(
+    data: DataSet,
+    reconstruction: types.Reconstruction,
+    tracks_manager: pymap.TracksManager,
+) -> None:
+    """Export match graph connectivity."""
+    logger.info("Exporting match graph...")
+    
+    all_shots = list(reconstruction.shots.keys())
+    all_points = list(reconstruction.points.keys())
+    
+    # Compute connectivity
+    connectivity = tracks_manager.get_all_pairs_connectivity(all_shots, all_points)
+    if not connectivity:
+        return
+
+    all_values = list(connectivity.values())
+    if not all_values:
+        return
+        
+    lowest = np.percentile(all_values, 5)
+    highest = np.percentile(all_values, 95)
+    
+    lines = []
+    colors = []
+
+    min_inliers = data.config.get("resection_min_inliers", 15)
+
+    for (node1, node2), edge in connectivity.items():
+        if edge < 5 * min_inliers:
+            continue
+            
+        if node1 not in reconstruction.shots or node2 not in reconstruction.shots:
+            continue
+            
+        shot1 = reconstruction.shots[node1]
+        shot2 = reconstruction.shots[node2]
+        
+        p1 = shot1.pose.get_origin()
+        p2 = shot2.pose.get_origin()
+        
+        # Normalize edge weight for color mapping
+        c_val = max(0.0, min(1.0, 1.0 - (float(edge) - lowest) / (highest - lowest + 1e-6)))
+        rgba = MATCHGRAPH_CMAP(1.0 - c_val)
+        
+        lines.append([p1, p2])
+        colors.append([int(c * 255) for c in rgba[:3]])
+
+    if lines:
+        rr.log(
+            "WORLD/STATS/MATCHGRAPH",
+            rr.LineStrips3D(
+                lines,
+                colors=colors,
+                radii=SIZE_MATCHGRAPH_LINE,
+            ),
+            static=True,
+        )
+        logger.info(f"Exported match graph with {len(lines)} edges")
+
+
+def _export_coverage_map(
+    data: DataSet,
+    reconstruction: types.Reconstruction,
+) -> None:
+    """Export coverage map as a tessellated quad."""
+    logger.info("Exporting coverage map...")
+    
+    if not reconstruction.points:
+        return
+
+    try:
+        from scipy.spatial import Delaunay
+    except ImportError:
+        logger.warning("Scipy not found, skipping coverage map triangulation.")
+        return
+
+    # 1. Compute Bounding Box
+    points = np.array([p.coordinates for p in reconstruction.points.values()])
+    if len(points) == 0:
+        return
+    
+    min_pt = np.percentile(points, 1, axis=0)
+    max_pt = np.percentile(points, 99, axis=0)
+    median_z = np.median(points[:, 2])
+
+    # Add some margin
+    margin_ratio = 0.1
+    extent = max_pt - min_pt
+    min_pt -= extent * margin_ratio
+    max_pt += extent * margin_ratio
+    
+    # 2. Generate Vertices from Frustums
+    vertices = []
+    
+    for shot in reconstruction.shots.values():
+        w = shot.camera.width
+        h = shot.camera.height
+        
+        m = 0.01
+        n_steps = 10
+        steps = np.linspace(0, 1, n_steps)
+        steps = m + steps * (1 - 2 * m)
+        
+        xs = w * steps
+        ys = h * steps
+        pixels = features.normalized_image_coordinates(np.array([[x, y] for y in ys for x in xs]), w, h)
+        
+        # Transform bearings to world frame
+        # pose is World -> Camera. Rotation part R.
+        bearings = shot.camera.pixel_bearing_many(pixels)
+        R_wc = shot.pose.get_rotation_matrix().T
+        bearings_world = bearings @ R_wc.T
+        
+        origin = shot.pose.get_origin()
+        
+        for direction in bearings_world:
+            # Intersect with Z = median_z
+            # P = O + t * D
+            # median_z = O_z + t * D_z  => t = (median_z - O_z) / D_z
+            
+            if abs(direction[2]) < 1e-6:
+                continue
+                
+            t = (median_z - origin[2]) / direction[2]
+            if t <= 0: # Behind camera or camera is inside plane
+                continue
+                
+            p_ground = origin + t * direction
+            
+            # Check bounds
+            if (p_ground[0] >= min_pt[0] and p_ground[0] <= max_pt[0] and
+                p_ground[1] >= min_pt[1] and p_ground[1] <= max_pt[1]):
+                vertices.append(p_ground)
+
+    if not vertices:
+        logger.warning("No frustum intersections found within bounds.")
+        return
+
+    # Remove duplicates/close points to avoid Delaunay issues
+    #vertices = np.unique(np.round(np.array(vertices), 3), axis=0)
+    
+    if len(vertices) < 3:
+        return
+
+    # 3. Delaunay Triangulation
+    vertices = np.array(vertices)
+    tri = Delaunay(vertices[:, :2])
+    indices = tri.simplices
+    
+    # 4. Compute Visibility
+    counts = np.zeros(len(vertices), dtype=int)
+    
+    for shot in reconstruction.shots.values():
+        # Transform to camera frame
+        p_cam = shot.pose.transform_many(vertices)
+        
+        # Check if in front of camera (Z > 0)
+        valid_z = p_cam[:, 2] > 0
+        indices_valid_z = np.where(valid_z)[0]
+        
+        if len(indices_valid_z) == 0:
+            continue
+            
+        p_cam_valid = p_cam[indices_valid_z]
+        projections = shot.camera.project_many(p_cam_valid)
+        
+        # Convert to pixels
+        w = shot.camera.width
+        h = shot.camera.height
+        normalizer = max(w, h)
+        
+        px = projections[:, 0] * normalizer + w / 2.0
+        py = projections[:, 1] * normalizer + h / 2.0
+        
+        # Check bounds
+        in_view = (px >= 0) & (px < w) & (py >= 0) & (py < h)
+        
+        # Update counts
+        counts[indices_valid_z[in_view]] += 1
+    
+    # 5. Colorize
+    # Cap between 2 and 5
+    min_count = 0.0
+    max_count = 20.0
+    
+    norm_counts = np.clip(counts, min_count, max_count)
+    norm_counts = (norm_counts - min_count) / (max_count - min_count)
+    
+    colors = COVERAGE_CMAP(norm_counts) # RGBA
+    vertex_colors = (colors[:, :3] * 255).astype(np.uint8)
+
+    # 6. Log
+    rr.log(
+        "WORLD/STATS/COVERAGE",
+        rr.Mesh3D(
+            vertex_positions=vertices,
+            vertex_colors=vertex_colors,
+            triangle_indices=indices,
+        ),
+        static=True
+    )
+    logger.info(f"Exported coverage map with {len(vertices)} vertices")
\ No newline at end of file

From 03f602e478a695e184d822f2dba4c6123c71c420 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Sun, 14 Dec 2025 23:38:10 +0100
Subject: [PATCH 211/235] Refactored with interface and added TextViews

---
 opensfm/actions/export_rerun.py | 1407 +++++++++++++++++++------------
 opensfm/dataset.py              |   18 +
 opensfm/dataset_base.py         |    8 +
 opensfm/report.py               |    7 +-
 opensfm/stats.py                |    9 +-
 5 files changed, 879 insertions(+), 570 deletions(-)

diff --git a/opensfm/actions/export_rerun.py b/opensfm/actions/export_rerun.py
index 74f84a852..6942dc753 100644
--- a/opensfm/actions/export_rerun.py
+++ b/opensfm/actions/export_rerun.py
@@ -1,74 +1,698 @@
 # pyre-strict
 import logging
-from typing import List, Optional
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple, Any
+import base64
+import os
 
 import numpy as np
-from opensfm import features, multiview, pymap, types
+from opensfm import features, multiview, pymap, types, io
 from opensfm.dataset import DataSet
 from opensfm import pygeometry
 
 import matplotlib.cm as cm
 import rerun as rr
 import rerun.blueprint as rrb
+from scipy.spatial import Delaunay
 
 logger: logging.Logger = logging.getLogger(__name__)
 
-# Visualization constants
+# --- Constants ---
+
+# Colors
 GPS_COLOR = [100, 180, 255]
-GCP_OBSERVATION_COLOR = [255, 160, 120]
 GCP_COMPUTED_COLOR = [120, 255, 140]
-GCP_REFERENCE_COLOR = [255, 230, 100] 
+GCP_REFERENCE_COLOR = [255, 230, 100]
 GCP_ERROR_COLOR = [255, 100, 100]
-FEATURE_COLOR = [100, 255, 220] 
-LABEL_COLOR = [220, 220, 220] 
+FEATURE_COLOR = [100, 255, 220]
+LABEL_COLOR = [220, 220, 220]
+CAMERA_PATH_COLOR = [255, 255, 255]
 
+# Sizes & Dimensions
 SIZE_TIE_POINT = 0.2
-
 SIZE_GPS_ARROW = 1.0
 SIZE_GPS_RESIDUAL_LINE = 0.05
-
 SIZE_GCP_TARGET = 2.0
 SIZE_GCP_THICKNESS = 0.05
+SIZE_GCP_2D_THICKNESS = 0.5
 SIZE_GCP_COMPUTED_ARROW = 0.1
 SIZE_GCP_RESIDUAL_LINE = 0.02
-
 SIZE_2D_POINT_GCP = 5.0
 SIZE_2D_POINT_FEATURE = 2.0
-
 SIZE_LABEL_SHIFT_SHOT = 0.5
-
 SIZE_MATCHGRAPH_LINE = 0.1
 SIZE_CAMERA_PATH_LINE = 0.5
+SIZE_GCP_2D_BOX_HALF = 5.0
+SIZE_GCP_2D_OFFSET = 5.0
 
+# Configuration
 MAX_IMAGE_WIDTH = 1500
-
+IMAGE_COMPRESSION_QUALITY = 50
+DEFAULT_IMAGE_PLANE_DISTANCE = 2.0
+KNN_FOR_SCALE = 5
+MATCHGRAPH_MIN_INLIERS_FACTOR = 5
+COVERAGE_GRID_STEPS = 10
+COVERAGE_MARGIN = 0.01
+COVERAGE_EXTENT_MARGIN = 0.1
+COVERAGE_MIN_COUNT = 0.0
+COVERAGE_MAX_COUNT = 20.0
+
+# Colormaps
 MATCHGRAPH_CMAP = cm.get_cmap("plasma")
 COVERAGE_CMAP = cm.get_cmap("viridis")
 
+
+# --- Abstractions ---
+
+class Drawer(ABC):
+    """Abstract base class for visualization backends."""
+
+    @abstractmethod
+    def init(self, title: str, output_path: str) -> None:
+        pass
+
+    @abstractmethod
+    def set_time(self, sequence_id: int) -> None:
+        pass
+
+    @abstractmethod
+    def log_shot(
+        self,
+        shot_id: str,
+        pose: pygeometry.Pose,
+        camera: pygeometry.Camera,
+        image: Optional[np.ndarray],
+        image_plane_distance: float,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_gps(
+        self,
+        shot_id: str,
+        pose: pygeometry.Pose,
+        gps_topo: np.ndarray,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_gcp_2d_observations(
+        self,
+        shot_id: str,
+        refs: List[Tuple[float, float]],
+        comps: List[Tuple[float, float]],
+        labels_refs: List[str],
+        labels_comps: List[str],
+        gcp_3d_errors: Dict[str, float],
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_points(self, positions: np.ndarray, colors: np.ndarray) -> None:
+        pass
+
+    @abstractmethod
+    def log_camera_path(self, points: List[np.ndarray]) -> None:
+        pass
+
+    @abstractmethod
+    def log_gcp_3d(
+        self,
+        gcp_id: str,
+        reference_pos: np.ndarray,
+        computed_pos: Optional[np.ndarray],
+        error: float = -1.0,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_matchgraph(self, lines: List[List[np.ndarray]], colors: List[List[int]]) -> None:
+        pass
+
+    @abstractmethod
+    def log_coverage_map(
+        self,
+        vertices: np.ndarray,
+        colors: np.ndarray,
+        indices: np.ndarray,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def log_reference_lla(self, lat: float, lon: float, alt: float) -> None:
+        pass
+
+    @abstractmethod
+    def log_stats_camera_models(self, stats: Dict[str, Any], data: DataSet) -> None:
+        pass
+
+    @abstractmethod
+    def log_stats_summary(self, stats: Dict[str, Any]) -> None:
+        pass
+
+    @abstractmethod
+    def log_stats_gps_bias(self, stats: Dict[str, Any]) -> None:
+        pass
+
+    @abstractmethod
+    def setup_blueprint(self) -> None:
+        pass
+
+
+class RerunDrawer(Drawer):
+    """Concrete implementation for Rerun visualization."""
+
+    def init(self, title: str, output_path: str) -> None:
+        rr.init(title, spawn=False)
+        rr.save(output_path)
+        rr.log("/", rr.ViewCoordinates.RIGHT_HAND_Z_UP)
+
+    def setup_blueprint(self) -> None:
+        blueprint = rrb.Blueprint(
+            rrb.Vertical(
+                rrb.Horizontal(
+                    rrb.Spatial3DView(
+                        origin="/WORLD",
+                        name="3D Scene",
+                        background=[13, 17, 23],  # Deep dark gray
+                        line_grid=rrb.LineGrid3D(visible=False),
+                        spatial_information=rrb.SpatialInformation(
+                            show_axes=False,
+                            show_bounding_box=False,
+                        ),
+                    ),
+                    rrb.Spatial2DView(
+                        origin="/SHOTS",
+                        name="Image View",
+                    ),
+                ),
+                rrb.Horizontal(
+                    rrb.TextDocumentView(origin="/STATS/SUMMARY", name="Summary"),
+                    rrb.TextDocumentView(origin="/STATS/CAMERAS", name="Camera Models"),
+                    rrb.TextDocumentView(origin="/STATS/GPS", name="GPS/GCP Details"),
+                ),
+                row_shares=[5, 2],
+            ),
+            collapse_panels=True,
+        )
+        rr.send_blueprint(blueprint)
+
+    def set_time(self, sequence_id: int) -> None:
+        rr.set_time_sequence("SHOTS", sequence_id)
+
+    def log_shot(
+        self,
+        shot_id: str,
+        pose: pygeometry.Pose,
+        camera: pygeometry.Camera,
+        image: Optional[np.ndarray],
+        image_plane_distance: float,
+    ) -> None:
+        # Pose
+        t = pose.get_origin()
+        R_world_from_camera = pose.get_rotation_matrix().T
+        
+        rr.log(
+            f"WORLD/SHOTS/{shot_id}",
+            rr.Transform3D(
+                translation=t,
+                mat3x3=R_world_from_camera,
+                from_parent=False,
+            ),
+        )
+        
+        labels_shift = np.array([0, 0, SIZE_LABEL_SHIFT_SHOT])
+        rr.log(
+            f"WORLD/SHOTS/{shot_id}",
+            rr.Points3D(
+                positions=labels_shift,
+                labels=[shot_id],
+                radii=0.0,
+                colors=[LABEL_COLOR],
+            ),
+            static=True,
+        )
+
+        # Pinhole & Image
+        width = int(camera.width)
+        height = int(camera.height)
+        width, height = _get_scaled_dimensions(width, height)
+        fx, fy, cx, cy = _get_camera_calibration(camera, width, height)
+
+        rr.log(
+            f"WORLD/SHOTS/{shot_id}/CAMERA",
+            rr.Pinhole(
+                resolution=[width, height],
+                focal_length=[fx, fy],
+                principal_point=[cx, cy],
+                image_plane_distance=image_plane_distance,
+            ),
+        )
+
+        if image is not None:
+            img_compressed = rr.Image(image).compress(jpeg_quality=IMAGE_COMPRESSION_QUALITY)
+            rr.log(f"WORLD/SHOTS/{shot_id}/CAMERA/IMAGE", img_compressed)
+            rr.log(f"SHOTS/IMAGE", img_compressed)
+
+    def log_gps(
+        self,
+        shot_id: str,
+        pose: pygeometry.Pose,
+        gps_topo: np.ndarray,
+    ) -> None:
+        base_path = f"WORLD/GPS/{shot_id}/"
+        origin = gps_topo.copy()
+        origin[2] += SIZE_GPS_ARROW
+        vector = np.array([0, 0, -SIZE_GPS_ARROW])
+
+        rr.log(
+            f"{base_path}/POSITION",
+            rr.Arrows3D(
+                origins=[origin],
+                vectors=[vector],
+                colors=[GPS_COLOR],
+                radii=SIZE_GPS_ARROW / 8.0,
+            ),
+            static=True,
+        )
+        rr.log(
+            f"{base_path}/RESIDUAL",
+            rr.LineStrips3D(
+                [[pose.get_origin(), gps_topo]],
+                colors=[GPS_COLOR],
+                radii=SIZE_GPS_RESIDUAL_LINE,
+            ),
+            static=True,
+        )
+
+    def log_gcp_2d_observations(
+        self,
+        shot_id: str,
+        refs: List[Tuple[float, float]],
+        comps: List[Tuple[float, float]],
+        labels_refs: List[str],
+        labels_comps: List[str],
+        gcp_3d_errors: Dict[str, float],
+    ) -> None:
+        # Reference: Checkerboard
+        if refs:
+            box_centers = []
+            box_half_sizes = []
+            box_colors = []
+            outline_centers = []
+            outline_half_sizes = []
+            outline_colors = []
+
+            q_half = SIZE_GCP_2D_BOX_HALF
+            offset = SIZE_GCP_2D_OFFSET
+
+            for (x, y) in refs:
+                # Top-Left quadrant
+                box_centers.append([x - offset, y - offset])
+                box_half_sizes.append([q_half, q_half])
+                box_colors.append(GCP_REFERENCE_COLOR)
+                # Bottom-Right quadrant
+                box_centers.append([x + offset, y + offset])
+                box_half_sizes.append([q_half, q_half])
+                box_colors.append(GCP_REFERENCE_COLOR)
+                # Outline
+                outline_centers.append([x, y])
+                outline_half_sizes.append([q_half * 2, q_half * 2])
+                outline_colors.append(GCP_REFERENCE_COLOR)
+
+            rr.log(
+                f"SHOTS/IMAGE/GCP/REFERENCE",
+                rr.Boxes2D(
+                    centers=box_centers,
+                    half_sizes=box_half_sizes,
+                    colors=box_colors,
+                    radii=SIZE_GCP_2D_THICKNESS,
+                ),
+            )
+            rr.log(
+                f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE",
+                rr.Boxes2D(
+                    centers=outline_centers,
+                    half_sizes=outline_half_sizes,
+                    colors=outline_colors,
+                    radii=SIZE_GCP_2D_THICKNESS,
+                ),
+            )
+            rr.log(
+                f"SHOTS/IMAGE/GCP/REFERENCE/LABELS",
+                rr.Points2D(
+                    refs,
+                    labels=labels_refs,
+                    radii=0,
+                    colors=LABEL_COLOR
+                )
+            )
+        else:
+            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE", rr.Clear(recursive=True))
+            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE", rr.Clear(recursive=True))
+            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/LABELS", rr.Clear(recursive=True))
+
+        # Computed: Arrow
+        if comps:
+            # Match computed to reference to draw arrows
+            ref_map = {label: pos for label, pos in zip(labels_refs, refs)}
+            origins = []
+            vectors = []
+            valid_labels = []
+
+            for label, comp_pos in zip(labels_comps, comps):
+                if label in ref_map:
+                    ref_pos = ref_map[label]
+                    vec = [comp_pos[0] - ref_pos[0], comp_pos[1] - ref_pos[1]]
+                    origins.append(ref_pos)
+                    vectors.append(vec)
+
+                    # Log the error as label
+                    error_3d = gcp_3d_errors.get(label, -1.0)
+                    if error_3d >= 0:
+                        valid_labels.append(f"{label}: {error_3d:.3f}m")
+                    else:
+                        valid_labels.append(label)
+            
+            if origins:
+                rr.log(
+                    f"SHOTS/IMAGE/GCP/COMPUTED",
+                    rr.Arrows2D(
+                        origins=origins,
+                        vectors=vectors,
+                        colors=[GCP_COMPUTED_COLOR],
+                        labels=valid_labels,
+                        radii=SIZE_GCP_2D_THICKNESS,
+                    ),
+                )
+            else:
+                rr.log(f"SHOTS/IMAGE/GCP/COMPUTED", rr.Clear(recursive=True))
+        else:
+            rr.log(f"SHOTS/IMAGE/GCP/COMPUTED", rr.Clear(recursive=True))
+
+    def log_points(self, positions: np.ndarray, colors: np.ndarray) -> None:
+        rr.log(
+            "WORLD/POINTS",
+            rr.Points3D(
+                positions=positions,
+                colors=colors,
+                radii=SIZE_TIE_POINT,
+            ),
+            static=True,
+        )
+
+    def log_camera_path(self, points: List[np.ndarray]) -> None:
+        rr.log(
+            "WORLD/PATH",
+            rr.LineStrips3D(
+                [points],
+                colors=[CAMERA_PATH_COLOR],
+                radii=SIZE_CAMERA_PATH_LINE,
+            ),
+            static=True,
+        )
+
+    def log_gcp_3d(
+        self,
+        gcp_id: str,
+        reference_pos: np.ndarray,
+        computed_pos: Optional[np.ndarray],
+        error: float = -1.0,
+    ) -> None:
+        base_path = f"WORLD/GCP/{gcp_id}"
+        quad_r = SIZE_GCP_TARGET / 4.0
+        thickness = SIZE_GCP_THICKNESS
+        pos_np = np.array(reference_pos)
+        color = GCP_REFERENCE_COLOR if computed_pos is not None else GCP_ERROR_COLOR
+
+        # Checkerboard
+        centers = [
+            pos_np + [-quad_r, quad_r, 0],
+            pos_np + [quad_r, -quad_r, 0]
+        ]
+        half_sizes = [[quad_r, quad_r, thickness]] * 2
+        
+        rr.log(
+            f"{base_path}/TARGET",
+            rr.Boxes3D(
+                centers=centers,
+                half_sizes=half_sizes,
+                colors=[color] * 2,
+                fill_mode="solid",
+            ),
+            static=True,
+        )
+        rr.log(
+            f"{base_path}/OUTLINE",
+            rr.Boxes3D(
+                centers=[pos_np],
+                half_sizes=[[SIZE_GCP_TARGET / 2.0, SIZE_GCP_TARGET / 2.0, thickness]],
+                colors=[color],
+                radii=thickness,
+                fill_mode="major_wireframe",
+            ),
+            static=True,
+        )
+
+        label = gcp_id
+        if error >= 0:
+            label = f"{gcp_id}: {error:.3f}m"
+
+        rr.log(
+            f"{base_path}",
+            rr.Points3D(
+                positions=[pos_np + [0, 0, SIZE_GCP_TARGET]],
+                labels=[label],
+                radii=0.0,
+                colors=[LABEL_COLOR],
+            ),
+            static=True,
+        )
+
+        if computed_pos is not None:
+            rr.log(
+                f"{base_path}/COMPUTED",
+                rr.Arrows3D(
+                    origins=[reference_pos],
+                    vectors=[computed_pos - reference_pos],
+                    colors=[GCP_COMPUTED_COLOR],
+                    radii=SIZE_GCP_COMPUTED_ARROW,
+                ),
+                static=True,
+            )
+
+    def log_matchgraph(self, lines: List[List[np.ndarray]], colors: List[List[int]]) -> None:
+        rr.log(
+            "WORLD/STATS/MATCHGRAPH",
+            rr.LineStrips3D(
+                lines,
+                colors=colors,
+                radii=SIZE_MATCHGRAPH_LINE,
+            ),
+            static=True,
+        )
+
+    def log_coverage_map(
+        self,
+        vertices: np.ndarray,
+        colors: np.ndarray,
+        indices: np.ndarray,
+    ) -> None:
+        rr.log(
+            "WORLD/STATS/COVERAGE",
+            rr.Mesh3D(
+                vertex_positions=vertices,
+                vertex_colors=colors,
+                triangle_indices=indices,
+            ),
+            static=True,
+        )
+
+    def log_reference_lla(self, lat: float, lon: float, alt: float) -> None:
+        rr.log(
+            "world/reference",
+            rr.TextDocument(
+                f"Reference LLA:\n"
+                f"Latitude: {lat:.6f}°\n"
+                f"Longitude: {lon:.6f}°\n"
+                f"Altitude: {alt:.2f}m",
+            ),
+        )
+
+    def log_stats_camera_models(self, stats: Dict[str, Any], data: DataSet) -> None:
+        if "camera_errors" not in stats:
+            return
+
+        md = "# Camera Models Details\n\n"
+        
+        for camera, params in stats["camera_errors"].items():
+            md += f"## Camera: {camera}\n"
+            
+            initial = params.get("initial_values", {})
+            optimized = params.get("optimized_values", {})
+            
+            # Collect all parameter names
+            keys = sorted(list(set(initial.keys()) | set(optimized.keys())))
+            
+            md += "| State | " + " | ".join(keys) + " |\n"
+            md += "| --- | " + " | ".join(["---"] * len(keys)) + " |\n"
+            
+            # Initial values row
+            row_init = "| Initial |"
+            for k in keys:
+                val = initial.get(k, "N/A")
+                if isinstance(val, float): val = f"{val:.4f}"
+                row_init += f" {val} |"
+            md += row_init + "\n"
+
+            # Optimized values row
+            row_opt = "| Optimized |"
+            for k in keys:
+                val = optimized.get(k, "N/A")
+                if isinstance(val, float): val = f"{val:.4f}"
+                row_opt += f" {val} |"
+            md += row_opt + "\n\n"
+
+            # Embed residual and heatmap images
+            sanitized_id = camera.replace("/", "_")
+            res_path = os.path.join(data.data_path, "stats", f"residuals_{sanitized_id}.png")
+            heat_path = os.path.join(data.data_path, "stats", f"heatmap_{sanitized_id}.png")
+            
+            res_b64 = None
+            if data.io_handler.isfile(res_path):
+                try:
+                    with data.io_handler.open_rb(res_path) as f:
+                        res_b64 = base64.b64encode(f.read()).decode("utf-8")
+                except Exception as e:
+                    logger.warning(f"Failed to embed residual image for {camera}: {e}")
+
+            heat_b64 = None
+            if data.io_handler.isfile(heat_path):
+                try:
+                    with data.io_handler.open_rb(heat_path) as f:
+                        heat_b64 = base64.b64encode(f.read()).decode("utf-8")
+                except Exception as e:
+                    logger.warning(f"Failed to embed heatmap image for {camera}: {e}")
+
+            if res_b64 or heat_b64:
+                md += "| Residuals | Heatmap |\n"
+                md += "| :---: | :---: |\n"
+                c1 = f"![Residuals](data:image/png;base64,{res_b64})" if res_b64 else ""
+                c2 = f"![Heatmap](data:image/png;base64,{heat_b64})" if heat_b64 else ""
+                md += f"| {c1} | {c2} |\n\n"
+
+        rr.log("STATS/CAMERAS", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+
+    def log_stats_summary(self, stats: Dict[str, Any]) -> None:
+        md = "# Processing Summary\n\n"
+
+        # Dataset Summary
+        if "processing_statistics" in stats:
+            ps = stats["processing_statistics"]
+            md += "## Dataset\n"
+            md += f"- **Date**: {ps.get('date', 'N/A')}\n"
+            if "area" in ps:
+                md += f"- **Area Covered**: {ps['area']/1e6:.6f} km²\n"
+            if "steps_times" in ps:
+                if "Total Time" in ps["steps_times"]:
+                    md += f"- **Total Time**: {ps['steps_times']['Total Time']:.2f} s\n"
+
+                md += "\n### Processing Time Details\n"
+                md += "| Step | Time |\n"
+                md += "| --- | --- |\n"
+                for step, time in ps["steps_times"].items():
+                    if step == "Total Time":
+                        continue
+                    md += f"| {step} | {time:.2f} s |\n"
+            md += "\n"
+
+        # Reconstruction Summary
+        if "reconstruction_statistics" in stats:
+            rs = stats["reconstruction_statistics"]
+            rec_shots = rs.get("reconstructed_shots_count", 0)
+            init_shots = rs.get("initial_shots_count", 0)
+            rec_points = rs.get("reconstructed_points_count", 0)
+            init_points = rs.get("initial_points_count", 0)
+            
+            ratio_shots = rec_shots / init_shots * 100 if init_shots > 0 else 0
+            ratio_points = rec_points / init_points * 100 if init_points > 0 else 0
+
+            md += "## Reconstruction\n"
+            md += f"- **Images**: {rec_shots}/{init_shots} ({ratio_shots:.1f}%)\n"
+            md += f"- **Points**: {rec_points}/{init_points} ({ratio_points:.1f}%)\n"
+            md += f"- **Components**: {rs.get('components', 0)}\n"
+            
+            if "features_statistics" in stats:
+                fs = stats["features_statistics"]
+                if "detected_features" in fs:
+                    md += f"- **Detected Features (median)**: {fs['detected_features'].get('median', 'N/A')}\n"
+                if "reconstructed_features" in fs:
+                    md += f"- **Reconstructed Features (median)**: {fs['reconstructed_features'].get('median', 'N/A')}\n"
+
+        rr.log("STATS/SUMMARY", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+
+    def log_stats_gps_bias(self, stats: Dict[str, Any]) -> None:
+        md = "# GPS/GCP Details\n\n"
+
+        # Errors
+        for error_type in ["gps", "gcp"]:
+            key = f"{error_type}_errors"
+            if key not in stats or "average_error" not in stats[key]:
+                continue
+            
+            err_stats = stats[key]
+            md += f"## {error_type.upper()} Errors (meters)\n"
+            md += "| Component | Mean | Sigma | RMS Error |\n"
+            md += "| --- | --- | --- | --- |\n"
+            
+            for comp in ["x", "y", "z"]:
+                mean = err_stats.get("mean", {}).get(comp, 0)
+                std = err_stats.get("std", {}).get(comp, 0)
+                rms = err_stats.get("error", {}).get(comp, 0)
+                md += f"| {comp.upper()} | {mean:.3f} | {std:.3f} | {rms:.3f} |\n"
+            
+            avg = err_stats.get("average_error", 0)
+            md += f"| **Total** | | | **{avg:.3f}** |\n\n"
+
+        # GPS Bias
+        if "camera_errors" in stats:
+            md += "## GPS Bias\n"
+            md += "| Camera | Scale | Translation | Rotation |\n"
+            md += "| --- | --- | --- | --- |\n"
+            
+            for camera, params in stats["camera_errors"].items():
+                if "bias" in params:
+                    bias = params["bias"]
+                    s = bias.get("scale", 1.0)
+                    t = bias.get("translation", [0,0,0])
+                    r = bias.get("rotation", [0,0,0])
+                    
+                    t_str = f"[{t[0]:.2f}, {t[1]:.2f}, {t[2]:.2f}]"
+                    r_str = f"[{r[0]:.2f}, {r[1]:.2f}, {r[2]:.2f}]"
+                    
+                    md += f"| {camera} | {s:.2f} | {t_str} | {r_str} |\n"
+
+        rr.log("STATS/GPS", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+
+
+# --- Main Logic ---
+
 def run_dataset(
     data: DataSet,
     output: Optional[str] = None,
     reconstruction_index: int = 0,
 ) -> None:
-    """Export reconstruction to Rerun format for 3D visualization.
-
-    Args:
-        data: OpenSfM dataset
-        output: Output .rrd file path (default: dataset_path/rerun.rrd)
-        reconstruction_index: Index of reconstruction to export (default: 0)
-    """
-
-    # Load reconstruction
+    """Export reconstruction to Rerun format for 3D visualization."""
+    
+    # 1. Load Data
     reconstructions = data.load_reconstruction()
     if not reconstructions:
         logger.error("No reconstructions found in dataset")
         return
 
     if reconstruction_index >= len(reconstructions):
-        logger.error(
-            f"Reconstruction index {reconstruction_index} out of range "
-            f"(found {len(reconstructions)} reconstructions)"
-        )
+        logger.error(f"Reconstruction index {reconstruction_index} out of range")
         return
 
     reconstruction = reconstructions[reconstruction_index]
@@ -78,90 +702,114 @@ def run_dataset(
         f"{len(reconstruction.points)} points"
     )
 
-    # Initialize Rerun
+    # 2. Initialize Drawer
     output_path = output or data.data_path + "/rerun.rrd"
-    rr.init("OpenSfM Reconstruction", spawn=False)
-    rr.save(output_path)
+    drawer = RerunDrawer()
+    drawer.init("OpenSfM Reconstruction", output_path)
+    drawer.setup_blueprint()
     logger.info(f"Saving Rerun data to {output_path}")
 
-    # Set up coordinate system (OpenSfM uses East-North-Up)
-    rr.log("/", rr.ViewCoordinates.RIGHT_HAND_Z_UP)
-
-    # Create a Spatial3D view to display the scene
-    blueprint = rrb.Blueprint(
-        rrb.Spatial3DView(
-            origin="/WORLD",
-            name="3D Scene",
-            background=[13, 17, 23], # Deep dark gray
-            line_grid=rrb.LineGrid3D(
-                visible=False,
-            ),
-            spatial_information=rrb.SpatialInformation(
-                show_axes=False,
-                show_bounding_box=False,
-            ),
-        ),
-        collapse_panels=False,
-        )
+    # 3. Precompute Data
+    image_plane_distance = _compute_image_plane_distance(reconstruction)
+    
+    # Precompute GCP observations per shot
+    gcp = data.load_ground_control_points() or []
+    gcp_triangulations = _compute_gcp_triangulations(data, reconstruction, gcp)
+    gcp_3d_errors = _compute_gcp_3d_errors(reconstruction, gcp, gcp_triangulations)
+    shot_gcp_obs = _precompute_gcp_observations(data, reconstruction, gcp, gcp_triangulations)
 
-    rr.send_blueprint(blueprint)
+    # 4. Time-Dependent Logging (Shots)
+    reference = reconstruction.reference
+    
+    for shot_id, shot in reconstruction.shots.items():
+        sequence_id = _get_shot_sequence_id(shot_id)
+        drawer.set_time(sequence_id)
+
+        # Load image
+        image = None
+        try:
+            image = data.load_image(shot_id)
+            width = int(shot.camera.width)
+            height = int(shot.camera.height)
+            width, height = _get_scaled_dimensions(width, height)
+            if image.shape[1] != width or image.shape[0] != height:
+                import cv2
+                image = cv2.resize(image, (width, height), interpolation=cv2.INTER_AREA)
+        except Exception as e:
+            logger.warning(f"Could not load image for {shot_id}: {e}")
+
+        # Log Shot Pose & Image
+        drawer.log_shot(shot_id, shot.pose, shot.camera, image, image_plane_distance)
+
+        # Log GPS
+        if reference and shot.metadata and shot.metadata.gps_position.has_value:
+            gps_topo = shot.metadata.gps_position.value
+            drawer.log_gps(shot_id, shot.pose, gps_topo)
+
+        # Log GCP 2D Observations
+        if shot_id in shot_gcp_obs:
+            obs = shot_gcp_obs[shot_id]
+            drawer.log_gcp_2d_observations(
+                shot_id,
+                obs["refs"],
+                obs["comps"],
+                obs["labels_refs"],
+                obs["labels_comps"],
+                gcp_3d_errors,
+            )
+        else:
+            drawer.log_gcp_2d_observations(shot_id, [], [], [], [], gcp_3d_errors)
 
-    # Export reference coordinate system
+    # 5. Static Logging (Structure & Stats)
+    
+    # Reference
     if reconstruction.reference:
         ref = reconstruction.reference
-        rr.log(
-            "world/reference",
-            rr.TextDocument(
-                f"Reference LLA:\n"
-                f"Latitude: {ref.lat:.6f}°\n"
-                f"Longitude: {ref.lon:.6f}°\n"
-                f"Altitude: {ref.alt:.2f}m",
-            ),
-        )
+        drawer.log_reference_lla(ref.lat, ref.lon, ref.alt)
 
-    # Export cameras (intrinsics)
-    _export_cameras(reconstruction)
+    # Load and log stats.json if available
+    try:
+        stats = data.load_stats()
+        if stats:
+            drawer.log_stats_summary(stats)
+            drawer.log_stats_camera_models(stats, data)
+            drawer.log_stats_gps_bias(stats)
+    except Exception as e:
+        logger.warning(f"Could not load or log stats.json: {e}")
 
-    # Export camera poses (shots)
-    _export_shots(data, reconstruction, _compute_image_plane_distance(reconstruction))
-    _export_camera_path(reconstruction)
+    # 3D Points
+    _export_points(reconstruction, drawer)
 
-    # Export 3D points
-    _export_points(reconstruction)
+    # Camera Path
+    _export_camera_path(reconstruction, drawer)
 
-    # Export Ground Control Points
-    gcp = data.load_ground_control_points()
+    # GCP 3D Geometry
     if gcp:
-        _export_gcp(data, reconstruction, gcp)
+        _export_gcp_3d(data, reconstruction, gcp, gcp_triangulations, gcp_3d_errors, drawer)
 
-    # Export tracks manager (optional, for visualizing observations)
+    # Match Graph
     if data.tracks_exists():
         tracks_manager = data.load_tracks_manager()
-        # _export_observations(reconstruction, tracks_manager)
-        _export_matchgraph(data, reconstruction, tracks_manager)
+        _export_matchgraph(data, reconstruction, tracks_manager, drawer)
 
-    _export_coverage_map(data, reconstruction)
+    # Coverage Map
+    _export_coverage_map(data, reconstruction, drawer)
 
     logger.info(f"Rerun export completed: {output_path}")
     logger.info(f"Open with: rerun {output_path}")
 
 
+# --- Helper Functions ---
+
 def _get_shot_sequence_id(shot_id: str) -> int:
-    """Extract integer ID from shot_id string (e.g., 'Shot 123' -> 123).
-    
-    If extraction fails, use hash of the shot_id to ensure uniqueness.
-    """
     try:
-        # Try to extract number from strings like "Shot 123" or "DSC_0123.jpg"
         import re
         numbers = re.findall(r'\d+', shot_id)
         if numbers:
-            return int(numbers[-1])  # Use the last number found
+            return int(numbers[-1])
     except:
         pass
-    
-    # Fallback: use hash of shot_id
-    return hash(shot_id) & 0x7FFFFFFF  # Ensure positive integer
+    return hash(shot_id) & 0x7FFFFFFF
 
 
 def _get_scaled_dimensions(width: int, height: int) -> tuple[int, int]:
@@ -174,26 +822,22 @@ def _get_scaled_dimensions(width: int, height: int) -> tuple[int, int]:
 def _compute_image_plane_distance(reconstruction: types.Reconstruction) -> float:
     positions = np.array([shot.pose.get_origin() for shot in reconstruction.shots.values()])
     if len(positions) < 2:
-        return 2.0
-        
+        return DEFAULT_IMAGE_PLANE_DISTANCE
     try:
         from scipy.spatial import KDTree
         tree = KDTree(positions)
-        dists, _ = tree.query(positions, k=5)
+        dists, _ = tree.query(positions, k=KNN_FOR_SCALE)
         median_nn_dist = np.median(dists[:, 1])
         return float(median_nn_dist)
     except ImportError:
-        logger.warning("Scipy not found, using default image plane distance.")
-        return 2.0
+        return DEFAULT_IMAGE_PLANE_DISTANCE
 
 
 def _get_camera_calibration(camera: pygeometry.Camera, width: int, height: int):
-    """Calculate camera intrinsic parameters."""
     fx = fy = camera.focal * max(width, height)
     if hasattr(camera, "focal_x") and hasattr(camera, "focal_y"):
         fx = camera.focal_x * max(width, height)
         fy = camera.focal_y * max(width, height)
-
     cx = width / 2.0
     cy = height / 2.0
     if hasattr(camera, "c_x") and hasattr(camera, "c_y"):
@@ -202,47 +846,100 @@ def _get_camera_calibration(camera: pygeometry.Camera, width: int, height: int):
     return fx, fy, cx, cy
 
 
-def _export_cameras(reconstruction: types.Reconstruction) -> None:
-    """Export camera models (intrinsics)."""
-    for camera_id, camera in reconstruction.cameras.items():
-        # Get camera parameters
-        width = int(camera.width)
-        height = int(camera.height)
-        width, height = _get_scaled_dimensions(width, height)
-        fx, fy, cx, cy = _get_camera_calibration(camera, width, height)
-        focal_length_px = camera.focal * max(width, height)
+def _compute_gcp_triangulations(
+    data: DataSet,
+    reconstruction: types.Reconstruction,
+    gcp: List[pymap.GroundControlPoint]
+) -> Dict[str, Optional[np.ndarray]]:
+    triangulations = {}
+    for point in gcp:
+        if point.lla:
+            triangulations[point.id] = multiview.triangulate_gcp(
+                point, reconstruction.shots, data.config["gcp_reprojection_error_threshold"]
+            )
+    return triangulations
 
-        # Log camera intrinsics (strip spaces from camera_id)
-        camera_id_clean = camera_id.replace(" ", "_")
-        rr.log(
-            f"world/cameras/{camera_id_clean}/info",
-            rr.TextDocument(
-                f"Camera: {camera_id}\n"
-                f"Type: {camera.projection_type}\n"
-                f"Resolution: {width}x{height}\n"
-                f"Focal: {focal_length_px:.1f}px\n"
-                f"Principal Point: ({cx:.1f}, {cy:.1f})"
-            ),
-        )
+
+def _compute_gcp_3d_errors(
+    reconstruction: types.Reconstruction,
+    gcp: List[pymap.GroundControlPoint],
+    triangulations: Dict[str, Optional[np.ndarray]]
+) -> Dict[str, float]:
+    errors = {}
+    reference = reconstruction.reference
+    for point in gcp:
+        if point.lla and point.id in triangulations and triangulations[point.id] is not None:
+             ref_pos = reference.to_topocentric(*point.lla_vec)
+             comp_pos = triangulations[point.id]
+             errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+        else:
+             errors[point.id] = -1.0
+    return errors
 
 
-def _export_shots(data: DataSet, reconstruction: types.Reconstruction, image_plane_distance: float) -> None:
-    """Export camera shots (poses and images)."""
+def _precompute_gcp_observations(
+    data: DataSet,
+    reconstruction: types.Reconstruction,
+    gcp: List[pymap.GroundControlPoint],
+    triangulations: Dict[str, Optional[np.ndarray]]
+) -> Dict[str, Dict[str, Any]]:
+    """Precompute 2D GCP observations per shot."""
+    shot_obs = defaultdict(lambda: {"refs": [], "comps": [], "labels_refs": [], "labels_comps": []})
     reference = reconstruction.reference
+    
+    for point in gcp:
+        if not point.lla:
+            continue
+            
+        triangulated = triangulations.get(point.id)
+        
+        # Project to shots
+        for obs in point.observations:
+            shot_id = obs.shot_id
+            if shot_id not in reconstruction.shots:
+                continue
+                
+            shot = reconstruction.shots[shot_id]
+            width = int(shot.camera.width)
+            height = int(shot.camera.height)
+            width, height = _get_scaled_dimensions(width, height)
+            normalizer = max(width, height)
 
-    for shot_id, shot in reconstruction.shots.items():
-        _export_shot_pose(shot, shot_id)
+            # Reference pixel
+            px = obs.projection[0] * normalizer + width / 2.0
+            py = obs.projection[1] * normalizer + height / 2.0
+            
+            shot_obs[shot_id]["refs"].append((px, py))
+            shot_obs[shot_id]["labels_refs"].append(point.id)
+
+            # Computed pixel
+            if triangulated is not None:
+                projected = shot.project(triangulated)
+                px_comp = projected[0] * normalizer + width / 2.0
+                py_comp = projected[1] * normalizer + height / 2.0
+                shot_obs[shot_id]["comps"].append((px_comp, py_comp))
+                shot_obs[shot_id]["labels_comps"].append(point.id)
+                
+    return shot_obs
 
-        # Collect GPS position and error line if available
-        if reference and shot.metadata and shot.metadata.gps_position.has_value:
-            gps_topo = shot.metadata.gps_position.value
-            _export_shot_gps(shot, shot_id, gps_topo)
 
-        _export_shot_pinhole(data, shot, shot_id, image_plane_distance)
+def _export_points(reconstruction: types.Reconstruction, drawer: Drawer) -> None:
+    if not reconstruction.points:
+        return
+    positions = []
+    colors = []
+    for point in reconstruction.points.values():
+        positions.append(point.coordinates)
+        c = point.color
+        if all(val <= 1.0 for val in c):
+            c = [int(val * 255) for val in c]
+        colors.append(c)
+    
+    drawer.log_points(np.array(positions), np.array(colors, dtype=np.uint8))
+    logger.info(f"Exported {len(positions)} automatic tie points")
 
 
-def _export_camera_path(reconstruction: types.Reconstruction) -> None:
-    """Export camera path based on capture time."""
+def _export_camera_path(reconstruction: types.Reconstruction, drawer: Drawer) -> None:
     shots_with_time = []
     for shot in reconstruction.shots.values():
         if shot.metadata and shot.metadata.capture_time.has_value:
@@ -251,385 +948,45 @@ def _export_camera_path(reconstruction: types.Reconstruction) -> None:
     if len(shots_with_time) < 2:
         return
 
-    # Sort by capture time
     shots_with_time.sort(key=lambda x: x.metadata.capture_time.value)
-    
     points = [shot.pose.get_origin() for shot in shots_with_time]
-    
-    rr.log(
-        "WORLD/PATH",
-        rr.LineStrips3D(
-            [points],
-            colors=[[255, 255, 255]], # White
-            radii=SIZE_CAMERA_PATH_LINE,
-        ),
-        static=True,
-    )
+    drawer.log_camera_path(points)
     logger.info(f"Exported camera path with {len(points)} points")
 
 
-def _export_shot_pose(shot: pymap.Shot, shot_id: str) -> None:
-    pose = shot.pose
-    R = pose.get_rotation_matrix()  # 3x3 rotation matrix
-    t = pose.get_origin()  # 3D position (camera center in world coords)
-
-    # Rerun expects rotation from world to camera
-    # OpenSfM GetRotationMatrix gives camera-to-world rotation
-    R_world_from_camera = R.T  # Transpose to get world-from-camera
-
-    # Log camera pose with integer sequence ID
-    sequence_id = _get_shot_sequence_id(shot_id)
-    rr.set_time_sequence("shot", sequence_id)
-    rr.log(
-        f"WORLD/SHOTS/{shot_id}",
-        rr.Transform3D(
-            translation=t,
-            mat3x3=R_world_from_camera,
-            from_parent=False,
-        ),
-    )
-
-    labels_shift = np.array([0, 0, SIZE_LABEL_SHIFT_SHOT])  # Shift labels above targets
-    rr.log(
-        f"WORLD/SHOTS/{shot_id}",
-        rr.Points3D(
-            positions=labels_shift,
-            labels=[shot_id],
-            radii=0.0,  # Invisible points, just for labels
-            colors=[LABEL_COLOR],  # White labels
-        ),
-        static=True,
-    )
-
-
-def _export_shot_pinhole(data: DataSet, shot: pymap.Shot, shot_id: str, image_plane_distance: float) -> None:
-    # Create pinhole camera for image projection
-    width = int(shot.camera.width)
-    height = int(shot.camera.height)
-    width, height = _get_scaled_dimensions(width, height)
-    fx, fy, cx, cy = _get_camera_calibration(shot.camera, width, height)
-
-    rr.log(
-        f"WORLD/SHOTS/{shot_id}/CAMERA",
-        rr.Pinhole(
-            resolution=[width, height],
-            focal_length=[fx, fy],
-            principal_point=[cx, cy],
-            image_plane_distance=image_plane_distance,
-        ),
-    )
-
-    # Load and log image if available
-    try:
-        image = data.load_image(shot_id)
-        
-        # Resize image if needed
-        if image.shape[1] != width or image.shape[0] != height:
-            import cv2
-            image = cv2.resize(image, (width, height), interpolation=cv2.INTER_AREA)
-
-        rr.log(
-            f"WORLD/SHOTS/{shot_id}/CAMERA/IMAGE",
-            rr.Image(image).compress(jpeg_quality=50),
-        )
-    except Exception as e:
-        logger.warning(f"Could not load image for {shot_id}: {e}")
-
-
-def _export_shot_gps(
-    shot: pymap.Shot,
-    shot_id: str,
-    gps_topo: np.ndarray,
-) -> None:
-
-    base_path = f"WORLD/GPS/{shot_id}/"
-
-    arrow_size = SIZE_GPS_ARROW
-    arrow_radii = arrow_size / 8.0
-    arrow_length = arrow_size  # Length of arrows for GPS positions
-    
-    origin = gps_topo.copy()
-    origin[2] += arrow_length
-    vector = np.array([0, 0, -arrow_length])
-
-    rr.log(
-        f"{base_path}/POSITION",
-        rr.Arrows3D(
-            origins=[origin],
-            vectors=[vector],
-            colors=[GPS_COLOR],  # Blue
-            radii=arrow_radii,
-        ),
-        static=True,
-    )
-
-    rr.log(
-        f"{base_path}/RESIDUAL",
-        rr.LineStrips3D(
-            [[shot.pose.get_origin(), gps_topo]],
-            colors=[GPS_COLOR],  # Blue
-            radii=SIZE_GPS_RESIDUAL_LINE,
-        ),
-        static=True,
-    )
-
-
-def _export_points(reconstruction: types.Reconstruction) -> None:
-    """Export 3D points (structure)."""
-
-    if not reconstruction.points:
-        return
-
-    # Collect all points
-    positions = []
-    colors = []
-    point_ids = []
-
-    for point_id, point in reconstruction.points.items():
-        positions.append(point.coordinates)
-        # Convert color from 0-1 to 0-255 if needed
-        color = point.color
-        if all(c <= 1.0 for c in color):
-            color = [int(c * 255) for c in color]
-        colors.append(color)
-        point_ids.append(point_id)
-
-    # Log all points at once for efficiency
-    rr.log(
-        "WORLD/POINTS",
-        rr.Points3D(
-            positions=np.array(positions),
-            colors=np.array(colors, dtype=np.uint8),
-            radii=SIZE_TIE_POINT,  # Small radius for tie points
-        ),
-        static=True,
-    )
-
-    logger.info(f"Exported {len(positions)} automatic tie points")
-
-
-def _export_gcp(
+def _export_gcp_3d(
     data: DataSet,
     reconstruction: types.Reconstruction,
     gcp: List[pymap.GroundControlPoint],
+    triangulations: Dict[str, Optional[np.ndarray]],
+    gcp_3d_errors: Dict[str, float],
+    drawer: Drawer
 ) -> None:
-    """Export Ground Control Points."""
-    if not gcp:
-        return
-
     reference = reconstruction.reference
-
+    count = 0
     for point in gcp:
-        # Get 3D position
         if point.lla:
-            # Convert from lat/lon/alt to topocentric coordinates
-            lla_vec = point.lla_vec
-            pos = reference.to_topocentric(*lla_vec)
-
-            # Try to triangulate GCP
-            triangulated = multiview.triangulate_gcp(
-                point, reconstruction.shots, data.config["gcp_reprojection_error_threshold"]
-            )
-
-            _export_single_gcp_geometry(point.id, pos, triangulated)
-            _export_gcp_observations(reconstruction, point)
-
-    logger.info(f"Exported {len(gcp)} Ground Control Points")
-
-
-def _export_gcp_observations(
-    reconstruction: types.Reconstruction, 
-    point: pymap.GroundControlPoint
-) -> None:
-    # Log GCP observations in images
-    for obs in point.observations:
-        shot_id = obs.shot_id
-        if shot_id in reconstruction.shots:
-            # Log 2D observation
-            shot = reconstruction.shots[shot_id]
-            width = int(shot.camera.width)
-            height = int(shot.camera.height)
-            width, height = _get_scaled_dimensions(width, height)
-            normalize = max(width, height)
-
-            # Convert from normalized to pixel coordinates
-            px = obs.projection[0] * normalize + width / 2.0
-            py = obs.projection[1] * normalize + height / 2.0
-
-            # Strip spaces from camera_id
-            camera_id_clean = shot.camera.id.replace(" ", "_")
-
-            # Set time sequence with integer ID
-            sequence_id = _get_shot_sequence_id(shot_id)
-            rr.set_time_sequence("shot", sequence_id)
-            rr.log(
-                f"world/cameras/{camera_id_clean}/shots/{shot_id}/pinhole/gcp/{point.id}",
-                rr.Points2D(
-                    [[px, py]],
-                    colors=[GCP_OBSERVATION_COLOR],
-                    radii=SIZE_2D_POINT_GCP,
-                    labels=[point.id],
-                ),
-            )
-
-
-def _export_single_gcp_geometry(
-    gcp_id: str,
-    reference_pos: np.ndarray,
-    computed_pos: Optional[np.ndarray],
-) -> None:
-    base_path = f"WORLD/GCP/{gcp_id}"
-
-    # Target dimensions (1m x 1m target)
-    target_size = SIZE_GCP_TARGET
-    quad_r = target_size / 4.0  # Half-size of a quadrant
-    thickness = SIZE_GCP_THICKNESS
-
-    pos_np = np.array(reference_pos)
-    color = GCP_REFERENCE_COLOR if computed_pos is not None else GCP_ERROR_COLOR
-
-    # Checkerboard boxes
-    centers = [
-        pos_np + [-quad_r, quad_r, 0],
-        pos_np + [quad_r, -quad_r, 0]
-    ]
-    half_sizes = [[quad_r, quad_r, thickness]] * 2
-    colors = [color] * 2
-
-    rr.log(
-        f"{base_path}/TARGET",
-        rr.Boxes3D(
-            centers=centers,
-            half_sizes=half_sizes,
-            colors=colors,
-            fill_mode="solid",
-        ),
-        static=True,
-    )
-
-    # Outline
-    rr.log(
-        f"{base_path}/OUTLINE",
-        rr.Boxes3D(
-            centers=[pos_np],
-            half_sizes=[[target_size / 2.0, target_size / 2.0, thickness]],
-            colors=[color],
-            radii=thickness,
-            fill_mode="major_wireframe",
-        ),
-        static=True,
-    )
-
-    # Label
-    labels_shift = np.array([0, 0, target_size])
-    rr.log(
-        f"{base_path}",
-        rr.Points3D(
-            positions=[pos_np + labels_shift],
-            labels=[gcp_id],
-            radii=0.0,
-            colors=[LABEL_COLOR],
-        ),
-        static=True,
-    )
-
-    # Computed position
-    if computed_pos is not None:
-        arrow_length = 0.5
-        origin = computed_pos.copy()
-        origin[2] += arrow_length
-        vector = np.array([0, 0, -arrow_length])
-
-        rr.log(
-            f"{base_path}/COMPUTED",
-            rr.Arrows3D(
-                origins=[origin],
-                vectors=[vector],
-                colors=[GCP_COMPUTED_COLOR],
-                radii=SIZE_GCP_COMPUTED_ARROW,
-            ),
-            static=True,
-        )
-
-        # Residual line
-        rr.log(
-            f"{base_path}/RESIDUAL",
-            rr.LineStrips3D(
-                [[computed_pos, reference_pos]],
-                colors=[GCP_COMPUTED_COLOR],
-                radii=SIZE_GCP_RESIDUAL_LINE,
-            ),
-            static=True,
-        )
-
-
-def _export_observations(
-    reconstruction: types.Reconstruction,
-    tracks_manager: pymap.TracksManager,
-) -> None:
-    """Export feature observations (2D points in images)."""
-
-    logger.info("Exporting feature observations...")
-
-    # Sample some tracks to avoid overwhelming the viewer
-    max_tracks = 1000
-    track_ids = list(reconstruction.points.keys())
-    if len(track_ids) > max_tracks:
-        import random
-
-        track_ids = random.sample(track_ids, max_tracks)
-
-    for track_id in track_ids:
-        if track_id not in reconstruction.points:
-            continue
-
-        observations = tracks_manager.get_track_observations(track_id)
-
-        for shot_id, obs in observations.items():
-            if shot_id not in reconstruction.shots:
-                continue
-
-            shot = reconstruction.shots[shot_id]
-            width = int(shot.camera.width)
-            height = int(shot.camera.height)
-            width, height = _get_scaled_dimensions(width, height)
-            normalize = max(width, height)
-
-            # Convert from normalized to pixel coordinates
-            px = obs.point[0] * normalize + width / 2.0
-            py = obs.point[1] * normalize + height / 2.0
-
-            # Strip spaces from camera_id
-            camera_id_clean = shot.camera.id.replace(" ", "_")
-
-            # Set time sequence with integer ID
-            sequence_id = _get_shot_sequence_id(shot_id)
-            rr.set_time_sequence("shot", sequence_id)
-            rr.log(
-                f"world/cameras/{camera_id_clean}/shots/{shot_id}/pinhole/features",
-                rr.Points2D(
-                    [[px, py]],
-                    colors=[FEATURE_COLOR],  # Green for features
-                    radii=SIZE_2D_POINT_FEATURE,
-                ),
-            )
+            pos = reference.to_topocentric(*point.lla_vec)
+            triangulated = triangulations.get(point.id)
+            
+            error = gcp_3d_errors.get(point.id, -1.0)
 
-    logger.info(f"Exported observations for {len(track_ids)} tracks")
+            drawer.log_gcp_3d(point.id, pos, triangulated, error)
+            count += 1
+    logger.info(f"Exported {count} Ground Control Points")
 
 
 def _export_matchgraph(
     data: DataSet,
     reconstruction: types.Reconstruction,
     tracks_manager: pymap.TracksManager,
+    drawer: Drawer
 ) -> None:
-    """Export match graph connectivity."""
     logger.info("Exporting match graph...")
-    
     all_shots = list(reconstruction.shots.keys())
     all_points = list(reconstruction.points.keys())
-    
-    # Compute connectivity
     connectivity = tracks_manager.get_all_pairs_connectivity(all_shots, all_points)
+    
     if not connectivity:
         return
 
@@ -642,23 +999,17 @@ def _export_matchgraph(
     
     lines = []
     colors = []
-
     min_inliers = data.config.get("resection_min_inliers", 15)
 
     for (node1, node2), edge in connectivity.items():
-        if edge < 5 * min_inliers:
+        if edge < MATCHGRAPH_MIN_INLIERS_FACTOR * min_inliers:
             continue
-            
         if node1 not in reconstruction.shots or node2 not in reconstruction.shots:
             continue
             
-        shot1 = reconstruction.shots[node1]
-        shot2 = reconstruction.shots[node2]
-        
-        p1 = shot1.pose.get_origin()
-        p2 = shot2.pose.get_origin()
+        p1 = reconstruction.shots[node1].pose.get_origin()
+        p2 = reconstruction.shots[node2].pose.get_origin()
         
-        # Normalize edge weight for color mapping
         c_val = max(0.0, min(1.0, 1.0 - (float(edge) - lowest) / (highest - lowest + 1e-6)))
         rgba = MATCHGRAPH_CMAP(1.0 - c_val)
         
@@ -666,35 +1017,19 @@ def _export_matchgraph(
         colors.append([int(c * 255) for c in rgba[:3]])
 
     if lines:
-        rr.log(
-            "WORLD/STATS/MATCHGRAPH",
-            rr.LineStrips3D(
-                lines,
-                colors=colors,
-                radii=SIZE_MATCHGRAPH_LINE,
-            ),
-            static=True,
-        )
+        drawer.log_matchgraph(lines, colors)
         logger.info(f"Exported match graph with {len(lines)} edges")
 
 
 def _export_coverage_map(
     data: DataSet,
     reconstruction: types.Reconstruction,
+    drawer: Drawer
 ) -> None:
-    """Export coverage map as a tessellated quad."""
     logger.info("Exporting coverage map...")
-    
     if not reconstruction.points:
         return
 
-    try:
-        from scipy.spatial import Delaunay
-    except ImportError:
-        logger.warning("Scipy not found, skipping coverage map triangulation.")
-        return
-
-    # 1. Compute Bounding Box
     points = np.array([p.coordinates for p in reconstruction.points.values()])
     if len(points) == 0:
         return
@@ -703,78 +1038,50 @@ def _export_coverage_map(
     max_pt = np.percentile(points, 99, axis=0)
     median_z = np.median(points[:, 2])
 
-    # Add some margin
-    margin_ratio = 0.1
     extent = max_pt - min_pt
-    min_pt -= extent * margin_ratio
-    max_pt += extent * margin_ratio
+    min_pt -= extent * COVERAGE_EXTENT_MARGIN
+    max_pt += extent * COVERAGE_EXTENT_MARGIN
     
-    # 2. Generate Vertices from Frustums
     vertices = []
-    
     for shot in reconstruction.shots.values():
         w = shot.camera.width
         h = shot.camera.height
         
-        m = 0.01
-        n_steps = 10
-        steps = np.linspace(0, 1, n_steps)
+        m = COVERAGE_MARGIN
+        steps = np.linspace(0, 1, COVERAGE_GRID_STEPS)
         steps = m + steps * (1 - 2 * m)
         
         xs = w * steps
         ys = h * steps
         pixels = features.normalized_image_coordinates(np.array([[x, y] for y in ys for x in xs]), w, h)
         
-        # Transform bearings to world frame
-        # pose is World -> Camera. Rotation part R.
         bearings = shot.camera.pixel_bearing_many(pixels)
         R_wc = shot.pose.get_rotation_matrix().T
         bearings_world = bearings @ R_wc.T
-        
         origin = shot.pose.get_origin()
         
         for direction in bearings_world:
-            # Intersect with Z = median_z
-            # P = O + t * D
-            # median_z = O_z + t * D_z  => t = (median_z - O_z) / D_z
-            
             if abs(direction[2]) < 1e-6:
                 continue
-                
             t = (median_z - origin[2]) / direction[2]
-            if t <= 0: # Behind camera or camera is inside plane
+            if t <= 0:
                 continue
-                
             p_ground = origin + t * direction
             
-            # Check bounds
             if (p_ground[0] >= min_pt[0] and p_ground[0] <= max_pt[0] and
                 p_ground[1] >= min_pt[1] and p_ground[1] <= max_pt[1]):
                 vertices.append(p_ground)
 
-    if not vertices:
-        logger.warning("No frustum intersections found within bounds.")
-        return
-
-    # Remove duplicates/close points to avoid Delaunay issues
-    #vertices = np.unique(np.round(np.array(vertices), 3), axis=0)
-    
-    if len(vertices) < 3:
+    if not vertices or len(vertices) < 3:
         return
 
-    # 3. Delaunay Triangulation
     vertices = np.array(vertices)
     tri = Delaunay(vertices[:, :2])
     indices = tri.simplices
     
-    # 4. Compute Visibility
     counts = np.zeros(len(vertices), dtype=int)
-    
     for shot in reconstruction.shots.values():
-        # Transform to camera frame
         p_cam = shot.pose.transform_many(vertices)
-        
-        # Check if in front of camera (Z > 0)
         valid_z = p_cam[:, 2] > 0
         indices_valid_z = np.where(valid_z)[0]
         
@@ -784,7 +1091,6 @@ def _export_coverage_map(
         p_cam_valid = p_cam[indices_valid_z]
         projections = shot.camera.project_many(p_cam_valid)
         
-        # Convert to pixels
         w = shot.camera.width
         h = shot.camera.height
         normalizer = max(w, h)
@@ -792,31 +1098,14 @@ def _export_coverage_map(
         px = projections[:, 0] * normalizer + w / 2.0
         py = projections[:, 1] * normalizer + h / 2.0
         
-        # Check bounds
         in_view = (px >= 0) & (px < w) & (py >= 0) & (py < h)
-        
-        # Update counts
         counts[indices_valid_z[in_view]] += 1
     
-    # 5. Colorize
-    # Cap between 2 and 5
-    min_count = 0.0
-    max_count = 20.0
-    
-    norm_counts = np.clip(counts, min_count, max_count)
-    norm_counts = (norm_counts - min_count) / (max_count - min_count)
+    norm_counts = np.clip(counts, COVERAGE_MIN_COUNT, COVERAGE_MAX_COUNT)
+    norm_counts = (norm_counts - COVERAGE_MIN_COUNT) / (COVERAGE_MAX_COUNT - COVERAGE_MIN_COUNT)
     
-    colors = COVERAGE_CMAP(norm_counts) # RGBA
+    colors = COVERAGE_CMAP(norm_counts)
     vertex_colors = (colors[:, :3] * 255).astype(np.uint8)
 
-    # 6. Log
-    rr.log(
-        "WORLD/STATS/COVERAGE",
-        rr.Mesh3D(
-            vertex_positions=vertices,
-            vertex_colors=vertex_colors,
-            triangle_indices=indices,
-        ),
-        static=True
-    )
+    drawer.log_coverage_map(vertices, vertex_colors, indices)
     logger.info(f"Exported coverage map with {len(vertices)} vertices")
\ No newline at end of file
diff --git a/opensfm/dataset.py b/opensfm/dataset.py
index 719d1ab30..2cfe4dce6 100644
--- a/opensfm/dataset.py
+++ b/opensfm/dataset.py
@@ -638,6 +638,24 @@ def save_ground_control_points(
         with self.io_handler.open_wt(self._ground_control_points_file()) as fout:
             io.write_ground_control_points(points, fout)
 
+    def _stats_file(self) -> str:
+        return os.path.join(self.data_path, "stats", "stats.json")
+
+    def load_stats(self) -> Dict[str, Any]:
+        """Load statistics from stats/stats.json."""
+        stats_file = self._stats_file()
+        if self.io_handler.isfile(stats_file):
+            with self.io_handler.open_rt(stats_file) as fin:
+                return io.json_load(fin)
+        return {}
+
+    def save_stats(self, stats: Dict[str, Any]) -> None:
+        """Save statistics to stats/stats.json."""
+        stats_file = self._stats_file()
+        self.io_handler.mkdir_p(os.path.dirname(stats_file))
+        with self.io_handler.open_wt(stats_file) as fout:
+            io.json_dump(stats, fout)
+
     def image_as_array(self, image: str) -> NDArray:
         logger.warning("image_as_array() is deprecated. Use load_image() instead.")
         return self.load_image(image)
diff --git a/opensfm/dataset_base.py b/opensfm/dataset_base.py
index b95db70c3..f01fadf87 100644
--- a/opensfm/dataset_base.py
+++ b/opensfm/dataset_base.py
@@ -239,5 +239,13 @@ def save_ground_control_points(
     ) -> None:
         pass
 
+    @abstractmethod
+    def load_stats(self) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def save_stats(self, stats: Dict[str, Any]) -> None:
+        pass
+
     def clean_up(self) -> None:
         pass
diff --git a/opensfm/report.py b/opensfm/report.py
index 274d13c73..0f795d63c 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -37,7 +37,7 @@ def __init__(self, data: DataSet) -> None:
         self.cell_height = 7
         self.total_size = 190
 
-        self.stats: Dict[str, Any] = self._read_stats_file("stats.json")
+        self.stats: Dict[str, Any] = data.load_stats()
 
     def save_report(self, filename: str) -> None:
         bytestring = self.pdf.output()
@@ -95,11 +95,6 @@ def _make_table(
                 self.pdf.cell(size, self.cell_height, col, align="L")
             self.pdf.set_xy(self.margin, self.pdf.get_y() + self.cell_height)
 
-    def _read_stats_file(self, filename: str) -> Dict[str, Any]:
-        file_path = os.path.join(self.output_path, filename)
-        with self.io_handler.open_rt(file_path) as fin:
-            return io.json_load(fin)
-
     def _make_section(self, title: str) -> None:
         self.pdf.set_font("Helvetica", "B", self.h1)
         self.pdf.set_text_color(*self.mapi_dark_grey)
diff --git a/opensfm/stats.py b/opensfm/stats.py
index 710bd27ac..11799c76d 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -316,11 +316,10 @@ def processing_statistics(
 
     steps_times = {}
     for step_name, report_file in steps.items():
-        file_path = os.path.join(data.data_path, "reports", report_file)
-        if os.path.exists(file_path):
-            with io.open_rt(file_path) as fin:
-                obj = io.json_load(fin)
-        else:
+        try:
+            report_str = data.load_report(report_file)
+            obj = io.json_loads(report_str)
+        except (IOError, OSError):
             obj = {}
         if "wall_time" in obj:
             steps_times[step_name] = obj["wall_time"]

From dfa6218869ceab86b865b7cf1314de2923e9b678 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 15 Dec 2025 12:23:23 +0100
Subject: [PATCH 212/235] Allow exporting pure GCP coordinates in their CS to
 highlight conversions issues

---
 opensfm/actions/export_rerun.py         | 92 +++++++++++++++++++------
 opensfm/commands/export_rerun.py        |  6 ++
 opensfm/io.py                           | 16 ++---
 opensfm/src/map/ground_control_points.h |  1 +
 opensfm/src/map/python/pybind.cc        |  1 +
 5 files changed, 87 insertions(+), 29 deletions(-)

diff --git a/opensfm/actions/export_rerun.py b/opensfm/actions/export_rerun.py
index 6942dc753..f95cb3ad3 100644
--- a/opensfm/actions/export_rerun.py
+++ b/opensfm/actions/export_rerun.py
@@ -2,14 +2,18 @@
 import logging
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Dict, List, Optional, Sequence, Tuple, Any
 import base64
 import os
 
 import numpy as np
+import pyproj
 from opensfm import features, multiview, pymap, types, io
+from opensfm import geo
 from opensfm.dataset import DataSet
 from opensfm import pygeometry
+from opensfm.actions import export_geocoords
+
 
 import matplotlib.cm as cm
 import rerun as rr
@@ -339,15 +343,6 @@ def log_gcp_2d_observations(
                     radii=SIZE_GCP_2D_THICKNESS,
                 ),
             )
-            rr.log(
-                f"SHOTS/IMAGE/GCP/REFERENCE/LABELS",
-                rr.Points2D(
-                    refs,
-                    labels=labels_refs,
-                    radii=0,
-                    colors=LABEL_COLOR
-                )
-            )
         else:
             rr.log(f"SHOTS/IMAGE/GCP/REFERENCE", rr.Clear(recursive=True))
             rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE", rr.Clear(recursive=True))
@@ -682,6 +677,7 @@ def run_dataset(
     data: DataSet,
     output: Optional[str] = None,
     reconstruction_index: int = 0,
+    proj: bool = False,
 ) -> None:
     """Export reconstruction to Rerun format for 3D visualization."""
     
@@ -696,6 +692,43 @@ def run_dataset(
         return
 
     reconstruction = reconstructions[reconstruction_index]
+
+    centering = None
+    if proj:
+        gcp_list_file = data._gcp_list_file()
+        if data.io_handler.isfile(gcp_list_file):
+            with data.io_handler.open_rt(gcp_list_file) as f:
+                proj_str = io.read_gcp_projection_string(f)
+            
+            if proj_str:
+                logger.info(f"Transforming reconstruction to geocoords: {proj_str}")
+                reference = data.load_reference()
+
+                # Transform to the GCP CS
+                projection = geo.construct_proj_transformer(proj_str, inverse=True)
+                geo.transform_reconstruction_with_proj(reconstruction, projection)
+
+                # Center the reconstruction to avoid large coordinates
+                all_points = [p.coordinates for p in reconstruction.points.values()]
+                if all_points:
+                    center = np.mean(all_points, axis=0)
+                else:
+                    all_origins = [shot.pose.get_origin() for shot in reconstruction.shots.values()]
+                    if all_origins:
+                        center = np.mean(all_origins, axis=0)
+                    else:
+                        center = np.zeros(3)
+
+                logger.info(f"Centering reconstruction at {center}")
+                centering = -center
+                
+                for point in reconstruction.points.values():
+                    point.coordinates += centering
+                for shot in reconstruction.shots.values():
+                    shot.pose.set_origin(shot.pose.get_origin() + centering)
+        else:
+             logger.warning("No gcp_list.txt found, skipping projection.")
+
     logger.info(
         f"Exporting reconstruction {reconstruction_index} with "
         f"{len(reconstruction.shots)} shots, "
@@ -715,7 +748,7 @@ def run_dataset(
     # Precompute GCP observations per shot
     gcp = data.load_ground_control_points() or []
     gcp_triangulations = _compute_gcp_triangulations(data, reconstruction, gcp)
-    gcp_3d_errors = _compute_gcp_3d_errors(reconstruction, gcp, gcp_triangulations)
+    gcp_3d_errors = _compute_gcp_3d_errors(reconstruction, gcp, gcp_triangulations, centering)
     shot_gcp_obs = _precompute_gcp_observations(data, reconstruction, gcp, gcp_triangulations)
 
     # 4. Time-Dependent Logging (Shots)
@@ -744,7 +777,13 @@ def run_dataset(
         # Log GPS
         if reference and shot.metadata and shot.metadata.gps_position.has_value:
             gps_topo = shot.metadata.gps_position.value
-            drawer.log_gps(shot_id, shot.pose, gps_topo)
+            gps_pos = gps_topo
+            if projection is not None:
+                gps_pos = np.array(geo.transform_to_proj(gps_topo, reference, projection))
+                if centering is not None:
+                    gps_pos += centering
+
+            drawer.log_gps(shot_id, shot.pose, gps_pos)
 
         # Log GCP 2D Observations
         if shot_id in shot_gcp_obs:
@@ -785,7 +824,7 @@ def run_dataset(
 
     # GCP 3D Geometry
     if gcp:
-        _export_gcp_3d(data, reconstruction, gcp, gcp_triangulations, gcp_3d_errors, drawer)
+        _export_gcp_3d(data, reconstruction, gcp, gcp_triangulations, gcp_3d_errors, drawer, centering)
 
     # Match Graph
     if data.tracks_exists():
@@ -863,15 +902,23 @@ def _compute_gcp_triangulations(
 def _compute_gcp_3d_errors(
     reconstruction: types.Reconstruction,
     gcp: List[pymap.GroundControlPoint],
-    triangulations: Dict[str, Optional[np.ndarray]]
+    triangulations: Dict[str, Optional[np.ndarray]],
+    centering: Optional[np.ndarray] = None,
 ) -> Dict[str, float]:
     errors = {}
     reference = reconstruction.reference
     for point in gcp:
-        if point.lla and point.id in triangulations and triangulations[point.id] is not None:
-             ref_pos = reference.to_topocentric(*point.lla_vec)
+        if point.id in triangulations and triangulations[point.id] is not None:
              comp_pos = triangulations[point.id]
-             errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+             
+             if centering is not None:
+                 ref_pos = np.array(point.coordinates) + centering
+                 errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+             elif point.lla:
+                 ref_pos = reference.to_topocentric(*point.lla_vec)
+                 errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+             else:
+                 errors[point.id] = -1.0
         else:
              errors[point.id] = -1.0
     return errors
@@ -960,15 +1007,20 @@ def _export_gcp_3d(
     gcp: List[pymap.GroundControlPoint],
     triangulations: Dict[str, Optional[np.ndarray]],
     gcp_3d_errors: Dict[str, float],
-    drawer: Drawer
+    drawer: Drawer,
+    centering: Optional[np.ndarray] = None,
 ) -> None:
     reference = reconstruction.reference
     count = 0
     for point in gcp:
-        if point.lla:
+        pos = None
+        if centering is not None:
+             pos = np.array(point.coordinates) + centering
+        elif point.lla:
             pos = reference.to_topocentric(*point.lla_vec)
+
+        if pos is not None:
             triangulated = triangulations.get(point.id)
-            
             error = gcp_3d_errors.get(point.id, -1.0)
 
             drawer.log_gcp_3d(point.id, pos, triangulated, error)
diff --git a/opensfm/commands/export_rerun.py b/opensfm/commands/export_rerun.py
index 3028c7b57..93fc9f493 100644
--- a/opensfm/commands/export_rerun.py
+++ b/opensfm/commands/export_rerun.py
@@ -16,6 +16,7 @@ def run_impl(self, dataset: DataSet, args: argparse.Namespace) -> None:
             dataset,
             output=args.output,
             reconstruction_index=args.reconstruction_index,
+            proj=args.proj,
         )
 
     def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
@@ -30,4 +31,9 @@ def add_arguments_impl(self, parser: argparse.ArgumentParser) -> None:
             type=int,
             default=0,
             help="Index of reconstruction to export (default: 0)",
+        )
+        parser.add_argument(
+            "--proj",
+            action="store_true",
+            help="Use coordinate system from gcp_list.txt",
         )
\ No newline at end of file
diff --git a/opensfm/io.py b/opensfm/io.py
index 7f2713ac6..198194ab5 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -878,6 +878,7 @@ def _read_gcp_list_lines(
             point.id = "unnamed-%d" % len(points)
             point.lla = {"latitude": lat, "longitude": lon, "altitude": alt}
             point.has_altitude = has_altitude
+            point.coordinates = [easting, northing, alt]
 
             points[key] = point
 
@@ -934,15 +935,6 @@ def read_gcp_projection_string(fileobj: IO[str]) -> Optional[str]:
     return None
 
 
-def read_gcp_projection(line: str) -> Optional[pyproj.Transformer]:
-    """Build a proj4 from the GCP format line."""
-    projection_string = _parse_projection_string(line)
-    if projection_string is None:
-        return None
-
-    return projection_string
-
-
 def _valid_gcp_line(line: str) -> bool:
     stripped = line.strip()
     return stripped != "" and stripped[0] != "#"
@@ -978,6 +970,9 @@ def read_ground_control_points(fileobj: IO[str]) -> List[pymap.GroundControlPoin
             point.lla = lla
             point.has_altitude = "altitude" in point.lla
 
+        if "coordinates" in point_dict:
+            point.coordinates = point_dict["coordinates"]
+
         observations = []
         observing_images = set()
         for o_dict in point_dict["observations"]:
@@ -1016,6 +1011,9 @@ def write_ground_control_points(
             if point.has_altitude:
                 point_obj["position"]["altitude"] = point.lla["altitude"]
 
+        if hasattr(point, "coordinates"):
+            point_obj["coordinates"] = list(point.coordinates)
+
         point_obj["observations"] = []
         for observation in point.observations:
             point_obj["observations"].append(
diff --git a/opensfm/src/map/ground_control_points.h b/opensfm/src/map/ground_control_points.h
index c8cb862bc..e8e41bf18 100644
--- a/opensfm/src/map/ground_control_points.h
+++ b/opensfm/src/map/ground_control_points.h
@@ -47,6 +47,7 @@ struct GroundControlPoint {
   bool has_altitude_ = false;
   AlignedVector<GroundControlPointObservation> observations_;
   std::map<std::string, double> lla_;
+  Vec3d coordinates_ = Vec3d::Zero();
   GroundControlPointRole role_;
 
   Vec3d GetLlaVec3d() const {
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index 4a74b4ce8..c8a2d9576 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -272,6 +272,7 @@ PYBIND11_MODULE(pymap, m) {
                      &map::GroundControlPoint::survey_point_id_)
       .def_readwrite("has_altitude", &map::GroundControlPoint::has_altitude_)
       .def_readwrite("lla", &map::GroundControlPoint::lla_)
+      .def_readwrite("coordinates", &map::GroundControlPoint::coordinates_)
       .def_property("lla_vec", &map::GroundControlPoint::GetLlaVec3d,
                     &map::GroundControlPoint::SetLla)
       .def_readwrite("role", &map::GroundControlPoint::role_)

From 352f8139cc5763321565dfd3a2ddd3443fe540e6 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 6 Jan 2026 18:05:18 +0100
Subject: [PATCH 213/235] Big refactor of the view layout Added OPK error
 display

---
 opensfm/actions/export_rerun.py | 646 +++++++++++++++++++++-----------
 1 file changed, 421 insertions(+), 225 deletions(-)

diff --git a/opensfm/actions/export_rerun.py b/opensfm/actions/export_rerun.py
index f95cb3ad3..d982cd0e9 100644
--- a/opensfm/actions/export_rerun.py
+++ b/opensfm/actions/export_rerun.py
@@ -1,14 +1,18 @@
 # pyre-strict
 import logging
+import re
 from abc import ABC, abstractmethod
 from collections import defaultdict
+from io import BytesIO
 from typing import Dict, List, Optional, Sequence, Tuple, Any
 import base64
 import os
 
 import numpy as np
 import pyproj
-from opensfm import features, multiview, pymap, types, io
+import cv2
+from PIL import Image as PILImage  # type: ignore[import-not-found]
+from opensfm import features, multiview, pymap, types, io, geometry
 from opensfm import geo
 from opensfm.dataset import DataSet
 from opensfm import pygeometry
@@ -18,7 +22,7 @@
 import matplotlib.cm as cm
 import rerun as rr
 import rerun.blueprint as rrb
-from scipy.spatial import Delaunay
+from scipy.spatial import Delaunay, KDTree
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -76,10 +80,6 @@ class Drawer(ABC):
     def init(self, title: str, output_path: str) -> None:
         pass
 
-    @abstractmethod
-    def set_time(self, sequence_id: int) -> None:
-        pass
-
     @abstractmethod
     def log_shot(
         self,
@@ -91,6 +91,17 @@ def log_shot(
     ) -> None:
         pass
 
+    @abstractmethod
+    def log_exif_orientation(
+        self,
+        shot_id: str,
+        R: np.ndarray,
+        t: np.ndarray,
+        camera: pygeometry.Camera,
+        image_plane_distance: float = 1.0,
+    ) -> None:
+        pass
+
     @abstractmethod
     def log_gps(
         self,
@@ -160,7 +171,7 @@ def log_stats_gps_bias(self, stats: Dict[str, Any]) -> None:
         pass
 
     @abstractmethod
-    def setup_blueprint(self) -> None:
+    def setup_blueprint(self, camera_ids: Sequence[str]) -> None:
         pass
 
 
@@ -172,39 +183,75 @@ def init(self, title: str, output_path: str) -> None:
         rr.save(output_path)
         rr.log("/", rr.ViewCoordinates.RIGHT_HAND_Z_UP)
 
-    def setup_blueprint(self) -> None:
+    def setup_blueprint(self, camera_ids: Sequence[str]) -> None:
+        # Left: summary + processing time + GPS/GCP errors + per-camera biases (stacked vertically)
+        bias_views = [
+            rrb.TextDocumentView(
+                origin=f"STATS/BIAS/{_sanitize_entity_path_component(cam)}",
+                name=f"CAMERA {cam} Bias",
+            )
+            for cam in camera_ids
+        ]
+
+        # Right: spatial viewport, then per-camera (params + residual + heatmap) rows
+        camera_rows = [
+            rrb.Horizontal(
+                rrb.TextDocumentView(
+                    origin=f"STATS/CAMERAS/{_sanitize_entity_path_component(cam)}/PARAMS",
+                    name=f"{cam} Params",
+                ),
+                rrb.Spatial2DView(
+                    origin=f"STATS/CAMERAS/{_sanitize_entity_path_component(cam)}/RESIDUAL",
+                    name=f"{cam} Residuals",
+                ),
+                rrb.Spatial2DView(
+                    origin=f"STATS/CAMERAS/{_sanitize_entity_path_component(cam)}/HEATMAP",
+                    name=f"{cam} Heatmap",
+                ),
+            )
+            for cam in camera_ids
+        ]
+
         blueprint = rrb.Blueprint(
-            rrb.Vertical(
-                rrb.Horizontal(
-                    rrb.Spatial3DView(
-                        origin="/WORLD",
-                        name="3D Scene",
-                        background=[13, 17, 23],  # Deep dark gray
-                        line_grid=rrb.LineGrid3D(visible=False),
-                        spatial_information=rrb.SpatialInformation(
-                            show_axes=False,
-                            show_bounding_box=False,
+            rrb.Horizontal(
+                rrb.Vertical(
+                    rrb.TextDocumentView(
+                        origin="STATS/SUMMARY", name="Processing Summary"),
+                    rrb.TextDocumentView(
+                        origin="STATS/PROCESSING_TIME", name="Processing Time Details"),
+                    rrb.TextDocumentView(
+                        origin="STATS/ERRORS/GPS", name="GPS Errors"),
+                    rrb.TextDocumentView(
+                        origin="STATS/ERRORS/GCP", name="GCP Errors"),
+                    rrb.TextDocumentView(
+                        origin="STATS/ERRORS/ORIENTATION", name="Orientation Errors"),
+                    *bias_views,
+                ),
+                rrb.Vertical(
+                    rrb.Horizontal(
+                        rrb.Spatial3DView(
+                            origin="WORLD",
+                            name="3D Scene",
+                            background=[13, 17, 23],
+                            line_grid=rrb.LineGrid3D(visible=False),
+                            spatial_information=rrb.SpatialInformation(
+                                show_axes=False,
+                                show_bounding_box=False,
+                            ),
                         ),
+                        rrb.Spatial2DView(origin="SHOTS", name="Image View"),
                     ),
-                    rrb.Spatial2DView(
-                        origin="/SHOTS",
-                        name="Image View",
-                    ),
+                    rrb.Vertical(*camera_rows),
+                    row_shares=[0.8, 0.2],
                 ),
-                rrb.Horizontal(
-                    rrb.TextDocumentView(origin="/STATS/SUMMARY", name="Summary"),
-                    rrb.TextDocumentView(origin="/STATS/CAMERAS", name="Camera Models"),
-                    rrb.TextDocumentView(origin="/STATS/GPS", name="GPS/GCP Details"),
-                ),
-                row_shares=[5, 2],
+                rrb.BlueprintPanel(state="expanded"),
+                rrb.SelectionPanel(state="collapsed"),
+                rrb.TimePanel(state="collapsed"),
+                column_shares=[0.15, 0.85],
             ),
-            collapse_panels=True,
         )
         rr.send_blueprint(blueprint)
 
-    def set_time(self, sequence_id: int) -> None:
-        rr.set_time_sequence("SHOTS", sequence_id)
-
     def log_shot(
         self,
         shot_id: str,
@@ -216,7 +263,7 @@ def log_shot(
         # Pose
         t = pose.get_origin()
         R_world_from_camera = pose.get_rotation_matrix().T
-        
+
         rr.log(
             f"WORLD/SHOTS/{shot_id}",
             rr.Transform3D(
@@ -224,8 +271,9 @@ def log_shot(
                 mat3x3=R_world_from_camera,
                 from_parent=False,
             ),
+            static=True,
         )
-        
+
         labels_shift = np.array([0, 0, SIZE_LABEL_SHIFT_SHOT])
         rr.log(
             f"WORLD/SHOTS/{shot_id}",
@@ -252,12 +300,53 @@ def log_shot(
                 principal_point=[cx, cy],
                 image_plane_distance=image_plane_distance,
             ),
+            static=True,
         )
 
         if image is not None:
-            img_compressed = rr.Image(image).compress(jpeg_quality=IMAGE_COMPRESSION_QUALITY)
-            rr.log(f"WORLD/SHOTS/{shot_id}/CAMERA/IMAGE", img_compressed)
-            rr.log(f"SHOTS/IMAGE", img_compressed)
+            img_compressed = rr.Image(image).compress(
+                jpeg_quality=IMAGE_COMPRESSION_QUALITY)
+            rr.log(f"WORLD/SHOTS/{shot_id}/CAMERA/IMAGE",
+                   img_compressed, static=True)
+            rr.log(f"SHOTS/IMAGE", img_compressed, static=True)
+
+    def log_exif_orientation(
+        self,
+        shot_id: str,
+        R: np.ndarray,
+        t: np.ndarray,
+        camera: pygeometry.Camera,
+        image_plane_distance: float = 1.0,
+    ) -> None:
+        path = f"WORLD/EXIF_SHOTS/{shot_id}"
+
+        # Log transform (camera-to-world)
+        rr.log(
+            path,
+            rr.Transform3D(
+                translation=t,
+                mat3x3=R.T,
+                from_parent=False,
+            ),
+            static=True,
+        )
+
+        # Log pinhole
+        width = int(camera.width)
+        height = int(camera.height)
+        width, height = _get_scaled_dimensions(width, height)
+        fx, fy, cx, cy = _get_camera_calibration(camera, width, height)
+
+        rr.log(
+            f"{path}/EXIF_SHOTS/CAMERA",
+            rr.Pinhole(
+                resolution=[width, height],
+                focal_length=[fx, fy],
+                principal_point=[cx, cy],
+                image_plane_distance=image_plane_distance,
+            ),
+            static=True,
+        )
 
     def log_gps(
         self,
@@ -333,6 +422,7 @@ def log_gcp_2d_observations(
                     colors=box_colors,
                     radii=SIZE_GCP_2D_THICKNESS,
                 ),
+                static=True,
             )
             rr.log(
                 f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE",
@@ -342,11 +432,14 @@ def log_gcp_2d_observations(
                     colors=outline_colors,
                     radii=SIZE_GCP_2D_THICKNESS,
                 ),
+                static=True,
             )
         else:
             rr.log(f"SHOTS/IMAGE/GCP/REFERENCE", rr.Clear(recursive=True))
-            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE", rr.Clear(recursive=True))
-            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/LABELS", rr.Clear(recursive=True))
+            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/OUTLINE",
+                   rr.Clear(recursive=True))
+            rr.log(f"SHOTS/IMAGE/GCP/REFERENCE/LABELS",
+                   rr.Clear(recursive=True))
 
         # Computed: Arrow
         if comps:
@@ -369,7 +462,7 @@ def log_gcp_2d_observations(
                         valid_labels.append(f"{label}: {error_3d:.3f}m")
                     else:
                         valid_labels.append(label)
-            
+
             if origins:
                 rr.log(
                     f"SHOTS/IMAGE/GCP/COMPUTED",
@@ -380,6 +473,7 @@ def log_gcp_2d_observations(
                         labels=valid_labels,
                         radii=SIZE_GCP_2D_THICKNESS,
                     ),
+                    static=True,
                 )
             else:
                 rr.log(f"SHOTS/IMAGE/GCP/COMPUTED", rr.Clear(recursive=True))
@@ -427,7 +521,7 @@ def log_gcp_3d(
             pos_np + [quad_r, -quad_r, 0]
         ]
         half_sizes = [[quad_r, quad_r, thickness]] * 2
-        
+
         rr.log(
             f"{base_path}/TARGET",
             rr.Boxes3D(
@@ -442,7 +536,8 @@ def log_gcp_3d(
             f"{base_path}/OUTLINE",
             rr.Boxes3D(
                 centers=[pos_np],
-                half_sizes=[[SIZE_GCP_TARGET / 2.0, SIZE_GCP_TARGET / 2.0, thickness]],
+                half_sizes=[[SIZE_GCP_TARGET / 2.0,
+                             SIZE_GCP_TARGET / 2.0, thickness]],
                 colors=[color],
                 radii=thickness,
                 fill_mode="major_wireframe",
@@ -519,97 +614,71 @@ def log_stats_camera_models(self, stats: Dict[str, Any], data: DataSet) -> None:
         if "camera_errors" not in stats:
             return
 
-        md = "# Camera Models Details\n\n"
-        
         for camera, params in stats["camera_errors"].items():
-            md += f"## Camera: {camera}\n"
-            
+            sanitized_id = _sanitize_entity_path_component(camera)
+            sanitized_id_spaces = _sanitize_entity_path_component(
+                camera, strip_spaces=False)
+
             initial = params.get("initial_values", {})
             optimized = params.get("optimized_values", {})
-            
-            # Collect all parameter names
+
             keys = sorted(list(set(initial.keys()) | set(optimized.keys())))
-            
-            md += "| State | " + " | ".join(keys) + " |\n"
-            md += "| --- | " + " | ".join(["---"] * len(keys)) + " |\n"
-            
-            # Initial values row
-            row_init = "| Initial |"
+            columns = {"State": ["Initial", "Optimized"]}
             for k in keys:
-                val = initial.get(k, "N/A")
-                if isinstance(val, float): val = f"{val:.4f}"
-                row_init += f" {val} |"
-            md += row_init + "\n"
+                columns[k] = [initial.get(k), optimized.get(k)]
 
-            # Optimized values row
-            row_opt = "| Optimized |"
-            for k in keys:
-                val = optimized.get(k, "N/A")
-                if isinstance(val, float): val = f"{val:.4f}"
-                row_opt += f" {val} |"
-            md += row_opt + "\n\n"
-
-            # Embed residual and heatmap images
-            sanitized_id = camera.replace("/", "_")
-            res_path = os.path.join(data.data_path, "stats", f"residuals_{sanitized_id}.png")
-            heat_path = os.path.join(data.data_path, "stats", f"heatmap_{sanitized_id}.png")
-            
-            res_b64 = None
-            if data.io_handler.isfile(res_path):
-                try:
-                    with data.io_handler.open_rb(res_path) as f:
-                        res_b64 = base64.b64encode(f.read()).decode("utf-8")
-                except Exception as e:
-                    logger.warning(f"Failed to embed residual image for {camera}: {e}")
-
-            heat_b64 = None
-            if data.io_handler.isfile(heat_path):
-                try:
-                    with data.io_handler.open_rb(heat_path) as f:
-                        heat_b64 = base64.b64encode(f.read()).decode("utf-8")
-                except Exception as e:
-                    logger.warning(f"Failed to embed heatmap image for {camera}: {e}")
-
-            if res_b64 or heat_b64:
-                md += "| Residuals | Heatmap |\n"
-                md += "| :---: | :---: |\n"
-                c1 = f"![Residuals](data:image/png;base64,{res_b64})" if res_b64 else ""
-                c2 = f"![Heatmap](data:image/png;base64,{heat_b64})" if heat_b64 else ""
-                md += f"| {c1} | {c2} |\n\n"
-
-        rr.log("STATS/CAMERAS", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+            _log_dataframe(
+                f"STATS/CAMERAS/{sanitized_id}/PARAMS",
+                columns,
+                static=True,
+            )
+
+            # Residuals + heatmap as real images for Spatial2D views
+            res_path = os.path.join(
+                data.data_path, "stats", f"residuals_{sanitized_id_spaces}.png")
+            heat_path = os.path.join(
+                data.data_path, "stats", f"heatmap_{sanitized_id_spaces}.png")
+
+            res_img = _try_load_image_as_numpy(data, res_path)
+            if res_img is not None:
+                rr.log(f"STATS/CAMERAS/{sanitized_id}/RESIDUAL",
+                       rr.Image(res_img), static=True)
+
+            heat_img = _try_load_image_as_numpy(data, heat_path)
+            if heat_img is not None:
+                rr.log(f"STATS/CAMERAS/{sanitized_id}/HEATMAP",
+                       rr.Image(heat_img), static=True)
 
     def log_stats_summary(self, stats: Dict[str, Any]) -> None:
+        # Keep Dataset + Reconstruction as markdown, but remove the time-details table (moved to DataFrame)
         md = "# Processing Summary\n\n"
 
-        # Dataset Summary
         if "processing_statistics" in stats:
             ps = stats["processing_statistics"]
             md += "## Dataset\n"
             md += f"- **Date**: {ps.get('date', 'N/A')}\n"
             if "area" in ps:
-                md += f"- **Area Covered**: {ps['area']/1e6:.6f} km²\n"
-            if "steps_times" in ps:
-                if "Total Time" in ps["steps_times"]:
-                    md += f"- **Total Time**: {ps['steps_times']['Total Time']:.2f} s\n"
-
-                md += "\n### Processing Time Details\n"
-                md += "| Step | Time |\n"
-                md += "| --- | --- |\n"
-                for step, time in ps["steps_times"].items():
-                    if step == "Total Time":
-                        continue
-                    md += f"| {step} | {time:.2f} s |\n"
+                md += f"- **Area Covered**: {ps['area'] / 1e6:.6f} km²\n"
+            if "steps_times" in ps and "Total Time" in ps["steps_times"]:
+                md += f"- **Total Time**: {ps['steps_times']['Total Time']:.2f} s\n"
             md += "\n"
 
-        # Reconstruction Summary
+            if "steps_times" in ps:
+                steps = list(ps["steps_times"].keys())
+                times = [float(ps["steps_times"][s]) for s in steps]
+                _log_dataframe(
+                    "STATS/PROCESSING_TIME",
+                    {"Step": steps, "Time (seconds)": times},
+                    static=True,
+                )
+
         if "reconstruction_statistics" in stats:
             rs = stats["reconstruction_statistics"]
             rec_shots = rs.get("reconstructed_shots_count", 0)
             init_shots = rs.get("initial_shots_count", 0)
             rec_points = rs.get("reconstructed_points_count", 0)
             init_points = rs.get("initial_points_count", 0)
-            
+
             ratio_shots = rec_shots / init_shots * 100 if init_shots > 0 else 0
             ratio_points = rec_points / init_points * 100 if init_points > 0 else 0
 
@@ -617,7 +686,7 @@ def log_stats_summary(self, stats: Dict[str, Any]) -> None:
             md += f"- **Images**: {rec_shots}/{init_shots} ({ratio_shots:.1f}%)\n"
             md += f"- **Points**: {rec_points}/{init_points} ({ratio_points:.1f}%)\n"
             md += f"- **Components**: {rs.get('components', 0)}\n"
-            
+
             if "features_statistics" in stats:
                 fs = stats["features_statistics"]
                 if "detected_features" in fs:
@@ -625,50 +694,84 @@ def log_stats_summary(self, stats: Dict[str, Any]) -> None:
                 if "reconstructed_features" in fs:
                     md += f"- **Reconstructed Features (median)**: {fs['reconstructed_features'].get('median', 'N/A')}\n"
 
-        rr.log("STATS/SUMMARY", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+        rr.log(
+            "STATS/SUMMARY",
+            rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN),
+            static=True,
+        )
 
     def log_stats_gps_bias(self, stats: Dict[str, Any]) -> None:
-        md = "# GPS/GCP Details\n\n"
+        def _log_errors_df(
+            dst_path: str,
+            err_stats: Dict[str, Any],
+            comps: Optional[List[str]] = None,
+            unit: str = "meters",
+        ) -> None:
+            if comps is None:
+                comps = ["x", "y", "z"]
+
+            rows_component: List[str] = []
+            rows_mean: List[Optional[float]] = []
+            rows_sigma: List[Optional[float]] = []
+            rows_rms: List[Optional[float]] = []
+
+            for c in comps:
+                rows_component.append(c.upper() if len(c)
+                                      == 1 else c.capitalize())
+                rows_mean.append(float(err_stats.get("mean", {}).get(c, 0.0)))
+                rows_sigma.append(float(err_stats.get("std", {}).get(c, 0.0)))
+                rows_rms.append(float(err_stats.get("error", {}).get(c, 0.0)))
+
+            rows_component.append("TOTAL")
+            rows_mean.append(None)
+            rows_sigma.append(None)
+            rows_rms.append(float(err_stats.get("average_error", 0.0)))
+
+            _log_dataframe(
+                dst_path,
+                {
+                    "Component": rows_component,
+                    f"Mean ({unit})": rows_mean,
+                    f"Sigma ({unit})": rows_sigma,
+                    f"RMS ({unit})": rows_rms,
+                },
+                static=True,
+            )
+
+        gps_key = "gps_errors"
+        if gps_key in stats and "average_error" in stats[gps_key]:
+            _log_errors_df("STATS/ERRORS/GPS", stats[gps_key])
+
+        gcp_key = "gcp_errors"
+        if gcp_key in stats and "average_error" in stats[gcp_key]:
+            _log_errors_df("STATS/ERRORS/GCP", stats[gcp_key])
+
+        opk_key = "opk_errors"
+        if opk_key in stats and "average_error" in stats[opk_key]:
+            _log_errors_df(
+                "STATS/ERRORS/ORIENTATION",
+                stats[opk_key],
+                comps=["omega", "phi", "kappa"],
+                unit="degrees",
+            )
 
-        # Errors
-        for error_type in ["gps", "gcp"]:
-            key = f"{error_type}_errors"
-            if key not in stats or "average_error" not in stats[key]:
-                continue
-            
-            err_stats = stats[key]
-            md += f"## {error_type.upper()} Errors (meters)\n"
-            md += "| Component | Mean | Sigma | RMS Error |\n"
-            md += "| --- | --- | --- | --- |\n"
-            
-            for comp in ["x", "y", "z"]:
-                mean = err_stats.get("mean", {}).get(comp, 0)
-                std = err_stats.get("std", {}).get(comp, 0)
-                rms = err_stats.get("error", {}).get(comp, 0)
-                md += f"| {comp.upper()} | {mean:.3f} | {std:.3f} | {rms:.3f} |\n"
-            
-            avg = err_stats.get("average_error", 0)
-            md += f"| **Total** | | | **{avg:.3f}** |\n\n"
-
-        # GPS Bias
         if "camera_errors" in stats:
-            md += "## GPS Bias\n"
-            md += "| Camera | Scale | Translation | Rotation |\n"
-            md += "| --- | --- | --- | --- |\n"
-            
             for camera, params in stats["camera_errors"].items():
-                if "bias" in params:
-                    bias = params["bias"]
-                    s = bias.get("scale", 1.0)
-                    t = bias.get("translation", [0,0,0])
-                    r = bias.get("rotation", [0,0,0])
-                    
-                    t_str = f"[{t[0]:.2f}, {t[1]:.2f}, {t[2]:.2f}]"
-                    r_str = f"[{r[0]:.2f}, {r[1]:.2f}, {r[2]:.2f}]"
-                    
-                    md += f"| {camera} | {s:.2f} | {t_str} | {r_str} |\n"
-
-        rr.log("STATS/GPS", rr.TextDocument(md, media_type=rr.MediaType.MARKDOWN), static=True)
+                if "bias" not in params:
+                    continue
+                bias = params["bias"]
+                s = float(bias.get("scale", 1.0))
+                t = bias.get("translation", [0.0, 0.0, 0.0])
+                r = bias.get("rotation", [0.0, 0.0, 0.0])
+
+                _log_dataframe(
+                    f"STATS/BIAS/{_sanitize_entity_path_component(camera)}",
+                    {
+                        "Component": ["Scale", "Translation X", "Translation Y", "Translation Z", "Rotation X", "Rotation Y", "Rotation Z"],
+                        "Value (meters or degrees)": [s, float(t[0]), float(t[1]), float(t[2]), float(r[0]), float(r[1]), float(r[2])],
+                    },
+                    static=True,
+                )
 
 
 # --- Main Logic ---
@@ -680,7 +783,7 @@ def run_dataset(
     proj: bool = False,
 ) -> None:
     """Export reconstruction to Rerun format for 3D visualization."""
-    
+
     # 1. Load Data
     reconstructions = data.load_reconstruction()
     if not reconstructions:
@@ -688,32 +791,39 @@ def run_dataset(
         return
 
     if reconstruction_index >= len(reconstructions):
-        logger.error(f"Reconstruction index {reconstruction_index} out of range")
+        logger.error(
+            f"Reconstruction index {reconstruction_index} out of range")
         return
 
     reconstruction = reconstructions[reconstruction_index]
 
     centering = None
+    projection = None
     if proj:
         gcp_list_file = data._gcp_list_file()
         if data.io_handler.isfile(gcp_list_file):
             with data.io_handler.open_rt(gcp_list_file) as f:
                 proj_str = io.read_gcp_projection_string(f)
-            
+
             if proj_str:
-                logger.info(f"Transforming reconstruction to geocoords: {proj_str}")
+                logger.info(
+                    f"Transforming reconstruction to geocoords: {proj_str}")
                 reference = data.load_reference()
 
                 # Transform to the GCP CS
-                projection = geo.construct_proj_transformer(proj_str, inverse=True)
-                geo.transform_reconstruction_with_proj(reconstruction, projection)
+                projection = geo.construct_proj_transformer(
+                    proj_str, inverse=True)
+                geo.transform_reconstruction_with_proj(
+                    reconstruction, projection)
 
                 # Center the reconstruction to avoid large coordinates
-                all_points = [p.coordinates for p in reconstruction.points.values()]
+                all_points = [
+                    p.coordinates for p in reconstruction.points.values()]
                 if all_points:
                     center = np.mean(all_points, axis=0)
                 else:
-                    all_origins = [shot.pose.get_origin() for shot in reconstruction.shots.values()]
+                    all_origins = [shot.pose.get_origin()
+                                   for shot in reconstruction.shots.values()]
                     if all_origins:
                         center = np.mean(all_origins, axis=0)
                     else:
@@ -721,13 +831,13 @@ def run_dataset(
 
                 logger.info(f"Centering reconstruction at {center}")
                 centering = -center
-                
+
                 for point in reconstruction.points.values():
                     point.coordinates += centering
                 for shot in reconstruction.shots.values():
                     shot.pose.set_origin(shot.pose.get_origin() + centering)
         else:
-             logger.warning("No gcp_list.txt found, skipping projection.")
+            logger.warning("No gcp_list.txt found, skipping projection.")
 
     logger.info(
         f"Exporting reconstruction {reconstruction_index} with "
@@ -739,24 +849,29 @@ def run_dataset(
     output_path = output or data.data_path + "/rerun.rrd"
     drawer = RerunDrawer()
     drawer.init("OpenSfM Reconstruction", output_path)
-    drawer.setup_blueprint()
+
+    camera_ids = sorted(
+        {shot.camera.id for shot in reconstruction.shots.values()})
+
+    drawer.setup_blueprint(camera_ids)
     logger.info(f"Saving Rerun data to {output_path}")
 
     # 3. Precompute Data
     image_plane_distance = _compute_image_plane_distance(reconstruction)
-    
+
     # Precompute GCP observations per shot
     gcp = data.load_ground_control_points() or []
     gcp_triangulations = _compute_gcp_triangulations(data, reconstruction, gcp)
-    gcp_3d_errors = _compute_gcp_3d_errors(reconstruction, gcp, gcp_triangulations, centering)
-    shot_gcp_obs = _precompute_gcp_observations(data, reconstruction, gcp, gcp_triangulations)
+    gcp_3d_errors = _compute_gcp_3d_errors(
+        reconstruction, gcp, gcp_triangulations, centering)
+    shot_gcp_obs = _precompute_gcp_observations(
+        data, reconstruction, gcp, gcp_triangulations)
 
     # 4. Time-Dependent Logging (Shots)
     reference = reconstruction.reference
-    
+
     for shot_id, shot in reconstruction.shots.items():
         sequence_id = _get_shot_sequence_id(shot_id)
-        drawer.set_time(sequence_id)
 
         # Load image
         image = None
@@ -766,25 +881,42 @@ def run_dataset(
             height = int(shot.camera.height)
             width, height = _get_scaled_dimensions(width, height)
             if image.shape[1] != width or image.shape[0] != height:
-                import cv2
-                image = cv2.resize(image, (width, height), interpolation=cv2.INTER_AREA)
+                image = cv2.resize(image, (width, height),
+                                   interpolation=cv2.INTER_AREA)
         except Exception as e:
             logger.warning(f"Could not load image for {shot_id}: {e}")
 
         # Log Shot Pose & Image
-        drawer.log_shot(shot_id, shot.pose, shot.camera, image, image_plane_distance)
+        drawer.log_shot(shot_id, shot.pose, shot.camera,
+                        image, image_plane_distance)
 
-        # Log GPS
+        # Log GPS & EXIF Orientation
+        gps_pos = None
         if reference and shot.metadata and shot.metadata.gps_position.has_value:
             gps_topo = shot.metadata.gps_position.value
             gps_pos = gps_topo
             if projection is not None:
-                gps_pos = np.array(geo.transform_to_proj(gps_topo, reference, projection))
+                gps_pos = np.array(geo.transform_to_proj(
+                    gps_topo, reference, projection))
                 if centering is not None:
                     gps_pos += centering
 
             drawer.log_gps(shot_id, shot.pose, gps_pos)
 
+        has_opk = shot.metadata and shot.metadata.opk_angles.has_value
+        if gps_pos is not None or has_opk:
+            t_exif = shot.pose.get_origin()
+            if has_opk:
+                opk = shot.metadata.opk_angles.value
+                R_exif = geometry.rotation_from_opk(
+                    np.radians(opk[0]), np.radians(opk[1]), np.radians(opk[2])
+                )
+            else:
+                R_exif = shot.pose.get_rotation_matrix()
+
+            drawer.log_exif_orientation(
+                shot_id, R_exif, t_exif, shot.camera, image_plane_distance)
+
         # Log GCP 2D Observations
         if shot_id in shot_gcp_obs:
             obs = shot_gcp_obs[shot_id]
@@ -797,10 +929,11 @@ def run_dataset(
                 gcp_3d_errors,
             )
         else:
-            drawer.log_gcp_2d_observations(shot_id, [], [], [], [], gcp_3d_errors)
+            drawer.log_gcp_2d_observations(
+                shot_id, [], [], [], [], gcp_3d_errors)
 
     # 5. Static Logging (Structure & Stats)
-    
+
     # Reference
     if reconstruction.reference:
         ref = reconstruction.reference
@@ -824,7 +957,8 @@ def run_dataset(
 
     # GCP 3D Geometry
     if gcp:
-        _export_gcp_3d(data, reconstruction, gcp, gcp_triangulations, gcp_3d_errors, drawer, centering)
+        _export_gcp_3d(data, reconstruction, gcp,
+                       gcp_triangulations, gcp_3d_errors, drawer, centering)
 
     # Match Graph
     if data.tracks_exists():
@@ -842,7 +976,6 @@ def run_dataset(
 
 def _get_shot_sequence_id(shot_id: str) -> int:
     try:
-        import re
         numbers = re.findall(r'\d+', shot_id)
         if numbers:
             return int(numbers[-1])
@@ -859,11 +992,11 @@ def _get_scaled_dimensions(width: int, height: int) -> tuple[int, int]:
 
 
 def _compute_image_plane_distance(reconstruction: types.Reconstruction) -> float:
-    positions = np.array([shot.pose.get_origin() for shot in reconstruction.shots.values()])
+    positions = np.array([shot.pose.get_origin()
+                         for shot in reconstruction.shots.values()])
     if len(positions) < 2:
         return DEFAULT_IMAGE_PLANE_DISTANCE
     try:
-        from scipy.spatial import KDTree
         tree = KDTree(positions)
         dists, _ = tree.query(positions, k=KNN_FOR_SCALE)
         median_nn_dist = np.median(dists[:, 1])
@@ -909,18 +1042,18 @@ def _compute_gcp_3d_errors(
     reference = reconstruction.reference
     for point in gcp:
         if point.id in triangulations and triangulations[point.id] is not None:
-             comp_pos = triangulations[point.id]
-             
-             if centering is not None:
-                 ref_pos = np.array(point.coordinates) + centering
-                 errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
-             elif point.lla:
-                 ref_pos = reference.to_topocentric(*point.lla_vec)
-                 errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
-             else:
-                 errors[point.id] = -1.0
+            comp_pos = triangulations[point.id]
+
+            if centering is not None:
+                ref_pos = np.array(point.coordinates) + centering
+                errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+            elif point.lla:
+                ref_pos = reference.to_topocentric(*point.lla_vec)
+                errors[point.id] = np.linalg.norm(comp_pos - ref_pos)
+            else:
+                errors[point.id] = -1.0
         else:
-             errors[point.id] = -1.0
+            errors[point.id] = -1.0
     return errors
 
 
@@ -931,21 +1064,22 @@ def _precompute_gcp_observations(
     triangulations: Dict[str, Optional[np.ndarray]]
 ) -> Dict[str, Dict[str, Any]]:
     """Precompute 2D GCP observations per shot."""
-    shot_obs = defaultdict(lambda: {"refs": [], "comps": [], "labels_refs": [], "labels_comps": []})
+    shot_obs = defaultdict(
+        lambda: {"refs": [], "comps": [], "labels_refs": [], "labels_comps": []})
     reference = reconstruction.reference
-    
+
     for point in gcp:
         if not point.lla:
             continue
-            
+
         triangulated = triangulations.get(point.id)
-        
+
         # Project to shots
         for obs in point.observations:
             shot_id = obs.shot_id
             if shot_id not in reconstruction.shots:
                 continue
-                
+
             shot = reconstruction.shots[shot_id]
             width = int(shot.camera.width)
             height = int(shot.camera.height)
@@ -955,7 +1089,7 @@ def _precompute_gcp_observations(
             # Reference pixel
             px = obs.projection[0] * normalizer + width / 2.0
             py = obs.projection[1] * normalizer + height / 2.0
-            
+
             shot_obs[shot_id]["refs"].append((px, py))
             shot_obs[shot_id]["labels_refs"].append(point.id)
 
@@ -966,7 +1100,7 @@ def _precompute_gcp_observations(
                 py_comp = projected[1] * normalizer + height / 2.0
                 shot_obs[shot_id]["comps"].append((px_comp, py_comp))
                 shot_obs[shot_id]["labels_comps"].append(point.id)
-                
+
     return shot_obs
 
 
@@ -981,7 +1115,7 @@ def _export_points(reconstruction: types.Reconstruction, drawer: Drawer) -> None
         if all(val <= 1.0 for val in c):
             c = [int(val * 255) for val in c]
         colors.append(c)
-    
+
     drawer.log_points(np.array(positions), np.array(colors, dtype=np.uint8))
     logger.info(f"Exported {len(positions)} automatic tie points")
 
@@ -991,7 +1125,7 @@ def _export_camera_path(reconstruction: types.Reconstruction, drawer: Drawer) ->
     for shot in reconstruction.shots.values():
         if shot.metadata and shot.metadata.capture_time.has_value:
             shots_with_time.append(shot)
-    
+
     if len(shots_with_time) < 2:
         return
 
@@ -1015,7 +1149,7 @@ def _export_gcp_3d(
     for point in gcp:
         pos = None
         if centering is not None:
-             pos = np.array(point.coordinates) + centering
+            pos = np.array(point.coordinates) + centering
         elif point.lla:
             pos = reference.to_topocentric(*point.lla_vec)
 
@@ -1037,18 +1171,19 @@ def _export_matchgraph(
     logger.info("Exporting match graph...")
     all_shots = list(reconstruction.shots.keys())
     all_points = list(reconstruction.points.keys())
-    connectivity = tracks_manager.get_all_pairs_connectivity(all_shots, all_points)
-    
+    connectivity = tracks_manager.get_all_pairs_connectivity(
+        all_shots, all_points)
+
     if not connectivity:
         return
 
     all_values = list(connectivity.values())
     if not all_values:
         return
-        
+
     lowest = np.percentile(all_values, 5)
     highest = np.percentile(all_values, 95)
-    
+
     lines = []
     colors = []
     min_inliers = data.config.get("resection_min_inliers", 15)
@@ -1058,13 +1193,14 @@ def _export_matchgraph(
             continue
         if node1 not in reconstruction.shots or node2 not in reconstruction.shots:
             continue
-            
+
         p1 = reconstruction.shots[node1].pose.get_origin()
         p2 = reconstruction.shots[node2].pose.get_origin()
-        
-        c_val = max(0.0, min(1.0, 1.0 - (float(edge) - lowest) / (highest - lowest + 1e-6)))
+
+        c_val = max(0.0, min(1.0, 1.0 - (float(edge) - lowest) /
+                    (highest - lowest + 1e-6)))
         rgba = MATCHGRAPH_CMAP(1.0 - c_val)
-        
+
         lines.append([p1, p2])
         colors.append([int(c * 255) for c in rgba[:3]])
 
@@ -1085,7 +1221,7 @@ def _export_coverage_map(
     points = np.array([p.coordinates for p in reconstruction.points.values()])
     if len(points) == 0:
         return
-    
+
     min_pt = np.percentile(points, 1, axis=0)
     max_pt = np.percentile(points, 99, axis=0)
     median_z = np.median(points[:, 2])
@@ -1093,25 +1229,26 @@ def _export_coverage_map(
     extent = max_pt - min_pt
     min_pt -= extent * COVERAGE_EXTENT_MARGIN
     max_pt += extent * COVERAGE_EXTENT_MARGIN
-    
+
     vertices = []
     for shot in reconstruction.shots.values():
         w = shot.camera.width
         h = shot.camera.height
-        
+
         m = COVERAGE_MARGIN
         steps = np.linspace(0, 1, COVERAGE_GRID_STEPS)
         steps = m + steps * (1 - 2 * m)
-        
+
         xs = w * steps
         ys = h * steps
-        pixels = features.normalized_image_coordinates(np.array([[x, y] for y in ys for x in xs]), w, h)
-        
+        pixels = features.normalized_image_coordinates(
+            np.array([[x, y] for y in ys for x in xs]), w, h)
+
         bearings = shot.camera.pixel_bearing_many(pixels)
         R_wc = shot.pose.get_rotation_matrix().T
         bearings_world = bearings @ R_wc.T
         origin = shot.pose.get_origin()
-        
+
         for direction in bearings_world:
             if abs(direction[2]) < 1e-6:
                 continue
@@ -1119,9 +1256,9 @@ def _export_coverage_map(
             if t <= 0:
                 continue
             p_ground = origin + t * direction
-            
+
             if (p_ground[0] >= min_pt[0] and p_ground[0] <= max_pt[0] and
-                p_ground[1] >= min_pt[1] and p_ground[1] <= max_pt[1]):
+                    p_ground[1] >= min_pt[1] and p_ground[1] <= max_pt[1]):
                 vertices.append(p_ground)
 
     if not vertices or len(vertices) < 3:
@@ -1130,34 +1267,93 @@ def _export_coverage_map(
     vertices = np.array(vertices)
     tri = Delaunay(vertices[:, :2])
     indices = tri.simplices
-    
+
     counts = np.zeros(len(vertices), dtype=int)
     for shot in reconstruction.shots.values():
         p_cam = shot.pose.transform_many(vertices)
         valid_z = p_cam[:, 2] > 0
         indices_valid_z = np.where(valid_z)[0]
-        
+
         if len(indices_valid_z) == 0:
             continue
-            
+
         p_cam_valid = p_cam[indices_valid_z]
         projections = shot.camera.project_many(p_cam_valid)
-        
+
         w = shot.camera.width
         h = shot.camera.height
         normalizer = max(w, h)
-        
+
         px = projections[:, 0] * normalizer + w / 2.0
         py = projections[:, 1] * normalizer + h / 2.0
-        
+
         in_view = (px >= 0) & (px < w) & (py >= 0) & (py < h)
         counts[indices_valid_z[in_view]] += 1
-    
+
     norm_counts = np.clip(counts, COVERAGE_MIN_COUNT, COVERAGE_MAX_COUNT)
-    norm_counts = (norm_counts - COVERAGE_MIN_COUNT) / (COVERAGE_MAX_COUNT - COVERAGE_MIN_COUNT)
-    
+    norm_counts = (norm_counts - COVERAGE_MIN_COUNT) / \
+        (COVERAGE_MAX_COUNT - COVERAGE_MIN_COUNT)
+
     colors = COVERAGE_CMAP(norm_counts)
     vertex_colors = (colors[:, :3] * 255).astype(np.uint8)
 
     drawer.log_coverage_map(vertices, vertex_colors, indices)
-    logger.info(f"Exported coverage map with {len(vertices)} vertices")
\ No newline at end of file
+    logger.info(f"Exported coverage map with {len(vertices)} vertices")
+
+
+def _sanitize_entity_path_component(value: str, strip_spaces: bool = True) -> str:
+    # Rerun entity paths use "/" as hierarchy separator.
+    sanitized = value.replace("/", "_")
+    if strip_spaces:
+        sanitized = sanitized.replace(" ", "_")
+    return sanitized
+
+
+def _try_load_image_as_numpy(data: DataSet, path: str) -> Optional[np.ndarray]:
+    if not data.io_handler.isfile(path):
+        return None
+    try:
+        with data.io_handler.open_rb(path) as f:
+            raw = f.read()
+        img = PILImage.open(BytesIO(raw))
+        if img.mode not in ("RGB", "RGBA"):
+            img = img.convert("RGB")
+        return np.array(img)
+    except Exception as e:
+        logger.warning(f"Failed to load image {path}: {e}")
+        return None
+
+
+def _log_dataframe(path: str, columns: Dict[str, Sequence[Any]], *, static: bool = True) -> None:
+    """
+    Log a dataframe in the way expected by `DataframeView` (Selection View).
+
+    Columns must be equal-length sequences (pad with None if needed).
+    """
+    if not columns:
+        return
+
+    cols: Dict[str, List[Any]] = {k: list(v) for k, v in columns.items()}
+    max_len = max((len(v) for v in cols.values()), default=0)
+    for k, v in cols.items():
+        if len(v) < max_len:
+            v.extend([None] * (max_len - len(v)))
+
+    # Convert dict to a Markdown Table string
+    header = "| " + " | ".join(cols.keys()) + " |"
+    separator = "| " + \
+        " | ".join([":---"] + ["---:"] * (len(cols) - 1)) + " |"
+    body = []
+    for i in range(max_len):
+        cells = []
+        for v in cols.values():
+            val = v[i]
+            if isinstance(val, (float, np.floating)):
+                cells.append(f"{val:.2f}")
+            else:
+                cells.append(str(val) if val is not None else "")
+        body.append("| " + " | ".join(cells) + " |")
+    md_table = "\n".join([header, separator] + body)
+
+    rr.log(path, rr.TextDocument(
+        md_table, media_type="text/markdown"), static=True)

From 553d588e84f8dd784dc4e84ec19c30f3b89c4854 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:09:40 +0100
Subject: [PATCH 214/235] clean: remove unused functions

---
 opensfm/reconstruction.py                     |  65 -------
 .../test_reconstruction_shot_neighborhood.py  | 171 ------------------
 2 files changed, 236 deletions(-)
 delete mode 100644 opensfm/test/test_reconstruction_shot_neighborhood.py

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 04c8249b2..cc5eb886d 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -131,71 +131,6 @@ def bundle_local(
     return pt_ids, report
 
 
-def shot_neighborhood(
-    reconstruction: types.Reconstruction,
-    central_shot_id: str,
-    radius: int,
-    min_common_points: int,
-    max_interior_size: int,
-) -> Tuple[Set[str], Set[str]]:
-    """Reconstructed shots near a given shot.
-
-    Returns:
-        a tuple with interior and boundary:
-        - interior: the list of shots at distance smaller than radius
-        - boundary: shots sharing at least on point with the interior
-
-    Central shot is at distance 0.  Shots at distance n + 1 share at least
-    min_common_points points with shots at distance n.
-    """
-    max_boundary_size = 1000000
-    interior = {central_shot_id}
-    for _distance in range(1, radius):
-        remaining = max_interior_size - len(interior)
-        if remaining <= 0:
-            break
-        neighbors = direct_shot_neighbors(
-            reconstruction, interior, min_common_points, remaining
-        )
-        interior.update(neighbors)
-    boundary = direct_shot_neighbors(
-        reconstruction, interior, 1, max_boundary_size)
-    return interior, boundary
-
-
-def direct_shot_neighbors(
-    reconstruction: types.Reconstruction,
-    shot_ids: Set[str],
-    min_common_points: int,
-    max_neighbors: int,
-) -> Set[str]:
-    """Reconstructed shots sharing reconstructed points with a shot set."""
-    points = set()
-    for shot_id in shot_ids:
-        shot = reconstruction.shots[shot_id]
-        valid_landmarks = shot.get_valid_landmarks()
-        for track in valid_landmarks:
-            if track.id in reconstruction.points:
-                points.add(track)
-
-    candidate_shots = set(reconstruction.shots) - set(shot_ids)
-    common_points = defaultdict(int)
-    for track in points:
-        neighbors = track.get_observations()
-        for neighbor in neighbors:
-            if neighbor.id in candidate_shots:
-                common_points[neighbor] += 1
-
-    pairs = sorted(common_points.items(), key=lambda x: -x[1])
-    neighbors = set()
-    for neighbor, num_points in pairs[:max_neighbors]:
-        if num_points >= min_common_points:
-            neighbors.add(neighbor.id)
-        else:
-            break
-    return neighbors
-
-
 def pairwise_reconstructability(common_tracks: int, rotation_inliers: int) -> float:
     """Likeliness of an image pair giving a good initial reconstruction."""
     outliers = common_tracks - rotation_inliers
diff --git a/opensfm/test/test_reconstruction_shot_neighborhood.py b/opensfm/test/test_reconstruction_shot_neighborhood.py
deleted file mode 100644
index 7af4dd8b2..000000000
--- a/opensfm/test/test_reconstruction_shot_neighborhood.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# pyre-strict
-from typing import List
-
-from opensfm import pygeometry, pymap, pysfm, reconstruction, types
-
-
-def _add_shot(rec: types.Reconstruction, shot_id: str, cam: pygeometry.Camera) -> None:
-    rec.create_shot(shot_id, cam.id)
-
-
-def _add_point(
-    rec: types.Reconstruction, point_id: str, observations: List[str]
-) -> None:
-    rec.create_point(point_id)
-    for shot_id in observations:
-        obs = pymap.Observation(100, 200, 0.5, 255, 0, 0, int(point_id))
-        rec.add_observation(shot_id, point_id, obs)
-
-
-def test_shot_neighborhood_linear_graph() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    _add_shot(rec, "im0", cam)
-    for i in range(1, 4):
-        p, n = "im" + str(i - 1), "im" + str(i)
-        _add_shot(rec, n, cam)
-        _add_point(rec, str(i), [p, n])
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im2", radius=1, min_common_points=1, max_interior_size=10
-    )
-    assert interior == {"im2"}
-    assert boundary == {"im1", "im3"}
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im2", radius=2, min_common_points=1, max_interior_size=10
-    )
-    assert interior == {"im1", "im2", "im3"}
-    assert boundary == {"im0"}
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im2", radius=3, min_common_points=1, max_interior_size=10
-    )
-    assert interior == {"im0", "im1", "im2", "im3"}
-    assert boundary == set()
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im2", radius=3, min_common_points=1, max_interior_size=3
-    )
-    assert interior == {"im1", "im2", "im3"}
-    assert boundary == {"im0"}
-
-
-def test_shot_neighborhood_linear_graph_cpp() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    _add_shot(rec, "im0", cam)
-    for i in range(1, 4):
-        p, n = "im" + str(i - 1), "im" + str(i)
-        _add_shot(rec, n, cam)
-        _add_point(rec, str(i), [p, n])
-
-    interior1, boundary1 = pysfm.BAHelpers.shot_neighborhood_ids(
-        rec.map, "im2", 1, 1, 10
-    )
-    assert interior1 == {"im2"}
-    assert boundary1 == {"im1", "im3"}
-
-    interior2, boundary2 = pysfm.BAHelpers.shot_neighborhood_ids(
-        rec.map, "im2", 2, 1, 10
-    )
-    assert interior2 == {"im1", "im2", "im3"}
-    assert boundary2 == {"im0"}
-
-    interior3, boundary3 = pysfm.BAHelpers.shot_neighborhood_ids(
-        rec.map, "im2", 3, 1, 10
-    )
-    assert interior3 == {"im0", "im1", "im2", "im3"}
-    assert boundary3 == set()
-
-    interior4, boundary4 = pysfm.BAHelpers.shot_neighborhood_ids(
-        rec.map, "im2", 3, 1, 3
-    )
-    assert interior4 == {"im1", "im2", "im3"}
-    assert boundary4 == {"im0"}
-
-
-def test_shot_neighborhood_complete_graph() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    for i in range(4):
-        _add_shot(rec, "im" + str(i), cam)
-    _add_point(rec, "1", rec.shots.keys())
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im2", radius=2, min_common_points=1, max_interior_size=10
-    )
-    assert interior == {"im0", "im1", "im2", "im3"}
-    assert boundary == set()
-
-
-def test_shot_neighborhood_sorted_results() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    _add_shot(rec, "im0", cam)
-    _add_shot(rec, "im1", cam)
-    _add_shot(rec, "im2", cam)
-    _add_point(rec, "1", ["im0", "im1"])
-    _add_point(rec, "2", ["im0", "im1"])
-    _add_point(rec, "3", ["im0", "im2"])
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im0", radius=2, min_common_points=1, max_interior_size=2
-    )
-    assert interior == {"im0", "im1"}
-    assert boundary == {"im2"}
-
-    _add_point(rec, "4", ["im0", "im2"])
-    _add_point(rec, "5", ["im0", "im2"])
-
-    interior, boundary = reconstruction.shot_neighborhood(
-        rec, "im0", radius=2, min_common_points=1, max_interior_size=2
-    )
-    assert interior == {"im0", "im2"}
-    assert boundary == {"im1"}
-
-
-def test_shot_neighborhood_complete_graph_cpp() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    for i in range(4):
-        _add_shot(rec, "im" + str(i), cam)
-    _add_point(rec, "1", rec.shots.keys())
-
-    interior, boundary = pysfm.BAHelpers.shot_neighborhood_ids(rec.map, "im2", 2, 1, 10)
-    assert interior == {"im0", "im1", "im2", "im3"}
-    assert boundary == set()
-
-
-def test_shot_neighborhood_sorted_results_cpp() -> None:
-    rec = types.Reconstruction()
-    cam = pygeometry.Camera.create_perspective(0.5, 0, 0)
-    cam.id = "cam1"
-    rec.add_camera(cam)
-    _add_shot(rec, "im0", cam)
-    _add_shot(rec, "im1", cam)
-    _add_shot(rec, "im2", cam)
-    _add_point(rec, "1", ["im0", "im1"])
-    _add_point(rec, "2", ["im0", "im1"])
-    _add_point(rec, "3", ["im0", "im2"])
-
-    interior, boundary = pysfm.BAHelpers.shot_neighborhood_ids(rec.map, "im0", 2, 1, 2)
-    assert interior == {"im0", "im1"}
-    assert boundary == {"im2"}
-
-    _add_point(rec, "4", ["im0", "im2"])
-    _add_point(rec, "5", ["im0", "im2"])
-
-    interior, boundary = pysfm.BAHelpers.shot_neighborhood_ids(rec.map, "im0", 2, 1, 2)
-    assert interior == {"im0", "im2"}
-    assert boundary == {"im1"}

From 12d69dc15b3b28837a4857a84903ea2733523daa Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:11:57 +0100
Subject: [PATCH 215/235] feat: add total used memory during reconstruction

---
 opensfm/reconstruction.py | 141 ++++++++++++++++++++------------------
 opensfm/tracking.py       |  23 +++----
 2 files changed, 83 insertions(+), 81 deletions(-)

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index cc5eb886d..55067385e 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -141,47 +141,24 @@ def pairwise_reconstructability(common_tracks: int, rotation_inliers: int) -> fl
         return 0
 
 
-TPairArguments = Tuple[
-    str, str, NDArray, NDArray, pygeometry.Camera, pygeometry.Camera, float
-]
-
-
-def compute_image_pairs(
-    track_dict: Dict[Tuple[str, str], tracking.TPairTracks], data: DataSetBase
-) -> List[Tuple[str, str]]:
-    """All matched image pairs sorted by reconstructability."""
-    cameras = data.load_camera_models()
-    args = _pair_reconstructability_arguments(track_dict, cameras, data)
-    processes = data.config["processes"]
-    result = parallel_map(_compute_pair_reconstructability, args, processes)
-    result = list(result)
-    pairs = [(im1, im2) for im1, im2, r in result if r > 0]
-    score = [r for im1, im2, r in result if r > 0]
-    order = np.argsort(-np.array(score))
-    return [pairs[o] for o in order]
-
-
-def _pair_reconstructability_arguments(
-    track_dict: Dict[Tuple[str, str], tracking.TPairTracks],
-    cameras: Dict[str, pygeometry.Camera],
-    data: DataSetBase,
-) -> List[TPairArguments]:
-    threshold = 4 * data.config["five_point_algo_threshold"]
-    args = []
-    for (im1, im2), (_, p1, p2) in track_dict.items():
-        camera1 = cameras[data.load_exif(im1)["camera"]]
-        camera2 = cameras[data.load_exif(im2)["camera"]]
-        args.append((im1, im2, p1, p2, camera1, camera2, threshold))
-    return args
-
-
-def _compute_pair_reconstructability(args: TPairArguments) -> Tuple[str, str, float]:
-    im1, im2, p1, p2, camera1, camera2, threshold = args
+def calculate_pair_reconstructability(
+    tracks_manager: pymap.TracksManager,
+    im1: str,
+    im2: str,
+    camera1: pygeometry.Camera,
+    camera2: pygeometry.Camera,
+    threshold: float,
+) -> float:
+    p1, p2 = _get_common_feature_arrays(tracks_manager, im1, im2)
     R, inliers = two_view_reconstruction_rotation_only(
         p1, p2, camera1, camera2, threshold
     )
-    r = pairwise_reconstructability(len(p1), len(inliers))
-    return (im1, im2, r)
+    return pairwise_reconstructability(len(p1), len(inliers))
+
+
+TPairArguments = Tuple[
+    str, str, NDArray, NDArray, pygeometry.Camera, pygeometry.Camera, float
+]
 
 
 def add_shot(
@@ -1716,14 +1693,8 @@ def _get_common_feature_arrays(
     im2: str,
 ) -> Tuple[NDArray, NDArray]:
     """Return the feature arrays of common tracks between two images."""
-    features1 = []
-    features2 = []
-    for _, p1, p2 in tracks_manager.get_all_common_observations(im1, im2):
-        features1.append(p1.point)
-        features2.append(p2.point)
-    features1 = np.array(features1)
-    features2 = np.array(features2)
-    return (features1, features2)
+    _, p1, p2 = tracks_manager.get_all_common_observations_arrays(im1, im2)
+    return p1, p2
 
 
 def compute_image_pairs_sequential(
@@ -1742,19 +1713,66 @@ def compute_image_pairs_sequential(
     for (im1, im2), size in connectivity.items():
         if size < min_common:
             continue
-        features1, features2 = _get_common_feature_arrays(
-            tracks_manager, im1, im2)
         camera1 = cameras[data.load_exif(im1)["camera"]]
         camera2 = cameras[data.load_exif(im2)["camera"]]
-        result = _compute_pair_reconstructability(
-            (im1, im2, features1, features2, camera1, camera2, threshold)
+        r = calculate_pair_reconstructability(
+            tracks_manager, im1, im2, camera1, camera2, threshold
         )
-        if result[2] > 0:
-            results.append(result)
+        if r > 0:
+            results.append((im1, im2, r))
     results.sort(key=lambda x: x[2], reverse=True)
     return [(im1, im2) for im1, im2, _ in results]
 
 
+def compute_image_pairs_with_reconstructability_parallel(
+    data: DataSetBase,
+    tracks_manager: pymap.TracksManager,
+    min_common: int = 50,
+) -> List[Tuple[str, str]]:
+    """Compute all possible pairs of images that share at least `min_common` points.
+
+    This runs in parallel and fuses the feature extraction and reconstructability
+    computation to save memory.
+    """
+    cameras = data.load_camera_models()
+    threshold = 4 * data.config["five_point_algo_threshold"]
+
+    shot_ids = tracks_manager.get_shot_ids()
+    shot_to_camera_id = {}
+    for shot in shot_ids:
+        shot_to_camera_id[shot] = data.load_exif(shot)["camera"]
+
+    def process_pair(pair):
+        im1, im2, size = pair
+        if size < min_common:
+            return None
+
+        camera1 = cameras[shot_to_camera_id[im1]]
+        camera2 = cameras[shot_to_camera_id[im2]]
+
+        r = calculate_pair_reconstructability(
+            tracks_manager, im1, im2, camera1, camera2, threshold
+        )
+        if r > 0:
+            return (im1, im2, r)
+        return None
+
+    logger.debug("Computing pairwise connectivity of images")
+    all_pairs_connectivity = tracks_manager.get_all_pairs_connectivity()
+    pairs = [(k[0], k[1], v) for k, v in all_pairs_connectivity.items()]
+
+    logger.debug(
+        f"Computing pairwise reconstructability with {data.config['processes']} processes")
+    processes = data.config["processes"]
+    batch_size = max(1, len(pairs) // (2 * processes))
+
+    results = context.parallel_map(process_pair, pairs, processes, batch_size)
+
+    valid_results = [r for r in results if r is not None]
+    valid_results.sort(key=lambda x: x[2], reverse=True)
+    return [(im1, im2) for im1, im2, _ in valid_results]
+
+
 def incremental_reconstruction(
     data: DataSetBase, tracks_manager: pymap.TracksManager
 ) -> Tuple[Dict[str, Any], List[types.Reconstruction]]:
@@ -1773,13 +1791,10 @@ def incremental_reconstruction(
 
     common_tracks = None
     if data.config["processes"] > 1:
-        # Get pairs in parallel, preload all features for all
-        # pairs of image. Features of an image can be stored
-        # repeatedly in multiple image pairs.
-        # Pros: fast; Cons: high memory usage
-        common_tracks = tracking.all_common_tracks_with_features(
-            tracks_manager, processes=data.config["processes"])
-        pairs = compute_image_pairs(common_tracks, data)
+        # Get pairs in parallel, computing reconstructability on the fly.
+        # Pros: fast, low memory usage
+        pairs = compute_image_pairs_with_reconstructability_parallel(
+            data, tracks_manager)
     else:
         # Get pairs sequentially, load features lazily.
         # Pros: low memory usage; Cons: slow
@@ -1794,13 +1809,7 @@ def incremental_reconstruction(
         if im1 in remaining_images and im2 in remaining_images:
             rec_report = {}
             report["reconstructions"].append(rec_report)
-            if common_tracks is not None:
-                # Save time if the common features are preloaded
-                _, p1, p2 = common_tracks[im1, im2]
-            else:
-                # At the sacrifice of lazily reloading the features, we avoid
-                # storing features for all view pairs in memory
-                p1, p2 = _get_common_feature_arrays(tracks_manager, im1, im2)
+            p1, p2 = _get_common_feature_arrays(tracks_manager, im1, im2)
             reconstruction, rec_report["bootstrap"] = bootstrap_reconstruction(
                 data, tracks_manager, im1, im2, p1, p2
             )
diff --git a/opensfm/tracking.py b/opensfm/tracking.py
index 2fbc0e196..a6298574e 100644
--- a/opensfm/tracking.py
+++ b/opensfm/tracking.py
@@ -42,7 +42,8 @@ def load_one(im):
         return im, features, colors, segmentations, instances, depths
 
     # Use context.parallel_map for parallel loading
-    results = context.parallel_map(load_one, images, dataset.config.get("processes", 1))
+    results = context.parallel_map(
+        load_one, images, dataset.config.get("processes", 1))
 
     features = {}
     colors = {}
@@ -124,7 +125,8 @@ def create_tracks_manager_from_matches_iter(
                 else NO_VALUE
             )
             instance = (
-                int(instances[image][featureid]) if image in instances else NO_VALUE
+                int(instances[image][featureid]
+                    ) if image in instances else NO_VALUE
             )
 
             obs = pymap.Observation(
@@ -227,17 +229,6 @@ def common_tracks(
 TPairTracks = Tuple[List[str], NDArray[np.float64], NDArray[np.float64]]
 
 
-def all_common_tracks_with_features(
-    tracks_manager: pymap.TracksManager,
-    min_common: int = 50,
-    processes: int = 1,
-) -> Dict[Tuple[str, str], TPairTracks]:
-    tracks = all_common_tracks(
-        tracks_manager, include_features=True, min_common=min_common, processes=processes
-    )
-    return cast(Dict[Tuple[str, str], TPairTracks], tracks)
-
-
 def all_common_tracks_without_features(
     tracks_manager: pymap.TracksManager,
     min_common: int = 50,
@@ -271,7 +262,8 @@ def process_pair(pair):
         im1, im2, size = pair
         if size < min_common:
             return None
-        track_ids, points1, points2 = tracks_manager.get_all_common_observations_arrays(im1, im2)
+        track_ids, points1, points2 = tracks_manager.get_all_common_observations_arrays(
+            im1, im2)
         if include_features:
             return (
                 (im1, im2),
@@ -281,7 +273,8 @@ def process_pair(pair):
             return ((im1, im2), track_ids,)
 
     logger.debug("Computing pairwise connectivity of images")
-    pairs = [(k[0], k[1], v) for k, v in tracks_manager.get_all_pairs_connectivity().items()]
+    pairs = [(k[0], k[1], v)
+             for k, v in tracks_manager.get_all_pairs_connectivity().items()]
 
     logger.debug(f"Gathering pairwise tracks with {processes} processes")
     batch_size = max(1, len(pairs) // (2 * processes))

From 6c72370aed451cac2c93bdbe9cd4164a9439c9cd Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:15:48 +0100
Subject: [PATCH 216/235] fix: ensure altitude computation always work :
 exhaustive minima search + polyfit near the minima

---
 opensfm/pairs_selection.py           | 71 ++++++++++++++++++++--------
 opensfm/test/test_pairs_selection.py |  2 +-
 2 files changed, 51 insertions(+), 22 deletions(-)

diff --git a/opensfm/pairs_selection.py b/opensfm/pairs_selection.py
index 194764883..75a5065d5 100644
--- a/opensfm/pairs_selection.py
+++ b/opensfm/pairs_selection.py
@@ -39,14 +39,15 @@ def get_gps_point(
     altitude = 0
     direction = np.array([0, 0, 1])
     return (
-        np.array(reference.to_topocentric(gps["latitude"], gps["longitude"], altitude)),
+        np.array(reference.to_topocentric(
+            gps["latitude"], gps["longitude"], altitude)),
         direction,
     )
 
 
 DEFAULT_Z = 1.0
 MAXIMUM_Z = 8000
-SAMPLE_Z = 100
+SAMPLE_Z = 25
 
 
 def sign(x: float) -> float:
@@ -85,23 +86,42 @@ def find_best_altitude(
     directions_base = np.array([p for p in directions.values()])
     origin_base = np.array([p for p in origin.values()])
 
-    samples_x, samples_y = [], []
-    for current_z in range(1, MAXIMUM_Z, SAMPLE_Z):
+    samples = []
+    for i, current_z in enumerate(range(1, MAXIMUM_Z, SAMPLE_Z)):
         scaled = origin_base + directions_base / DEFAULT_Z * current_z
         current_size = (np.max(scaled[:, 0]) - np.min(scaled[:, 0])) ** 2 + (
             np.max(scaled[:, 1]) - np.min(scaled[:, 1])
         ) ** 2
-        samples_x.append(current_z)
-        samples_y.append(current_size)
+        samples.append((current_z, current_size, i))
 
-    coeffs = np.polyfit(samples_x, samples_y, 2)
-    extrema = -coeffs[1] / (2 * coeffs[0])
-    if extrema < 0:
+    # Find the minima manually
+    min_z, min_size, index = min(samples, key=lambda t: t[1])
+    logger.info(
+        f"Minimum found at sampling altitude {min_z} with size {min_size}")
+
+    if index == 0 or index == len(samples) - 1:
+        logger.info(
+            f"Altitude extrema is at the boundary of search space. Using default altitude of {DEFAULT_Z}"
+        )
+        return DEFAULT_Z
+
+    # Refine with polynomial fitting
+    before = max(0, index - 1)
+    after = min(len(samples) - 1, index + 1)
+    coeffs = np.polyfit(
+        [samples[i][0] for i in range(before, after + 1)],
+        [samples[i][1] for i in range(before, after + 1)],
+        2,
+    )
+    real_minimum = -coeffs[1] / (2 * coeffs[0])
+    logger.info(f"Refined altitude extrema at {real_minimum}")
+
+    if real_minimum < 0:
         logger.info(
-            f"Altitude is negative ({extrema}) : viewing directions are probably divergent. Using default altitude of {DEFAULT_Z}"
+            f"Altitude is negative ({real_minimum}) : viewing directions are probably divergent. Using default altitude of {DEFAULT_Z}"
         )
-        extrema = DEFAULT_Z
-    return extrema
+        real_minimum = DEFAULT_Z
+    return real_minimum
 
 
 def get_representative_points(
@@ -137,12 +157,14 @@ def get_representative_points(
             raise RuntimeError(
                 f"GPS / OPK / YPR {has_gps, has_opk, has_ypr} tag combination unsupported"
             )
-        origin[image], directions[image] = map_method[method_id](exif, reference)
+        origin[image], directions[image] = map_method[method_id](
+            exif, reference)
 
     if had_orientation:
         altitude = find_best_altitude(origin, directions)
         logger.info(f"Altitude for orientation based matching {altitude}")
-        directions_scaled = {k: v / DEFAULT_Z * altitude for k, v in directions.items()}
+        directions_scaled = {k: v / DEFAULT_Z *
+                             altitude for k, v in directions.items()}
         points = {k: origin[k] + directions_scaled[k] for k in images}
     else:
         points = origin
@@ -179,9 +201,11 @@ def match_candidates_by_distance(
 
     # we don't want to loose some images because of missing GPS :
     # either ALL of them or NONE of them are used for getting pairs
-    difference = abs(len(representative_points) - len(set(images_cand + images_ref)))
+    difference = abs(len(representative_points) -
+                     len(set(images_cand + images_ref)))
     if difference > 0:
-        logger.warning(f"Couldn't fetch {difference} images. Returning NO pairs.")
+        logger.warning(
+            f"Couldn't fetch {difference} images. Returning NO pairs.")
         return set()
 
     points = np.zeros((len(representative_points), 3))
@@ -273,7 +297,8 @@ def produce_edges(
     # will only produce one diagonal edge, so by jittering it, we get more
     # chances of getting such diagonal edges and having more diversity
     for _ in range(rounds):
-        points_current = copy.copy(points) + np.random.rand(*points.shape) * scale
+        points_current = copy.copy(
+            points) + np.random.rand(*points.shape) * scale
         triangles = spatial.Delaunay(points_current).simplices
         for (image1, image2), _ in produce_edges(triangles):
             pairs.add((image1, image2))
@@ -479,7 +504,8 @@ def construct_pairs(
             pairs.update(
                 # pyre-fixme[6]: For 4th argument expected `List[int]` but got
                 #  `ndarray[typing.Any, dtype[typing.Any]]`.
-                pairs_from_neighbors(im, exifs, distances, order, other, max_neighbors)
+                pairs_from_neighbors(im, exifs, distances,
+                                     order, other, max_neighbors)
             )
         else:
             for i in order[:max_neighbors]:
@@ -636,7 +662,8 @@ def match_candidates_from_metadata(
         o = set()
         b = set()
         v = set()
-        pairs = {sorted_pair(i, j) for i in images_ref for j in images_cand if i != j}
+        pairs = {sorted_pair(i, j)
+                 for i in images_ref for j in images_cand if i != j}
     else:
         d = match_candidates_by_distance(
             images_ref, images_cand, exifs, reference, gps_neighbors, max_distance
@@ -644,7 +671,8 @@ def match_candidates_from_metadata(
         g = match_candidates_by_graph(
             images_ref, images_cand, exifs, reference, graph_rounds
         )
-        t = match_candidates_by_time(images_ref, images_cand, exifs, time_neighbors)
+        t = match_candidates_by_time(
+            images_ref, images_cand, exifs, time_neighbors)
         o = match_candidates_by_order(images_ref, images_cand, order_neighbors)
         b = match_candidates_with_bow(
             data,
@@ -711,7 +739,8 @@ def load_histograms(data: DataSetBase, images: Iterable[str]) -> Dict[str, NDArr
     histograms = {}
     bows = bow.load_bows(data.config)
     for im in images:
-        filtered_words = feature_loader.instance.load_words(data, im, masked=True)
+        filtered_words = feature_loader.instance.load_words(
+            data, im, masked=True)
         if filtered_words is None:
             logger.error("No words in image {}".format(im))
             continue
diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index dd8d0c5b8..ca43f14e8 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -171,7 +171,7 @@ def test_find_best_altitude_convergent() -> None:
         "1": np.array([1.0, 0.0, -1.0]),
     }
     altitude = pairs_selection.find_best_altitude(origins, directions)
-    assert np.allclose([altitude], [2.0], atol=1e-2)
+    assert np.allclose([altitude], [1.0], atol=1e-2)
 
 
 def test_find_best_altitude_divergent() -> None:

From a151a94eeb295149f2df1a88ade27056a6755d8b Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:16:26 +0100
Subject: [PATCH 217/235] feat: log memory used during reconstruction stage

---
 opensfm/context.py        | 17 ++++++++++++++---
 opensfm/reconstruction.py | 16 +++++++++++++---
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/opensfm/context.py b/opensfm/context.py
index 4cf7558ef..9386d4375 100644
--- a/opensfm/context.py
+++ b/opensfm/context.py
@@ -18,7 +18,8 @@
 
 abspath: str = os.path.dirname(os.path.realpath(__file__))
 SENSOR_DATA: str = os.path.join(abspath, "data", "sensor_data.json")
-CAMERA_CALIBRATION: str = os.path.join(abspath, "data", "camera_calibration.yaml")
+CAMERA_CALIBRATION: str = os.path.join(
+    abspath, "data", "camera_calibration.yaml")
 BOW_PATH: str = os.path.join(abspath, "data", "bow")
 
 
@@ -26,7 +27,8 @@
 OPENCV5: bool = int(cv2.__version__.split(".")[0]) >= 5
 OPENCV4: bool = int(cv2.__version__.split(".")[0]) >= 4
 OPENCV44: bool = (
-    int(cv2.__version__.split(".")[0]) == 4 and int(cv2.__version__.split(".")[1]) >= 4
+    int(cv2.__version__.split(".")[0]) == 4 and int(
+        cv2.__version__.split(".")[1]) >= 4
 )
 OPENCV3: bool = int(cv2.__version__.split(".")[0]) >= 3
 
@@ -61,7 +63,8 @@ def parallel_map(
             batch_size = (
                 min(batch_size, max_batch_size) if max_batch_size else batch_size
             )
-            res = Parallel(batch_size=batch_size)(delayed(func)(arg) for arg in args)
+            res = Parallel(batch_size=batch_size)(
+                delayed(func)(arg) for arg in args)
 
     cv2.setNumThreads(threads_used)
     return res
@@ -126,6 +129,14 @@ def current_memory_usage() -> int:
         return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * rusage_unit
 
 
+def log_memory(stage: str) -> int:
+    """Log memory usage at a given stage and return usage in KB."""
+    mem_kb = current_memory_usage()
+    mem_gb = mem_kb / 1024 / 1024 / 1024
+    logger.info(f"[Memory] {stage}: {mem_gb:.1f} GB")
+    return mem_kb
+
+
 def processes_that_fit_in_memory(desired: int, per_process: int) -> int:
     """Amount of parallel BoW process that fit in memory."""
     available_mem = memory_available()
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 55067385e..113de5882 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -28,7 +28,7 @@
     types,
 )
 from opensfm.align import align_reconstruction, apply_similarity
-from opensfm.context import current_memory_usage, parallel_map
+from opensfm import context
 from opensfm.dataset_base import DataSetBase
 
 
@@ -538,7 +538,7 @@ def reconstruction_from_relative_pose(
     )
 
     report["decision"] = "Success"
-    report["memory_usage"] = current_memory_usage()
+    report["memory_usage"] = context.current_memory_usage()
     return reconstruction, report
 
 
@@ -1442,6 +1442,9 @@ def grow_reconstruction(
     config = data.config
     report = {"steps": []}
 
+    initial_memory = context.log_memory("grow_reconstruction start")
+    report["initial_memory_usage"] = initial_memory
+
     camera_priors = data.load_camera_models()
     rig_camera_priors = data.load_rig_cameras()
 
@@ -1525,7 +1528,7 @@ def grow_reconstruction(
             step: Dict[str, Union[List[int], List[str], int, List[int], Any]] = {
                 "images": list(new_shots),
                 "resection": resrep,
-                "memory_usage": current_memory_usage(),
+                "memory_usage": context.current_memory_usage(),
             }
             report["steps"].append(step)
 
@@ -1613,6 +1616,13 @@ def grow_reconstruction(
         logger.info("Removed isolated: {}".format(isolated))
 
     paint_reconstruction(data, tracks_manager, reconstruction)
+    final_memory = context.log_memory("grow_reconstruction end")
+    report["final_memory_usage"] = final_memory
+    report["memory_delta"] = final_memory - initial_memory
+    logger.info(
+        f"[Memory] Total memory change during grow_reconstruction: "
+        f"{(final_memory - initial_memory) / 1024 / 1024:.1f} GB"
+    )
     return reconstruction, report
 
 

From dd1578c31471a6cabb9b894e5e10f6ce57754fe0 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:18:34 +0100
Subject: [PATCH 218/235] fix: one last fix for GCP weighting : that one
 actually improves !

---
 opensfm/config.py                 |  2 +-
 opensfm/src/sfm/src/ba_helpers.cc | 25 ++++++++++++++-----------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index 9a1915d24..a07d6bf3d 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -267,7 +267,7 @@ class OpenSfMConfig:
     # The default vertical standard deviation of the GCPs (in meters)
     gcp_vertical_sd: float = 0.1
     # Global weight for GCPs, expressed a ratio of the sum of (# projections) + (# shots) + (# relative motions)
-    gcp_global_weight: float = 0.1
+    gcp_global_weight: float = 0.04
     # The standard deviation of the rig translation
     rig_translation_sd: float = 0.1
     # The standard deviation of the rig rotation
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 06925b73b..51d460414 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -390,7 +390,6 @@ size_t BAHelpers::AddGCPToBundle(
   const auto& reference = map.GetTopocentricConverter();
   const auto& shots = map.GetShots();
 
-
   const float reproj_threshold =
       config["gcp_reprojection_error_threshold"].cast<float>();
 
@@ -417,15 +416,15 @@ size_t BAHelpers::AddGCPToBundle(
       }
     }
 
-    if(!valid_shots) {
+    if (!valid_shots) {
       continue;
     }
     avg_observations /= valid_shots;
-    const double weight_factor =  std::sqrt(std::max(1.0, avg_observations));
-
+    const double weight_factor = std::sqrt(std::max(1.0, avg_observations));
 
-    const double prior_balance = std::sqrt(std::max(1.0, (double)valid_shots));
-    const double prior_weight = config["gcp_global_weight"].cast<double>() * weight_factor * prior_balance;
+    const double prior_balance = std::max(1.0, (double)valid_shots);
+    const double prior_weight = config["gcp_global_weight"].cast<double>() *
+                                weight_factor * prior_balance;
     constexpr auto point_constant{false};
     ba.AddPoint(point_id, coordinates, point_constant);
     if (!point.lla_.empty()) {
@@ -437,13 +436,14 @@ size_t BAHelpers::AddGCPToBundle(
     }
 
     // Now iterate through the observations
-    const double obs_weight = config["gcp_global_weight"].cast<double>() * weight_factor;
+    const double obs_weight = config["gcp_global_weight"].cast<double>() *
+                              weight_factor * prior_balance;
     for (const auto& obs : point.observations_) {
       const auto& shot_id = obs.shot_id_;
       if (shots.count(shot_id) > 0) {
         constexpr double scale{0.001};
         ba.AddPointProjectionObservation(shot_id, point_id, obs.projection_,
-                                         scale  / obs_weight);
+                                         scale / obs_weight);
         ++added_gcp_observations;
       }
     }
@@ -955,13 +955,13 @@ void BAHelpers::BundleToMap(const bundle::BundleAdjuster& bundle_adjuster,
 
   // Update points
   for (auto& point : output_map.GetLandmarks()) {
-    if(!bundle_adjuster.HasPoint(point.first)) {
+    if (!bundle_adjuster.HasPoint(point.first)) {
       continue;
     }
     auto pt = bundle_adjuster.GetPoint(point.first);
     if (!pt.GetValue().allFinite()) {
       // set large reprojection errors
-      for(auto& proj_error : pt.reprojection_errors) {
+      for (auto& proj_error : pt.reprojection_errors) {
         proj_error.second.setConstant(1.0);
       }
     }
@@ -997,7 +997,10 @@ void BAHelpers::AlignmentConstraints(
         continue;
       }
       Vec3d coordinates;
-      if (TriangulateGCP(point, shots, config["gcp_reprojection_error_threshold"].cast<float>(), coordinates)) {
+      if (TriangulateGCP(
+              point, shots,
+              config["gcp_reprojection_error_threshold"].cast<float>(),
+              coordinates)) {
         Xp.row(idx) = topocentricConverter.ToTopocentric(point.GetLlaVec3d());
         X.row(idx) = coordinates;
         ++idx;

From d151064c29a062aeddfe320f0a38acee58fdbcd4 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:28:03 +0100
Subject: [PATCH 219/235] fix: fix test

---
 opensfm/test/test_pairs_selection.py              | 2 +-
 opensfm/test/test_reconstruction_triangulation.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/opensfm/test/test_pairs_selection.py b/opensfm/test/test_pairs_selection.py
index ca43f14e8..d9b22cb19 100644
--- a/opensfm/test/test_pairs_selection.py
+++ b/opensfm/test/test_pairs_selection.py
@@ -109,7 +109,7 @@ def test_match_candidates_from_metadata_bow(lund_path: str) -> None:
     )
     data_generation.save_config(config, lund_path)
     data = dataset.DataSet(lund_path)
-    match_candidates_from_metadata(data, assert_count=5)
+    match_candidates_from_metadata(data, assert_count=4)
 
 
 def test_match_candidates_from_metadata_gps(lund_path: str) -> None:
diff --git a/opensfm/test/test_reconstruction_triangulation.py b/opensfm/test/test_reconstruction_triangulation.py
index 5b6a53718..e2dfba95b 100644
--- a/opensfm/test/test_reconstruction_triangulation.py
+++ b/opensfm/test/test_reconstruction_triangulation.py
@@ -40,7 +40,7 @@ def test_reconstruction_triangulation(
     assert 0.01 < errors["absolute_gps_rmse"] < 0.1
 
     # Sanity check that GCP error is similar to the generated gcp_noise
-    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.054
+    assert 0.01 < errors["absolute_gcp_rmse_horizontal"] < 0.056
     assert 0.005 < errors["absolute_gcp_rmse_vertical"] < 0.04
 
     # Check that the GPS bias (only translation) is recovered

From 06a938eaa1793c9af0fe941c93e7e2de79cf5cec Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:40:54 +0100
Subject: [PATCH 220/235] feat: save memory on the tracks amanger : depth as
 float (we don't use it anyway) + distinct storage for Observation and
 std::srtring in separate pool, so we stoee connections as indexes.

---
 opensfm/src/foundation/union_find.h           |   2 +-
 opensfm/src/map/observation.h                 |  10 +-
 opensfm/src/map/python/pybind.cc              |   3 +-
 opensfm/src/map/src/tracks_manager.cc         | 307 +++++++++++-------
 opensfm/src/map/test/tracks_manager_test.cc   |   7 -
 opensfm/src/map/tracks_manager.h              |  46 ++-
 opensfm/src/sfm/python/pybind.cc              |   2 -
 opensfm/src/sfm/src/tracks_helpers.cc         |   7 -
 opensfm/src/sfm/test/tracks_helpers_test.cc   |  10 -
 opensfm/src/sfm/tracks_helpers.h              |   2 -
 .../test/test_reconstruction_incremental.py   |   4 +-
 11 files changed, 233 insertions(+), 167 deletions(-)

diff --git a/opensfm/src/foundation/union_find.h b/opensfm/src/foundation/union_find.h
index a4fb69410..929b7c532 100644
--- a/opensfm/src/foundation/union_find.h
+++ b/opensfm/src/foundation/union_find.h
@@ -50,7 +50,7 @@ std::vector<std::vector<UnionFindElement<T>*>> GetUnionFindClusters(
 
   std::vector<std::vector<UnionFindElement<T>*>> clusters;
   clusters.reserve(aggregations.size());
-  for (const auto agg : aggregations) {
+  for (const auto& agg : aggregations) {
     clusters.emplace_back(agg.second);
   }
 
diff --git a/opensfm/src/map/observation.h b/opensfm/src/map/observation.h
index 80ba6eebd..ac3c6e7a9 100644
--- a/opensfm/src/map/observation.h
+++ b/opensfm/src/map/observation.h
@@ -8,18 +8,18 @@
 namespace map {
 
 struct Depth {
-  double value;
+  float value;
   bool is_radial;
-  double std_deviation;
+  float std_deviation;
 
   Depth() = default;
-  Depth(double value_, bool is_radial_, double std_deviation_)
+  Depth(float value_, bool is_radial_, float std_deviation_)
       : value(value_), is_radial(is_radial_), std_deviation(std_deviation_) {}
 };
 
 struct Observation {
   Observation() = default;
-  Observation(double x, double y, double s, int r, int g, int b, int feature,
+  Observation(double x, double y, float s, int r, int g, int b, int feature,
               int segmentation = NO_SEMANTIC_VALUE,
               int instance = NO_SEMANTIC_VALUE,
               const std::optional<Depth>& depth = std::nullopt)
@@ -38,7 +38,7 @@ struct Observation {
 
   // Mandatory data
   Eigen::Vector2d point;
-  double scale{1.};
+  float scale{1.};
   Eigen::Vector3i color;
   int feature_id{0};
 
diff --git a/opensfm/src/map/python/pybind.cc b/opensfm/src/map/python/pybind.cc
index c8a2d9576..57f470f8f 100644
--- a/opensfm/src/map/python/pybind.cc
+++ b/opensfm/src/map/python/pybind.cc
@@ -291,7 +291,6 @@ PYBIND11_MODULE(pymap, m) {
       .def_static("merge_tracks_manager",
                   &map::TracksManager::MergeTracksManager)
       .def("add_observation", &map::TracksManager::AddObservation)
-      .def("remove_observation", &map::TracksManager::RemoveObservation)
       .def("num_shots", &map::TracksManager::NumShots)
       .def("num_tracks", &map::TracksManager::NumTracks)
       .def("get_shot_ids", &map::TracksManager::GetShotIds)
@@ -308,7 +307,7 @@ PYBIND11_MODULE(pymap, m) {
            py::call_guard<py::gil_scoped_release>())
       .def("get_all_common_observations_arrays",
            &map::TracksManager::GetAllCommonObservationsArrays,
-           py::call_guard<py::gil_scoped_release>())     
+           py::call_guard<py::gil_scoped_release>())
       .def("get_all_pairs_connectivity",
            &map::TracksManager::GetAllPairsConnectivity,
            py::arg("shots") = std::vector<map::ShotId>(),
diff --git a/opensfm/src/map/src/tracks_manager.cc b/opensfm/src/map/src/tracks_manager.cc
index 881dfa2e0..e3c6c23d6 100644
--- a/opensfm/src/map/src/tracks_manager.cc
+++ b/opensfm/src/map/src/tracks_manager.cc
@@ -1,7 +1,10 @@
-#include <foundation/union_find.h>
 #include <foundation/types.h>
+#include <foundation/union_find.h>
 #include <map/tracks_manager.h>
 
+#include <algorithm>
+#include <iostream>
+#include <numeric>
 #include <optional>
 #include <sstream>
 #include <unordered_set>
@@ -183,104 +186,156 @@ map::TracksManager InstanciateFromStreamT(S& fstream) {
 }  // namespace
 
 namespace map {
-void TracksManager::AddObservation(const ShotId& shot_id,
-                                   const TrackId& track_id,
-                                   const Observation& observation) {
-  tracks_per_shot_[shot_id][track_id] = observation;
-  shots_per_track_[track_id][shot_id] = observation;
-}
 
-void TracksManager::RemoveObservation(const ShotId& shot_id,
-                                      const TrackId& track_id) {
-  const auto find_shot = tracks_per_shot_.find(shot_id);
-  if (find_shot == tracks_per_shot_.end()) {
-    throw std::runtime_error("Accessing invalid shot ID");
+TracksManager::StringId TracksManager::GetShotIndex(const ShotId& id) {
+  const auto it = shot_id_to_index_.find(id);
+  if (it == shot_id_to_index_.end()) {
+    throw std::runtime_error("Accessing invalid shot ID: " + id);
   }
-  const auto find_track = shots_per_track_.find(track_id);
-  if (find_track == shots_per_track_.end()) {
-    throw std::runtime_error("Accessing invalid track ID");
-  }
-  find_shot->second.erase(track_id);
-  find_track->second.erase(shot_id);
+  return it->second;
 }
 
-int TracksManager::NumShots() const { return tracks_per_shot_.size(); }
-
-int TracksManager::NumTracks() const { return shots_per_track_.size(); }
+TracksManager::StringId TracksManager::GetTrackIndex(const TrackId& id) {
+  const auto it = track_id_to_index_.find(id);
+  if (it == track_id_to_index_.end()) {
+    throw std::runtime_error("Accessing invalid track ID: " + id);
+  }
+  return it->second;
+}
 
-bool TracksManager::HasShotObservations(const ShotId& shot) const {
-  return tracks_per_shot_.count(shot) > 0;
+TracksManager::StringId TracksManager::GetOrInsertShotIndex(const ShotId& id) {
+  const auto it = shot_id_to_index_.find(id);
+  if (it != shot_id_to_index_.end()) {
+    return it->second;
+  }
+  const StringId idx = shot_ids_.size();
+  shot_ids_.push_back(id);
+  shot_id_to_index_[id] = idx;
+  tracks_per_shot_.emplace_back();
+  return idx;
 }
 
-std::vector<ShotId> TracksManager::GetShotIds() const {
-  std::vector<ShotId> shots;
-  shots.reserve(tracks_per_shot_.size());
-  for (const auto& it : tracks_per_shot_) {
-    shots.push_back(it.first);
+TracksManager::StringId TracksManager::GetOrInsertTrackIndex(
+    const TrackId& id) {
+  const auto it = track_id_to_index_.find(id);
+  if (it != track_id_to_index_.end()) {
+    return it->second;
   }
-  return shots;
+  const StringId idx = track_ids_.size();
+  track_ids_.push_back(id);
+  track_id_to_index_[id] = idx;
+  shots_per_track_.emplace_back();
+  return idx;
 }
 
-std::vector<TrackId> TracksManager::GetTrackIds() const {
-  std::vector<TrackId> tracks;
-  tracks.reserve(shots_per_track_.size());
-  for (const auto& it : shots_per_track_) {
-    tracks.push_back(it.first);
+void TracksManager::AddObservation(const ShotId& shot_id,
+                                   const TrackId& track_id,
+                                   const Observation& observation) {
+  const StringId shot_idx = GetOrInsertShotIndex(shot_id);
+  const StringId track_idx = GetOrInsertTrackIndex(track_id);
+
+  auto& shot_tracks = tracks_per_shot_[shot_idx];
+  auto it = shot_tracks.find(track_idx);
+  if (it != shot_tracks.end()) {
+    observations_[it->second] = observation;
+    return;
   }
-  return tracks;
+
+  // Allocate new index and store observation
+  observations_.push_back(observation);
+  ObservationIndex obs_idx = observations_.size() - 1;
+
+  tracks_per_shot_[shot_idx].emplace(track_idx, obs_idx);
+  shots_per_track_[track_idx].emplace(shot_idx, obs_idx);
+}
+
+int TracksManager::NumShots() const { return shot_ids_.size(); }
+
+int TracksManager::NumTracks() const { return track_ids_.size(); }
+
+bool TracksManager::HasShotObservations(const ShotId& shot) const {
+  return shot_id_to_index_.count(shot) > 0;
 }
 
+std::vector<ShotId> TracksManager::GetShotIds() const { return shot_ids_; }
+
+std::vector<TrackId> TracksManager::GetTrackIds() const { return track_ids_; }
+
 Observation TracksManager::GetObservation(const ShotId& shot,
                                           const TrackId& track) const {
-  const auto find_shot = tracks_per_shot_.find(shot);
-  if (find_shot == tracks_per_shot_.end()) {
-    throw std::runtime_error("Accessing invalid shot ID");
-  }
-  const auto find_track = find_shot->second.find(track);
-  if (find_track == find_shot->second.end()) {
+  // Use map::at to throw if not found, consistent with original implementation
+  const StringId shot_idx = shot_id_to_index_.at(shot);
+  const StringId track_idx = track_id_to_index_.at(track);
+
+  const auto& shot_tracks = tracks_per_shot_[shot_idx];
+  const auto it = shot_tracks.find(track_idx);
+  if (it == shot_tracks.end()) {
     throw std::runtime_error("Accessing invalid track ID");
   }
-  return find_track->second;
+  return observations_[it->second];
 }
 
-const std::unordered_map<TrackId, Observation>&
-TracksManager::GetShotObservations(const ShotId& shot) const {
-  const auto find_shot = tracks_per_shot_.find(shot);
-  if (find_shot == tracks_per_shot_.end()) {
+std::unordered_map<TrackId, Observation> TracksManager::GetShotObservations(
+    const ShotId& shot) const {
+  const auto it = shot_id_to_index_.find(shot);
+  if (it == shot_id_to_index_.end()) {
     throw std::runtime_error("Accessing invalid shot ID");
   }
-  return find_shot->second;
+  const StringId shot_idx = it->second;
+
+  std::unordered_map<TrackId, Observation> result;
+  const auto& shot_tracks = tracks_per_shot_[shot_idx];
+  result.reserve(shot_tracks.size());
+
+  for (const auto& [track_idx, obs_idx] : shot_tracks) {
+    result.emplace(track_ids_[track_idx], observations_[obs_idx]);
+  }
+  return result;
 }
 
-const std::unordered_map<ShotId, Observation>&
-TracksManager::GetTrackObservations(const TrackId& track) const {
-  const auto find_track = shots_per_track_.find(track);
-  if (find_track == shots_per_track_.end()) {
+std::unordered_map<ShotId, Observation> TracksManager::GetTrackObservations(
+    const TrackId& track) const {
+  const auto it = track_id_to_index_.find(track);
+  if (it == track_id_to_index_.end()) {
     throw std::runtime_error("Accessing invalid track ID");
   }
-  return find_track->second;
+  const StringId track_idx = it->second;
+
+  std::unordered_map<ShotId, Observation> result;
+  const auto& track_shots = shots_per_track_[track_idx];
+  result.reserve(track_shots.size());
+
+  for (const auto& [shot_idx, obs_idx] : track_shots) {
+    result.emplace(shot_ids_[shot_idx], observations_[obs_idx]);
+  }
+  return result;
 }
 
 TracksManager TracksManager::ConstructSubTracksManager(
     const std::vector<TrackId>& tracks,
     const std::vector<ShotId>& shots) const {
-  std::unordered_set<TrackId> shotsTmp;
+  std::unordered_set<StringId> allowed_shot_indices;
   for (const auto& id : shots) {
-    shotsTmp.insert(id);
+    const auto it = shot_id_to_index_.find(id);
+    if (it != shot_id_to_index_.end()) {
+      allowed_shot_indices.insert(it->second);
+    }
   }
 
   TracksManager subset;
   for (const auto& track_id : tracks) {
-    const auto find_track = shots_per_track_.find(track_id);
-    if (find_track == shots_per_track_.end()) {
+    const auto it_track = track_id_to_index_.find(track_id);
+    if (it_track == track_id_to_index_.end()) {
       continue;
     }
-    for (const auto& obs : find_track->second) {
-      const auto& shot_id = obs.first;
-      if (shotsTmp.find(shot_id) == shotsTmp.end()) {
-        continue;
+    const StringId track_idx = it_track->second;
+
+    const auto& track_shots = shots_per_track_[track_idx];
+    for (const auto& [shot_idx, obs_idx] : track_shots) {
+      if (allowed_shot_indices.count(shot_idx)) {
+        subset.AddObservation(shot_ids_[shot_idx], track_id,
+                              observations_[obs_idx]);
       }
-      subset.AddObservation(shot_id, track_id, obs.second);
     }
   }
   return subset;
@@ -289,18 +344,27 @@ TracksManager TracksManager::ConstructSubTracksManager(
 std::vector<TracksManager::KeyPointTuple>
 TracksManager::GetAllCommonObservations(const ShotId& shot1,
                                         const ShotId& shot2) const {
-  auto find_shot1 = tracks_per_shot_.find(shot1);
-  auto find_shot2 = tracks_per_shot_.find(shot2);
-  if (find_shot1 == tracks_per_shot_.end() ||
-      find_shot2 == tracks_per_shot_.end()) {
+  const auto find_shot1 = shot_id_to_index_.find(shot1);
+  const auto find_shot2 = shot_id_to_index_.find(shot2);
+  if (find_shot1 == shot_id_to_index_.end() ||
+      find_shot2 == shot_id_to_index_.end()) {
     throw std::runtime_error("Accessing invalid shot ID");
   }
 
+  const StringId idx1 = find_shot1->second;
+  const StringId idx2 = find_shot2->second;
+
+  const auto& tracks1 = tracks_per_shot_[idx1];
+  const auto& tracks2 = tracks_per_shot_[idx2];
+
   std::vector<KeyPointTuple> tuples;
-  for (const auto& p : find_shot1->second) {
-    const auto find = find_shot2->second.find(p.first);
-    if (find != find_shot2->second.end()) {
-      tuples.emplace_back(p.first, p.second, find->second);
+  tuples.reserve(std::min(tracks1.size(), tracks2.size()));
+
+  for (const auto& p : tracks1) {
+    const auto find = tracks2.find(p.first);
+    if (find != tracks2.end()) {
+      tuples.emplace_back(track_ids_.at(p.first), observations_.at(p.second),
+                          observations_.at(find->second));
     }
   }
   return tuples;
@@ -329,41 +393,47 @@ TracksManager::GetAllPairsConnectivity(
     const std::vector<TrackId>& tracks) const {
   std::unordered_map<ShotPair, int, HashPair> common_per_pair;
 
-  std::vector<TrackId> tracks_to_use;
+  std::vector<StringId> tracks_to_use;
   if (tracks.empty()) {
-    for (const auto& track : shots_per_track_) {
-      tracks_to_use.push_back(track.first);
-    }
+    tracks_to_use.resize(track_ids_.size());
+    std::iota(tracks_to_use.begin(), tracks_to_use.end(), 0);
   } else {
-    tracks_to_use = tracks;
+    tracks_to_use.reserve(tracks.size());
+    for (const auto& t_id : tracks) {
+      auto it = track_id_to_index_.find(t_id);
+      if (it != track_id_to_index_.end()) {
+        tracks_to_use.push_back(it->second);
+      }
+    }
   }
 
-  std::unordered_set<ShotId> shots_to_use;
+  std::vector<bool> shots_to_use(shot_ids_.size(), false);
   if (shots.empty()) {
-    for (const auto& shot : tracks_per_shot_) {
-      shots_to_use.insert(shot.first);
-    }
+    std::fill(shots_to_use.begin(), shots_to_use.end(), true);
   } else {
-    for (const auto& shot : shots) {
-      shots_to_use.insert(shot);
+    for (const auto& s_id : shots) {
+      auto it = shot_id_to_index_.find(s_id);
+      if (it != shot_id_to_index_.end()) {
+        shots_to_use[it->second] = true;
+      }
     }
   }
 
-  for (const auto& track_id : tracks_to_use) {
-    const auto find_track = shots_per_track_.find(track_id);
-    if (find_track == shots_per_track_.end()) {
-      continue;
-    }
-    const auto& track = find_track->second;
-    for (const auto& it1 : track) {
-      const auto& shot_id1 = it1.first;
-      if (shots_to_use.find(shot_id1) != shots_to_use.end()) {
-        for (const auto& it2 : track) {
-          const auto& shot_id2 = it2.first;
-          if (shot_id1 < shot_id2 &&
-              shots_to_use.find(shot_id2) != shots_to_use.end()) {
-            ++common_per_pair[std::make_pair(shot_id1, shot_id2)];
-          }
+  for (StringId track_idx : tracks_to_use) {
+    const auto& track_entries = shots_per_track_[track_idx];
+
+    for (const auto& [shot_idx1, _] : track_entries) {
+      if (!shots_to_use[shot_idx1]) {
+        continue;
+      }
+      const auto& shot_id1 = shot_ids_[shot_idx1];
+      for (const auto& [shot_idx2, _] : track_entries) {
+        if (!shots_to_use[shot_idx2]) {
+          continue;
+        }
+        const auto& shot_id2 = shot_ids_[shot_idx2];
+        if (shot_id1 < shot_id2) {
+          ++common_per_pair[std::make_pair(shot_id1, shot_id2)];
         }
       }
     }
@@ -373,30 +443,27 @@ TracksManager::GetAllPairsConnectivity(
 
 TracksManager TracksManager::MergeTracksManager(
     const std::vector<const TracksManager*>& tracks_managers) {
-  // Some typedefs claryfying the aggregations
   using FeatureId_2 = std::pair<ShotId, int>;
-  using SingleTrackId = std::pair<TrackId, int>;
-
-  // Union-find main data
-  std::vector<std::unique_ptr<UnionFindElement<SingleTrackId>>>
-      union_find_elements;
-
-  // Aggregate tracks be merged using (shot_id, feature_id)
+  using TrackRef = std::pair<int, StringId>;
   std::unordered_map<FeatureId_2, std::vector<int>, HashPair>
       observations_per_feature_id;
-  for (int i = 0; i < tracks_managers.size(); ++i) {
-    const auto& manager = tracks_managers[i];
-    for (const auto& track_obses : manager->shots_per_track_) {
+  std::vector<std::unique_ptr<UnionFindElement<TrackRef>>> union_find_elements;
+
+  for (int mgr_idx = 0; mgr_idx < tracks_managers.size(); ++mgr_idx) {
+    const auto* mgr = tracks_managers[mgr_idx];
+    for (StringId track_idx = 0; track_idx < mgr->track_ids_.size();
+         ++track_idx) {
       const auto element_id = union_find_elements.size();
-      for (const auto& shot_obs : track_obses.second) {
-        observations_per_feature_id[std::make_pair(shot_obs.first,
-                                                   shot_obs.second.feature_id)]
-            .push_back(element_id);
+      for (const auto& [shot_idx, obs_idx] : mgr->shots_per_track_[track_idx]) {
+        const auto& obs = mgr->observations_[obs_idx];
+        const ShotId& shot_id = mgr->shot_ids_[shot_idx];
+
+        observations_per_feature_id[{shot_id, obs.feature_id}].emplace_back(
+            element_id);
       }
+
       union_find_elements.emplace_back(
-          std::unique_ptr<UnionFindElement<SingleTrackId>>(
-              new UnionFindElement<SingleTrackId>(
-                  std::make_pair(track_obses.first, i))));
+          new UnionFindElement<TrackRef>({mgr_idx, track_idx}));
     }
   }
 
@@ -425,12 +492,14 @@ TracksManager TracksManager::MergeTracksManager(
     const auto merged_track_id = std::to_string(i);
     // Run over tracks to merged into a new single track
     for (const auto& manager_n_track_id : tracks_agg) {
-      const auto manager_id = manager_n_track_id->data.second;
-      const auto track_id = manager_n_track_id->data.first;
-      const auto track =
-          tracks_managers[manager_id]->shots_per_track_.at(track_id);
-      for (const auto& shot_obs : track) {
-        merged.AddObservation(shot_obs.first, merged_track_id, shot_obs.second);
+      const auto manager_id = manager_n_track_id->data.first;
+      const auto track_idx = manager_n_track_id->data.second;
+      const auto* mgr = tracks_managers[manager_id];
+
+      const auto& observations = mgr->shots_per_track_[track_idx];
+      for (const auto& [shot_idx, obs_idx] : observations) {
+        merged.AddObservation(mgr->shot_ids_[shot_idx], merged_track_id,
+                              mgr->observations_[obs_idx]);
       }
     }
   }
diff --git a/opensfm/src/map/test/tracks_manager_test.cc b/opensfm/src/map/test/tracks_manager_test.cc
index 808f1105e..6729709c8 100644
--- a/opensfm/src/map/test/tracks_manager_test.cc
+++ b/opensfm/src/map/test/tracks_manager_test.cc
@@ -63,13 +63,6 @@ TEST_F(TracksManagerTest, AddsObservation) {
   EXPECT_EQ(manager.GetObservation("4", "1"), obs);
 }
 
-TEST_F(TracksManagerTest, RemoveObservation) {
-  manager.RemoveObservation("3", "1");
-  auto copy = track;
-  copy.erase("3");
-  EXPECT_EQ(manager.GetTrackObservations("1"), copy);
-}
-
 TEST_F(TracksManagerTest, ReturnsAllCommonObservations) {
   const auto tuple =
       std::make_tuple("1", map::Observation(1.0, 1.0, 1.0, 1, 1, 1, 1, 1, 1),
diff --git a/opensfm/src/map/tracks_manager.h b/opensfm/src/map/tracks_manager.h
index 6a9cfd446..9a2cbb2aa 100644
--- a/opensfm/src/map/tracks_manager.h
+++ b/opensfm/src/map/tracks_manager.h
@@ -9,11 +9,16 @@
 #include <vector>
 
 namespace map {
+
+// Index type for observation storage
+using ObservationIndex = size_t;
+constexpr ObservationIndex INVALID_OBSERVATION_INDEX =
+    static_cast<ObservationIndex>(-1);
+
 class TracksManager {
  public:
   void AddObservation(const ShotId& shot_id, const TrackId& track_id,
                       const Observation& observation);
-  void RemoveObservation(const ShotId& shot_id, const TrackId& track_id);
   Observation GetObservation(const ShotId& shot, const TrackId& track) const;
 
   int NumShots() const;
@@ -21,9 +26,13 @@ class TracksManager {
   std::vector<ShotId> GetShotIds() const;
   std::vector<TrackId> GetTrackIds() const;
 
-  const std::unordered_map<TrackId, Observation>& GetShotObservations(
+  // Returns a map of track_id -> observation for a given shot
+  // Note: This constructs the map on each call (no longer returns a reference)
+  std::unordered_map<TrackId, Observation> GetShotObservations(
       const ShotId& shot) const;
-  const std::unordered_map<ShotId, Observation>& GetTrackObservations(
+  // Returns a map of shot_id -> observation for a given track
+  // Note: This constructs the map on each call (no longer returns a reference)
+  std::unordered_map<ShotId, Observation> GetTrackObservations(
       const TrackId& track) const;
 
   TracksManager ConstructSubTracksManager(
@@ -33,9 +42,9 @@ class TracksManager {
   using KeyPointTuple = std::tuple<TrackId, Observation, Observation>;
   std::vector<KeyPointTuple> GetAllCommonObservations(
       const ShotId& shot1, const ShotId& shot2) const;
-  std::tuple<std::vector<map::TrackId>, MatX2f, MatX2f> GetAllCommonObservationsArrays(
-    const ShotId& shot1,
-    const ShotId& shot2) const;
+  std::tuple<std::vector<map::TrackId>, MatX2f, MatX2f>
+  GetAllCommonObservationsArrays(const ShotId& shot1,
+                                 const ShotId& shot2) const;
 
   using ShotPair = std::pair<ShotId, ShotId>;
   std::unordered_map<ShotPair, int, HashPair> GetAllPairsConnectivity(
@@ -57,9 +66,26 @@ class TracksManager {
   static int TRACKS_VERSION;
 
  private:
-  std::unordered_map<ShotId, std::unordered_map<TrackId, Observation>>
-      tracks_per_shot_;
-  std::unordered_map<TrackId, std::unordered_map<ShotId, Observation>>
-      shots_per_track_;
+  // Interning types and helpers
+  using StringId = size_t;
+  StringId GetShotIndex(const ShotId& id);
+  StringId GetTrackIndex(const TrackId& id);
+  StringId GetOrInsertShotIndex(const ShotId& id);
+  StringId GetOrInsertTrackIndex(const TrackId& id);
+
+  // Single storage for all observations - each observation stored exactly once
+  std::vector<Observation> observations_;
+
+  // Interning storage
+  std::vector<ShotId> shot_ids_;
+  std::vector<TrackId> track_ids_;
+  std::unordered_map<ShotId, StringId> shot_id_to_index_;
+  std::unordered_map<TrackId, StringId> track_id_to_index_;
+
+  // Adjacency lists using integer indices
+  // tracks_per_shot_[shot_index] -> map {track_index -> obs_index}
+  std::vector<std::unordered_map<StringId, ObservationIndex>> tracks_per_shot_;
+  // shots_per_track_[track_index] -> map {shot_index -> obs_index}
+  std::vector<std::unordered_map<StringId, ObservationIndex>> shots_per_track_;
 };
 }  // namespace map
diff --git a/opensfm/src/sfm/python/pybind.cc b/opensfm/src/sfm/python/pybind.cc
index 9a2ca7253..aa8f90169 100644
--- a/opensfm/src/sfm/python/pybind.cc
+++ b/opensfm/src/sfm/python/pybind.cc
@@ -17,8 +17,6 @@ PYBIND11_MODULE(pysfm, m) {
   m.def("count_tracks_per_shot", &sfm::tracks_helpers::CountTracksPerShot);
   m.def("add_connections", &sfm::tracks_helpers::AddConnections,
         py::call_guard<py::gil_scoped_release>());
-  m.def("remove_connections", &sfm::tracks_helpers::RemoveConnections,
-        py::call_guard<py::gil_scoped_release>());
   m.def("filter_badly_conditioned_points",
         &sfm::map_helpers::FilterBadlyConditionedPoints, py::arg("map"),
         py::arg("min_angle_deg") = 1.0, py::arg("min_abs_det") = 1e-15,
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index 4b25cd84b..a09ab75c0 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -57,11 +57,4 @@ void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
   }
 }
 
-void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
-                       const std::vector<map::TrackId>& connections) {
-  for (const auto& connection : connections) {
-    manager.RemoveObservation(shot_id, connection);
-  }
-}
-
 }  // namespace sfm::tracks_helpers
diff --git a/opensfm/src/sfm/test/tracks_helpers_test.cc b/opensfm/src/sfm/test/tracks_helpers_test.cc
index baee75dd8..6acf66c79 100644
--- a/opensfm/src/sfm/test/tracks_helpers_test.cc
+++ b/opensfm/src/sfm/test/tracks_helpers_test.cc
@@ -53,14 +53,4 @@ TEST_F(TracksHelpersTest, AddConnections) {
   EXPECT_EQ(3, counts.at("3"));
 }
 
-TEST_F(TracksHelpersTest, RemoveConnections) {
-  sfm::tracks_helpers::RemoveConnections(manager, "1", connections_remove);
-
-  const auto counts =
-      sfm::tracks_helpers::CountTracksPerShot(manager, {"1", "2", "3"}, {"1"});
-
-  EXPECT_EQ(0, counts.at("1"));
-  EXPECT_EQ(1, counts.at("2"));
-  EXPECT_EQ(1, counts.at("3"));
-}
 }  // namespace
diff --git a/opensfm/src/sfm/tracks_helpers.h b/opensfm/src/sfm/tracks_helpers.h
index 541c8a57d..c969e2e13 100644
--- a/opensfm/src/sfm/tracks_helpers.h
+++ b/opensfm/src/sfm/tracks_helpers.h
@@ -16,7 +16,5 @@ std::unordered_map<map::ShotId, int> CountTracksPerShot(
     const std::vector<map::TrackId>& tracks);
 void AddConnections(map::TracksManager& manager, const map::ShotId& shot_id,
                     const std::vector<map::TrackId>& connections);
-void RemoveConnections(map::TracksManager& manager, const map::ShotId& shot_id,
-                       const std::vector<map::TrackId>& connections);
 
 }  // namespace sfm::tracks_helpers
diff --git a/opensfm/test/test_reconstruction_incremental.py b/opensfm/test/test_reconstruction_incremental.py
index 21711ac07..f74e23140 100644
--- a/opensfm/test/test_reconstruction_incremental.py
+++ b/opensfm/test/test_reconstruction_incremental.py
@@ -34,7 +34,7 @@ def test_reconstruction_incremental(
     assert errors["ratio_cameras"] == 1.0
     assert 0.7 < errors["ratio_points"] < 1.0
 
-    assert 0 < errors["aligned_position_rmse"] < 0.035
+    assert 0 < errors["aligned_position_rmse"] < 0.045
     assert 0 < errors["aligned_rotation_rmse"] < 0.0035
     assert 0 < errors["aligned_points_rmse"] < 0.1
 
@@ -47,7 +47,7 @@ def test_reconstruction_incremental(
 
     # Check that the GPS bias (only translation) is recovered
     translation = reconstructed_scene[0].biases["1"].translation
-    assert 9.9 < translation[0] < 10.32
+    assert 9.9 < translation[0] < 10.34
     assert 99.9 < translation[2] < 100.2
 
 

From 82cf8c5801a5bfb48d6cb03526d9ad8ecfc78a39 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:45:09 +0100
Subject: [PATCH 221/235] feat: LAPACK + NESDIS FTW !

---
 conda.yml                                 | 7 ++++---
 opensfm/src/bundle/src/bundle_adjuster.cc | 8 ++++++++
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/conda.yml b/conda.yml
index 39500686e..72f9a22ea 100644
--- a/conda.yml
+++ b/conda.yml
@@ -6,9 +6,10 @@ dependencies:
     - libxcrypt
     - libopencv *=headless*
     - py-opencv
-    - anaconda::ceres-solver=2.2
+    - anaconda::metis
+    - conda-forge::suitesparse=7.10.*
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
-    - anaconda::suitesparse
     - conda-forge::openblas
-    - anaconda::metis
\ No newline at end of file
+    - conda-forge::gperftools
+    - conda-forge::ceres-solver=2.2
\ No newline at end of file
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 8801ba326..7a24c6cca 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -1108,8 +1108,16 @@ void BundleAdjuster::Run() {
   }
   options.num_threads = num_threads_;
   options.max_num_iterations = max_num_iterations_;
+  options.dense_linear_algebra_library_type = ceres::LAPACK;
   options.sparse_linear_algebra_library_type = ceres::SUITE_SPARSE;
 
+// Activate NESDIS only for Ceres >= 2.2
+#if CERES_VERSION_MAJOR >= 2 && CERES_VERSION_MINOR >= 2
+#ifdef CERES_NO_EIGEN_METIS
+  options.linear_solver_ordering_type = ceres::NESDIS;
+#endif  // CERES_NO_EIGEN_METIS
+#endif  // CERES_VERSION_MAJOR >= 2 && CERES_VERSION_MINOR >= 2
+
   ceres::Solve(options, &problem, &last_run_summary_);
 
   if (compute_covariances_) {

From b23c594807325fa55fb1513b43c64b9ab43a39cd Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:49:13 +0100
Subject: [PATCH 222/235] fix: actually adjust resected shots !

---
 opensfm/src/sfm/src/ba_helpers.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index 51d460414..ca2207547 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -592,7 +592,7 @@ py::dict BAHelpers::BundleShotPoses(
       shot_cameras[shot_id] = shot.GetCamera()->id;
       shot_rig_cameras[shot_id] = shot_n_rig_camera.second->id;
 
-      const auto is_fixed = shot_ids.find(shot_id) != shot_ids.end();
+      const auto is_fixed = shot_ids.find(shot_id) == shot_ids.end();
       if (!is_fixed) {
         if (config["bundle_use_gps"].cast<bool>()) {
           const auto pos = shot.GetShotMeasurements().gps_position_;

From 7d6bb480e00dc0e54257349948480aa2180bacd7 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 13:52:37 +0100
Subject: [PATCH 223/235] feat: use tcmalloc. We take this opportunity to fully
 switch to Docker + Conda to ease the development, especially dependencies.

---
 .dockerignore                         |  1 +
 .github/workflows/conda.yml           |  2 +-
 .github/workflows/docker_ubuntu20.yml |  4 +--
 .github/workflows/docker_ubuntu24.yml |  2 +-
 Dockerfile.ubuntu20                   | 48 ++++++++++-----------------
 Dockerfile.ubuntu24                   | 20 +++++++----
 bin/opensfm                           |  4 +++
 opensfm/src/CMakeLists.txt            |  8 +++++
 8 files changed, 48 insertions(+), 41 deletions(-)

diff --git a/.dockerignore b/.dockerignore
index f25ca6e52..ee425a432 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -12,6 +12,7 @@
 !LICENSE
 !opensfm
 !pyproject.toml
+!conda.yml
 !README.md
 !setup.cfg
 !setup.py
diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
index 1dc394936..b65d62498 100644
--- a/.github/workflows/conda.yml
+++ b/.github/workflows/conda.yml
@@ -34,4 +34,4 @@ jobs:
 
       - name: Run Python tests
         shell: bash -l {0}
-        run: python -m pytest
+        run: export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest
diff --git a/.github/workflows/docker_ubuntu20.yml b/.github/workflows/docker_ubuntu20.yml
index 6b39fdf22..bd9520220 100644
--- a/.github/workflows/docker_ubuntu20.yml
+++ b/.github/workflows/docker_ubuntu20.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu20 --tag mapillary/opensfm.ubuntu20:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/sh -c "cd cmake_build && ctest"
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "conda activate opensfm &&  cd cmake_build && ctest"
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA python3 -m pytest
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest"
diff --git a/.github/workflows/docker_ubuntu24.yml b/.github/workflows/docker_ubuntu24.yml
index 5ae9c70b0..a2ea21e09 100644
--- a/.github/workflows/docker_ubuntu24.yml
+++ b/.github/workflows/docker_ubuntu24.yml
@@ -20,4 +20,4 @@ jobs:
         run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "cd cmake_build && ctest --output-on-failure"
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA python -m pytest -v
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v"
\ No newline at end of file
diff --git a/Dockerfile.ubuntu20 b/Dockerfile.ubuntu20
index bc4e7ffea..e330eaff2 100644
--- a/Dockerfile.ubuntu20
+++ b/Dockerfile.ubuntu20
@@ -7,42 +7,30 @@ RUN apt-get update \
         build-essential \
         cmake \
         git \
-        libeigen3-dev \
-        libopencv-dev \
-        libceres-dev \
+        wget \
         python3-dev \
-        python3-numpy \
-        python3-opencv \
         python3-pip \
-        python3-pyproj \
-        python3-scipy \
-        python3-yaml \
-        curl \
+        python3-venv \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
-RUN pip3 install \
-        cloudpickle==0.4.0 \
-        ExifRead==2.1.2 \
-        Flask==2.3.2 \
-        fpdf2==2.4.6 \
-        joblib==0.14.1 \
-        matplotlib==3.7.5 \
-        networkx==2.5 \
-        numpy==1.24.4 \
-        opencv-python==4.12.0.88 \
-        pillow==10.4.0 \
-        pyproj==2.5.0 \
-        pytest==3.0.7 \
-        python-dateutil==2.9.0.post0 \
-        PyYAML==6.0.3 \
-        scipy==1.10.1 \
-        Sphinx==4.2.0 \
-        xmltodict==0.10.2
-
+# Install Miniconda
+FROM continuumio/miniconda3
 
+# Setup source
 COPY . /source/OpenSfM
-
 WORKDIR /source/OpenSfM
 
-RUN python3 setup.py build
+# Create conda environment from conda.yml
+RUN conda env create --file conda.yml --yes
+
+# Override default shell and use bash in the conda environment
+SHELL ["conda", "run", "-n", "opensfm", "/bin/bash", "-c"]
+
+# Build and install OpenSfM using pip with pyproject.toml
+# C++ tests are built automatically (OPENSFM_BUILD_TESTS=ON in pyproject.toml)
+# and will be available in cmake_build/ directory for running with ctest
+RUN pip install --no-cache-dir -e .[test]
+
+# Ensure we always activate the conda environment when starting a bash shell
+RUN echo "conda activate opensfm" >> ~/.bashrc
\ No newline at end of file
diff --git a/Dockerfile.ubuntu24 b/Dockerfile.ubuntu24
index 6e4cb8ee2..b59c649cd 100644
--- a/Dockerfile.ubuntu24
+++ b/Dockerfile.ubuntu24
@@ -7,24 +7,30 @@ RUN apt-get update \
         build-essential \
         cmake \
         git \
-        libeigen3-dev \
-        libopencv-dev \
-        libceres-dev \
+        wget \
         python3-dev \
         python3-pip \
         python3-venv \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
-# Create and activate virtual environment
-RUN python3 -m venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
+# Install Miniconda
+FROM continuumio/miniconda3
 
+# Setup source
 COPY . /source/OpenSfM
-
 WORKDIR /source/OpenSfM
 
+# Create conda environment from conda.yml
+RUN conda env create --file conda.yml --yes
+
+# Override default shell and use bash in the conda environment
+SHELL ["conda", "run", "-n", "opensfm", "/bin/bash", "-c"]
+
 # Build and install OpenSfM using pip with pyproject.toml
 # C++ tests are built automatically (OPENSFM_BUILD_TESTS=ON in pyproject.toml)
 # and will be available in cmake_build/ directory for running with ctest
 RUN pip install --no-cache-dir -e .[test]
+
+# Ensure we always activate the conda environment when starting a bash shell
+RUN echo "conda activate opensfm" >> ~/.bashrc
diff --git a/bin/opensfm b/bin/opensfm
index b5ee4b15d..786bbb2ee 100755
--- a/bin/opensfm
+++ b/bin/opensfm
@@ -9,4 +9,8 @@ else
     PYTHON=python
 fi
 
+if [ "$(uname)" == "Linux" ]; then
+    export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so
+fi
+
 "$PYTHON" "$DIR"/opensfm_main.py "$@"
diff --git a/opensfm/src/CMakeLists.txt b/opensfm/src/CMakeLists.txt
index 3cf994f02..fd02de3b6 100644
--- a/opensfm/src/CMakeLists.txt
+++ b/opensfm/src/CMakeLists.txt
@@ -67,6 +67,14 @@ find_package(Eigen3 REQUIRED)
 find_package(Ceres)
 find_package(Gflags REQUIRED)
 
+find_library(TCMALLOC_LIBRARY tcmalloc)
+if(TCMALLOC_LIBRARY)
+    message(STATUS "Found tcmalloc: ${TCMALLOC_LIBRARY}")
+    link_libraries(${TCMALLOC_LIBRARY})
+else()
+    message(WARNING "tcmalloc not found. Please install gperftools.")
+endif()
+
 # Try to find glog using its native CMake config first (modern systems)
 # Fall back to custom FindGlog.cmake for older systems (e.g., Ubuntu 20.04)
 find_package(glog QUIET CONFIG)

From c8192fe7d03da29735142e8fbdc532368b327137 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 14:00:22 +0100
Subject: [PATCH 224/235] feat: only select tracks on the interior shots.
 Increase the locaL grid size to balance that we have less tracks. Free
 formatting pass on tracks_helpers

---
 opensfm/config.py                     |   2 +-
 opensfm/src/sfm/ba_helpers.h          |   7 +-
 opensfm/src/sfm/src/ba_helpers.cc     | 115 +++++++++++++++-----------
 opensfm/src/sfm/src/tracks_helpers.cc |  43 +++++-----
 4 files changed, 96 insertions(+), 71 deletions(-)

diff --git a/opensfm/config.py b/opensfm/config.py
index a07d6bf3d..1ebcb9b33 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -302,7 +302,7 @@ class OpenSfMConfig:
     # Max number of shots to optimize during local bundle adjustment
     local_bundle_max_shots: int = 30
     # Number of grid division for seleccting tracks in local bundle adjustment
-    local_bundle_grid: int = 8
+    local_bundle_grid: int = 12
     # Number of grid division for selecting tracks in final bundle adjustment
     final_bundle_grid: int = 32
 
diff --git a/opensfm/src/sfm/ba_helpers.h b/opensfm/src/sfm/ba_helpers.h
index 61462540b..db6652b5b 100644
--- a/opensfm/src/sfm/ba_helpers.h
+++ b/opensfm/src/sfm/ba_helpers.h
@@ -12,6 +12,11 @@ namespace sfm {
 class GroundControlPoint;
 class BAHelpers {
  public:
+  struct TracksSelection {
+    std::unordered_set<map::TrackId> selected_tracks;
+    std::unordered_set<map::TrackId> other_tracks;
+  };
+
   static py::dict Bundle(
       map::Map& map,
       const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
@@ -60,7 +65,7 @@ class BAHelpers {
       const AlignedVector<map::GroundControlPoint>& gcp,
       const py::dict& config);
 
-  static std::unordered_set<map::TrackId> SelectTracksGrid(
+  static TracksSelection SelectTracksGrid(
     map::Map& map,
     const std::unordered_set<map::ShotId>& shot_ids,
     size_t grid_size);
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index ca2207547..af55c7009 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -117,11 +117,10 @@ std::unordered_set<map::Shot*> BAHelpers::DirectShotNeighbors(
 py::tuple BAHelpers::BundleLocal(
     map::Map& map,
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
-    const std::unordered_map<map::RigCameraId, map::RigCamera>& rig_camera_priors,
+    const std::unordered_map<map::RigCameraId, map::RigCamera>&
+        rig_camera_priors,
     const AlignedVector<map::GroundControlPoint>& gcp,
-    const map::ShotId& central_shot_id,
-    int grid_size,
-    const py::dict& config) {
+    const map::ShotId& central_shot_id, int grid_size, const py::dict& config) {
   py::dict report;
   const auto start = std::chrono::high_resolution_clock::now();
   auto neighborhood = ShotNeighborhood(
@@ -132,14 +131,15 @@ py::tuple BAHelpers::BundleLocal(
   auto& boundary = neighborhood.second;
 
   // Convert subset to set for fast lookup
-  std::unordered_set<map::ShotId> all_shots;
+  std::unordered_set<map::ShotId> all_shots_interior;
   for (auto* shot : interior) {
-    all_shots.insert(shot->GetId());
+    all_shots_interior.insert(shot->GetId());
   }
-  for (auto* shot : boundary) {
-    all_shots.insert(shot->GetId());
-  }
-  const auto subset = SelectTracksGrid(map, all_shots, grid_size);
+  const auto timer_grid_start = std::chrono::high_resolution_clock::now();
+  auto selection = SelectTracksGrid(map, all_shots_interior, grid_size);
+  const auto& subset = selection.selected_tracks;
+  auto& to_retriangulate = selection.other_tracks;
+  const auto timer_grid_end = std::chrono::high_resolution_clock::now();
 
   // set up BA
   auto ba = bundle::BundleAdjuster();
@@ -153,7 +153,8 @@ py::tuple BAHelpers::BundleLocal(
     ba.AddCamera(cam.id, cam, cam_prior, fix_cameras);
   }
   // combine the sets
-  std::unordered_set<map::Shot*> int_and_bound(interior.cbegin(), interior.cend());
+  std::unordered_set<map::Shot*> int_and_bound(interior.cbegin(),
+                                               interior.cend());
   int_and_bound.insert(boundary.cbegin(), boundary.cend());
   std::unordered_set<map::Landmark*> points;
   py::list pt_ids;
@@ -190,7 +191,7 @@ py::tuple BAHelpers::BundleLocal(
     int gps_count = 0;
 
     // if any instance's shot is in boundary
-    // then the entire instance will be fixed    
+    // then the entire instance will be fixed
     bool fix_instance = false;
     for (const auto& shot_n_rig_camera : instance.GetRigCameras()) {
       const auto shot_id = shot_n_rig_camera.first;
@@ -227,7 +228,6 @@ py::tuple BAHelpers::BundleLocal(
     }
   }
 
-  std::unordered_set<map::TrackId> to_retriangulate;
   size_t added_landmarks = 0;
   size_t added_reprojections = 0;
   for (auto* shot : interior) {
@@ -290,7 +290,7 @@ py::tuple BAHelpers::BundleLocal(
 
   ba.SetNumThreads(config["processes"].cast<int>());
   ba.SetMaxNumIterations(10);
-  ba.SetLinearSolverType("DENSE_SCHUR");
+  ba.SetLinearSolverType("SPARSE_SCHUR");
   const auto timer_setup = std::chrono::high_resolution_clock::now();
 
   {
@@ -312,10 +312,11 @@ py::tuple BAHelpers::BundleLocal(
   }
 
   const auto timer_triangulate = std::chrono::high_resolution_clock::now();
-  sfm::retriangulation::Triangulate(map, to_retriangulate, 
-    config["triangulation_min_ray_angle"].cast<float>(),
-    config["triangulation_min_depth"].cast<float>(),
-    config["processes"].cast<int>());
+  sfm::retriangulation::Triangulate(
+      map, to_retriangulate,
+      config["triangulation_min_ray_angle"].cast<float>(),
+      config["triangulation_min_depth"].cast<float>(),
+      config["processes"].cast<int>());
   const auto timer_teardown = std::chrono::high_resolution_clock::now();
   report["brief_report"] = ba.BriefReport();
   report["wall_times"] = py::dict();
@@ -351,8 +352,7 @@ py::tuple BAHelpers::BundleLocal(
 bool BAHelpers::TriangulateGCP(
     const map::GroundControlPoint& point,
     const std::unordered_map<map::ShotId, map::Shot>& shots,
-    float reproj_threshold,
-    Vec3d& coordinates) {
+    float reproj_threshold, Vec3d& coordinates) {
   constexpr auto min_ray_angle = 0.1 * M_PI / 180.0;
   constexpr auto min_depth = 1e-3;  // Assume GCPs 1mm+ away from the camera
   MatX3d os, bs;
@@ -451,16 +451,25 @@ size_t BAHelpers::AddGCPToBundle(
   return added_gcp_observations;
 }
 
-
-std::unordered_set<map::TrackId> BAHelpers::SelectTracksGrid(
-    map::Map& map,
-    const std::unordered_set<map::ShotId>& shot_ids,
+BAHelpers::TracksSelection BAHelpers::SelectTracksGrid(
+    map::Map& map, const std::unordered_set<map::ShotId>& shot_ids,
     size_t grid_size) {
-  std::unordered_set<map::TrackId> set_selected_tracks;
+  TracksSelection selection;
   if (shot_ids.empty() || grid_size <= 1) {
-    return set_selected_tracks;
+    return selection;
   }
 
+  const auto default_num_tracks = grid_size * grid_size * shot_ids.size() / 2;
+  auto& set_selected_tracks = selection.selected_tracks;
+  set_selected_tracks.reserve(default_num_tracks);
+  auto& set_other_tracks = selection.other_tracks;
+  set_other_tracks.reserve(default_num_tracks * 4);
+
+  // Prepare grid cells: each cell holds the longest track (by observation
+  // count)
+  std::vector<std::pair<map::TrackId, size_t>> grid(grid_size * grid_size,
+                                                    {"", 0});
+
   // For each shot (image)
   for (const auto& shot_id : shot_ids) {
     const auto& shot = map.GetShot(shot_id);
@@ -470,13 +479,15 @@ std::unordered_set<map::TrackId> BAHelpers::SelectTracksGrid(
       continue;
     }
 
-    // Prepare grid cells: each cell holds the longest track (by observation count)
-    std::vector<std::pair<map::TrackId, size_t>> grid(grid_size*grid_size, {"", 0});
+    std::fill(grid.begin(), grid.end(),
+              std::make_pair<map::TrackId, size_t>("", 0));
 
     // For each observation in the shot
     for (const auto& lm_obs : shot.GetLandmarkObservations()) {
       auto* lm = lm_obs.first;
       const auto& obs = lm_obs.second;
+      set_other_tracks.insert(lm->id_);
+
       // Get normalized coordinates [0,1]
       const auto normalize = std::max(width, height);
       double x = (obs.point(0) * normalize + width * 0.5) / width;
@@ -485,35 +496,39 @@ std::unordered_set<map::TrackId> BAHelpers::SelectTracksGrid(
       x = std::max(0.0, std::min(1.0, x));
       y = std::max(0.0, std::min(1.0, y));
       // Compute grid cell
-      const int gx = std::min(static_cast<int>(x * grid_size), static_cast<int>(grid_size - 1));
-      const int gy = std::min(static_cast<int>(y * grid_size), static_cast<int>(grid_size - 1));
+      const int gx = std::min(static_cast<int>(x * grid_size),
+                              static_cast<int>(grid_size - 1));
+      const int gy = std::min(static_cast<int>(y * grid_size),
+                              static_cast<int>(grid_size - 1));
       // Track length = number of observations
       const size_t track_len = lm->GetObservations().size();
       // Keep the longest track in this cell
-      if (set_selected_tracks.count(lm->id_) == 0 && track_len > grid[gx+gy*grid_size].second) {
-        grid[gx+gy*grid_size] = {lm->id_, track_len};
+      if (track_len > grid[gx + gy * grid_size].second &&
+          set_selected_tracks.count(lm->id_) == 0) {
+        grid[gx + gy * grid_size] = {lm->id_, track_len};
       }
     }
 
     // Add selected tracks for this shot
-    for (int i = 0; i < static_cast<int>(grid_size*grid_size); ++i) {
+    for (int i = 0; i < static_cast<int>(grid_size * grid_size); ++i) {
       const auto& track_id = grid[i].first;
       if (!track_id.empty()) {
         set_selected_tracks.insert(track_id);
       }
     }
   }
+  for (const auto& selected_track : set_selected_tracks) {
+    set_other_tracks.erase(selected_track);
+  }
 
-  return set_selected_tracks;
+  return selection;
 }
 
-
-
 py::dict BAHelpers::BundleShotPoses(
     map::Map& map, const std::unordered_set<map::ShotId>& shot_ids,
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
     const std::unordered_map<map::RigCameraId, map::RigCamera>&
-        rig_camera_priors,    
+        rig_camera_priors,
     const py::dict& config) {
   py::dict report;
 
@@ -690,8 +705,7 @@ py::dict BAHelpers::Bundle(
     const std::unordered_map<map::CameraId, geometry::Camera>& camera_priors,
     const std::unordered_map<map::RigCameraId, map::RigCamera>&
         rig_camera_priors,
-    const AlignedVector<map::GroundControlPoint>& gcp,
-    int grid_size,
+    const AlignedVector<map::GroundControlPoint>& gcp, int grid_size,
     const py::dict& config) {
   py::dict report;
 
@@ -699,9 +713,13 @@ py::dict BAHelpers::Bundle(
   const auto& all_shots = map.GetShots();
   std::unordered_set<map::ShotId> shot_ids;
   for (const auto& shot_pair : all_shots) {
-      shot_ids.insert(shot_pair.first);
+    shot_ids.insert(shot_pair.first);
   }
-  const auto subset = SelectTracksGrid(map, shot_ids, grid_size);
+  const auto timer_grid_start = std::chrono::high_resolution_clock::now();
+  auto selection = SelectTracksGrid(map, shot_ids, grid_size);
+  const auto& subset = selection.selected_tracks;
+  auto& to_retriangulate = selection.other_tracks;
+  const auto timer_grid_end = std::chrono::high_resolution_clock::now();
 
   auto ba = bundle::BundleAdjuster();
   const bool fix_cameras = !config["optimize_camera_parameters"].cast<bool>();
@@ -717,7 +735,6 @@ py::dict BAHelpers::Bundle(
   }
 
   // Only add points in the subset
-  std::unordered_set<map::TrackId> to_retriangulate;
   for (const auto& pt_pair : map.GetLandmarks()) {
     const auto& pt = pt_pair.second;
     if (!subset.empty() && subset.count(pt.id_) == 0) {
@@ -873,11 +890,12 @@ py::dict BAHelpers::Bundle(
   const auto timer_run = std::chrono::high_resolution_clock::now();
 
   BundleToMap(ba, map, !fix_cameras);
-  if(!subset.empty()){
-    sfm::retriangulation::Triangulate(map, to_retriangulate, 
-      config["triangulation_min_ray_angle"].cast<float>(),
-      config["triangulation_min_depth"].cast<float>(),
-      config["processes"].cast<int>());
+  if (!subset.empty()) {
+    sfm::retriangulation::Triangulate(
+        map, to_retriangulate,
+        config["triangulation_min_ray_angle"].cast<float>(),
+        config["triangulation_min_depth"].cast<float>(),
+        config["processes"].cast<int>());
   }
   const auto timer_triangulate = std::chrono::high_resolution_clock::now();
 
@@ -904,7 +922,8 @@ py::dict BAHelpers::Bundle(
           .count() /
       1000000.0;
   report["num_images"] = map.GetShots().size();
-  report["num_points"] = subset.empty() ? map.GetLandmarks().size() : subset.size();
+  report["num_points"] =
+      subset.empty() ? map.GetLandmarks().size() : subset.size();
   report["num_reprojections"] = added_reprojections;
   return report;
 }
diff --git a/opensfm/src/sfm/src/tracks_helpers.cc b/opensfm/src/sfm/src/tracks_helpers.cc
index a09ab75c0..c1ceda591 100644
--- a/opensfm/src/sfm/src/tracks_helpers.cc
+++ b/opensfm/src/sfm/src/tracks_helpers.cc
@@ -1,4 +1,5 @@
-#include "sfm/tracks_helpers.h"
+#include <foundation/memory.h>
+#include <sfm/tracks_helpers.h>
 
 #include <unordered_set>
 #include <vector>
@@ -11,40 +12,40 @@ std::unordered_map<map::ShotId, int> CountTracksPerShot(
   for (const auto& track : tracks) {
     tracks_set.insert(track);
   }
-  
+
   std::unordered_map<map::ShotId, int> counts;
   for (int i = 0; i < shots.size(); ++i) {
     counts[shots[i]] = 0;
   }
 
 #pragma omp parallel
-{
-  std::vector<int> thread_counts(shots.size(), 0);
+  {
+    std::vector<int> thread_counts(shots.size(), 0);
 #pragma omp for
-  for (int i = 0; i < shots.size(); ++i) {
-    const auto& shot = shots[i];
-    const auto& observations = manager.GetShotObservations(shot);
-
-    int sum = 0;
-    for (const auto& obs : observations) {
-      const auto& trackID = obs.first;
-      if (tracks_set.find(trackID) == tracks_set.end()) {
-        continue;
+    for (int i = 0; i < shots.size(); ++i) {
+      const auto& shot = shots[i];
+      const auto observations = manager.GetShotObservations(shot);
+
+      int sum = 0;
+      for (const auto& obs : observations) {
+        const auto& trackID = obs.first;
+        if (tracks_set.find(trackID) == tracks_set.end()) {
+          continue;
+        }
+        ++sum;
       }
-      ++sum;
+      thread_counts[i] = sum;
     }
-    thread_counts[i] = sum;
-  }
 
 #pragma omp critical
-  {
-    for (int i = 0; i < shots.size(); ++i) {
-      if (thread_counts[i] > 0) {
-        counts[shots[i]] = thread_counts[i];
+    {
+      for (int i = 0; i < shots.size(); ++i) {
+        if (thread_counts[i] > 0) {
+          counts[shots[i]] = thread_counts[i];
+        }
       }
     }
   }
-}
 
   return counts;
 }

From da8a5cba8987699ae3b02e72c253d2aefcf58176 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 14:13:33 +0100
Subject: [PATCH 225/235] feat: optimize bundle problems setup and add timers

---
 opensfm/src/bundle/bundle_adjuster.h      |   7 +-
 opensfm/src/bundle/python/pybind.cc       |   3 +-
 opensfm/src/bundle/src/bundle_adjuster.cc |  32 +++-
 opensfm/src/map/landmark.h                |   8 +-
 opensfm/src/map/shot.h                    |  14 +-
 opensfm/src/map/src/landmark.cc           |  18 +-
 opensfm/src/map/src/map.cc                |  25 ++-
 opensfm/src/map/test/map_test.cc          |   6 +-
 opensfm/src/sfm/src/ba_helpers.cc         | 203 +++++++++++++++-------
 opensfm/test/utils.py                     |  15 +-
 10 files changed, 229 insertions(+), 102 deletions(-)

diff --git a/opensfm/src/bundle/bundle_adjuster.h b/opensfm/src/bundle/bundle_adjuster.h
index 64c89ce10..ecf6c9cb1 100644
--- a/opensfm/src/bundle/bundle_adjuster.h
+++ b/opensfm/src/bundle/bundle_adjuster.h
@@ -174,7 +174,7 @@ class BundleAdjuster {
   // Basic
   void AddCamera(const std::string& id, const geometry::Camera& camera,
                  const geometry::Camera& prior, bool constant);
-  void AddPoint(const std::string& id, const Vec3d& position, bool constant);
+  Point* AddPoint(const std::string& id, const Vec3d& position, bool constant);
   void AddPointPrior(const std::string& id, const Vec3d& position,
                      const Vec3d& std_deviation, bool has_altitude_prior);
   void SetCameraBias(const std::string& id, const geometry::Similarity& bias);
@@ -204,6 +204,9 @@ class BundleAdjuster {
       const std::string& shot, const std::string& point,
       const Vec2d& observation, double std_deviation,
       const std::optional<map::Depth>& depth_prior = std::nullopt);
+  void AddPointProjectionObservationRaw(
+      Shot* shot, Point* point, const Vec2d& observation, double std_deviation,
+      const std::optional<map::Depth>& depth_prior);
 
   // Relative motion constraints
   void AddRelativeMotion(const RelativeMotion& rm);
@@ -275,11 +278,13 @@ class BundleAdjuster {
   geometry::Similarity GetBias(const std::string& id) const;
   Reconstruction GetReconstruction(const std::string& reconstruction_id) const;
   Point GetPoint(const std::string& id) const;
+  Point* GetPointRaw(const std::string& id);
   bool HasPoint(const std::string& id) const;
   RigCamera GetRigCamera(const std::string& rig_camera_id) const;
   RigInstance GetRigInstance(const std::string& instance_id) const;
   std::map<std::string, RigCamera> GetRigCameras() const;
   std::map<std::string, RigInstance> GetRigInstances() const;
+  Shot* GetShotRaw(const std::string& id);
 
   // Minimization details
   std::string BriefReport() const;
diff --git a/opensfm/src/bundle/python/pybind.cc b/opensfm/src/bundle/python/pybind.cc
index 27b662147..9c8372786 100644
--- a/opensfm/src/bundle/python/pybind.cc
+++ b/opensfm/src/bundle/python/pybind.cc
@@ -68,7 +68,8 @@ PYBIND11_MODULE(pybundle, m) {
            &bundle::BundleAdjuster::AddRigInstancePositionPrior)
       .def("set_scale_sharing", &bundle::BundleAdjuster::SetScaleSharing)
       .def("get_reconstruction", &bundle::BundleAdjuster::GetReconstruction)
-      .def("add_point", &bundle::BundleAdjuster::AddPoint)
+      .def("add_point", &bundle::BundleAdjuster::AddPoint,
+           py::return_value_policy::reference)
       .def("add_point_prior", &bundle::BundleAdjuster::AddPointPrior)
       .def("get_point", &bundle::BundleAdjuster::GetPoint)
       .def("has_point", &bundle::BundleAdjuster::HasPoint)
diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 7a24c6cca..8bf6a1270 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -210,8 +210,8 @@ void BundleAdjuster::AddReconstructionInstance(
   reconstructions_assignments_[instance_id] = reconstruction_id;
 }
 
-void BundleAdjuster::AddPoint(const std::string& id, const Vec3d& position,
-                              bool constant) {
+Point* BundleAdjuster::AddPoint(const std::string& id, const Vec3d& position,
+                                bool constant) {
   auto point =
       &points_
            .emplace(std::piecewise_construct, std::forward_as_tuple(id),
@@ -221,6 +221,7 @@ void BundleAdjuster::AddPoint(const std::string& id, const Vec3d& position,
   if (constant) {
     point->SetParametersToOptimize({});
   }
+  return point;
 }
 
 void BundleAdjuster::AddPointPrior(const std::string& point_id,
@@ -247,7 +248,20 @@ void BundleAdjuster::AddPointProjectionObservation(
   o.coordinates = observation;
   o.std_deviation = std_deviation;
   o.depth_prior = depth_prior;
-  point_projection_observations_.push_back(o);
+  point_projection_observations_.emplace_back(o);
+}
+
+void BundleAdjuster::AddPointProjectionObservationRaw(
+    Shot* shot, Point* point, const Vec2d& observation, double std_deviation,
+    const std::optional<map::Depth>& depth_prior) {
+  PointProjectionObservation o;
+  o.shot = shot;
+  o.camera = shot->GetCamera();
+  o.point = point;
+  o.coordinates = observation;
+  o.std_deviation = std_deviation;
+  o.depth_prior = depth_prior;
+  point_projection_observations_.emplace_back(o);
 }
 
 void BundleAdjuster::AddRelativeMotion(const RelativeMotion& rm) {
@@ -809,7 +823,8 @@ void BundleAdjuster::Run() {
         projection_type, use_analytic_, observation, projection_loss, &problem);
 
     // Add relative depth error blocks
-    geometry::Dispatch<AddRelativeDepthError>(projection_type, observation, projection_loss, &problem);
+    geometry::Dispatch<AddRelativeDepthError>(projection_type, observation,
+                                              projection_loss, &problem);
   }
 
   // Add relative motion errors
@@ -1243,6 +1258,10 @@ Point BundleAdjuster::GetPoint(const std::string& id) const {
   return points_.at(id);
 }
 
+Point* BundleAdjuster::GetPointRaw(const std::string& id) {
+  return &points_.at(id);
+}
+
 bool BundleAdjuster::HasPoint(const std::string& id) const {
   return points_.find(id) != points_.end();
 }
@@ -1275,10 +1294,15 @@ RigInstance BundleAdjuster::GetRigInstance(
 std::map<std::string, RigCamera> BundleAdjuster::GetRigCameras() const {
   return rig_cameras_;
 }
+
 std::map<std::string, RigInstance> BundleAdjuster::GetRigInstances() const {
   return rig_instances_;
 }
 
+Shot* BundleAdjuster::GetShotRaw(const std::string& id) {
+  return &shots_.at(id);
+}
+
 std::string BundleAdjuster::BriefReport() const {
   return last_run_summary_.BriefReport();
 }
diff --git a/opensfm/src/map/landmark.h b/opensfm/src/map/landmark.h
index 0df854431..506db4bd1 100644
--- a/opensfm/src/map/landmark.h
+++ b/opensfm/src/map/landmark.h
@@ -8,6 +8,7 @@
 #include <unordered_map>
 namespace map {
 class Shot;
+struct Observation;
 
 class Landmark {
  public:
@@ -21,11 +22,12 @@ class Landmark {
   void SetColor(const Vec3i& color) { color_ = color; }
 
   // Utility functions
-  void AddObservation(Shot* shot, const FeatureId& feat_id);
+  void AddObservation(Shot* shot, const Observation* observation);
   void RemoveObservation(Shot* shot);
   size_t NumberOfObservations() const;
   FeatureId GetObservationIdInShot(Shot* shot) const;
-  const std::map<Shot*, FeatureId, KeyCompare>& GetObservations() const;
+  const Observation& GetObservationInShot(Shot* shot) const;
+  const std::map<Shot*, const Observation*, KeyCompare>& GetObservations() const;
   void ClearObservations() { observations_.clear(); }
 
   // Comparisons
@@ -47,7 +49,7 @@ class Landmark {
 
  private:
   Vec3d global_pos_;  // point in global
-  std::map<Shot*, FeatureId, KeyCompare> observations_;
+  std::map<Shot*, const Observation*, KeyCompare> observations_;
   Vec3i color_;
   std::map<ShotId, Eigen::VectorXd> reproj_errors_;
 };
diff --git a/opensfm/src/map/shot.h b/opensfm/src/map/shot.h
index 89ce77264..670652b8c 100644
--- a/opensfm/src/map/shot.h
+++ b/opensfm/src/map/shot.h
@@ -101,9 +101,11 @@ class Shot {
   const Observation& GetObservation(const FeatureId id) const {
     return landmark_observations_.at(landmark_id_.at(id));
   }
-  void CreateObservation(Landmark* lm, const Observation& obs) {
-    landmark_observations_.insert(std::make_pair(lm, obs));
+  const Observation* CreateObservation(Landmark* lm, const Observation& obs) {
+    const auto inserted =
+        landmark_observations_.insert(std::make_pair(lm, obs));
     landmark_id_.insert(std::make_pair(obs.feature_id, lm));
+    return &inserted.first->second;
   }
   Observation* GetLandmarkObservation(Landmark* lm) {
     return &landmark_observations_.at(lm);
@@ -117,6 +119,14 @@ class Shot {
     }
   }
   void RemoveLandmarkObservation(const FeatureId id);
+  void ClearLandmarkObservationsUnsafe() {
+    // Use swap idiom to actually release memory, not just clear elements.
+    // clear() may retain allocated memory/bucket capacity.
+    decltype(landmark_observations_) empty_obs;
+    landmark_observations_.swap(empty_obs);
+    decltype(landmark_id_) empty_ids;
+    landmark_id_.swap(empty_ids);
+  }
 
   // Metadata such as GPS, IMU, time
   const ShotMeasurements& GetShotMeasurements() const {
diff --git a/opensfm/src/map/src/landmark.cc b/opensfm/src/map/src/landmark.cc
index 14b1f6ed5..9cbfba89d 100644
--- a/opensfm/src/map/src/landmark.cc
+++ b/opensfm/src/map/src/landmark.cc
@@ -24,14 +24,22 @@ FeatureId Landmark::GetObservationIdInShot(Shot* shot) const {
   if (obs_it == observations_.end()) {
     throw std::runtime_error("Accessing with invalid shot ptr!");
   }
-  return observations_.at(shot);
+  return observations_.at(shot)->feature_id;
 }
 
-void Landmark::AddObservation(Shot* shot, const FeatureId& feat_id) {
-  observations_.emplace(shot, feat_id);
+const Observation& Landmark::GetObservationInShot(Shot* shot) const {
+  auto obs_it = observations_.find(shot);
+  if (obs_it == observations_.end()) {
+    throw std::runtime_error("Accessing with invalid shot ptr!");
+  }
+  return *observations_.at(shot);
+}
+
+void Landmark::AddObservation(Shot* shot, const Observation* observation) {
+  observations_[shot] = observation;
 }
-const std::map<Shot*, FeatureId, KeyCompare>& Landmark::GetObservations()
-    const {
+const std::map<Shot*, const Observation*, KeyCompare>&
+Landmark::GetObservations() const {
   return observations_;
 }
 
diff --git a/opensfm/src/map/src/map.cc b/opensfm/src/map/src/map.cc
index e8773ca2c..096758d98 100644
--- a/opensfm/src/map/src/map.cc
+++ b/opensfm/src/map/src/map.cc
@@ -66,8 +66,8 @@ std::unique_ptr<Map> Map::DeepCopy(const Map& map, bool copy_observations) {
 
 void Map::AddObservation(Shot* const shot, Landmark* const lm,
                          const Observation& obs) {
-  lm->AddObservation(shot, obs.feature_id);
-  shot->CreateObservation(lm, obs);
+  auto* observation = shot->CreateObservation(lm, obs);
+  lm->AddObservation(shot, observation);
 }
 
 void Map::AddObservation(const ShotId& shot_id, const LandmarkId& lm_id,
@@ -131,16 +131,11 @@ Landmark& Map::GetLandmark(const LandmarkId& lm_id) {
 }
 
 void Map::ClearObservationsAndLandmarks() {
-  // first JUST delete the observations of the landmark
-  for (auto& id_lm : landmarks_) {
-    auto& observations = id_lm.second.GetObservations();
-    for (const auto& obs : observations) {
-      obs.first->RemoveLandmarkObservation(obs.second);
-    }
-    id_lm.second.ClearObservations();
+  for (auto& shot_pair : shots_) {
+    shot_pair.second.ClearLandmarkObservationsUnsafe();
   }
-  // then clear the landmarks_
-  landmarks_.clear();
+  decltype(landmarks_) empty_landmarks;
+  landmarks_.swap(empty_landmarks);
 }
 
 void Map::CleanLandmarksBelowMinObservations(const size_t min_observations) {
@@ -151,8 +146,8 @@ void Map::CleanLandmarksBelowMinObservations(const size_t min_observations) {
       const auto& observations = landmark.GetObservations();
       for (const auto& obs : observations) {
         Shot* shot = obs.first;
-        const auto feat_id = obs.second;
-        shot->RemoveLandmarkObservation(feat_id);
+        const auto* feat = obs.second;
+        shot->RemoveLandmarkObservation(feat->feature_id);
       }
       // 3) Remove from landmarks
       it = landmarks_.erase(it);
@@ -308,8 +303,8 @@ void Map::RemoveLandmark(const LandmarkId& lm_id) {
     const auto& observations = landmark.GetObservations();
     for (const auto& obs : observations) {
       Shot* shot = obs.first;
-      const auto feat_id = obs.second;
-      shot->RemoveLandmarkObservation(feat_id);
+      const auto feat = obs.second;
+      shot->RemoveLandmarkObservation(feat->feature_id);
     }
 
     // 3) Remove from landmarks
diff --git a/opensfm/src/map/test/map_test.cc b/opensfm/src/map/test/map_test.cc
index ee737cfda..29be042de 100644
--- a/opensfm/src/map/test/map_test.cc
+++ b/opensfm/src/map/test/map_test.cc
@@ -268,8 +268,8 @@ TEST_F(OneCameraMapFixture, ComputeReprojectionErrorNormalized) {
   auto errors =
       map.ComputeReprojectionErrors(manager, map::Map::ErrorType::Normalized);
   const auto computed = errors["0"]["1"];
-  ASSERT_NEAR(expected[0] / scale, computed[0], 1e-8);
-  ASSERT_NEAR(expected[1] / scale, computed[1], 1e-8);
+  ASSERT_NEAR(expected[0] / scale, computed[0], 1e-7);
+  ASSERT_NEAR(expected[1] / scale, computed[1], 1e-7);
 }
 
 class OneRigMapFixture : public EmptyMapFixture {
@@ -344,7 +344,7 @@ TEST_F(ToyMapFixture, ToTracksManager) {
   ASSERT_EQ(manager.NumTracks(), map.NumberOfLandmarks());
   ASSERT_EQ(manager.NumShots(), map.NumberOfShots() + map.NumberOfPanoShots());
   for (const auto& shot_pair : map.GetShots()) {
-    const auto& shot_obs1 = manager.GetShotObservations(shot_pair.first);
+    const auto shot_obs1 = manager.GetShotObservations(shot_pair.first);
     const auto& shot_obs2 = shot_pair.second.GetLandmarkObservations();
 
     ASSERT_EQ(shot_obs1.size(), shot_obs2.size());
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index af55c7009..c4479af40 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -122,11 +122,14 @@ py::tuple BAHelpers::BundleLocal(
     const AlignedVector<map::GroundControlPoint>& gcp,
     const map::ShotId& central_shot_id, int grid_size, const py::dict& config) {
   py::dict report;
-  const auto start = std::chrono::high_resolution_clock::now();
+
+  const auto timer_neighborhood_start =
+      std::chrono::high_resolution_clock::now();
   auto neighborhood = ShotNeighborhood(
       map, central_shot_id, config["local_bundle_radius"].cast<size_t>(),
       config["local_bundle_min_common_points"].cast<size_t>(),
       config["local_bundle_max_shots"].cast<size_t>());
+  const auto timer_neighborhood_end = std::chrono::high_resolution_clock::now();
   auto& interior = neighborhood.first;
   auto& boundary = neighborhood.second;
 
@@ -142,6 +145,7 @@ py::tuple BAHelpers::BundleLocal(
   const auto timer_grid_end = std::chrono::high_resolution_clock::now();
 
   // set up BA
+  const auto start = std::chrono::high_resolution_clock::now();
   auto ba = bundle::BundleAdjuster();
   ba.SetUseAnalyticDerivatives(
       config["bundle_analytic_derivatives"].cast<bool>());
@@ -156,8 +160,6 @@ py::tuple BAHelpers::BundleLocal(
   std::unordered_set<map::Shot*> int_and_bound(interior.cbegin(),
                                                interior.cend());
   int_and_bound.insert(boundary.cbegin(), boundary.cend());
-  std::unordered_set<map::Landmark*> points;
-  py::list pt_ids;
 
   constexpr bool point_constant{false};
   constexpr bool rig_camera_constant{true};
@@ -228,48 +230,61 @@ py::tuple BAHelpers::BundleLocal(
     }
   }
 
-  size_t added_landmarks = 0;
-  size_t added_reprojections = 0;
+  double t_projections = 0;
+  const auto t_pts_start = std::chrono::high_resolution_clock::now();
+
+  // Retrieve a mapping between map shots and bundle shots we're just created
+  std::unordered_map<map::Shot*, bundle::Shot*> shot_lookup;
+  shot_lookup.reserve(interior.size() + boundary.size());
   for (auto* shot : interior) {
-    // Add all points of the shots that are in the interior
-    for (const auto& lm_obs : shot->GetLandmarkObservations()) {
-      auto* lm = lm_obs.first;
-      // Only add points in the subset
-      if (!subset.empty() && subset.count(lm->id_) == 0) {
-        to_retriangulate.insert(lm->id_);
-        continue;
-      }
-      if (points.count(lm) == 0) {
-        points.insert(lm);
-        pt_ids.append(lm->id_);
-        ba.AddPoint(lm->id_, lm->GetGlobalPos(), point_constant);
-        ++added_landmarks;
-      }
-      const auto& obs = lm_obs.second;
-      ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_, obs.point,
-                                       obs.scale, obs.depth_prior);
-      ++added_reprojections;
-    }
+    shot_lookup[shot] = ba.GetShotRaw(shot->id_);
   }
   for (auto* shot : boundary) {
-    for (const auto& lm_obs : shot->GetLandmarkObservations()) {
-      auto* lm = lm_obs.first;
-      // Only add points in the subset
-      if (!subset.empty() && subset.count(lm->id_) == 0) {
-        to_retriangulate.insert(lm->id_);
-        continue;
-      }
-      if (points.count(lm) > 0) {
-        const auto& obs = lm_obs.second;
-        ba.AddPointProjectionObservation(shot->id_, lm_obs.first->id_,
-                                         obs.point, obs.scale, obs.depth_prior);
-        ++added_reprojections;
+    shot_lookup[shot] = ba.GetShotRaw(shot->id_);
+  }
+
+  // Run over selected tracks only and add all their observations
+  std::unordered_set<map::Landmark*> points;
+  py::list pt_ids;
+  size_t added_landmarks = 0;
+  size_t added_reprojections = 0;
+  for (const auto& selected_track_id : subset) {
+    auto& lm = map.GetLandmark(selected_track_id);
+
+    auto* ba_point = ba.AddPoint(lm.id_, lm.GetGlobalPos(), point_constant);
+
+    points.insert(&lm);
+    pt_ids.append(lm.id_);
+    ++added_landmarks;
+
+    for (const auto& obs_pair : lm.GetObservations()) {
+      auto* shot = obs_pair.first;
+      auto* obs = obs_pair.second;
+
+      auto s_it = shot_lookup.find(shot);
+      if (s_it == shot_lookup.end()) {
+        throw std::runtime_error("Shot " + shot->id_ +
+                                 " not found in bundle adjuster");
       }
+      ba.AddPointProjectionObservationRaw(s_it->second, ba_point, obs->point,
+                                          obs->scale, obs->depth_prior);
+      ++added_reprojections;
     }
   }
 
+  t_projections += std::chrono::duration_cast<std::chrono::microseconds>(
+                       std::chrono::high_resolution_clock::now() - t_pts_start)
+                       .count() /
+                   1000000.0;
+
   if (config["bundle_use_gcp"].cast<bool>() && !gcp.empty()) {
+    const auto t_gcp_start = std::chrono::high_resolution_clock::now();
     AddGCPToBundle(ba, map, gcp, config);
+    t_projections +=
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::high_resolution_clock::now() - t_gcp_start)
+            .count() /
+        1000000.0;
   }
 
   ba.SetPointProjectionLossFunction(
@@ -311,19 +326,33 @@ py::tuple BAHelpers::BundleLocal(
     point->SetReprojectionErrors(pt.reprojection_errors);
   }
 
-  const auto timer_triangulate = std::chrono::high_resolution_clock::now();
+  const auto timer_teardown = std::chrono::high_resolution_clock::now();
   sfm::retriangulation::Triangulate(
       map, to_retriangulate,
       config["triangulation_min_ray_angle"].cast<float>(),
       config["triangulation_min_depth"].cast<float>(),
       config["processes"].cast<int>());
-  const auto timer_teardown = std::chrono::high_resolution_clock::now();
+  const auto timer_triangulate = std::chrono::high_resolution_clock::now();
+
   report["brief_report"] = ba.BriefReport();
   report["wall_times"] = py::dict();
+  report["wall_times"]["neighborhood"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(
+          timer_neighborhood_end - timer_neighborhood_start)
+          .count() /
+      1000000.0;
   report["wall_times"]["setup"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_setup - start)
           .count() /
       1000000.0;
+  report["wall_times"]["setup_projections"] = t_projections;
+  report["wall_times"]["setup_other"] =
+      report["wall_times"]["setup"].cast<double>() - t_projections;
+  report["wall_times"]["grid"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_grid_end -
+                                                            timer_grid_start)
+          .count() /
+      1000000.0;
   report["wall_times"]["run"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_run -
                                                             timer_setup)
@@ -331,12 +360,12 @@ py::tuple BAHelpers::BundleLocal(
       1000000.0;
   report["wall_times"]["teardown"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_teardown -
-                                                            timer_triangulate)
+                                                            timer_run)
           .count() /
       1000000.0;
   report["wall_times"]["triangulate"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_triangulate -
-                                                            timer_run)
+                                                            timer_teardown)
           .count() /
       1000000.0;
   report["num_images"] = interior.size();
@@ -637,6 +666,7 @@ py::dict BAHelpers::BundleShotPoses(
   }
 
   // add observations
+  const auto t_projections_start = std::chrono::high_resolution_clock::now();
   for (const auto& shot_id : shot_ids) {
     const auto& shot = map.GetShot(shot_id);
     for (const auto& lm_obs : shot.GetLandmarkObservations()) {
@@ -645,6 +675,11 @@ py::dict BAHelpers::BundleShotPoses(
                                        obs.scale, obs.depth_prior);
     }
   }
+  const double t_projections =
+      std::chrono::duration_cast<std::chrono::microseconds>(
+          std::chrono::high_resolution_clock::now() - t_projections_start)
+          .count() /
+      1000000.0;
 
   ba.SetPointProjectionLossFunction(
       config["loss_function"].cast<std::string>(),
@@ -687,6 +722,9 @@ py::dict BAHelpers::BundleShotPoses(
       std::chrono::duration_cast<std::chrono::microseconds>(timer_setup - start)
           .count() /
       1000000.0;
+  report["wall_times"]["setup_projections"] = t_projections;
+  report["wall_times"]["setup_other"] =
+      report["wall_times"]["setup"].cast<double>() - t_projections;
   report["wall_times"]["run"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_run -
                                                             timer_setup)
@@ -735,13 +773,24 @@ py::dict BAHelpers::Bundle(
   }
 
   // Only add points in the subset
-  for (const auto& pt_pair : map.GetLandmarks()) {
-    const auto& pt = pt_pair.second;
-    if (!subset.empty() && subset.count(pt.id_) == 0) {
-      to_retriangulate.insert(pt.id_);
-      continue;
+  std::unordered_map<const map::Landmark*, bundle::Point*> landmark_lookup;
+  landmark_lookup.reserve(subset.empty() ? map.GetLandmarks().size()
+                                         : subset.size());
+
+  // Two different - yet similar - loops to avoid
+  // one dummy structure allocation
+  if (!subset.empty()) {
+    for (const auto& track_id : subset) {
+      const auto& pt = map.GetLandmark(track_id);
+      ba.AddPoint(pt.id_, pt.GetGlobalPos(), false);
+      landmark_lookup[&pt] = ba.GetPointRaw(pt.id_);
+    }
+  } else {
+    for (const auto& lm_pair : map.GetLandmarks()) {
+      const auto& pt = lm_pair.second;
+      ba.AddPoint(pt.id_, pt.GetGlobalPos(), false);
+      landmark_lookup[&pt] = ba.GetPointRaw(pt.id_);
     }
-    ba.AddPoint(pt.id_, pt.GetGlobalPos(), false);
   }
 
   auto align_method = config["align_method"].cast<std::string>();
@@ -827,31 +876,52 @@ py::dict BAHelpers::Bundle(
     }
   }
 
+  double t_projections = 0;
+  const auto t_obs_start = std::chrono::high_resolution_clock::now();
   size_t added_reprojections = 0;
+
+  std::unordered_map<const map::Shot*, bundle::Shot*> shot_lookup;
+  shot_lookup.reserve(map.GetShots().size());
+
   for (const auto& shot_pair : map.GetShots()) {
     const auto& shot = shot_pair.second;
 
-    // that one doesn't have it's rig counterpart
     if (do_add_align_vector) {
       constexpr double std_dev = 1e-3;
       ba.AddAbsoluteUpVector(shot.id_, up_vector, std_dev);
     }
+    shot_lookup[&shot] = ba.GetShotRaw(shot.id_);
+  }
 
-    // setup observations for any shot type
-    for (const auto& lm_obs : shot.GetLandmarkObservations()) {
-      if (!subset.empty() && subset.count(lm_obs.first->id_) == 0) {
-        to_retriangulate.insert(lm_obs.first->id_);
-        continue;
+  for (const auto& lm_pair : landmark_lookup) {
+    const map::Landmark* lm = lm_pair.first;
+    bundle::Point* bp = lm_pair.second;
+
+    for (const auto& obs_entry : lm->GetObservations()) {
+      map::Shot* shot = obs_entry.first;
+      const map::Observation* obs = obs_entry.second;
+
+      auto s_it = shot_lookup.find(shot);
+      if (s_it != shot_lookup.end()) {
+        ba.AddPointProjectionObservationRaw(s_it->second, bp, obs->point,
+                                            obs->scale, obs->depth_prior);
+        ++added_reprojections;
       }
-      const auto& obs = lm_obs.second;
-      ba.AddPointProjectionObservation(shot.id_, lm_obs.first->id_, obs.point,
-                                       obs.scale, obs.depth_prior);
-      ++added_reprojections;
     }
   }
+  t_projections += std::chrono::duration_cast<std::chrono::microseconds>(
+                       std::chrono::high_resolution_clock::now() - t_obs_start)
+                       .count() /
+                   1000000.0;
 
   if (config["bundle_use_gcp"].cast<bool>() && !gcp.empty()) {
+    const auto t_gcp_start = std::chrono::high_resolution_clock::now();
     AddGCPToBundle(ba, map, gcp, config);
+    t_projections +=
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::high_resolution_clock::now() - t_gcp_start)
+            .count() /
+        1000000.0;
   }
 
   if (config["bundle_compensate_gps_bias"].cast<bool>() && !gcp.empty()) {
@@ -890,6 +960,8 @@ py::dict BAHelpers::Bundle(
   const auto timer_run = std::chrono::high_resolution_clock::now();
 
   BundleToMap(ba, map, !fix_cameras);
+  const auto timer_teardown = std::chrono::high_resolution_clock::now();
+
   if (!subset.empty()) {
     sfm::retriangulation::Triangulate(
         map, to_retriangulate,
@@ -899,26 +971,33 @@ py::dict BAHelpers::Bundle(
   }
   const auto timer_triangulate = std::chrono::high_resolution_clock::now();
 
-  const auto timer_teardown = std::chrono::high_resolution_clock::now();
   report["brief_report"] = ba.BriefReport();
   report["wall_times"] = py::dict();
   report["wall_times"]["setup"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_setup - start)
           .count() /
       1000000.0;
+  report["wall_times"]["setup_projections"] = t_projections;
+  report["wall_times"]["setup_other"] =
+      report["wall_times"]["setup"].cast<double>() - t_projections;
+  report["wall_times"]["grid"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_grid_end -
+                                                            timer_grid_start)
+          .count() /
+      1000000.0;
   report["wall_times"]["run"] =
       std::chrono::duration_cast<std::chrono::microseconds>(timer_run -
                                                             timer_setup)
           .count() /
       1000000.0;
-  report["wall_times"]["triangulate"] =
-      std::chrono::duration_cast<std::chrono::microseconds>(timer_triangulate -
+  report["wall_times"]["teardown"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_teardown -
                                                             timer_run)
           .count() /
       1000000.0;
-  report["wall_times"]["teardown"] =
-      std::chrono::duration_cast<std::chrono::microseconds>(timer_teardown -
-                                                            timer_triangulate)
+  report["wall_times"]["triangulate"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(timer_triangulate -
+                                                            timer_teardown)
           .count() /
       1000000.0;
   report["num_images"] = map.GetShots().size();
diff --git a/opensfm/test/utils.py b/opensfm/test/utils.py
index a668f07c7..2167314a7 100644
--- a/opensfm/test/utils.py
+++ b/opensfm/test/utils.py
@@ -6,7 +6,8 @@
 
 
 def assert_cameras_equal(cam1: pygeometry.Camera, cam2: pygeometry.Camera) -> None:
-    assert np.allclose(cam1.get_parameters_values(), cam2.get_parameters_values())
+    assert np.allclose(cam1.get_parameters_values(),
+                       cam2.get_parameters_values())
     assert cam1.projection_type == cam2.projection_type
     assert cam1.width == cam2.width
     assert cam1.height == cam2.height
@@ -64,7 +65,8 @@ def assert_shots_equal(
     assert np.allclose(shot1.pose.get_Rt(), shot2.pose.get_Rt(), 1e-5)
     assert shot1.merge_cc == shot2.merge_cc
     assert np.allclose(shot1.covariance, shot2.covariance)
-    assert_metadata_equal(shot1.metadata, shot2.metadata, test_mapillary_specific)
+    assert_metadata_equal(shot1.metadata, shot2.metadata,
+                          test_mapillary_specific)
 
 
 def assert_bias_equal(
@@ -112,7 +114,8 @@ def assert_maps_equal(
 
     # Pano shots are different objects of same value
     for shot_id in map1.get_pano_shots():
-        shot1, shot2 = map1.get_pano_shots()[shot_id], map2.get_pano_shots()[shot_id]
+        shot1, shot2 = map1.get_pano_shots()[shot_id], map2.get_pano_shots()[
+            shot_id]
         assert shot1 is not shot2
         assert_shots_equal(shot1, shot2, test_mapillary_specific)
 
@@ -128,10 +131,10 @@ def assert_maps_equal(
         assert len(obs) == len(obs_cpy)
 
         # Observations are different objects of same value
-        for shot, obs_id in obs.items():
-            obs1 = shot.get_observation(obs_id)
+        for shot, obs in obs.items():
+            obs1 = shot.get_observation(obs.id)
             shot_cpy = map2.get_shots()[shot.id]
-            obs_cpy = shot_cpy.get_observation(obs_id)
+            obs_cpy = shot_cpy.get_observation(obs.id)
             assert obs1 is not obs_cpy
 
     # Topocentric reference are different objects of same value

From 9f4f09f76da0ab05622e35396131ad3784f3fb8f Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 14:36:18 +0100
Subject: [PATCH 226/235] feat: added multithreaded + consumer/producer
 triangulation.

---
 opensfm/reconstruction.py              |  53 +++--
 opensfm/src/foundation/CMakeLists.txt  |   3 +
 opensfm/src/foundation/memory.h        |  15 ++
 opensfm/src/foundation/src/memory.cc   |  23 ++
 opensfm/src/foundation/threading.h     |  48 +++++
 opensfm/src/sfm/python/pybind.cc       |   5 +
 opensfm/src/sfm/retriangulation.h      |  15 +-
 opensfm/src/sfm/src/ba_helpers.cc      |   4 +-
 opensfm/src/sfm/src/retriangulation.cc | 286 +++++++++++++++++++------
 9 files changed, 362 insertions(+), 90 deletions(-)
 create mode 100644 opensfm/src/foundation/memory.h
 create mode 100644 opensfm/src/foundation/src/memory.cc
 create mode 100644 opensfm/src/foundation/threading.h

diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 113de5882..6b384a497 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1102,32 +1102,39 @@ def retriangulate(
     report = {}
     report["num_points_before"] = len(reconstruction.points)
 
-    threshold = config["triangulation_threshold"]
-    min_ray_angle = config["triangulation_min_ray_angle"]
-    min_depth = config["triangulation_min_depth"]
-    refinement_iterations = config["triangulation_refinement_iterations"]
+    if config["triangulation_type"] == "FULL":
+        reconstruction.points = {}
+        pysfm.reconstruct_from_tracks_manager(
+            reconstruction.map, tracks_manager, config
+        )
+    else:
+        threshold = config["triangulation_threshold"]
+        min_ray_angle = config["triangulation_min_ray_angle"]
+        min_depth = config["triangulation_min_depth"]
+        refinement_iterations = config["triangulation_refinement_iterations"]
 
-    reconstruction.points = {}
+        reconstruction.points = {}
 
-    all_shots_ids = set(tracks_manager.get_shot_ids())
+        all_shots_ids = set(tracks_manager.get_shot_ids())
 
-    triangulator = TrackTriangulator(
-        reconstruction, TrackHandlerTrackManager(
-            tracks_manager, reconstruction)
-    )
-    tracks = set()
-    for image in reconstruction.shots.keys():
-        if image in all_shots_ids:
-            tracks.update(tracks_manager.get_shot_observations(image).keys())
-    for track in tracks:
-        if config["triangulation_type"] == "ROBUST":
-            triangulator.triangulate_robust(
-                track, threshold, min_ray_angle, min_depth, refinement_iterations
-            )
-        elif config["triangulation_type"] == "FULL":
-            triangulator.triangulate(
-                track, threshold, min_ray_angle, min_depth, refinement_iterations
-            )
+        triangulator = TrackTriangulator(
+            reconstruction, TrackHandlerTrackManager(
+                tracks_manager, reconstruction)
+        )
+        tracks = set()
+        for image in reconstruction.shots.keys():
+            if image in all_shots_ids:
+                tracks.update(
+                    tracks_manager.get_shot_observations(image).keys())
+        for track in tracks:
+            if config["triangulation_type"] == "ROBUST":
+                triangulator.triangulate_robust(
+                    track, threshold, min_ray_angle, min_depth, refinement_iterations
+                )
+            else:
+                raise ValueError(
+                    f"This should be handled before in CPP: {config['triangulation_type']}"
+                )
 
     report["num_points_after"] = len(reconstruction.points)
     chrono.lap("retriangulate")
diff --git a/opensfm/src/foundation/CMakeLists.txt b/opensfm/src/foundation/CMakeLists.txt
index 9508d1882..09557051f 100644
--- a/opensfm/src/foundation/CMakeLists.txt
+++ b/opensfm/src/foundation/CMakeLists.txt
@@ -1,10 +1,13 @@
 set(FOUNDATION_FILES
+    memory.h
     stl_extensions.h
+    threading.h
     types.h
     newton_raphson.h
     numeric.h
     optional.h
     union_find.h
+    src/memory.cc
     src/types.cc
     src/newton_raphson.cc
     src/numeric.cc
diff --git a/opensfm/src/foundation/memory.h b/opensfm/src/foundation/memory.h
new file mode 100644
index 000000000..7e355429d
--- /dev/null
+++ b/opensfm/src/foundation/memory.h
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace foundation {
+
+// RAII class to limit the number of malloc arenas on Linux/glibc
+// This helps reduce memory fragmentation when using many OpenMP threads.
+// Does nothing on non-Linux platforms as their allocation are supposedly
+// smarter than glibc's malloc.
+class ScopedMallocArena {
+ public:
+  ScopedMallocArena();
+  ~ScopedMallocArena();
+};
+
+}  // namespace foundation
diff --git a/opensfm/src/foundation/src/memory.cc b/opensfm/src/foundation/src/memory.cc
new file mode 100644
index 000000000..bf989efe4
--- /dev/null
+++ b/opensfm/src/foundation/src/memory.cc
@@ -0,0 +1,23 @@
+#include <foundation/memory.h>
+
+#ifdef __linux__
+#include <malloc.h>
+#endif
+
+namespace foundation {
+
+ScopedMallocArena::ScopedMallocArena() {
+#ifdef __linux__
+  // Limit to 2 arenas to prevent excessive fragmentation with many threads
+  mallopt(M_ARENA_MAX, 2);
+#endif
+}
+
+ScopedMallocArena::~ScopedMallocArena() {
+#ifdef __linux__
+  // 0 means default behavior (based M_ARENA_TEST)
+  mallopt(M_ARENA_MAX, 0);
+#endif
+}
+
+}  // namespace foundation
diff --git a/opensfm/src/foundation/threading.h b/opensfm/src/foundation/threading.h
new file mode 100644
index 000000000..0cdbdbba3
--- /dev/null
+++ b/opensfm/src/foundation/threading.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+
+namespace foundation {
+
+template <typename T>
+class ConcurrentQueue {
+ public:
+  void Push(T result) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    queue_.push(std::move(result));
+    cv_.notify_one();
+  }
+
+  bool Pop(T& result) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [this] { return !queue_.empty() || finished_; });
+    if (queue_.empty()) {
+      return false;
+    }
+    result = std::move(queue_.front());
+    queue_.pop();
+    return true;
+  }
+
+  void Finish() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    finished_ = true;
+    cv_.notify_all();
+  }
+
+  size_t Size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return queue_.size();
+  }
+
+ private:
+  std::queue<T> queue_;
+  mutable std::mutex mutex_;
+  std::condition_variable cv_;
+  bool finished_ = false;
+};
+
+}  // namespace foundation
diff --git a/opensfm/src/sfm/python/pybind.cc b/opensfm/src/sfm/python/pybind.cc
index aa8f90169..4fd2bcd12 100644
--- a/opensfm/src/sfm/python/pybind.cc
+++ b/opensfm/src/sfm/python/pybind.cc
@@ -38,4 +38,9 @@ PYBIND11_MODULE(pysfm, m) {
 
   m.def("realign_maps", &sfm::retriangulation::RealignMaps,
         py::call_guard<py::gil_scoped_release>());
+
+  m.def("reconstruct_from_tracks_manager",
+        &sfm::retriangulation::ReconstructFromTracksManager, py::arg("map"),
+        py::arg("tracks_manager"), py::arg("config"),
+        py::call_guard<py::gil_scoped_release>());
 }
diff --git a/opensfm/src/sfm/retriangulation.h b/opensfm/src/sfm/retriangulation.h
index 58b39b436..531aed88d 100644
--- a/opensfm/src/sfm/retriangulation.h
+++ b/opensfm/src/sfm/retriangulation.h
@@ -1,11 +1,20 @@
 #pragma once
-#include <unordered_set>
-
 #include <map/map.h>
 #include <map/tracks_manager.h>
+#include <pybind11/pybind11.h>
+
+#include <unordered_set>
+
+namespace py = pybind11;
 
 namespace sfm::retriangulation {
 void RealignMaps(const map::Map& reference, map::Map& to_align,
                  bool update_points);
-int Triangulate(map::Map& map, const std::unordered_set<map::TrackId>& track_ids, float min_angle, float min_depth, int processing_threads);
+int Triangulate(map::Map& map,
+                const std::unordered_set<map::TrackId>& track_ids,
+                float reproj_threshold, float min_angle, float min_depth,
+                int processing_threads);
+void ReconstructFromTracksManager(map::Map& map,
+                                  const map::TracksManager& tracks_manager,
+                                  const py::dict& config);
 }  // namespace sfm::retriangulation
diff --git a/opensfm/src/sfm/src/ba_helpers.cc b/opensfm/src/sfm/src/ba_helpers.cc
index c4479af40..57f75b7df 100644
--- a/opensfm/src/sfm/src/ba_helpers.cc
+++ b/opensfm/src/sfm/src/ba_helpers.cc
@@ -328,7 +328,7 @@ py::tuple BAHelpers::BundleLocal(
 
   const auto timer_teardown = std::chrono::high_resolution_clock::now();
   sfm::retriangulation::Triangulate(
-      map, to_retriangulate,
+      map, to_retriangulate, config["triangulation_threshold"].cast<float>(),
       config["triangulation_min_ray_angle"].cast<float>(),
       config["triangulation_min_depth"].cast<float>(),
       config["processes"].cast<int>());
@@ -964,7 +964,7 @@ py::dict BAHelpers::Bundle(
 
   if (!subset.empty()) {
     sfm::retriangulation::Triangulate(
-        map, to_retriangulate,
+        map, to_retriangulate, config["triangulation_threshold"].cast<float>(),
         config["triangulation_min_ray_angle"].cast<float>(),
         config["triangulation_min_depth"].cast<float>(),
         config["processes"].cast<int>());
diff --git a/opensfm/src/sfm/src/retriangulation.cc b/opensfm/src/sfm/src/retriangulation.cc
index 2173a5d39..2c51a8ffd 100644
--- a/opensfm/src/sfm/src/retriangulation.cc
+++ b/opensfm/src/sfm/src/retriangulation.cc
@@ -1,11 +1,27 @@
+#include <foundation/memory.h>
+#include <foundation/threading.h>
+#include <geometry/triangulation.h>
 #include <map/defines.h>
+#include <map/map.h>
 #include <map/tracks_manager.h>
+#include <omp.h>
 #include <sfm/retriangulation.h>
+#include <sfm/tracks_helpers.h>
 
-#include <geometry/triangulation.h>
-#include <map/map.h>
-
+#include <atomic>
+#include <condition_variable>
 #include <limits>
+#include <mutex>
+#include <queue>
+#include <random>
+
+namespace {
+struct TriangulationResult {
+  map::TrackId track_id;
+  Vec3d position;
+  std::vector<std::pair<map::Shot*, map::Observation>> observations;
+};
+}  // namespace
 
 namespace sfm::retriangulation {
 void RealignMaps(const map::Map& map_from, map::Map& map_to,
@@ -116,79 +132,225 @@ void RealignMaps(const map::Map& map_from, map::Map& map_to,
   }
 }
 
-int Triangulate(map::Map& map, const std::unordered_set<map::TrackId>& track_ids, float min_angle, float min_depth, int processing_threads) {
-    constexpr size_t kDefaultObservations = 10;
-    const float min_angle_rad = min_angle * M_PI / 180.0;
+void ReconstructFromTracksManager(map::Map& map,
+                                  const map::TracksManager& tracks_manager,
+                                  const py::dict& config) {
+  foundation::ScopedMallocArena scoped_malloc_arena;
 
-    int count = 0;
-    std::vector<map::TrackId> track_ids_vec(track_ids.begin(), track_ids.end());
-    std::vector<map::TrackId> to_delete;
-#pragma omp parallel num_threads(processing_threads)
-    {
-      std::vector<map::TrackId> thread_to_delete;
+  const float triangulation_threshold =
+      config["triangulation_threshold"].cast<float>();
+  const float min_angle = config["triangulation_min_ray_angle"].cast<float>();
+  const float min_depth = config["triangulation_min_depth"].cast<float>();
+  const int refinement_iterations =
+      config["triangulation_refinement_iterations"].cast<int>();
+  int processes = config["processes"].cast<int>();
+  const float min_angle_rad = min_angle * M_PI / 180.0;
 
-      std::vector<double> threshold_list(kDefaultObservations, 1.0);
-      MatX3d origins(kDefaultObservations, 3);
-      MatX3d bearings(kDefaultObservations, 3);
-#pragma omp for schedule(static)
-      for (int i = 0; i < static_cast<int>(track_ids_vec.size()); ++i) {
-          const auto& track_id = track_ids_vec.at(i);
-          if (!map.HasLandmark(track_id)) {
-              continue;
-          }
-          auto& landmark = map.GetLandmark(track_id);
-          const auto& observations = landmark.GetObservations();
-          const size_t num_observations = observations.size();
-          if (num_observations < 2) {
-              thread_to_delete.push_back(track_id);
-              continue;
-          }
+  // Clear existing observations and landmarks
+  map.ClearObservationsAndLandmarks();
+
+  auto& shots = map.GetShots();
+  auto track_ids = tracks_manager.GetTrackIds();
+
+  // Randomize track ids to avoid threads to only get invalid tracks
+  std::shuffle(track_ids.begin(), track_ids.end(),
+               std::mt19937{std::random_device{}()});
 
-          if(threshold_list.size() != num_observations) {
-              threshold_list.resize(num_observations, 1.0);
+  // Helper lambda to process a single track
+  auto process_track =
+      [&](const map::TrackId& track_id,
+          std::vector<std::pair<map::Shot*, map::Observation>>& track_obs,
+          std::vector<double>& thresholds, MatX3d& origins,
+          MatX3d& bearings) -> std::pair<bool, Vec3d> {
+    const auto obs_dict = tracks_manager.GetTrackObservations(track_id);
+
+    track_obs.clear();
+    track_obs.reserve(obs_dict.size());
+
+    for (const auto& kv : obs_dict) {
+      const auto it = shots.find(kv.first);
+      if (it != shots.end()) {
+        track_obs.emplace_back(&it->second, kv.second);
+      }
+    }
+
+    if (track_obs.size() < 2) {
+      return {false, Vec3d::Zero()};
+    }
+
+    const size_t track_size = track_obs.size();
+    if (thresholds.size() < track_size) {
+      thresholds.resize(track_size, triangulation_threshold);
+    }
+
+    if (static_cast<size_t>(origins.rows()) < track_size) {
+      origins.resize(track_size, 3);
+      bearings.resize(track_size, 3);
+    }
+
+    for (size_t j = 0; j < track_size; ++j) {
+      origins.row(j) = track_obs[j].first->GetPose()->GetOrigin();
+      bearings.row(j) = track_obs[j].first->Bearing(track_obs[j].second.point);
+    }
+
+    auto res = geometry::TriangulateBearingsMidpoint(
+        origins.topRows(track_size), bearings.topRows(track_size), thresholds,
+        min_angle_rad, min_depth);
+
+    if (res.first) {
+      Vec3d refined = geometry::PointRefinement(
+          origins.topRows(track_size), bearings.topRows(track_size), res.second,
+          refinement_iterations);
+      return {true, refined};
+    }
+    return {false, Vec3d::Zero()};
+  };
+
+  foundation::ConcurrentQueue<TriangulationResult> queue;
+  std::atomic<int> producers_active{0};
+
+  // 0 - Parallel track triangulation and valid observation collection per shot
+  // (per thread, then re-aggregated)
+#pragma omp parallel num_threads(processes)
+  {
+    const int thread_id = omp_get_thread_num();
+    const int num_threads = omp_get_num_threads();
+
+    // Reusable buffers per thread
+    std::vector<double> thresholds;
+    MatX3d origins, bearings;
+    std::vector<std::pair<map::Shot*, map::Observation>> track_obs;
+
+    if (num_threads == 1) {
+      // Sequential fallback
+      for (const auto& track_id : track_ids) {
+        auto res =
+            process_track(track_id, track_obs, thresholds, origins, bearings);
+        if (res.first) {
+          auto& landmark = map.CreateLandmark(track_id, res.second);
+          for (const auto& shot_n_obs : track_obs) {
+            auto* new_obs = shot_n_obs.first->CreateObservation(
+                &landmark, shot_n_obs.second);
+            landmark.AddObservation(shot_n_obs.first, new_obs);
           }
-          if(origins.rows() !=  num_observations) {
-              origins.resize(num_observations, 3);
+        }
+      }
+    } else {
+      // Producer-Consumer Pattern
+#pragma omp single
+      producers_active = num_threads - 1;
+
+      if (thread_id == 0) {
+        // Consumer: Thread 0
+        TriangulationResult res;
+        while (queue.Pop(res)) {
+          auto& landmark = map.CreateLandmark(res.track_id, res.position);
+          for (const auto& obs_pair : res.observations) {
+            auto* new_obs =
+                obs_pair.first->CreateObservation(&landmark, obs_pair.second);
+            landmark.AddObservation(obs_pair.first, new_obs);
           }
-          if(bearings.rows() !=  num_observations) {
-              bearings.resize(num_observations, 3);
+        }
+      } else {
+        // Producers: Threads 1..N-1
+        // Manual loop distribution with stride
+        for (size_t i = thread_id - 1; i < track_ids.size();
+             i += (num_threads - 1)) {
+          const auto& track_id = track_ids[i];
+          auto res =
+              process_track(track_id, track_obs, thresholds, origins, bearings);
+          if (res.first) {
+            queue.Push({track_id, res.second, track_obs});
           }
+        }
 
-          int idx = 0;
-          for (const auto& obs_pair : observations) {
-              const map::Shot* shot = obs_pair.first;
-              origins.row(idx) = shot->GetPose()->GetOrigin();
-              bearings.row(idx) = shot->LandmarkBearing(&landmark);
-              ++idx;
-          }
+        if (--producers_active == 0) {
+          queue.Finish();
+        }
+      }
+    }
+  }
+}
 
-          // Triangulate using midpoint method
-          const auto ok_pos = geometry::TriangulateBearingsMidpoint(origins, bearings, threshold_list,
-                                                                    min_angle_rad, min_depth);
-          if (!ok_pos.first) {
-            thread_to_delete.push_back(track_id);
-          }
-          else  {
-            landmark.SetGlobalPos(ok_pos.second);
+int Triangulate(map::Map& map,
+                const std::unordered_set<map::TrackId>& track_ids,
+                float reproj_threshold, float min_angle, float min_depth,
+                int processing_threads) {
+  foundation::ScopedMallocArena scoped_malloc_arena;
 
-            // Refine the triangulated point
-            const auto pos_refined = geometry::PointRefinement(origins, bearings, landmark.GetGlobalPos(), 20);
-            landmark.SetGlobalPos(pos_refined);
-          }
+  constexpr size_t kDefaultObservations = 10;
+  const float min_angle_rad = min_angle * M_PI / 180.0;
+
+  int count = 0;
+  std::vector<map::TrackId> track_ids_vec(track_ids.begin(), track_ids.end());
+  std::vector<map::TrackId> to_delete;
+#pragma omp parallel num_threads(processing_threads)
+  {
+    std::vector<map::TrackId> thread_to_delete;
+
+    std::vector<double> threshold_list(kDefaultObservations, reproj_threshold);
+    MatX3d origins(kDefaultObservations, 3);
+    MatX3d bearings(kDefaultObservations, 3);
+#pragma omp for schedule(static)
+    for (int i = 0; i < static_cast<int>(track_ids_vec.size()); ++i) {
+      const auto& track_id = track_ids_vec.at(i);
+      if (!map.HasLandmark(track_id)) {
+        continue;
       }
+      auto& landmark = map.GetLandmark(track_id);
+      const auto& observations = landmark.GetObservations();
+      const size_t num_observations = observations.size();
+      if (num_observations < 2) {
+        thread_to_delete.push_back(track_id);
+        continue;
+      }
+
+      if (threshold_list.size() != num_observations) {
+        threshold_list.resize(num_observations, reproj_threshold);
+      }
+      if (origins.rows() != num_observations) {
+        origins.resize(num_observations, 3);
+      }
+      if (bearings.rows() != num_observations) {
+        bearings.resize(num_observations, 3);
+      }
+
+      int idx = 0;
+      for (const auto& obs_pair : observations) {
+        const map::Shot* shot = obs_pair.first;
+        origins.row(idx) = shot->GetPose()->GetOrigin();
+        bearings.row(idx) = shot->LandmarkBearing(&landmark);
+        ++idx;
+      }
+
+      // Triangulate using midpoint method
+      const auto ok_pos = geometry::TriangulateBearingsMidpoint(
+          origins, bearings, threshold_list, min_angle_rad, min_depth);
+      if (!ok_pos.first) {
+        thread_to_delete.push_back(track_id);
+      } else {
+        landmark.SetGlobalPos(ok_pos.second);
+
+        // Refine the triangulated point
+        const auto pos_refined = geometry::PointRefinement(
+            origins, bearings, landmark.GetGlobalPos(), 20);
+        landmark.SetGlobalPos(pos_refined);
+      }
+    }
 #pragma omp critical
-      {
-        to_delete.insert(to_delete.end(), thread_to_delete.begin(), thread_to_delete.end());
-      }  
+    {
+      to_delete.insert(to_delete.end(), thread_to_delete.begin(),
+                       thread_to_delete.end());
     }
+  }
 
-    // Remove landmarks that were not triangulated
-    for (const auto& track_id : to_delete) {
-      if (map.HasLandmark(track_id)) {
-        map.RemoveLandmark(track_id);
-      }
+  // Remove landmarks that were not triangulated
+  for (const auto& track_id : to_delete) {
+    if (map.HasLandmark(track_id)) {
+      map.RemoveLandmark(track_id);
     }
-    return count;
+  }
+  return count;
 }
 
 }  // namespace sfm::retriangulation

From 2061cd3430b0f0c2d0b8a56cce49233599460ee6 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 14:36:51 +0100
Subject: [PATCH 227/235] feat: welcome AI friends !

---
 .github/copilot-instructions.md | 52 +++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 .github/copilot-instructions.md

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 000000000..d103a476a
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,52 @@
+# OpenSfM AI Coding Instructions
+
+## 1. Architecture & "Big Picture"
+OpenSfM is a Structure-from-Motion library with a hybrid architecture:
+- **Core Logic (C++)**: Heavy computational tasks (geometry, bundle adjustment, features) are implemented in C++ under `opensfm/src/`. These are exposed to Python as compiled modules (e.g., `pygeometry`, `pymap`, `pfm`) using **PyBind11**.
+- **Pipeline Layout (Python)**: The application logic, pipeline orchestration, and user interface are in Python (`opensfm/` package).
+- **Data Abstraction**: The `DataSet` class (`opensfm/dataset.py`) is the central definition for filesystem interactions. All pipeline stages read/write to a hardcoded directory structure (`images/`, `config.yaml`, `reconstruction.json`) managed by this class.
+- **State Management**: The `Reconstruction` class (`opensfm/types.py`) wraps the C++ `pymap.Map` object. This pattern (Python class holding a C++ handle) is pervasive.
+
+## 2. Key Developer Workflows
+
+### Building
+The project uses `scikit-build-core` to compile C++ extensions.
+- **Full Build**: `pip install -e .[test]` (Builds C++ extensions and tests, and installs the package in editable mode).
+- **Rebuild C++**: Re-running `pip install -e .` is usually required after changing `.cc` files.
+- **Dependencies**: Managed via `pyproject.toml` for managing Python dependencies. Outer envinvironment (C++ toolchain, libraries) is set up through `conda` and the `conda.yml` file. Any change to `conda.yml` requires recreating the conda environment with `conda env create --file conda.yml --yes`, then activating it with `conda activate opensfm`. Note that before running the build commands, the conda environment must be activated once.
+
+### Testing
+- **Framework**: `pytest` is used for all tests.
+- **Location**: `opensfm/test/` for Python tests. C++ tests are in `./cmake_build`.
+- **Synthetic Data**: Python tests heavily rely on synthetic scenes generated in `opensfm/test/conftest.py`. Look for fixtures like `scene_synthetic` or `scene_synthetic_cube`.
+- **Run Tests**: `pytest opensfm/test/` for Python tests. C++ tests can be run via `ctest` with `cd cmake_build && ctest --output-on-failure && cd ..`.
+
+### Running the Pipeline
+- **Entry Point**: `bin/opensfm` (shell script) -> `bin/opensfm_main.py`.
+- **Commands**: Each CLI command (e.g., `detect_features`, `reconstruct`) is implemented as a module in `opensfm/commands/`.
+- **Example**: `bin/opensfm reconstruct path/to/dataset` invokes the `run()` method in `opensfm/commands/reconstruct.py`.
+
+## 3. Coding Conventions & Patterns
+
+### Python/C++ Interop
+- **Wrappers**: Do not use C++ objects directly if a Python wrapper exists (e.g., use `opensfm.types.Reconstruction` instead of `opensfm.pymap.Map` where possible). 
+- **Extensions**: C++ extensions are imported from the root package (e.g., `from opensfm import pygeometry`).
+
+### Type Hinting
+- **Strictness**: The codebase uses `pyre-strict`. Ensure all new code has complete type annotations. A comment `# pyre-strict` is often present at the top of files.
+
+### Configuration
+- **Definition**: Default parameters are in `opensfm/config.py` (dataclass `OpenSfMConfig`).
+- **Overrides**: Parameters are overridden by `config.yaml` in the dataset directory.
+- **Access**: Access config values via `data.config['param_name']` (where `data` is a `DataSet` instance).
+
+## 4. Essential Files
+- `opensfm/dataset.py`: **READ THIS FIRST** when dealing with file I/O. Defines where every file lives.
+- `opensfm/types.py`: Defines key data structures (`Reconstruction`, `Shot`, `Camera`).
+- `opensfm/config.py`: Documentation for all tunable parameters.
+- `opensfm/src/map/map.cc`: The backing C++ implementation for `Reconstruction`.
+- `opensfm/commands/`: Implementation of individual pipeline steps.
+
+## 5. Common Pitfalls
+- **Direct File Access**: Avoid manual `open()` calls. Use `dataset.load_*` and `dataset.save_*` methods to ensure consistency with the expected directory structure.
+- **Geometry Types**: Be careful with rotation representations (angle-axis vs matrices). `pygeometry` exposes helper functions; check `opensfm/src/geometry/` for implementation details if behavior is unclear.

From 0e3152fda93efc95dfec7299d58120a86200d542 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Mon, 12 Jan 2026 20:46:31 +0100
Subject: [PATCH 228/235] feat: add debug parameters to limit the number of
 shots when debugging large datasets

---
 opensfm/config.py         |  2 ++
 opensfm/reconstruction.py | 12 ++++++++++++
 2 files changed, 14 insertions(+)

diff --git a/opensfm/config.py b/opensfm/config.py
index 1ebcb9b33..a9e1234d4 100644
--- a/opensfm/config.py
+++ b/opensfm/config.py
@@ -305,6 +305,8 @@ class OpenSfMConfig:
     local_bundle_grid: int = 12
     # Number of grid division for selecting tracks in final bundle adjustment
     final_bundle_grid: int = 32
+    # For debugging purpose of large datasets: limit the maximum number of shots in incremental reconstruction
+    incremental_max_shots_count: int = 0
 
     # Remove uncertain and isolated points from the final point cloud
     filter_final_point_cloud: bool = False
diff --git a/opensfm/reconstruction.py b/opensfm/reconstruction.py
index 6b384a497..c7ce44cb9 100644
--- a/opensfm/reconstruction.py
+++ b/opensfm/reconstruction.py
@@ -1601,6 +1601,11 @@ def grow_reconstruction(
                 logger.info("Some images can not be added")
                 break
 
+        if config["incremental_max_shots_count"] > 0 and len(reconstruction.shots) >= config["incremental_max_shots_count"]:
+            logger.info(
+                f"Reached the maximum number of shots: {config['incremental_max_shots_count']}")
+            break
+
     logger.info("-------------------------------------------------------")
 
     align_result = align_reconstruction(
@@ -1844,6 +1849,13 @@ def incremental_reconstruction(
                 reconstructions = sorted(
                     reconstructions, key=lambda x: -len(x.shots))
 
+            if data.config["incremental_max_shots_count"] > 0 and sum(
+                len(r.shots) for r in reconstructions
+            ) >= data.config["incremental_max_shots_count"]:
+                logger.info(
+                    f"Reached the maximum number of shots")
+                break
+
     for k, r in enumerate(reconstructions):
         logger.info(
             "Reconstruction {}: {} images, {} points".format(

From 778498d13cb033e5844464dc4224a37dfdf8b419 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 14:52:08 +0100
Subject: [PATCH 229/235] fix: oupsy : correctly disable METIS

---
 opensfm/src/bundle/src/bundle_adjuster.cc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index 8bf6a1270..627a12cbe 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -1129,13 +1129,17 @@ void BundleAdjuster::Run() {
 // Activate NESDIS only for Ceres >= 2.2
 #if CERES_VERSION_MAJOR >= 2 && CERES_VERSION_MINOR >= 2
 #ifdef CERES_NO_EIGEN_METIS
+  options.linear_solver_ordering_type = ceres::AMD;
+#else
   options.linear_solver_ordering_type = ceres::NESDIS;
 #endif  // CERES_NO_EIGEN_METIS
 #endif  // CERES_VERSION_MAJOR >= 2 && CERES_VERSION_MINOR >= 2
 
   ceres::Solve(options, &problem, &last_run_summary_);
 
-  if (compute_covariances_) {
+  std::cout << last_run_summary_.FullReport() << std::endl;
+
+    if (compute_covariances_) {
     ComputeCovariances(&problem);
   }
   if (compute_reprojection_errors_) {

From 7bc0903098accab865f2e08fd3f5b01919b6c5a9 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 17:08:27 +0100
Subject: [PATCH 230/235] fix: fix ceres

---
 opensfm/src/bundle/src/bundle_adjuster.cc | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/opensfm/src/bundle/src/bundle_adjuster.cc b/opensfm/src/bundle/src/bundle_adjuster.cc
index ede7c22c6..ad5b89033 100644
--- a/opensfm/src/bundle/src/bundle_adjuster.cc
+++ b/opensfm/src/bundle/src/bundle_adjuster.cc
@@ -618,14 +618,17 @@ void BundleAdjuster::Run() {
     // Lock parameters based on bitmask of parameters : only constant for now
     if (cam.GetParametersToOptimize().empty()) {
       problem.SetParameterBlockConstant(data.data());
-    }else if (i.second.GetValue().GetProjectionType() == geometry::ProjectionType::BROWN){
-        // Keep aspect ratio constant (BROWN only)
+    } else if (cam.GetValue().GetProjectionType() ==
+               geometry::ProjectionType::BROWN) {
+      // Keep aspect ratio constant (BROWN only)
 #if CERES_VERSION_MAJOR == 2 && CERES_VERSION_MINOR >= 2
-        ceres::SubsetManifold *subset_parameterization = new ceres::SubsetManifold(data.size(), { 6 });
-        problem.SetManifold(data.data(), subset_parameterization);
+      ceres::SubsetManifold* subset_parameterization =
+          new ceres::SubsetManifold(data.size(), {6});
+      problem.SetManifold(data.data(), subset_parameterization);
 #else
-        ceres::SubsetParameterization *subset_parameterization = new ceres::SubsetParameterization(data.size(), { 6 });
-        problem.SetParameterization(data.data(), subset_parameterization);
+      ceres::SubsetParameterization* subset_parameterization =
+          new ceres::SubsetParameterization(data.size(), {6});
+      problem.SetParameterization(data.data(), subset_parameterization);
 #endif
     }
 
@@ -1146,9 +1149,7 @@ void BundleAdjuster::Run() {
 
   ceres::Solve(options, &problem, &last_run_summary_);
 
-  std::cout << last_run_summary_.FullReport() << std::endl;
-
-    if (compute_covariances_) {
+  if (compute_covariances_) {
     ComputeCovariances(&problem);
   }
   if (compute_reprojection_errors_) {

From 2a34a63080776671f81ab37906598435b8e7f853 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 17:08:42 +0100
Subject: [PATCH 231/235] fix: fix imports

---
 pyproject.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index a932c8131..c1259015b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,6 +14,7 @@ authors = [
 ]
 
 dependencies = [
+    "bs4>=0.0.2",
     "cloudpickle>=0.4.0",
     "exifread>=2.1.2",
     "flask>=2.3.2",
@@ -27,9 +28,12 @@ dependencies = [
     "python-dateutil>=2.7",
     "pyyaml>=5.4",
     "scipy>=1.10.0",
+    "rasterio>=1.4.4",
+    "rawpy>=0.25.1",
     "xmltodict>=0.10.2",
     "opencv-python>=4.8.0",
     "rerun-sdk==0.27.2",
+    "vmem>=1.0.2",
 ]
 
 [project.optional-dependencies]

From 7a18393bd5f06141b3613677f6a79b632d73cb84 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 17:09:03 +0100
Subject: [PATCH 232/235] fix: rebase fixes

---
 opensfm/context.py     | 2 +-
 opensfm/exif.py        | 3 ++-
 opensfm/io.py          | 6 +++++-
 opensfm/large/tools.py | 2 +-
 4 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/opensfm/context.py b/opensfm/context.py
index c6f5a8e9c..d61f33d91 100644
--- a/opensfm/context.py
+++ b/opensfm/context.py
@@ -41,7 +41,7 @@
 
 
 # Parallel processes
-def parallel_map(func, args, num_proc: int, max_batch_size: int = 1):
+def parallel_map(func, args, num_proc: int, max_batch_size: int = 1, backend="threading"):
     """Run function for all arguments using multiple processes."""
     # De-activate/Restore any inner OpenCV threading
     threads_used = cv2.getNumThreads()
diff --git a/opensfm/exif.py b/opensfm/exif.py
index 84818e1e8..cc888d716 100644
--- a/opensfm/exif.py
+++ b/opensfm/exif.py
@@ -4,9 +4,10 @@
 import logging
 from codecs import encode, decode
 from bs4 import BeautifulSoup
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, BinaryIO, Callable, Union
 
 import exifread
+import math
 import numpy as np
 import xmltodict as x2d
 from opensfm import geometry, pygeometry
diff --git a/opensfm/io.py b/opensfm/io.py
index 6e4c9dc08..3af8112e2 100644
--- a/opensfm/io.py
+++ b/opensfm/io.py
@@ -1246,7 +1246,7 @@ def open_rt(path: str) -> TextIO:
 
 def imread(
     path: str, grayscale: bool = False, unchanged: bool = False, anydepth: bool = False
-) -> ndarray:
+) -> NDArray:
     _, ext = os.path.splitext(path)
     if ext.lower() == ".tiff" or ext.lower() == ".tif":
         return imread_rasterio(path, grayscale, unchanged, anydepth)
@@ -1527,6 +1527,10 @@ def symlink(cls, src_path: str, dst_path: str, **kwargs):
             raise Exception("symlinks are not supported on win32")
         os.symlink(src_path, dst_path, **kwargs)
 
+    @classmethod
+    def open(cls, *args, **kwargs) -> IO[Any]:
+        return open(*args, **kwargs)
+    
     @classmethod
     def open_wb(cls, path: str) -> BinaryIO:
         return open(path, "wb")
diff --git a/opensfm/large/tools.py b/opensfm/large/tools.py
index b9323582d..e88956387 100644
--- a/opensfm/large/tools.py
+++ b/opensfm/large/tools.py
@@ -3,7 +3,6 @@
 
 import itertools
 import logging
-from functools import lru_cache
 from typing import Callable, Dict, List, NamedTuple, Tuple
 
 import cv2
@@ -29,6 +28,7 @@
     types,
 )
 from opensfm.large.metadataset import MetaDataSet
+from opensfm.large.lru_cache import lru_cache
 
 logger: logging.Logger = logging.getLogger(__name__)
 

From dc7c77a121109b5e77047d55a09d46b393418272 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 17:09:18 +0100
Subject: [PATCH 233/235] feat: add OPK in the report

---
 opensfm/report.py | 22 ++++++++++++----------
 opensfm/stats.py  |  4 ++--
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/opensfm/report.py b/opensfm/report.py
index f1e9629ed..443de8447 100644
--- a/opensfm/report.py
+++ b/opensfm/report.py
@@ -14,10 +14,10 @@
 
 
 class Report:
-    def __init__(self, data: DataSet) -> None:
-        self.output_path: str = os.path.join(data.data_path, "stats")
-        self.dataset_name: str = os.path.basename(data.data_path)
-        self.io_handler: io.IoFilesystemBase = data.io_handler
+    def __init__(self, data: DataSet, stats = None) -> None:
+        self.output_path = os.path.join(data.data_path, "stats")
+        self.dataset_name = os.path.basename(data.data_path)
+        self.io_handler = data.io_handler
 
         self.mapi_light_light_green = [255, 255, 255]
         self.mapi_light_green = [0, 0, 0]
@@ -190,7 +190,7 @@ def make_dataset_summary(self) -> None:
             [
                 "Processing Time",
                 #f"{self.stats['processing_statistics']['steps_times']['Total Time']:.2f} seconds",
-                self.stats['odm_processing_statistics']['total_time_human'],
+                self.stats['odm_processing_statistics']['total_time_human'] if 'odm_processing_statistics' in self.stats else f"{self.stats['processing_statistics']['steps_times']['Total Time']:.2f} seconds",
             ],
             ["Capture Start", self.stats["processing_statistics"]["start_date"]],
             ["Capture End", self.stats["processing_statistics"]["end_date"]],
@@ -262,11 +262,12 @@ def make_processing_summary(self) -> None:
                 ])
 
         # GSD (if available)
-        if self.stats['odm_processing_statistics'].get('average_gsd'):
-            rows.insert(3, [
-                "Average Ground Sampling Distance (GSD)",
-                f"{self.stats['odm_processing_statistics']['average_gsd']:.1f} cm"
-            ])
+        if 'odm_processing_statistics'  in self.stats:
+            if self.stats['odm_processing_statistics'].get('average_gsd'):
+                rows.insert(3, [
+                    "Average Ground Sampling Distance (GSD)",
+                    f"{self.stats['odm_processing_statistics']['average_gsd']:.1f} cm"
+                ])
         
         row_gps_gcp = [" / ".join(geo_string) + " errors"]
         geo_errors = []
@@ -724,6 +725,7 @@ def generate_report(self) -> None:
         else:
             self.make_align_details()
 
+        self.make_orientation_details()
         self.add_page_break()
 
         self.make_features_details()
diff --git a/opensfm/stats.py b/opensfm/stats.py
index d92f8cdca..af61c56e7 100644
--- a/opensfm/stats.py
+++ b/opensfm/stats.py
@@ -211,7 +211,7 @@ def td_errors(data: DataSetBase, tracks_manager, reconstructions):
             if len(ray_errors) > 0:
                 errors.append((np.max(np.array(ray_errors), axis=0)))
 
-    return _gps_gcp_errors_stats(errors)
+    return _gps_gcp_opk_errors_stats(errors, ["x", "y", "z"])
 
 
 def gps_errors(reconstructions: List[types.Reconstruction]) -> Dict[str, Any]:
@@ -317,7 +317,7 @@ def gcp_errors(
     with open(os.path.join(data.data_path, "stats", "ground_control_points.json"), 'w') as f:
         f.write(json.dumps(gcp_stats, indent=4))
     
-    return _gps_gcp_errors_stats(np.array(all_errors))
+    return _gps_gcp_opk_errors_stats(np.array(all_errors), ["x", "y", "z"])
 
 
 def _compute_errors(

From 8954b63783635d8a71b239350501bf3085f4d6d8 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Tue, 13 Jan 2026 17:28:42 +0100
Subject: [PATCH 234/235] fix: another docker + conda try

---
 .github/workflows/docker_ubuntu20.yml | 4 ++--
 .github/workflows/docker_ubuntu24.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/docker_ubuntu20.yml b/.github/workflows/docker_ubuntu20.yml
index bd9520220..0e6ffa3d4 100644
--- a/.github/workflows/docker_ubuntu20.yml
+++ b/.github/workflows/docker_ubuntu20.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu20 --tag mapillary/opensfm.ubuntu20:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "conda activate opensfm &&  cd cmake_build && ctest"
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm &&  cd cmake_build && ctest"
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest"
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest"
\ No newline at end of file
diff --git a/.github/workflows/docker_ubuntu24.yml b/.github/workflows/docker_ubuntu24.yml
index a2ea21e09..d7822b9da 100644
--- a/.github/workflows/docker_ubuntu24.yml
+++ b/.github/workflows/docker_ubuntu24.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu24 --tag mapillary/opensfm.ubuntu24:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "cd cmake_build && ctest --output-on-failure"
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && cd cmake_build && ctest --output-on-failure"
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v"
\ No newline at end of file
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v"
\ No newline at end of file

From 4aecbaef10691e462509807f15c16483c58080a9 Mon Sep 17 00:00:00 2001
From: "Yann N." <yannoun@gmail.com>
Date: Wed, 14 Jan 2026 11:28:28 +0100
Subject: [PATCH 235/235] fix: fuck single quotes

---
 .github/workflows/docker_ubuntu20.yml | 4 ++--
 .github/workflows/docker_ubuntu24.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/docker_ubuntu20.yml b/.github/workflows/docker_ubuntu20.yml
index 0e6ffa3d4..d89e3adf8 100644
--- a/.github/workflows/docker_ubuntu20.yml
+++ b/.github/workflows/docker_ubuntu20.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu20 --tag mapillary/opensfm.ubuntu20:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm &&  cd cmake_build && ctest"
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm &&  cd cmake_build && ctest'
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest"
\ No newline at end of file
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest'
\ No newline at end of file
diff --git a/.github/workflows/docker_ubuntu24.yml b/.github/workflows/docker_ubuntu24.yml
index d7822b9da..8a9f25eed 100644
--- a/.github/workflows/docker_ubuntu24.yml
+++ b/.github/workflows/docker_ubuntu24.yml
@@ -17,7 +17,7 @@ jobs:
         run: docker build . --file Dockerfile.ubuntu24 --tag mapillary/opensfm.ubuntu24:$GITHUB_SHA
 
       - name: Run C++ tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && cd cmake_build && ctest --output-on-failure"
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && cd cmake_build && ctest --output-on-failure'
 
       - name: Run Python tests
-        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c "source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v"
\ No newline at end of file
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v'
\ No newline at end of file