diff --git a/examples/bundle_adjuster.cc b/examples/bundle_adjuster.cc
index 5619c52..e7b154e 100644
--- a/examples/bundle_adjuster.cc
+++ b/examples/bundle_adjuster.cc
@@ -64,6 +64,9 @@
 #include "glog/logging.h"
 #include "snavely_reprojection_error.h"
 
+// clang-format makes the gflags definitions too verbose
+// clang-format off
+
 DEFINE_string(input, "", "Input File name");
 DEFINE_string(trust_region_strategy, "levenberg_marquardt",
               "Options are: levenberg_marquardt, dogleg.");
@@ -74,7 +77,7 @@
             "refine each successful trust region step.");
 
 DEFINE_string(blocks_for_inner_iterations, "automatic", "Options are: "
-            "automatic, cameras, points, cameras,points, points,cameras");
+              "automatic, cameras, points, cameras,points, points,cameras");
 
 DEFINE_string(linear_solver, "sparse_schur", "Options are: "
               "sparse_schur, dense_schur, iterative_schur, sparse_normal_cholesky, "
@@ -100,8 +103,8 @@
 DEFINE_bool(robustify, false, "Use a robust loss function.");
 
 DEFINE_double(eta, 1e-2, "Default value for eta. Eta determines the "
-             "accuracy of each linear solve of the truncated newton step. "
-             "Changing this parameter can affect solve performance.");
+              "accuracy of each linear solve of the truncated newton step. "
+              "Changing this parameter can affect solve performance.");
 
 DEFINE_int32(num_threads, 1, "Number of threads.");
 DEFINE_int32(num_iterations, 5, "Number of iterations.");
@@ -126,8 +129,11 @@
 DEFINE_string(final_ply, "", "Export the refined BAL file data as a PLY "
               "file.");
 
+// clang-format on
+
 namespace ceres {
 namespace examples {
+namespace {
 
 void SetLinearSolver(Solver::Options* options) {
   CHECK(StringToLinearSolverType(FLAGS_linear_solver,
@@ -137,11 +143,11 @@
   CHECK(StringToVisibilityClusteringType(FLAGS_visibility_clustering,
                                          &options->visibility_clustering_type));
   CHECK(StringToSparseLinearAlgebraLibraryType(
-            FLAGS_sparse_linear_algebra_library,
-            &options->sparse_linear_algebra_library_type));
+      FLAGS_sparse_linear_algebra_library,
+      &options->sparse_linear_algebra_library_type));
   CHECK(StringToDenseLinearAlgebraLibraryType(
-            FLAGS_dense_linear_algebra_library,
-            &options->dense_linear_algebra_library_type));
+      FLAGS_dense_linear_algebra_library,
+      &options->dense_linear_algebra_library_type));
   options->use_explicit_schur_complement = FLAGS_explicit_schur_complement;
   options->use_mixed_precision_solves = FLAGS_mixed_precision_solves;
   options->max_num_refinement_iterations = FLAGS_max_num_refinement_iterations;
@@ -161,31 +167,37 @@
       LOG(INFO) << "Camera blocks for inner iterations";
       options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 0);
+        options->inner_iteration_ordering->AddElementToGroup(
+            cameras + camera_block_size * i, 0);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "points") {
       LOG(INFO) << "Point blocks for inner iterations";
       options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_points; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(points + point_block_size * i, 0);
+        options->inner_iteration_ordering->AddElementToGroup(
+            points + point_block_size * i, 0);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "cameras,points") {
       LOG(INFO) << "Camera followed by point blocks for inner iterations";
       options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 0);
+        options->inner_iteration_ordering->AddElementToGroup(
+            cameras + camera_block_size * i, 0);
       }
       for (int i = 0; i < num_points; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(points + point_block_size * i, 1);
+        options->inner_iteration_ordering->AddElementToGroup(
+            points + point_block_size * i, 1);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "points,cameras") {
       LOG(INFO) << "Point followed by camera blocks for inner iterations";
       options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 1);
+        options->inner_iteration_ordering->AddElementToGroup(
+            cameras + camera_block_size * i, 1);
       }
       for (int i = 0; i < num_points; ++i) {
-        options->inner_iteration_ordering->AddElementToGroup(points + point_block_size * i, 0);
+        options->inner_iteration_ordering->AddElementToGroup(
+            points + point_block_size * i, 0);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "automatic") {
       LOG(INFO) << "Choosing automatic blocks for inner iterations";
@@ -210,8 +222,7 @@
     return;
   }
 
-  ceres::ParameterBlockOrdering* ordering =
-      new ceres::ParameterBlockOrdering;
+  ceres::ParameterBlockOrdering* ordering = new ceres::ParameterBlockOrdering;
 
   // The points come before the cameras.
   for (int i = 0; i < num_points; ++i) {
@@ -265,14 +276,11 @@
     CostFunction* cost_function;
     // Each Residual block takes a point and a camera as input and
     // outputs a 2 dimensional residual.
-    cost_function =
-        (FLAGS_use_quaternions)
-        ? SnavelyReprojectionErrorWithQuaternions::Create(
-            observations[2 * i + 0],
-            observations[2 * i + 1])
-        : SnavelyReprojectionError::Create(
-            observations[2 * i + 0],
-            observations[2 * i + 1]);
+    cost_function = (FLAGS_use_quaternions)
+                        ? SnavelyReprojectionErrorWithQuaternions::Create(
+                              observations[2 * i + 0], observations[2 * i + 1])
+                        : SnavelyReprojectionError::Create(
+                              observations[2 * i + 0], observations[2 * i + 1]);
 
     // If enabled use Huber's loss function.
     LossFunction* loss_function = FLAGS_robustify ? new HuberLoss(1.0) : NULL;
@@ -288,9 +296,8 @@
 
   if (FLAGS_use_quaternions && FLAGS_use_local_parameterization) {
     LocalParameterization* camera_parameterization =
-        new ProductParameterization(
-            new QuaternionParameterization(),
-            new IdentityParameterization(6));
+        new ProductParameterization(new QuaternionParameterization(),
+                                    new IdentityParameterization(6));
     for (int i = 0; i < bal_problem->num_cameras(); ++i) {
       problem->SetParameterization(cameras + camera_block_size * i,
                                    camera_parameterization);
@@ -309,9 +316,8 @@
 
   srand(FLAGS_random_seed);
   bal_problem.Normalize();
-  bal_problem.Perturb(FLAGS_rotation_sigma,
-                      FLAGS_translation_sigma,
-                      FLAGS_point_sigma);
+  bal_problem.Perturb(
+      FLAGS_rotation_sigma, FLAGS_translation_sigma, FLAGS_point_sigma);
 
   BuildProblem(&bal_problem, &problem);
   Solver::Options options;
@@ -327,11 +333,12 @@
   }
 }
 
+}  // namespace
 }  // namespace examples
 }  // namespace ceres
 
 int main(int argc, char** argv) {
-  CERES_GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
+  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
   google::InitGoogleLogging(argv[0]);
   if (FLAGS_input.empty()) {
     LOG(ERROR) << "Usage: bundle_adjuster --input=bal_problem";