diff --git a/include/ceres/ordered_groups.h b/include/ceres/ordered_groups.h
index e373d35..dff859d 100644
--- a/include/ceres/ordered_groups.h
+++ b/include/ceres/ordered_groups.h
@@ -84,11 +84,8 @@
     element_to_group_.clear();
   }
 
-  // Remove the element, no matter what group it is in. If the element
-  // is not a member of any group, calling this method will result in
-  // a crash.
-  //
-  // Return value indicates if the element was actually removed.
+  // Remove the element, no matter what group it is in. Return value
+  // indicates if the element was actually removed.
   bool Remove(const T element) {
     const int current_group = GroupId(element);
     if (current_group < 0) {
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index f544f8f..1ebf442 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -454,6 +454,13 @@
     event_logger.AddEvent("ConstructOrdering");
   }
 
+  if (original_options.inner_iteration_ordering != NULL) {
+    // Make a copy, as the options struct takes ownership of the
+    // ordering objects.
+    options.inner_iteration_ordering =
+        new ParameterBlockOrdering(*original_options.inner_iteration_ordering);
+  }
+
   // Create the three objects needed to minimize: the transformed program, the
   // evaluator, and the linear solver.
   scoped_ptr<Program> reduced_program(CreateReducedProgram(&options,
@@ -544,7 +551,7 @@
                    << "Disabling inner iterations.";
     } else {
       inner_iteration_minimizer.reset(
-          CreateInnerIterationMinimizer(original_options,
+          CreateInnerIterationMinimizer(options,
                                         *reduced_program,
                                         problem_impl->parameter_map(),
                                         summary));
@@ -974,14 +981,13 @@
 
 
 // Strips varying parameters and residuals, maintaining order, and updating
-// num_eliminate_blocks.
-bool SolverImpl::RemoveFixedBlocksFromProgram(Program* program,
-                                              ParameterBlockOrdering* ordering,
-                                              double* fixed_cost,
-                                              string* error) {
-  vector<ParameterBlock*>* parameter_blocks =
-      program->mutable_parameter_blocks();
-
+// orderings.
+bool SolverImpl::RemoveFixedBlocksFromProgram(
+    Program* program,
+    ParameterBlockOrdering* linear_solver_ordering,
+    ParameterBlockOrdering* inner_iteration_ordering,
+    double* fixed_cost,
+    string* error) {
   scoped_array<double> residual_block_evaluate_scratch;
   if (fixed_cost != NULL) {
     residual_block_evaluate_scratch.reset(
@@ -989,70 +995,79 @@
     *fixed_cost = 0.0;
   }
 
-  // Mark all the parameters as unused. Abuse the index member of the parameter
-  // blocks for the marking.
+  vector<ParameterBlock*>* parameter_blocks =
+      program->mutable_parameter_blocks();
+  vector<ResidualBlock*>* residual_blocks =
+      program->mutable_residual_blocks();
+
+  // Mark all the parameters as unused. Abuse the index member of the
+  // parameter blocks for the marking.
   for (int i = 0; i < parameter_blocks->size(); ++i) {
     (*parameter_blocks)[i]->set_index(-1);
   }
 
   // Filter out residual that have all-constant parameters, and mark all the
   // parameter blocks that appear in residuals.
-  {
-    vector<ResidualBlock*>* residual_blocks =
-        program->mutable_residual_blocks();
-    int j = 0;
-    for (int i = 0; i < residual_blocks->size(); ++i) {
-      ResidualBlock* residual_block = (*residual_blocks)[i];
-      int num_parameter_blocks = residual_block->NumParameterBlocks();
+  int num_active_residual_blocks = 0;
+  for (int i = 0; i < residual_blocks->size(); ++i) {
+    ResidualBlock* residual_block = (*residual_blocks)[i];
+    int num_parameter_blocks = residual_block->NumParameterBlocks();
 
-      // Determine if the residual block is fixed, and also mark varying
-      // parameters that appear in the residual block.
-      bool all_constant = true;
-      for (int k = 0; k < num_parameter_blocks; k++) {
-        ParameterBlock* parameter_block = residual_block->parameter_blocks()[k];
-        if (!parameter_block->IsConstant()) {
-          all_constant = false;
-          parameter_block->set_index(1);
-        }
-      }
-
-      if (!all_constant) {
-        (*residual_blocks)[j++] = (*residual_blocks)[i];
-      } else if (fixed_cost != NULL) {
-        // The residual is constant and will be removed, so its cost is
-        // added to the variable fixed_cost.
-        double cost = 0.0;
-        if (!residual_block->Evaluate(true,
-                                      &cost,
-                                      NULL,
-                                      NULL,
-                                      residual_block_evaluate_scratch.get())) {
-          *error = StringPrintf("Evaluation of the residual %d failed during "
-                                "removal of fixed residual blocks.", i);
-          return false;
-        }
-        *fixed_cost += cost;
+    // Determine if the residual block is fixed, and also mark varying
+    // parameters that appear in the residual block.
+    bool all_constant = true;
+    for (int k = 0; k < num_parameter_blocks; k++) {
+      ParameterBlock* parameter_block = residual_block->parameter_blocks()[k];
+      if (!parameter_block->IsConstant()) {
+        all_constant = false;
+        parameter_block->set_index(1);
       }
     }
-    residual_blocks->resize(j);
-  }
 
-  // Filter out unused or fixed parameter blocks, and update
-  // the ordering.
-  {
-    vector<ParameterBlock*>* parameter_blocks =
-        program->mutable_parameter_blocks();
-    int j = 0;
-    for (int i = 0; i < parameter_blocks->size(); ++i) {
-      ParameterBlock* parameter_block = (*parameter_blocks)[i];
-      if (parameter_block->index() == 1) {
-        (*parameter_blocks)[j++] = parameter_block;
-      } else {
-        ordering->Remove(parameter_block->mutable_user_state());
+    if (!all_constant) {
+      (*residual_blocks)[num_active_residual_blocks++] = residual_block;
+    } else if (fixed_cost != NULL) {
+      // The residual is constant and will be removed, so its cost is
+      // added to the variable fixed_cost.
+      double cost = 0.0;
+      if (!residual_block->Evaluate(true,
+                                    &cost,
+                                    NULL,
+                                    NULL,
+                                    residual_block_evaluate_scratch.get())) {
+        *error = StringPrintf("Evaluation of the residual %d failed during "
+                              "removal of fixed residual blocks.", i);
+        return false;
       }
+      *fixed_cost += cost;
     }
-    parameter_blocks->resize(j);
   }
+  residual_blocks->resize(num_active_residual_blocks);
+
+  // Filter out unused or fixed parameter blocks, and update the
+  // linear_solver_ordering and the inner_iteration_ordering (if
+  // present).
+  int num_active_parameter_blocks = 0;
+  for (int i = 0; i < parameter_blocks->size(); ++i) {
+    ParameterBlock* parameter_block = (*parameter_blocks)[i];
+    if (parameter_block->index() == -1) {
+      // Parameter block is constant.
+      if (linear_solver_ordering != NULL) {
+        linear_solver_ordering->Remove(parameter_block->mutable_user_state());
+      }
+
+      // It is not necessary that the inner iteration ordering contain
+      // this parameter block. But calling Remove is safe, as it will
+      // just return false.
+      if (inner_iteration_ordering != NULL) {
+        inner_iteration_ordering->Remove(parameter_block->mutable_user_state());
+      }
+      continue;
+    }
+
+    (*parameter_blocks)[num_active_parameter_blocks++] = parameter_block;
+  }
+  parameter_blocks->resize(num_active_parameter_blocks);
 
   if (!(((program->NumResidualBlocks() == 0) &&
          (program->NumParameterBlocks() == 0)) ||
@@ -1077,9 +1092,11 @@
       options->linear_solver_ordering;
   const int min_group_id =
       linear_solver_ordering->group_to_elements().begin()->first;
-
+  ParameterBlockOrdering* inner_iteration_ordering =
+      options->inner_iteration_ordering;
   if (!RemoveFixedBlocksFromProgram(transformed_program.get(),
                                     linear_solver_ordering,
+                                    inner_iteration_ordering,
                                     fixed_cost,
                                     error)) {
     return NULL;
diff --git a/internal/ceres/solver_impl.h b/internal/ceres/solver_impl.h
index 2b7ca3e..aef63b0 100644
--- a/internal/ceres/solver_impl.h
+++ b/internal/ceres/solver_impl.h
@@ -120,15 +120,24 @@
       string* error);
 
   // Remove the fixed or unused parameter blocks and residuals
-  // depending only on fixed parameters from the problem. Also updates
-  // num_eliminate_blocks, since removed parameters changes the point
-  // at which the eliminated blocks is valid.  If fixed_cost is not
-  // NULL, the residual blocks that are removed are evaluated and the
-  // sum of their cost is returned in fixed_cost.
-  static bool RemoveFixedBlocksFromProgram(Program* program,
-                                           ParameterBlockOrdering* ordering,
-                                           double* fixed_cost,
-                                           string* error);
+  // depending only on fixed parameters from the program.
+  //
+  // If either linear_solver_ordering or inner_iteration_ordering are
+  // not NULL, the constant parameter blocks are removed from them
+  // too.
+  //
+  // If fixed_cost is not NULL, the residual blocks that are removed
+  // are evaluated and the sum of their cost is returned in
+  // fixed_cost.
+  //
+  // If a failure is encountered, the function returns false with a
+  // description of the failure in error.
+  static bool RemoveFixedBlocksFromProgram(
+      Program* program,
+      ParameterBlockOrdering* linear_solver_ordering,
+      ParameterBlockOrdering* inner_iteration_ordering,
+      double* fixed_cost,
+      string* error);
 
   static bool IsOrderingValid(const Solver::Options& options,
                               const ProblemImpl* problem_impl,
diff --git a/internal/ceres/solver_impl_test.cc b/internal/ceres/solver_impl_test.cc
index 583ef4e..30eeea2 100644
--- a/internal/ceres/solver_impl_test.cc
+++ b/internal/ceres/solver_impl_test.cc
@@ -88,19 +88,26 @@
 
   string error;
   {
-    ParameterBlockOrdering ordering;
-    ordering.AddElementToGroup(&x, 0);
-    ordering.AddElementToGroup(&y, 0);
-    ordering.AddElementToGroup(&z, 0);
+    ParameterBlockOrdering linear_solver_ordering;
+    linear_solver_ordering.AddElementToGroup(&x, 0);
+    linear_solver_ordering.AddElementToGroup(&y, 0);
+    linear_solver_ordering.AddElementToGroup(&z, 0);
+
+    ParameterBlockOrdering inner_iteration_ordering;
+    inner_iteration_ordering.AddElementToGroup(&x, 0);
+    inner_iteration_ordering.AddElementToGroup(&y, 0);
+    inner_iteration_ordering.AddElementToGroup(&z, 0);
 
     Program program(*problem.mutable_program());
     EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                         &ordering,
+                                                         &linear_solver_ordering,
+                                                         &inner_iteration_ordering,
                                                          NULL,
                                                          &error));
     EXPECT_EQ(program.NumParameterBlocks(), 3);
     EXPECT_EQ(program.NumResidualBlocks(), 3);
-    EXPECT_EQ(ordering.NumElements(), 3);
+    EXPECT_EQ(linear_solver_ordering.NumElements(), 3);
+    EXPECT_EQ(inner_iteration_ordering.NumElements(), 3);
   }
 }
 
@@ -112,18 +119,23 @@
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &x);
   problem.SetParameterBlockConstant(&x);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+
+  ParameterBlockOrdering inner_iteration_ordering;
+  inner_iteration_ordering.AddElementToGroup(&x, 0);
 
   Program program(problem.program());
   string error;
   EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                       &ordering,
+                                                       &linear_solver_ordering,
+                                                       &inner_iteration_ordering,
                                                        NULL,
                                                        &error));
   EXPECT_EQ(program.NumParameterBlocks(), 0);
   EXPECT_EQ(program.NumResidualBlocks(), 0);
-  EXPECT_EQ(ordering.NumElements(), 0);
+  EXPECT_EQ(linear_solver_ordering.NumElements(), 0);
+  EXPECT_EQ(inner_iteration_ordering.NumElements(), 0);
 }
 
 TEST(SolverImpl, RemoveFixedBlocksNoResidualBlocks) {
@@ -136,21 +148,27 @@
   problem.AddParameterBlock(&y, 1);
   problem.AddParameterBlock(&z, 1);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 0);
-  ordering.AddElementToGroup(&z, 0);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 0);
+  linear_solver_ordering.AddElementToGroup(&z, 0);
 
+  ParameterBlockOrdering inner_iteration_ordering;
+  inner_iteration_ordering.AddElementToGroup(&x, 0);
+  inner_iteration_ordering.AddElementToGroup(&y, 0);
+  inner_iteration_ordering.AddElementToGroup(&z, 0);
 
   Program program(problem.program());
   string error;
   EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                       &ordering,
+                                                       &linear_solver_ordering,
+                                                       &inner_iteration_ordering,
                                                        NULL,
                                                        &error));
   EXPECT_EQ(program.NumParameterBlocks(), 0);
   EXPECT_EQ(program.NumResidualBlocks(), 0);
-  EXPECT_EQ(ordering.NumElements(), 0);
+  EXPECT_EQ(linear_solver_ordering.NumElements(), 0);
+  EXPECT_EQ(inner_iteration_ordering.NumElements(), 0);
 }
 
 TEST(SolverImpl, RemoveFixedBlocksOneParameterBlockConstant) {
@@ -163,10 +181,15 @@
   problem.AddParameterBlock(&y, 1);
   problem.AddParameterBlock(&z, 1);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 0);
-  ordering.AddElementToGroup(&z, 0);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 0);
+  linear_solver_ordering.AddElementToGroup(&z, 0);
+
+  ParameterBlockOrdering inner_iteration_ordering;
+  inner_iteration_ordering.AddElementToGroup(&x, 0);
+  inner_iteration_ordering.AddElementToGroup(&y, 0);
+  inner_iteration_ordering.AddElementToGroup(&z, 0);
 
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &x);
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &y);
@@ -176,12 +199,14 @@
   Program program(problem.program());
   string error;
   EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                       &ordering,
+                                                       &linear_solver_ordering,
+                                                       &inner_iteration_ordering,
                                                        NULL,
                                                        &error));
   EXPECT_EQ(program.NumParameterBlocks(), 1);
   EXPECT_EQ(program.NumResidualBlocks(), 1);
-  EXPECT_EQ(ordering.NumElements(), 1);
+  EXPECT_EQ(linear_solver_ordering.NumElements(), 1);
+  EXPECT_EQ(inner_iteration_ordering.NumElements(), 1);
 }
 
 TEST(SolverImpl, RemoveFixedBlocksNumEliminateBlocks) {
@@ -198,22 +223,31 @@
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 0);
-  ordering.AddElementToGroup(&z, 1);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 0);
+  linear_solver_ordering.AddElementToGroup(&z, 1);
+
+  ParameterBlockOrdering inner_iteration_ordering;
+  inner_iteration_ordering.AddElementToGroup(&x, 0);
+  inner_iteration_ordering.AddElementToGroup(&y, 0);
+  inner_iteration_ordering.AddElementToGroup(&z, 1);
 
   Program program(problem.program());
   string error;
   EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                       &ordering,
+                                                       &linear_solver_ordering,
+                                                       &inner_iteration_ordering,
                                                        NULL,
                                                        &error));
   EXPECT_EQ(program.NumParameterBlocks(), 2);
   EXPECT_EQ(program.NumResidualBlocks(), 2);
-  EXPECT_EQ(ordering.NumElements(), 2);
-  EXPECT_EQ(ordering.GroupId(&y), 0);
-  EXPECT_EQ(ordering.GroupId(&z), 1);
+  EXPECT_EQ(linear_solver_ordering.NumElements(), 2);
+  EXPECT_EQ(linear_solver_ordering.GroupId(&y), 0);
+  EXPECT_EQ(linear_solver_ordering.GroupId(&z), 1);
+  EXPECT_EQ(inner_iteration_ordering.NumElements(), 2);
+  EXPECT_EQ(inner_iteration_ordering.GroupId(&y), 0);
+  EXPECT_EQ(inner_iteration_ordering.GroupId(&z), 1);
 }
 
 TEST(SolverImpl, RemoveFixedBlocksFixedCost) {
@@ -230,10 +264,10 @@
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 0);
-  ordering.AddElementToGroup(&z, 1);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 0);
+  linear_solver_ordering.AddElementToGroup(&z, 1);
 
   double fixed_cost = 0.0;
   Program program(problem.program());
@@ -250,14 +284,15 @@
 
   string error;
   EXPECT_TRUE(SolverImpl::RemoveFixedBlocksFromProgram(&program,
-                                                       &ordering,
+                                                       &linear_solver_ordering,
+                                                       NULL,
                                                        &fixed_cost,
                                                        &error));
   EXPECT_EQ(program.NumParameterBlocks(), 2);
   EXPECT_EQ(program.NumResidualBlocks(), 2);
-  EXPECT_EQ(ordering.NumElements(), 2);
-  EXPECT_EQ(ordering.GroupId(&y), 0);
-  EXPECT_EQ(ordering.GroupId(&z), 1);
+  EXPECT_EQ(linear_solver_ordering.NumElements(), 2);
+  EXPECT_EQ(linear_solver_ordering.GroupId(&y), 0);
+  EXPECT_EQ(linear_solver_ordering.GroupId(&z), 1);
   EXPECT_DOUBLE_EQ(fixed_cost, expected_fixed_cost);
 }
 
@@ -278,14 +313,14 @@
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &y);
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &y);
 
-  ParameterBlockOrdering* ordering = new ParameterBlockOrdering;
-  ordering->AddElementToGroup(&x, 0);
-  ordering->AddElementToGroup(&y, 0);
-  ordering->AddElementToGroup(&z, 1);
+  ParameterBlockOrdering* linear_solver_ordering = new ParameterBlockOrdering;
+  linear_solver_ordering->AddElementToGroup(&x, 0);
+  linear_solver_ordering->AddElementToGroup(&y, 0);
+  linear_solver_ordering->AddElementToGroup(&z, 1);
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = ordering;
+  options.linear_solver_ordering = linear_solver_ordering;
 
   const vector<ResidualBlock*>& residual_blocks =
       problem.program().residual_blocks();
@@ -340,14 +375,14 @@
   problem.AddResidualBlock(new BinaryCostFunction(), NULL, &x, &z);  // 6 x
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &y);       // 7
 
-  ParameterBlockOrdering* ordering = new ParameterBlockOrdering;
-  ordering->AddElementToGroup(&x, 0);
-  ordering->AddElementToGroup(&z, 0);
-  ordering->AddElementToGroup(&y, 1);
+  ParameterBlockOrdering* linear_solver_ordering = new ParameterBlockOrdering;
+  linear_solver_ordering->AddElementToGroup(&x, 0);
+  linear_solver_ordering->AddElementToGroup(&z, 0);
+  linear_solver_ordering->AddElementToGroup(&y, 1);
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = ordering;
+  options.linear_solver_ordering = linear_solver_ordering;
 
   // Create the reduced program. This should remove the fixed block "z",
   // marking the index to -1 at the same time. x and y also get indices.
@@ -409,14 +444,14 @@
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &y);
   problem.AddResidualBlock(new UnaryCostFunction(), NULL, &z);
 
-  ParameterBlockOrdering* ordering = new ParameterBlockOrdering;
-  ordering->AddElementToGroup(&x, 0);
-  ordering->AddElementToGroup(&z, 0);
-  ordering->AddElementToGroup(&y, 0);
+  ParameterBlockOrdering* linear_solver_ordering = new ParameterBlockOrdering;
+  linear_solver_ordering->AddElementToGroup(&x, 0);
+  linear_solver_ordering->AddElementToGroup(&z, 0);
+  linear_solver_ordering->AddElementToGroup(&y, 0);
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = ordering;
+  options.linear_solver_ordering = linear_solver_ordering;
 
   string error;
   scoped_ptr<Program> reduced_program(
@@ -453,14 +488,14 @@
   problem.AddParameterBlock(&y, 1);
   problem.AddParameterBlock(&z, 1);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 1);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 1);
 
   Program program(problem.program());
   string error;
   EXPECT_FALSE(SolverImpl::ApplyUserOrdering(problem.parameter_map(),
-                                             &ordering,
+                                             &linear_solver_ordering,
                                              &program,
                                              &error));
 }
@@ -475,16 +510,16 @@
   problem.AddParameterBlock(&y, 1);
   problem.AddParameterBlock(&z, 1);
 
-  ParameterBlockOrdering ordering;
-  ordering.AddElementToGroup(&x, 0);
-  ordering.AddElementToGroup(&y, 2);
-  ordering.AddElementToGroup(&z, 1);
+  ParameterBlockOrdering linear_solver_ordering;
+  linear_solver_ordering.AddElementToGroup(&x, 0);
+  linear_solver_ordering.AddElementToGroup(&y, 2);
+  linear_solver_ordering.AddElementToGroup(&z, 1);
 
   Program* program = problem.mutable_program();
   string error;
 
   EXPECT_TRUE(SolverImpl::ApplyUserOrdering(problem.parameter_map(),
-                                            &ordering,
+                                            &linear_solver_ordering,
                                             program,
                                             &error));
   const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();