more changes

1 files changed, 428 insertions, 430 deletions

diff --git a/src/transformations/loop_basic.cc b/src/transformations/loop_basic.cc
index a058598..1be0981 100644
--- a/src/transformations/loop_basic.cc
+++ b/src/transformations/loop_basic.cc
@@ -19,7 +19,7 @@ void Loop::permute(const std::vector<int> &pi) {
   std::set<int> active;
   for (int i = 0; i < stmt.size(); i++)
     active.insert(i);
-  
+
   permute(active, pi);
 }
 
@@ -30,12 +30,13 @@ void Loop::original() {
   setLexicalOrder(0, active);
   //apply_xform();
 }
+
 void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
   // check for sanity of parameters
   int starting_order;
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument(
-      "invalid statement number " + to_string(stmt_num));
+        "invalid statement number " + to_string(stmt_num));
   std::set<int> active;
   if (level < 0 || level > stmt[stmt_num].loop_level.size())
     throw std::invalid_argument("3invalid loop level " + to_string(level));
@@ -61,14 +62,14 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++)
     if (level + pi.size() - 1 > stmt[*i].loop_level.size())
       throw std::invalid_argument(
-        "invalid permutation for statement " + to_string(*i));
-  
+          "invalid permutation for statement " + to_string(*i));
+
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-  
+
   // Update transformation relations
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
     int n = stmt[*i].xform.n_out();
@@ -97,7 +98,7 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
     stmt[*i].xform = Composition(mapping, stmt[*i].xform);
     stmt[*i].xform.simplify();
   }
-  
+
   // get the permuation for dependence vectors
   std::vector<int> t;
   for (int i = 0; i < pi.size(); i++)
@@ -122,41 +123,41 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
     dep_pi[i] = t[i - min_dep_dim];
   for (int i = max_dep_dim + 1; i < dep.num_dim(); i++)
     dep_pi[i] = i;
-  
+
   dep.permute(dep_pi, active);
-  
+
   // update the dependence graph
   DependenceGraph g(dep.num_dim());
   for (int i = 0; i < dep.vertex.size(); i++)
     g.insert();
   for (int i = 0; i < dep.vertex.size(); i++)
     for (DependenceGraph::EdgeList::iterator j =
-           dep.vertex[i].second.begin(); j != dep.vertex[i].second.end();
+        dep.vertex[i].second.begin(); j != dep.vertex[i].second.end();
          j++) {
       if ((active.find(i) != active.end()
            && active.find(j->first) != active.end())) {
         std::vector<DependenceVector> dv = j->second;
         for (int k = 0; k < dv.size(); k++) {
           switch (dv[k].type) {
-          case DEP_W2R:
-          case DEP_R2W:
-          case DEP_W2W:
-          case DEP_R2R: {
-            std::vector<coef_t> lbounds(dep.num_dim());
-            std::vector<coef_t> ubounds(dep.num_dim());
-            for (int d = 0; d < dep.num_dim(); d++) {
-              lbounds[d] = dv[k].lbounds[dep_pi[d]];
-              ubounds[d] = dv[k].ubounds[dep_pi[d]];
+            case DEP_W2R:
+            case DEP_R2W:
+            case DEP_W2W:
+            case DEP_R2R: {
+              std::vector<coef_t> lbounds(dep.num_dim());
+              std::vector<coef_t> ubounds(dep.num_dim());
+              for (int d = 0; d < dep.num_dim(); d++) {
+                lbounds[d] = dv[k].lbounds[dep_pi[d]];
+                ubounds[d] = dv[k].ubounds[dep_pi[d]];
+              }
+              dv[k].lbounds = lbounds;
+              dv[k].ubounds = ubounds;
+              break;
             }
-            dv[k].lbounds = lbounds;
-            dv[k].ubounds = ubounds;
-            break;
-          }
-          case DEP_CONTROL: {
-            break;
-          }
-          default:
-            throw loop_error("unknown dependence type");
+            case DEP_CONTROL: {
+              break;
+            }
+            default:
+              throw loop_error("unknown dependence type");
           }
         }
         g.connect(i, j->first, dv);
@@ -168,27 +169,27 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
         std::vector<DependenceVector> dv = j->second;
         for (int k = 0; k < dv.size(); k++)
           switch (dv[k].type) {
-          case DEP_W2R:
-          case DEP_R2W:
-          case DEP_W2W:
-          case DEP_R2R: {
-            for (int d = 0; d < dep.num_dim(); d++)
-              if (dep_pi[d] != d) {
-                dv[k].lbounds[d] = -posInfinity;
-                dv[k].ubounds[d] = posInfinity;
-              }
-            break;
-          }
-          case DEP_CONTROL:
-            break;
-          default:
-            throw loop_error("unknown dependence type");
+            case DEP_W2R:
+            case DEP_R2W:
+            case DEP_W2W:
+            case DEP_R2R: {
+              for (int d = 0; d < dep.num_dim(); d++)
+                if (dep_pi[d] != d) {
+                  dv[k].lbounds[d] = -posInfinity;
+                  dv[k].ubounds[d] = posInfinity;
+                }
+              break;
+            }
+            case DEP_CONTROL:
+              break;
+            default:
+              throw loop_error("unknown dependence type");
           }
         g.connect(i, j->first, dv);
       }
     }
   dep = g;
-  
+
   // update loop level information
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
     int cur_dep_dim = min_dep_dim;
@@ -196,66 +197,67 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
     for (int j = 1; j <= stmt[*i].loop_level.size(); j++)
       if (j >= level && j < level + pi.size()) {
         switch (stmt[*i].loop_level[pi_inverse[j - level] - 1].type) {
-        case LoopLevelOriginal:
-          new_loop_level[j - 1].type = LoopLevelOriginal;
-          new_loop_level[j - 1].payload = cur_dep_dim++;
-          new_loop_level[j - 1].parallel_level =
-            stmt[*i].loop_level[pi_inverse[j - level] - 1].parallel_level;
-          break;
-        case LoopLevelTile: {
-          new_loop_level[j - 1].type = LoopLevelTile;
-          int ref_level = stmt[*i].loop_level[pi_inverse[j - level]
-                                              - 1].payload;
-          if (ref_level >= level && ref_level < level + pi.size())
-            new_loop_level[j - 1].payload = pi_inverse[ref_level
-                                                       - level];
-          else
-            new_loop_level[j - 1].payload = ref_level;
-          new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
-                                                                     - 1].parallel_level;
-          break;
-        }
-        default:
-          throw loop_error(
-            "unknown loop level information for statement "
-            + to_string(*i));
+          case LoopLevelOriginal:
+            new_loop_level[j - 1].type = LoopLevelOriginal;
+            new_loop_level[j - 1].payload = cur_dep_dim++;
+            new_loop_level[j - 1].parallel_level =
+                stmt[*i].loop_level[pi_inverse[j - level] - 1].parallel_level;
+            break;
+          case LoopLevelTile: {
+            new_loop_level[j - 1].type = LoopLevelTile;
+            int ref_level = stmt[*i].loop_level[pi_inverse[j - level]
+                                                - 1].payload;
+            if (ref_level >= level && ref_level < level + pi.size())
+              new_loop_level[j - 1].payload = pi_inverse[ref_level
+                                                         - level];
+            else
+              new_loop_level[j - 1].payload = ref_level;
+            new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
+                                                                       - 1].parallel_level;
+            break;
+          }
+          default:
+            throw loop_error(
+                "unknown loop level information for statement "
+                + to_string(*i));
         }
       } else {
         switch (stmt[*i].loop_level[j - 1].type) {
-        case LoopLevelOriginal:
-          new_loop_level[j - 1].type = LoopLevelOriginal;
-          new_loop_level[j - 1].payload =
-            stmt[*i].loop_level[j - 1].payload;
-          new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
-                                                                     - 1].parallel_level;
-          break;
-        case LoopLevelTile: {
-          new_loop_level[j - 1].type = LoopLevelTile;
-          int ref_level = stmt[*i].loop_level[j - 1].payload;
-          if (ref_level >= level && ref_level < level + pi.size())
-            new_loop_level[j - 1].payload = pi_inverse[ref_level
-                                                       - level];
-          else
-            new_loop_level[j - 1].payload = ref_level;
-          new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
-                                                                     - 1].parallel_level;
-          break;
-        }
-        default:
-          throw loop_error(
-            "unknown loop level information for statement "
-            + to_string(*i));
+          case LoopLevelOriginal:
+            new_loop_level[j - 1].type = LoopLevelOriginal;
+            new_loop_level[j - 1].payload =
+                stmt[*i].loop_level[j - 1].payload;
+            new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
+                                                                       - 1].parallel_level;
+            break;
+          case LoopLevelTile: {
+            new_loop_level[j - 1].type = LoopLevelTile;
+            int ref_level = stmt[*i].loop_level[j - 1].payload;
+            if (ref_level >= level && ref_level < level + pi.size())
+              new_loop_level[j - 1].payload = pi_inverse[ref_level
+                                                         - level];
+            else
+              new_loop_level[j - 1].payload = ref_level;
+            new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
+                                                                       - 1].parallel_level;
+            break;
+          }
+          default:
+            throw loop_error(
+                "unknown loop level information for statement "
+                + to_string(*i));
         }
       }
     stmt[*i].loop_level = new_loop_level;
   }
-  
+
   setLexicalOrder(2 * level - 2, active, starting_order);
 }
+
 void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
   if (active.size() == 0 || pi.size() == 0)
     return;
-  
+
   // check for sanity of parameters
   int level = pi[0];
   for (int i = 1; i < pi.size(); i++)
@@ -287,14 +289,14 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
       for (int j = 0; j < 2 * level - 3; j += 2)
         if (lex[j] != lex2[j])
           throw std::invalid_argument(
-            "statements to permute must be in the same subloop");
+              "statements to permute must be in the same subloop");
       for (int j = 0; j < pi.size(); j++)
         if (!(stmt[*i].loop_level[level + j - 1].type
               == stmt[ref_stmt_num].loop_level[level + j - 1].type
               && stmt[*i].loop_level[level + j - 1].payload
-              == stmt[ref_stmt_num].loop_level[level + j - 1].payload))
+                 == stmt[ref_stmt_num].loop_level[level + j - 1].payload))
           throw std::invalid_argument(
-            "permuted loops must have the same loop level types");
+              "permuted loops must have the same loop level types");
     }
   }
   // invalidate saved codegen computation
@@ -302,7 +304,7 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-  
+
   // Update transformation relations
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
     int n = stmt[*i].xform.n_out();
@@ -328,11 +330,11 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
       h.update_coef(mapping.output_var(2 * j), 1);
       h.update_coef(mapping.input_var(2 * j), -1);
     }
-    
+
     stmt[*i].xform = Composition(mapping, stmt[*i].xform);
     stmt[*i].xform.simplify();
   }
-  
+
   // get the permuation for dependence vectors
   std::vector<int> t;
   for (int i = 0; i < pi.size(); i++)
@@ -357,41 +359,41 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
     dep_pi[i] = t[i - min_dep_dim];
   for (int i = max_dep_dim + 1; i < num_dep_dim; i++)
     dep_pi[i] = i;
-  
+
   dep.permute(dep_pi, active);
-  
+
   // update the dependence graph
   DependenceGraph g(dep.num_dim());
   for (int i = 0; i < dep.vertex.size(); i++)
     g.insert();
   for (int i = 0; i < dep.vertex.size(); i++)
     for (DependenceGraph::EdgeList::iterator j =
-           dep.vertex[i].second.begin(); j != dep.vertex[i].second.end();
+        dep.vertex[i].second.begin(); j != dep.vertex[i].second.end();
          j++) {         //
       if ((active.find(i) != active.end()
            && active.find(j->first) != active.end())) {
         std::vector<DependenceVector> dv = j->second;
         for (int k = 0; k < dv.size(); k++) {
           switch (dv[k].type) {
-          case DEP_W2R:
-          case DEP_R2W:
-          case DEP_W2W:
-          case DEP_R2R: {
-            std::vector<coef_t> lbounds(num_dep_dim);
-            std::vector<coef_t> ubounds(num_dep_dim);
-            for (int d = 0; d < num_dep_dim; d++) {
-              lbounds[d] = dv[k].lbounds[dep_pi[d]];
-              ubounds[d] = dv[k].ubounds[dep_pi[d]];
+            case DEP_W2R:
+            case DEP_R2W:
+            case DEP_W2W:
+            case DEP_R2R: {
+              std::vector<coef_t> lbounds(num_dep_dim);
+              std::vector<coef_t> ubounds(num_dep_dim);
+              for (int d = 0; d < num_dep_dim; d++) {
+                lbounds[d] = dv[k].lbounds[dep_pi[d]];
+                ubounds[d] = dv[k].ubounds[dep_pi[d]];
+              }
+              dv[k].lbounds = lbounds;
+              dv[k].ubounds = ubounds;
+              break;
             }
-            dv[k].lbounds = lbounds;
-            dv[k].ubounds = ubounds;
-            break;
-          }
-          case DEP_CONTROL: {
-            break;
-          }
-          default:
-            throw loop_error("unknown dependence type");
+            case DEP_CONTROL: {
+              break;
+            }
+            default:
+              throw loop_error("unknown dependence type");
           }
         }
         g.connect(i, j->first, dv);
@@ -403,27 +405,27 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
         std::vector<DependenceVector> dv = j->second;
         for (int k = 0; k < dv.size(); k++)
           switch (dv[k].type) {
-          case DEP_W2R:
-          case DEP_R2W:
-          case DEP_W2W:
-          case DEP_R2R: {
-            for (int d = 0; d < num_dep_dim; d++)
-              if (dep_pi[d] != d) {
-                dv[k].lbounds[d] = -posInfinity;
-                dv[k].ubounds[d] = posInfinity;
-              }
-            break;
-          }
-          case DEP_CONTROL:
-            break;
-          default:
-            throw loop_error("unknown dependence type");
+            case DEP_W2R:
+            case DEP_R2W:
+            case DEP_W2W:
+            case DEP_R2R: {
+              for (int d = 0; d < num_dep_dim; d++)
+                if (dep_pi[d] != d) {
+                  dv[k].lbounds[d] = -posInfinity;
+                  dv[k].ubounds[d] = posInfinity;
+                }
+              break;
+            }
+            case DEP_CONTROL:
+              break;
+            default:
+              throw loop_error("unknown dependence type");
           }
         g.connect(i, j->first, dv);
       }
     }
   dep = g;
-  
+
   // update loop level information
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
     int cur_dep_dim = min_dep_dim;
@@ -431,65 +433,65 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
     for (int j = 1; j <= stmt[*i].loop_level.size(); j++)
       if (j >= level && j < level + pi.size()) {
         switch (stmt[*i].loop_level[reverse_pi[j - level] - 1].type) {
-        case LoopLevelOriginal:
-          new_loop_level[j - 1].type = LoopLevelOriginal;
-          new_loop_level[j - 1].payload = cur_dep_dim++;
-          new_loop_level[j - 1].parallel_level =
-            stmt[*i].loop_level[reverse_pi[j - level] - 1].parallel_level;
-          break;
-        case LoopLevelTile: {
-          new_loop_level[j - 1].type = LoopLevelTile;
-          int ref_level = stmt[*i].loop_level[reverse_pi[j - level]-1].payload;
-          if (ref_level >= level && ref_level < level + pi.size())
-            new_loop_level[j - 1].payload = reverse_pi[ref_level
-                                                       - level];
-          else
-            new_loop_level[j - 1].payload = ref_level;
-          new_loop_level[j - 1].parallel_level =
-            stmt[*i].loop_level[reverse_pi[j - level] - 1].parallel_level;
-          break;
-        }
-        default:
-          throw loop_error(
-            "unknown loop level information for statement "
-            + to_string(*i));
+          case LoopLevelOriginal:
+            new_loop_level[j - 1].type = LoopLevelOriginal;
+            new_loop_level[j - 1].payload = cur_dep_dim++;
+            new_loop_level[j - 1].parallel_level =
+                stmt[*i].loop_level[reverse_pi[j - level] - 1].parallel_level;
+            break;
+          case LoopLevelTile: {
+            new_loop_level[j - 1].type = LoopLevelTile;
+            int ref_level = stmt[*i].loop_level[reverse_pi[j - level] - 1].payload;
+            if (ref_level >= level && ref_level < level + pi.size())
+              new_loop_level[j - 1].payload = reverse_pi[ref_level
+                                                         - level];
+            else
+              new_loop_level[j - 1].payload = ref_level;
+            new_loop_level[j - 1].parallel_level =
+                stmt[*i].loop_level[reverse_pi[j - level] - 1].parallel_level;
+            break;
+          }
+          default:
+            throw loop_error(
+                "unknown loop level information for statement "
+                + to_string(*i));
         }
       } else {
         switch (stmt[*i].loop_level[j - 1].type) {
-        case LoopLevelOriginal:
-          new_loop_level[j - 1].type = LoopLevelOriginal;
-          new_loop_level[j - 1].payload =
-            stmt[*i].loop_level[j - 1].payload;
-          new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
-                                                                     - 1].parallel_level;
-          break;
-        case LoopLevelTile: {
-          new_loop_level[j - 1].type = LoopLevelTile;
-          int ref_level = stmt[*i].loop_level[j - 1].payload;
-          if (ref_level >= level && ref_level < level + pi.size())
-            new_loop_level[j - 1].payload = reverse_pi[ref_level
-                                                       - level];
-          else
-            new_loop_level[j - 1].payload = ref_level;
-          new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
-                                                                     - 1].parallel_level;
-          break;
-        }
-        default:
-          throw loop_error(
-            "unknown loop level information for statement "
-            + to_string(*i));
+          case LoopLevelOriginal:
+            new_loop_level[j - 1].type = LoopLevelOriginal;
+            new_loop_level[j - 1].payload =
+                stmt[*i].loop_level[j - 1].payload;
+            new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
+                                                                       - 1].parallel_level;
+            break;
+          case LoopLevelTile: {
+            new_loop_level[j - 1].type = LoopLevelTile;
+            int ref_level = stmt[*i].loop_level[j - 1].payload;
+            if (ref_level >= level && ref_level < level + pi.size())
+              new_loop_level[j - 1].payload = reverse_pi[ref_level
+                                                         - level];
+            else
+              new_loop_level[j - 1].payload = ref_level;
+            new_loop_level[j - 1].parallel_level = stmt[*i].loop_level[j
+                                                                       - 1].parallel_level;
+            break;
+          }
+          default:
+            throw loop_error(
+                "unknown loop level information for statement "
+                + to_string(*i));
         }
       }
     stmt[*i].loop_level = new_loop_level;
   }
-  
+
   setLexicalOrder(2 * level - 2, active);
 }
 
 
-void Loop::set_array_size(std::string name, int size ){
-  array_dims.insert(std::pair<std::string, int >(name, size));
+void Loop::set_array_size(std::string name, int size) {
+  array_dims.insert(std::pair<std::string, int>(name, size));
 }
 
 
@@ -499,23 +501,23 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
     throw std::invalid_argument("invalid statement " + to_string(stmt_num));
   if (level <= 0 || level > stmt[stmt_num].loop_level.size())
     throw std::invalid_argument("4invalid loop level " + to_string(level));
-  
+
   std::set<int> result;
   int dim = 2 * level - 1;
   std::vector<int> lex = getLexicalOrder(stmt_num);
   std::set<int> same_loop = getStatements(lex, dim - 1);
-  
+
   Relation cond2 = copy(cond);
   cond2.simplify();
   cond2 = EQs_to_GEQs(cond2);
   Conjunct *c = cond2.single_conjunct();
   int cur_lex = lex[dim - 1];
-  
+
   for (GEQ_Iterator gi(c->GEQs()); gi; gi++) {
     int max_level = (*gi).max_tuple_pos();
     Relation single_cond(max_level);
     single_cond.and_with_GEQ(*gi);
-    
+
     // TODO: should decide where to place newly created statements with
     // complementary split condition from dependence graph.
     bool place_after;
@@ -525,7 +527,7 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
       place_after = true;
     else
       place_after = false;
-    
+
     bool temp_place_after;      // = place_after;
     bool assigned = false;
     int part1_to_part2;
@@ -549,11 +551,11 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
                              Extend_Set(Complement(copy(single_cond)),
                                         n - max_level));
       }
-      
+
       //split dependence check
-      
+
       if (max_level > level) {
-        
+
         DNF_Iterator di1(stmt[*i].IS.query_DNF());
         DNF_Iterator di2(part1.query_DNF());
         for (; di1 && di2; di1++, di2++) {
@@ -569,34 +571,34 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
             bool identical = false;
             if (identical = !strcmp((*cvi1).var->char_name(),
                                     (*cvi2).var->char_name())) {
-              
+
               for (; cvi1 && cvi2; cvi1++, cvi2++) {
-                
+
                 if (((*cvi1).coef != (*cvi2).coef
                      || (*ei1).get_const()
-                     != (*ei2).get_const())
+                        != (*ei2).get_const())
                     || (strcmp((*cvi1).var->char_name(),
                                (*cvi2).var->char_name()))) {
-                  
+
                   same++;
                 }
               }
             }
             if ((same != 0) || !identical) {
-              
+
               dimension = dimension - 1;
-              
+
               while (stmt[*i].loop_level[dimension].type
                      == LoopLevelTile)
                 dimension =
-                  stmt[*i].loop_level[dimension].payload;
-              
+                    stmt[*i].loop_level[dimension].payload;
+
               dimension = stmt[*i].loop_level[dimension].payload;
-              
+
               for (int i = 0; i < stmt.size(); i++) {
                 std::vector<std::pair<int, DependenceVector> > D;
                 for (DependenceGraph::EdgeList::iterator j =
-                       dep.vertex[i].second.begin();
+                    dep.vertex[i].second.begin();
                      j != dep.vertex[i].second.end(); j++) {
                   for (int k = 0; k < j->second.size(); k++) {
                     DependenceVector dv = j->second[k];
@@ -604,19 +606,19 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
                       if (dv.hasNegative(dimension)
                           && !dv.quasi)
                         throw loop_error(
-                          "loop error: Split is illegal, dependence violation!");
-                    
+                            "loop error: Split is illegal, dependence violation!");
+
                   }
                 }
               }
-              
+
             }
-            
+
             GEQ_Iterator gi1 = (*di1)->GEQs();
             GEQ_Iterator gi2 = (*di2)->GEQs();
-            
+
             for (; gi1 && gi2; gi++, gi2++) {
-              
+
               Constr_Vars_Iter cvi1(*gi1);
               Constr_Vars_Iter cvi2(*gi2);
               int dimension = (*cvi1).var->get_position();
@@ -624,33 +626,33 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
               bool identical = false;
               if (identical = !strcmp((*cvi1).var->char_name(),
                                       (*cvi2).var->char_name())) {
-                
+
                 for (; cvi1 && cvi2; cvi1++, cvi2++) {
-                  
+
                   if (((*cvi1).coef != (*cvi2).coef
                        || (*gi1).get_const()
-                       != (*gi2).get_const())
+                          != (*gi2).get_const())
                       || (strcmp((*cvi1).var->char_name(),
                                  (*cvi2).var->char_name()))) {
-                    
+
                     same++;
                   }
                 }
               }
               if ((same != 0) || !identical) {
                 dimension = dimension - 1;
-                
+
                 while (stmt[*i].loop_level[dimension].type
                        == LoopLevelTile)
                   stmt[*i].loop_level[dimension].payload;
-                
+
                 dimension =
-                  stmt[*i].loop_level[dimension].payload;
-                
+                    stmt[*i].loop_level[dimension].payload;
+
                 for (int i = 0; i < stmt.size(); i++) {
                   std::vector<std::pair<int, DependenceVector> > D;
                   for (DependenceGraph::EdgeList::iterator j =
-                         dep.vertex[i].second.begin();
+                      dep.vertex[i].second.begin();
                        j != dep.vertex[i].second.end();
                        j++) {
                     for (int k = 0; k < j->second.size();
@@ -659,22 +661,22 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
                       if (dv.type != DEP_CONTROL)
                         if (dv.hasNegative(dimension)
                             && !dv.quasi)
-                          
+
                           throw loop_error(
-                            "loop error: Split is illegal, dependence violation!");
-                      
+                              "loop error: Split is illegal, dependence violation!");
+
                     }
                   }
                 }
-                
+
               }
-              
+
             }
-            
+
           }
-          
+
         }
-        
+
         DNF_Iterator di3(stmt[*i].IS.query_DNF());
         DNF_Iterator di4(part2.query_DNF());        //
         for (; di3 && di4; di3++, di4++) {
@@ -688,52 +690,52 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
             bool identical = false;
             if (identical = !strcmp((*cvi1).var->char_name(),
                                     (*cvi2).var->char_name())) {
-              
+
               for (; cvi1 && cvi2; cvi1++, cvi2++) {
-                
+
                 if (((*cvi1).coef != (*cvi2).coef
                      || (*ei1).get_const()
-                     != (*ei2).get_const())
+                        != (*ei2).get_const())
                     || (strcmp((*cvi1).var->char_name(),
                                (*cvi2).var->char_name()))) {
-                  
+
                   same++;
                 }
               }
             }
             if ((same != 0) || !identical) {
               dimension = dimension - 1;
-              
+
               while (stmt[*i].loop_level[dimension].type
                      == LoopLevelTile)
                 stmt[*i].loop_level[dimension].payload;
-              
+
               dimension = stmt[*i].loop_level[dimension].payload;
-              
+
               for (int i = 0; i < stmt.size(); i++) {
                 std::vector<std::pair<int, DependenceVector> > D;
                 for (DependenceGraph::EdgeList::iterator j =
-                       dep.vertex[i].second.begin();
+                    dep.vertex[i].second.begin();
                      j != dep.vertex[i].second.end(); j++) {
                   for (int k = 0; k < j->second.size(); k++) {
                     DependenceVector dv = j->second[k];
                     if (dv.type != DEP_CONTROL)
                       if (dv.hasNegative(dimension)
                           && !dv.quasi)
-                        
+
                         throw loop_error(
-                          "loop error: Split is illegal, dependence violation!");
-                    
+                            "loop error: Split is illegal, dependence violation!");
+
                   }
                 }
               }
-              
+
             }
-            
+
           }
           GEQ_Iterator gi1 = (*di3)->GEQs();
           GEQ_Iterator gi2 = (*di4)->GEQs();
-          
+
           for (; gi1 && gi2; gi++, gi2++) {
             Constr_Vars_Iter cvi1(*gi1);
             Constr_Vars_Iter cvi2(*gi2);
@@ -742,66 +744,66 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
             bool identical = false;
             if (identical = !strcmp((*cvi1).var->char_name(),
                                     (*cvi2).var->char_name())) {
-              
+
               for (; cvi1 && cvi2; cvi1++, cvi2++) {
-                
+
                 if (((*cvi1).coef != (*cvi2).coef
                      || (*gi1).get_const()
-                     != (*gi2).get_const())
+                        != (*gi2).get_const())
                     || (strcmp((*cvi1).var->char_name(),
                                (*cvi2).var->char_name()))) {
-                  
+
                   same++;
                 }
               }
             }
             if ((same != 0) || !identical) {
               dimension = dimension - 1;
-              
+
               while (stmt[*i].loop_level[dimension].type        //
                      == LoopLevelTile)
                 stmt[*i].loop_level[dimension].payload;
-              
+
               dimension = stmt[*i].loop_level[dimension].payload;
-              
+
               for (int i = 0; i < stmt.size(); i++) {
                 std::vector<std::pair<int, DependenceVector> > D;
                 for (DependenceGraph::EdgeList::iterator j =
-                       dep.vertex[i].second.begin();
+                    dep.vertex[i].second.begin();
                      j != dep.vertex[i].second.end(); j++) {
                   for (int k = 0; k < j->second.size(); k++) {
                     DependenceVector dv = j->second[k];
                     if (dv.type != DEP_CONTROL)
                       if (dv.hasNegative(dimension)
                           && !dv.quasi)
-                        
+
                         throw loop_error(
-                          "loop error: Split is illegal, dependence violation!");
-                    
+                            "loop error: Split is illegal, dependence violation!");
+
                   }
                 }
               }
-              
+
             }
-            
+
           }
-          
+
         }
-        
+
       }
-      
+
       stmt[*i].IS = part1;
-      
+
       int n1 = part2.n_set();
       int m = this->known.n_set();
       Relation test;
-      if(m > n1)
+      if (m > n1)
         test = Intersection(copy(this->known),
                             Extend_Set(copy(part2), m - part2.n_set()));
       else
         test = Intersection(copy(part2),
                             Extend_Set(copy(this->known), n1 - this->known.n_set()));
-      
+
       if (test.is_upper_bound_satisfiable()) {
         Statement new_stmt;
         new_stmt.code = stmt[*i].code->clone();
@@ -809,20 +811,20 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
         new_stmt.xform = copy(stmt[*i].xform);
         new_stmt.ir_stmt_node = NULL;
         new_stmt.loop_level = stmt[*i].loop_level;
-        
+
         new_stmt.has_inspector = stmt[*i].has_inspector;
         new_stmt.reduction = stmt[*i].reduction;
         new_stmt.reductionOp = stmt[*i].reductionOp;
-        
+
         stmt_nesting_level_.push_back(stmt_nesting_level_[*i]);
-        
-        
+
+
         if (place_after)
           assign_const(new_stmt.xform, dim - 1, cur_lex + 1);
         else
           assign_const(new_stmt.xform, dim - 1, cur_lex - 1);
-        
-        fprintf(stderr, "loop_basic.cc L828 adding stmt %d\n", stmt.size()); 
+
+        fprintf(stderr, "loop_basic.cc L828 adding stmt %d\n", stmt.size());
         stmt.push_back(new_stmt);
 
         uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
@@ -832,7 +834,7 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
         if (*i == stmt_num)
           result.insert(stmt.size() - 1);
       }
-      
+
     }
     // make adjacent lexical number available for new statements
     if (place_after) {
@@ -846,20 +848,20 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
     int dep_dim = get_dep_dim_of(stmt_num, level);
     for (int i = 0; i < old_num_stmt; i++) {
       std::vector<std::pair<int, std::vector<DependenceVector> > > D;
-      
+
       for (DependenceGraph::EdgeList::iterator j =
-             dep.vertex[i].second.begin();
+          dep.vertex[i].second.begin();
            j != dep.vertex[i].second.end(); j++) {
         if (same_loop.find(i) != same_loop.end()) {
           if (same_loop.find(j->first) != same_loop.end()) {
             if (what_stmt_num.find(i) != what_stmt_num.end()
                 && what_stmt_num.find(j->first)
-                != what_stmt_num.end())
+                   != what_stmt_num.end())
               dep.connect(what_stmt_num[i],
                           what_stmt_num[j->first], j->second);
             if (place_after
                 && what_stmt_num.find(j->first)
-                != what_stmt_num.end()) {
+                   != what_stmt_num.end()) {
               std::vector<DependenceVector> dvs;
               for (int k = 0; k < j->second.size(); k++) {
                 DependenceVector dv = j->second[k];
@@ -871,11 +873,11 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
               }
               if (dvs.size() > 0)
                 D.push_back(
-                  std::make_pair(what_stmt_num[j->first],
-                                 dvs));
+                    std::make_pair(what_stmt_num[j->first],
+                                   dvs));
             } else if (!place_after
                        && what_stmt_num.find(i)
-                       != what_stmt_num.end()) {
+                          != what_stmt_num.end()) {
               std::vector<DependenceVector> dvs;
               for (int k = 0; k < j->second.size(); k++) {
                 DependenceVector dv = j->second[k];
@@ -887,7 +889,7 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
               }
               if (dvs.size() > 0)
                 dep.connect(what_stmt_num[i], j->first, dvs);
-              
+
             }
           } else {
             if (what_stmt_num.find(i) != what_stmt_num.end())
@@ -896,17 +898,17 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
         } else if (same_loop.find(j->first) != same_loop.end()) {
           if (what_stmt_num.find(j->first) != what_stmt_num.end())
             D.push_back(
-              std::make_pair(what_stmt_num[j->first],
-                             j->second));
+                std::make_pair(what_stmt_num[j->first],
+                               j->second));
         }
       }
-      
+
       for (int j = 0; j < D.size(); j++)
         dep.connect(i, D[j].first, D[j].second);
     }
-    
+
   }
-  
+
   return result;
 }
 
@@ -914,28 +916,28 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
                 const std::vector<int> &skew_amount) {
   if (stmt_nums.size() == 0)
     return;
-  
+
   // check for sanity of parameters
   int ref_stmt_num = *(stmt_nums.begin());
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
     if (*i < 0 || *i >= stmt.size())
       throw std::invalid_argument(
-        "invalid statement number " + to_string(*i));
+          "invalid statement number " + to_string(*i));
     if (level < 1 || level > stmt[*i].loop_level.size())
       throw std::invalid_argument(
-        "5invalid loop level " + to_string(level));
+          "5invalid loop level " + to_string(level));
     for (int j = stmt[*i].loop_level.size(); j < skew_amount.size(); j++)
       if (skew_amount[j] != 0)
         throw std::invalid_argument("invalid skewing formula");
   }
-  
+
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-  
+
   // set trasformation relations
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
@@ -953,18 +955,18 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
     for (int j = 0; j < skew_amount.size(); j++)
       if (skew_amount[j] != 0)
         h.update_coef(r.input_var(2 * (j + 1)), skew_amount[j]);
-    
+
     stmt[*i].xform = Composition(r, stmt[*i].xform);
     stmt[*i].xform.simplify();
   }
-  
+
   // update dependence graph
   if (stmt[ref_stmt_num].loop_level[level - 1].type == LoopLevelOriginal) {
     int dep_dim = stmt[ref_stmt_num].loop_level[level - 1].payload;
     for (std::set<int>::const_iterator i = stmt_nums.begin();
          i != stmt_nums.end(); i++)
       for (DependenceGraph::EdgeList::iterator j =
-             dep.vertex[*i].second.begin();
+          dep.vertex[*i].second.begin();
            j != dep.vertex[*i].second.end(); j++)
         if (stmt_nums.find(j->first) != stmt_nums.end()) {
           // dependence between skewed statements
@@ -984,7 +986,7 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
                   else {
                     if (cur_dep_dim != -1
                         && !(dv.lbounds[cur_dep_dim] == 0
-                             && dv.ubounds[cur_dep_dim]== 0))
+                             && dv.ubounds[cur_dep_dim] == 0))
                       lb = -posInfinity;
                   }
                   if (ub != posInfinity
@@ -1022,24 +1024,24 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
               }
               dv.lbounds[dep_dim] = lb;
               dv.ubounds[dep_dim] = ub;
-              if ((dv.isCarried(dep_dim) && dv.hasPositive(dep_dim)) 
+              if ((dv.isCarried(dep_dim) && dv.hasPositive(dep_dim))
                   && dv.quasi)
                 dv.quasi = false;
-              
-              if ((dv.isCarried(dep_dim) && dv.hasNegative(dep_dim)) 
+
+              if ((dv.isCarried(dep_dim) && dv.hasNegative(dep_dim))
                   && !dv.quasi)
                 throw loop_error(
-                  "loop error: Skewing is illegal, dependence violation!");
+                    "loop error: Skewing is illegal, dependence violation!");
               dv.lbounds[dep_dim] = lb;
               dv.ubounds[dep_dim] = ub;
               if ((dv.isCarried(dep_dim)
                    && dv.hasPositive(dep_dim)) && dv.quasi)
                 dv.quasi = false;
-              
+
               if ((dv.isCarried(dep_dim)
                    && dv.hasNegative(dep_dim)) && !dv.quasi)
                 throw loop_error(
-                  "loop error: Skewing is illegal, dependence violation!");
+                    "loop error: Skewing is illegal, dependence violation!");
             }
           }
           j->second = dvs;
@@ -1059,7 +1061,7 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
     for (int i = 0; i < dep.vertex.size(); i++)
       if (stmt_nums.find(i) == stmt_nums.end())
         for (DependenceGraph::EdgeList::iterator j =
-               dep.vertex[i].second.begin();
+            dep.vertex[i].second.begin();
              j != dep.vertex[i].second.end(); j++)
           if (stmt_nums.find(j->first) != stmt_nums.end()) {
             // dependence from unskewed statement to skewed statement becomes jumbled,
@@ -1081,34 +1083,34 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
 void Loop::shift(const std::set<int> &stmt_nums, int level, int shift_amount) {
   if (stmt_nums.size() == 0)
     return;
-  
+
   // check for sanity of parameters
   int ref_stmt_num = *(stmt_nums.begin());
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
     if (*i < 0 || *i >= stmt.size())
       throw std::invalid_argument(
-        "invalid statement number " + to_string(*i));
+          "invalid statement number " + to_string(*i));
     if (level < 1 || level > stmt[*i].loop_level.size())
       throw std::invalid_argument(
-        "6invalid loop level " + to_string(level));
+          "6invalid loop level " + to_string(level));
   }
-  
+
   // do nothing
   if (shift_amount == 0)
     return;
-  
+
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-  
+
   // set trasformation relations
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
     int n = stmt[*i].xform.n_out();
-    
+
     Relation r(n, n);
     F_And *f_root = r.add_and();
     for (int j = 1; j <= n; j++) {
@@ -1118,18 +1120,18 @@ void Loop::shift(const std::set<int> &stmt_nums, int level, int shift_amount) {
       if (j == 2 * level)
         h.update_const(shift_amount);
     }
-    
+
     stmt[*i].xform = Composition(r, stmt[*i].xform);
     stmt[*i].xform.simplify();
   }
-  
+
   // update dependence graph
   if (stmt[ref_stmt_num].loop_level[level - 1].type == LoopLevelOriginal) {
     int dep_dim = stmt[ref_stmt_num].loop_level[level - 1].payload;
     for (std::set<int>::const_iterator i = stmt_nums.begin();
          i != stmt_nums.end(); i++)
       for (DependenceGraph::EdgeList::iterator j =
-             dep.vertex[*i].second.begin();
+          dep.vertex[*i].second.begin();
            j != dep.vertex[*i].second.end(); j++)
         if (stmt_nums.find(j->first) == stmt_nums.end()) {
           // dependence from shifted statement to unshifted statement
@@ -1148,7 +1150,7 @@ void Loop::shift(const std::set<int> &stmt_nums, int level, int shift_amount) {
     for (int i = 0; i < dep.vertex.size(); i++)
       if (stmt_nums.find(i) == stmt_nums.end())
         for (DependenceGraph::EdgeList::iterator j =
-               dep.vertex[i].second.begin();
+            dep.vertex[i].second.begin();
              j != dep.vertex[i].second.end(); j++)
           if (stmt_nums.find(j->first) != stmt_nums.end()) {
             // dependence from unshifted statement to shifted statement
@@ -1180,35 +1182,36 @@ void Loop::reverse(const std::set<int> &stmt_nums, int level) {
 void Loop::fuse(const std::set<int> &stmt_nums, int level) {
   if (stmt_nums.size() == 0 || stmt_nums.size() == 1)
     return;
-  
+
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-  
+
   int dim = 2 * level - 1;
   // check for sanity of parameters
   std::vector<int> ref_lex;
   int ref_stmt_num;
-  apply_xform(); 
+  apply_xform();
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
     if (*i < 0 || *i >= stmt.size()) {
-      fprintf(stderr, "statement number %d   should be in [0, %d)\n", *i, stmt.size()); 
+      fprintf(stderr, "statement number %d   should be in [0, %d)\n", *i, stmt.size());
       throw std::invalid_argument(
-        "FUSE invalid statement number " + to_string(*i));
+          "FUSE invalid statement number " + to_string(*i));
     }
     if (level <= 0
-        //    || (level > (stmt[*i].xform.n_out() - 1) / 2
-        //    || level > stmt[*i].loop_level.size())
-      ) {
+      //    || (level > (stmt[*i].xform.n_out() - 1) / 2
+      //    || level > stmt[*i].loop_level.size())
+        ) {
       fprintf(stderr, "FUSE level %d ", level);
       fprintf(stderr, "must be greater than zero and \n");
-      fprintf(stderr, "must NOT be greater than (%d - 1)/2 == %d   and\n", stmt[*i].xform.n_out(), (stmt[*i].xform.n_out() - 1) / 2);
+      fprintf(stderr, "must NOT be greater than (%d - 1)/2 == %d   and\n", stmt[*i].xform.n_out(),
+              (stmt[*i].xform.n_out() - 1) / 2);
       fprintf(stderr, "must NOT be greater than %d\n", stmt[*i].loop_level.size());
       throw std::invalid_argument(
-        "FUSE invalid loop level " + to_string(level));
+          "FUSE invalid loop level " + to_string(level));
     }
     if (ref_lex.size() == 0) {
       ref_lex = getLexicalOrder(*i);
@@ -1218,11 +1221,11 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
       for (int j = 0; j < dim - 1; j += 2)
         if (lex[j] != ref_lex[j])
           throw std::invalid_argument(
-            "statements for fusion must be in the same level-"
-            + to_string(level - 1) + " subloop");
+              "statements for fusion must be in the same level-"
+              + to_string(level - 1) + " subloop");
     }
   }
-  
+
   // collect lexicographical order values from to-be-fused statements
   std::set<int> lex_values;
   for (std::set<int>::const_iterator i = stmt_nums.begin();
@@ -1233,9 +1236,9 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
   if (lex_values.size() == 1)
     return;
   // negative dependence would prevent fusion
-  
+
   int dep_dim = get_dep_dim_of(ref_stmt_num, level);
-  
+
   for (std::set<int>::iterator i = lex_values.begin(); i != lex_values.end();
        i++) {
     ref_lex[dim - 1] = *i;
@@ -1254,25 +1257,25 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
             if (dvs[k].isCarried(dep_dim)
                 && dvs[k].hasNegative(dep_dim))
               throw loop_error(
-                "loop error: statements " + to_string(*ii)
-                + " and " + to_string(*jj)
-                + " cannot be fused together due to negative dependence");
+                  "loop error: statements " + to_string(*ii)
+                  + " and " + to_string(*jj)
+                  + " cannot be fused together due to negative dependence");
           dvs = dep.getEdge(*jj, *ii);
           for (int k = 0; k < dvs.size(); k++)
             if (dvs[k].isCarried(dep_dim)
                 && dvs[k].hasNegative(dep_dim))
               throw loop_error(
-                "loop error: statements " + to_string(*jj)
-                + " and " + to_string(*ii)
-                + " cannot be fused together due to negative dependence");
+                  "loop error: statements " + to_string(*jj)
+                  + " and " + to_string(*ii)
+                  + " cannot be fused together due to negative dependence");
         }
     }
   }
-  
+
   std::set<int> same_loop = getStatements(ref_lex, dim - 3);
-  
+
   std::vector<std::set<int> > s = sort_by_same_loops(same_loop, level);
-  
+
   std::vector<bool> s2;
 
   for (int i = 0; i < s.size(); i++) {
@@ -1283,27 +1286,27 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
        kk++)
     for (int i = 0; i < s.size(); i++)
       if (s[i].find(*kk) != s[i].end()) {
-        
+
         s2[i] = true;
       }
-  
+
   try {
-    
+
     //Dependence Check for Ordering Constraint
     //Graph<std::set<int>, bool> dummy = construct_induced_graph_at_level(s5,
     //    dep, dep_dim);
-    
+
     Graph<std::set<int>, bool> g = construct_induced_graph_at_level(s, dep,
                                                                     dep_dim);
     std::cout << g;
     s = typed_fusion(g, s2);
   } catch (const loop_error &e) {
-    
+
     throw loop_error(
-      "statements cannot be fused together due to negative dependence");
-    
+        "statements cannot be fused together due to negative dependence");
+
   }
-  
+
   int order = 0;
   for (int i = 0; i < s.size(); i++) {
     for (std::set<int>::iterator it = s[i].begin(); it != s[i].end(); it++) {
@@ -1314,7 +1317,7 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
 
 
   //plan for selective typed fusion
-  
+
   /*
     1. sort the lex values of the statements
     2. construct induced graph on sorted statements
@@ -1419,7 +1422,6 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
 }
 
 
-
 void Loop::distribute(const std::set<int> &stmt_nums, int level) {
   if (stmt_nums.size() == 0 || stmt_nums.size() == 1)
     return;
@@ -1439,13 +1441,13 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
        i != stmt_nums.end(); i++) {
     if (*i < 0 || *i >= stmt.size())
       throw std::invalid_argument(
-        "invalid statement number " + to_string(*i));
-    
+          "invalid statement number " + to_string(*i));
+
     if (level < 1
         || (level > (stmt[*i].xform.n_out() - 1) / 2
             || level > stmt[*i].loop_level.size()))
       throw std::invalid_argument(
-        "8invalid loop level " + to_string(level));
+          "8invalid loop level " + to_string(level));
     if (ref_lex.size() == 0) {
       ref_lex = getLexicalOrder(*i);
       ref_stmt_num = *i;
@@ -1454,8 +1456,8 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
       for (int j = 0; j <= dim - 1; j += 2)
         if (lex[j] != ref_lex[j])
           throw std::invalid_argument(
-            "statements for distribution must be in the same level-"
-            + to_string(level) + " subloop");
+              "statements for distribution must be in the same level-"
+              + to_string(level) + " subloop");
     }
   }
 
@@ -1517,7 +1519,7 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
   // nothing to distribute
   if (s2.size() == 1)
     throw loop_error(
-      "loop error: no statement can be distributed due to dependence cycle");
+        "loop error: no statement can be distributed due to dependence cycle");
   std::vector<std::set<int> > s3;
   for (int i = 0; i < s2.size(); i++) {
     std::set<int> t;
@@ -1564,16 +1566,14 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
     order++;
   }
   // no need to update dependence graph
-  
+
   return;
 }
 
 
-
-
 std::vector<IR_ArrayRef *> FindOuterArrayRefs(IR_Code *ir,
                                               std::vector<IR_ArrayRef *> &arr_refs) {
-    std::vector<IR_ArrayRef *> to_return;
+  std::vector<IR_ArrayRef *> to_return;
   for (int i = 0; i < arr_refs.size(); i++)
     if (!ir->parent_is_array(arr_refs[i])) {
       int j;
@@ -1587,38 +1587,36 @@ std::vector<IR_ArrayRef *> FindOuterArrayRefs(IR_Code *ir,
 }
 
 
-
-
-
 std::vector<std::vector<std::string> > constructInspectorVariables(IR_Code *ir,
-                                                                   std::set<IR_ArrayRef *> &arr, std::vector<std::string> &index) {
-  
-  fprintf(stderr, "constructInspectorVariables()\n"); 
+                                                                   std::set<IR_ArrayRef *> &arr,
+                                                                   std::vector<std::string> &index) {
+
+  fprintf(stderr, "constructInspectorVariables()\n");
 
   std::vector<std::vector<std::string> > to_return;
-  
+
   for (std::set<IR_ArrayRef *>::iterator i = arr.begin(); i != arr.end();
        i++) {
-    
+
     std::vector<std::string> per_index;
-    
+
     CG_outputRepr *subscript = (*i)->index(0);
-    
+
     if ((*i)->n_dim() > 1)
       throw ir_error(
-        "multi-dimensional array support non-existent for flattening currently");
-    
+          "multi-dimensional array support non-existent for flattening currently");
+
     while (ir->QueryExpOperation(subscript) == IR_OP_ARRAY_VARIABLE) {
-      
+
       std::vector<CG_outputRepr *> v = ir->QueryExpOperand(subscript);
-      
+
       IR_ArrayRef *ref = static_cast<IR_ArrayRef *>(ir->Repr2Ref(v[0]));
       //per_index.push_back(ref->name());
-      
+
       subscript = ref->index(0);
-      
+
     }
-    
+
     if (ir->QueryExpOperation(subscript) == IR_OP_VARIABLE) {
       std::vector<CG_outputRepr *> v = ir->QueryExpOperand(subscript);
       IR_ScalarRef *ref = static_cast<IR_ScalarRef *>(ir->Repr2Ref(v[0]));
@@ -1627,25 +1625,25 @@ std::vector<std::vector<std::string> > constructInspectorVariables(IR_Code *ir,
       for (j = 0; j < index.size(); j++)
         if (index[j] == ref->name())
           break;
-      
+
       if (j == index.size())
         throw ir_error("Non index variable in array expression");
-      
+
       int k;
       for (k = 0; k < to_return.size(); k++)
         if (to_return[k][0] == ref->name())
           break;
-      if (k == to_return.size()) { 
+      if (k == to_return.size()) {
         to_return.push_back(per_index);
-        fprintf(stderr, "adding index %s\n", ref->name().c_str()); 
+        fprintf(stderr, "adding index %s\n", ref->name().c_str());
       }
-      
+
     }
-    
+
   }
-  
+
   return to_return;
-  
+
 }
 
 /*std::vector<CG_outputRepr *> constructInspectorData(IR_Code *ir, std::vector<std::vector<std::string> >  &indices){
@@ -1669,99 +1667,99 @@ std::vector<std::vector<std::string> > constructInspectorVariables(IR_Code *ir,
   
 */
 
-CG_outputRepr * checkAndGenerateIndirectMappings(CG_outputBuilder * ocg,
-                                                 std::vector<std::vector<std::string> > &indices,
-                                                 CG_outputRepr * instance, CG_outputRepr * class_def,
-                                                 CG_outputRepr * count_var) {
-  
+CG_outputRepr *checkAndGenerateIndirectMappings(CG_outputBuilder *ocg,
+                                                std::vector<std::vector<std::string> > &indices,
+                                                CG_outputRepr *instance, CG_outputRepr *class_def,
+                                                CG_outputRepr *count_var) {
+
   CG_outputRepr *to_return = NULL;
-  
+
   for (int i = 0; i < indices.size(); i++)
     if (indices[i].size() > 1) {
       std::string index = indices[i][indices[i].size() - 1];
       CG_outputRepr *rep = ocg->CreateArrayRefExpression(
-        ocg->CreateDotExpression(instance,
-                                 ocg->lookup_member_data(class_def, index, instance)),
-        count_var);
+          ocg->CreateDotExpression(instance,
+                                   ocg->lookup_member_data(class_def, index, instance)),
+          count_var);
       for (int j = indices[i].size() - 2; j >= 0; j--)
         rep = ocg->CreateArrayRefExpression(indices[i][j], rep);
-      
+
       CG_outputRepr *lhs = ocg->CreateArrayRefExpression(
-        ocg->CreateDotExpression(instance,
-                                 ocg->lookup_member_data(class_def, indices[i][0], instance)),
-        count_var);
-      
+          ocg->CreateDotExpression(instance,
+                                   ocg->lookup_member_data(class_def, indices[i][0], instance)),
+          count_var);
+
       to_return = ocg->StmtListAppend(to_return,
                                       ocg->CreateAssignment(0, lhs, rep));
-      
+
     }
-  
+
   return to_return;
-  
+
 }
 
 CG_outputRepr *generatePointerAssignments(CG_outputBuilder *ocg,
                                           std::string prefix_name,
                                           std::vector<std::vector<std::string> > &indices,
-                                          CG_outputRepr *instance, 
+                                          CG_outputRepr *instance,
                                           CG_outputRepr *class_def) {
-  
+
   fprintf(stderr, "generatePointerAssignments()\n");
   CG_outputRepr *list = NULL;
 
-  fprintf(stderr, "prefix '%s',   %d indices\n",  prefix_name.c_str(), indices.size()); 
+  fprintf(stderr, "prefix '%s',   %d indices\n", prefix_name.c_str(), indices.size());
   for (int i = 0; i < indices.size(); i++) {
-    
+
     std::string s = prefix_name + "_" + indices[i][0];
 
-    fprintf(stderr, "s %s\n", s.c_str()); 
-    
+    fprintf(stderr, "s %s\n", s.c_str());
+
     // create a variable definition for a pointer to int with this name
     // that seems to be the only actual result of this routine ... 
     //chillAST_VarDecl *vd = new chillAST_VarDecl( "int",  prefix_name.c_str(), "*", NULL);
     //vd->print(); printf("\n"); fflush(stdout); 
     //vd->dump(); printf("\n"); fflush(stdout); 
-    
+
     CG_outputRepr *ptr_exp = ocg->CreatePointer(s); // but dropped on the floor. unused 
     //fprintf(stderr, "ptr_exp created\n"); 
-    
+
     //CG_outputRepr *rhs = ocg->CreateDotExpression(instance,
     //                                              ocg->lookup_member_data(class_def, indices[i][0], instance));
-    
+
     //CG_outputRepr *ptr_assignment = ocg->CreateAssignment(0, ptr_exp, rhs);
-    
+
     //list = ocg->StmtListAppend(list, ptr_assignment);
-    
+
   }
-  
+
   fprintf(stderr, "generatePointerAssignments() DONE\n\n");
   return list;
 }
 
 void Loop::normalize(int stmt_num, int loop_level) {
-  
+
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument(
-      
-      "invalid statement number " + to_string(stmt_num));
-  
+
+        "invalid statement number " + to_string(stmt_num));
+
   if (loop_level <= 0)
     throw std::invalid_argument(
-      "12invalid loop level " + to_string(loop_level));
+        "12invalid loop level " + to_string(loop_level));
   if (loop_level > stmt[stmt_num].loop_level.size())
     throw std::invalid_argument(
-      "there is no loop level " + to_string(loop_level)
-      + " for statement " + to_string(stmt_num));
-  
+        "there is no loop level " + to_string(loop_level)
+        + " for statement " + to_string(stmt_num));
+
   apply_xform(stmt_num);
-  
+
   Relation r = copy(stmt[stmt_num].IS);
-  
+
   Relation bound = get_loop_bound(r, loop_level, this->known);
   if (!bound.has_single_conjunct() || !bound.is_satisfiable()
       || bound.is_tautology())
     throw loop_error("unable to extract loop bound for normalize");
-  
+
   // extract the loop stride
   coef_t stride;
   std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(bound,
@@ -1770,31 +1768,31 @@ void Loop::normalize(int stmt_num, int loop_level) {
     stride = 1;
   else
     stride = abs(result.first.get_coef(result.second))
-      / gcd(abs(result.first.get_coef(result.second)),
-            abs(result.first.get_coef(bound.set_var(loop_level))));
-  
+             / gcd(abs(result.first.get_coef(result.second)),
+                   abs(result.first.get_coef(bound.set_var(loop_level))));
+
   if (stride != 1)
     throw loop_error(
-      "normalize currently only handles unit stride, non unit stride present in loop bounds");
-  
+        "normalize currently only handles unit stride, non unit stride present in loop bounds");
+
   GEQ_Handle lb;
-  
+
   Conjunct *c = bound.query_DNF()->single_conjunct();
   for (GEQ_Iterator gi(c->GEQs()); gi; gi++) {
     int coef = (*gi).get_coef(bound.set_var(loop_level));
     if (coef > 0)
       lb = *gi;
   }
-  
+
   //Loop bound already zero
   //Nothing to do.
   if (lb.is_const(bound.set_var(loop_level)) && lb.get_const() == 0)
     return;
-  
+
   if (lb.is_const_except_for_global(bound.set_var(loop_level))) {
-    
+
     int n = stmt[stmt_num].xform.n_out();
-    
+
     Relation r(n, n);
     F_And *f_root = r.add_and();
     for (int j = 1; j <= n; j++)
@@ -1803,10 +1801,10 @@ void Loop::normalize(int stmt_num, int loop_level) {
         h.update_coef(r.input_var(j), 1);
         h.update_coef(r.output_var(j), -1);
       }
-    
+
     stmt[stmt_num].xform = Composition(r, stmt[stmt_num].xform);
     stmt[stmt_num].xform.simplify();
-    
+
     for (Constr_Vars_Iter ci(lb); ci; ci++) {
       if ((*ci).var->kind() == Global_Var) {
         Global_Var_ID g = (*ci).var->get_global_var();
@@ -1816,24 +1814,24 @@ void Loop::normalize(int stmt_num, int loop_level) {
         else
           v = stmt[stmt_num].xform.get_local(g,
                                              (*ci).var->function_of());
-        
+
         F_And *f_super_root = stmt[stmt_num].xform.and_with_and();
         F_Exists *f_exists = f_super_root->add_exists();
         F_And *f_root = f_exists->add_and();
-        
+
         EQ_Handle h = f_root->add_EQ();
         h.update_coef(stmt[stmt_num].xform.output_var(2 * loop_level),
                       1);
         h.update_coef(stmt[stmt_num].xform.input_var(loop_level), -1);
         h.update_coef(v, 1);
-        
+
         stmt[stmt_num].xform.simplify();
       }
-      
+
     }
-    
+
   } else
     throw loop_error("loop bounds too complex for normalize!");
-  
+
 }