something that only builds ...

13 files changed, 16809 insertions, 2735 deletions

diff --git a/src/chill.cc b/src/chill.cc
index 6ca0c4c..b91d383 100644
--- a/src/chill.cc
+++ b/src/chill.cc
@@ -9,7 +9,6 @@
 #include "loop.hh"
 #include <omega.h>
 #include "ir_code.hh"
-#include "ir_rose.hh"
 
 #include "chillmodule.hh" // Python wrapper functions for CHiLL
 
@@ -76,8 +75,6 @@ int main( int argc, char* argv[] )
     lnum_start = get_loop_num_start();
     lnum_end = get_loop_num_end();
     DEBUG_PRINT("calling ROSE code gen?    loop num %d\n", lnum);
-    finalize_loop(lnum_start, lnum_end);
-    ((IR_roseCode*)(ir_code))->finalizeRose();
     delete ir_code;
   }
   Py_Finalize();
diff --git a/src/chill_ast.cc b/src/chill_ast.cc
new file mode 100644
index 0000000..93afd97
--- /dev/null
+++ b/src/chill_ast.cc
@@ -0,0 +1,6493 @@
+
+
+
+#include "chill_ast.hh"
+
+using namespace std;
+
+int chillAST_node::chill_scalar_counter = 0;
+int chillAST_node::chill_array_counter  = 1;
+
+
+const char* Chill_AST_Node_Names[] = { 
+  "Unknown AST node type",
+  "SourceFile",
+  "TypedefDecl",
+  "VarDecl",
+  //  "ParmVarDecl",  not used any more
+  "FunctionDecl",
+  "RecordDecl",
+  "MacroDefinition", 
+  "CompoundStmt",
+  "ForStmt",
+  "TernaryOperator",
+  "BinaryOperator",
+  "UnaryOperator",
+  "ArraySubscriptExpr",
+  "MemberExpr",
+  "DeclRefExpr",
+  "IntegerLiteral",
+  "FloatingLiteral",
+  "ImplicitCastExpr", // not sure we need this
+  "ReturnStmt",
+  "CallExpr",
+  "DeclStmt", 
+  "ParenExpr",
+  "CStyleCastExpr",
+  "CStyleAddressOf",
+  "IfStmt",
+  "SizeOf",
+  "Malloc", 
+  "Free",
+  "NoOp",
+// CUDA specific 
+  "CudaMalloc",
+  "CudaFree",
+  "CudaMemcpy",
+  "CudaKernelCall",
+  "CudaSyncthreads",
+  "fake1",
+  "fake2", 
+  "fake3"
+};
+
+char *parseUnderlyingType( char *sometype ) {
+  int len = strlen(sometype);
+  //fprintf(stderr, "parseUnderlyingType( %s )\n", sometype); 
+  char *underlying = strdup(sometype); 
+  char *p;
+  char *start = underlying;
+
+  // ugly.  we want to turn "float *" into "float" but "struct abc *" into struct abc.
+  // there are probably many more cases. have an approved list?   TODO 
+  if (strstr(underlying, "struct ")) start += 7;  // (length("struct "))
+  //fprintf(stderr, "sometype '%s'   start '%s'\n", sometype, start); 
+  if (p = index(start, ' ')) *p = '\0'; // end at first space     leak
+  if (p = index(start, '[')) *p = '\0'; // leak
+  if (p = index(start, '*')) *p = '\0'; // leak
+  
+  return underlying; 
+}
+
+void printSymbolTable( chillAST_SymbolTable *st ) { 
+  //printf("%d entries\n", st->size()); 
+  if (!st) return;
+  for (int i=0; i<st->size(); i++) {  printf("%d  ", i ); (*st)[i]->printName(); printf("\n"); } 
+  if (st->size() )printf("\n");
+  fflush(stdout); 
+}
+
+void printSymbolTableMoreInfo( chillAST_SymbolTable *st ) { 
+  //printf("%d entries\n", st->size()); 
+  if (!st) return;
+  for (int i=0; i<st->size(); i++) { printf("%d  ", i ); (*st)[i]->print(); printf("\n"); } 
+  if (st->size() )printf("\n");
+  fflush(stdout); 
+}
+
+
+bool symbolTableHasVariableNamed( chillAST_SymbolTable *table, const char *name ) {
+  if (!table) return false; // ?? 
+  int numvars = table->size();
+  for (int i=0; i<numvars; i++) { 
+    chillAST_VarDecl *vd = (*table)[i];
+    if (!strcmp(name, vd->varname)) return true;  // need to check type? 
+  }
+  return false;
+}
+
+
+
+chillAST_VarDecl *symbolTableFindVariableNamed( chillAST_SymbolTable *table, const char *name ){  // fwd decl TODO too many similar named functions
+  if (!table) return NULL; // ?? 
+
+  // see if name has a dot or arrow (->) indicating that it is a structure/class
+  const char *cdot = strstr( name, "." );
+  const char *carrow = strstr(name, "->");  // initial 'c' for const - can't change those
+
+  char *varname;
+  char *subpart = NULL;
+
+  if (cdot || carrow) { 
+    fprintf(stderr, "symbolTableFindVariableNamed(), name '%s' looks like a struct\n", name); 
+
+    // so, look for the first part in the symbol table.
+    // warning, this could be looking for a->b.c.d->e.f->g
+    varname = strdup( name );
+
+    char *dot   = strstr(varname, "." );
+    char *arrow = strstr( varname, "->" );
+    if (dot != NULL && arrow != NULL ) { // dot AND arrow, 
+      fprintf(stderr, "chillast.cc symbolTableFindVariableNamed(), name '%s' has both dot and arrow? TODO\n");
+      exit(-1); 
+    }
+    else if (dot != NULL && !arrow) { // just dot(s).  dot points to the first one 
+      //fprintf(stderr, "name '%s' has dot(s)\n", varname);
+      *dot = '\0'; // end string at the dot
+      subpart = &(dot[1]);
+      fprintf(stderr, "will now look for a struct/class named %s that has member %s\n", varname, subpart);
+
+    }
+    else if (arrow != NULL && !dot) { // just arrow(s)  arrow points to the first one
+      //fprintf(stderr, "name '%s' has arrow(s)\n", varname);
+      *arrow = '\0'; // end string at the arrow
+      subpart = &(arrow[2]); 
+      fprintf(stderr, "will now look for a struct/class named %s that has member %s\n", varname, subpart);
+    }
+    else { // impossible 
+      fprintf(stderr, "chillast.cc symbolTableFindVariableNamed(), varname '%s', looks like a struct,  but I can't figure it out\n", varname);
+      exit(-1); 
+    }
+  }
+  else { 
+    varname = strdup(name); 
+  }
+
+  int numvars = table->size();
+  for (int i=0; i<numvars; i++) { 
+    chillAST_VarDecl *vd = (*table)[i];
+    if (!strcmp(varname, vd->varname)) { 
+      fprintf(stderr, "found variable named %s\n", varname);
+
+      if (!subpart) return vd;  // need to check type? 
+
+      // OK, we have a variable, which looks like a struct/class, and a subpart that is some member names
+      //fprintf(stderr, "but I don't know how to check if it has member %s\n", subpart); 
+      
+      char *dot   = strstr(subpart, "." );
+      char *arrow = strstr(subpart, "->" );
+      
+      if (!dot && !arrow) { // whew, only one level of struct
+        //fprintf(stderr, "whew, only one level of struct\n"); 
+        
+        // make sure this variable definition is a struct
+        if (vd->isAStruct()) { 
+          //fprintf(stderr, "%s is a struct of type %s\n", varname, vd->getTypeString()); 
+          if (vd->isVarDecl()) { 
+            chillAST_RecordDecl  *rd = vd->getStructDef(); 
+            if (rd) { 
+              //fprintf(stderr, "has a recordDecl\n"); 
+              
+              chillAST_VarDecl *sp = rd->findSubpart( subpart );
+              if (sp) fprintf(stderr, "found a struct member named %s\n", subpart);
+              else fprintf(stderr, "DIDN'T FIND a struct member named %s\n", subpart);
+              return sp;  // return the subpart?? 
+            }
+            else { 
+              fprintf(stderr, "no recordDecl\n"); 
+              exit(-1); 
+            }
+          }
+          else { 
+            fprintf(stderr, "NOT a VarDecl???\n"); // impossible
+          }
+        }
+        else { 
+          fprintf(stderr, "false alarm. %s is a variable, but doesn't have subparts\n", varname); 
+          return NULL; // false alarm. a variable of the correct name exists, but is not a struct 
+        }
+      }
+      
+      fprintf(stderr, "chillast.cc symbolTableFindVariableNamed(), name '%s'  can't figure out multiple levels of struct yet!\n"); 
+
+      exit(-1); 
+    }
+  }
+  return NULL;
+}
+
+
+
+char *ulhack( char *brackets ) // remove UL from numbers, MODIFIES the argument!
+{
+  //fprintf(stderr, "ulhack( \"%s\"  -> ", brackets); 
+ // another hack. remove "UL" from integers 
+  int len = strlen(brackets);
+  for (int i=0; i< len-2; i++) {
+    if (isdigit(brackets[i])) {
+      if (brackets[i+1] == 'U' && brackets[i+2] == 'L') { 
+        // remove 
+        for (int j=i+3; j<len; j++) brackets[j-2] = brackets[j];
+        len -=2;
+        brackets[len] = '\0';
+      }
+    }
+  }
+  //fprintf(stderr, "\"%s\" )\n", brackets); 
+  return brackets;
+}
+
+
+char *restricthack( char *typeinfo ) // remove __restrict__ , MODIFIES the argument!
+{
+  //if (!isRestrict( typeinfo )) return typeinfo;
+
+  // there is a "__restrict__ " somewhere embedded. remove it.
+  // duplicate work 
+  std::string r( "__restrict__" );
+  std::string t( typeinfo );
+  size_t index = t.find( r );
+
+  if (index == std::string::npos)  return typeinfo; 
+
+  char *c = &( typeinfo[index] ); 
+  char *after = c + 12;
+  if (*after == ' ') after++;
+
+  //fprintf(stderr, "after = '%s'\n", after); 
+
+  while (*after != '\0') *c++ = *after++; 
+  *c = '\0';
+
+  return typeinfo; 
+
+}
+
+
+
+
+
+char *parseArrayParts( char *sometype ) {
+  int len = strlen(sometype);
+  char *arraypart = (char *)calloc(1 + strlen(sometype), sizeof(char));// leak
+
+  int c = 0;
+  for (int i=0; i<strlen(sometype); ) { 
+    if ( sometype[i] == '*') arraypart[c++] = '*';
+    if ( sometype[i] == '[') { 
+      while (sometype[i] != ']') {
+        arraypart[c++] = sometype[i++];
+      }
+      arraypart[c++] = ']'; 
+    }
+    i += 1;
+  }
+  ulhack(arraypart);
+  restricthack( arraypart );
+
+  //fprintf(stderr, "parseArrayParts( %s ) => %s\n", sometype, arraypart); 
+  return arraypart;
+}
+
+
+
+
+
+
+
+char *splitTypeInfo( char *underlyingtype ) { // return the bracketed part of a type
+  char *ap = ulhack(parseArrayParts( underlyingtype ));  // return this
+
+  // now need to remove all that from the underlyingtype to get 
+  char *arraypart = strdup("");  // leak
+  if (index(underlyingtype, '[')) {
+    // looks like an array 
+    free(arraypart);
+    char *start = index(underlyingtype, '['); // wrong.  can have int *buh[32]
+    arraypart = strdup( start );
+    if (*(start-1) == ' ') start--;  // hack 
+    *start = '\0';
+
+    // ugly. very leaky 
+    strcpy( underlyingtype, parseUnderlyingType( underlyingtype )); 
+    
+    // ulhack( arraypart ); 
+  }
+  return ap;  // leak unless caller frees this 
+}
+
+
+
+bool isRestrict( const char *sometype ) { // does not modify sometype
+  string r( "__restrict__" );
+  string t( sometype );
+  return (std::string::npos != t.find( r ) );
+}
+
+
+
+bool streq( const char *a, const char *b) { return !strcmp(a,b); };  // slightly less ugly // TODO enums
+
+void chillindent( int howfar, FILE *fp ) { for (int i=0; i<howfar; i++) fprintf(fp, "  ");  }
+
+
+
+chillAST_VarDecl * chillAST_node::findVariableNamed( const char *name ) { // generic, recursive
+  fprintf(stderr, "nodetype %s  findVariableNamed( %s )\n", getTypeString(), name ); 
+  if (hasSymbolTable()) { // look in my symbol table if I have one
+    fprintf(stderr, "%s has a symbol table\n",  getTypeString()); 
+    chillAST_VarDecl *vd = symbolTableFindVariableNamed( getSymbolTable(), name);
+    if (vd) {
+      fprintf(stderr, "found it\n"); 
+      return vd; // found locally
+    }
+    fprintf(stderr, "%s has a symbol table but couldn't find %s\n", getTypeString(), name ); 
+  }
+  if (!parent) {
+    fprintf(stderr, "%s has no parent\n", getTypeString());
+    return NULL; // no more recursion available
+  }
+  // recurse upwards
+  //fprintf(stderr, "recursing from %s up to parent %p\n", getTypeString(), parent);
+  fprintf(stderr, "recursing from %s up to parent\n", getTypeString());
+  return parent->findVariableNamed( name ); 
+}
+
+
+chillAST_RecordDecl * chillAST_node::findRecordDeclNamed( const char *name ) { // recursive
+  fprintf(stderr, "%s::findRecordDeclNamed( %s )\n", getTypeString(), name); 
+  // look in children
+  int numchildren = children.size();
+  fprintf(stderr, "%d children\n", numchildren); 
+  for (int i=0; i<numchildren; i++) {
+    fprintf(stderr, "child %d  %s\n", i, children[i]->getTypeString());
+    if (children[i]->isRecordDecl()) {
+      chillAST_RecordDecl *RD = (chillAST_RecordDecl *)children[i];
+      fprintf(stderr, "it is a recordDecl named '%s' vs '%s'\n", RD->getName(), name); 
+      if (!strcmp( RD->getName(), name )) {
+        fprintf(stderr, "FOUND IT\n"); 
+        return RD;
+      }
+    }
+  }   
+    
+  if (!parent) return NULL; // no more recursion available
+  // recurse upwards
+  return parent->findRecordDeclNamed( name ); 
+}
+
+
+void chillAST_node::printPreprocBEFORE( int indent, FILE *fp ) { 
+  int numstmts = preprocessinginfo.size(); 
+  //if (0 != numstmts) { 
+  //  fprintf(fp, "chillAST_node::printPreprocBEFORE()  %d statements\n", numstmts); 
+  //} 
+  
+  
+  for (int i=0; i< numstmts; i++) { 
+    //fprintf(fp, "stmt %d   %d\n", i, preprocessinginfo[i]->position); 
+    if (preprocessinginfo[i]->position == CHILL_PREPROCESSING_LINEBEFORE || 
+        preprocessinginfo[i]->position == CHILL_PREPROCESSING_IMMEDIATELYBEFORE) {
+      //fprintf(stderr, "before %d\n", preprocessinginfo[i]->position); 
+      preprocessinginfo[i]->print(indent, fp); 
+    }
+  }
+}
+
+void chillAST_node::printPreprocAFTER( int indent, FILE *fp ) { 
+  for (int i=0; i< preprocessinginfo.size(); i++) { 
+    if (preprocessinginfo[i]->position == CHILL_PREPROCESSING_LINEAFTER || 
+        preprocessinginfo[i]->position ==  CHILL_PREPROCESSING_TOTHERIGHT) { 
+      //fprintf(stderr, "after %d\n", preprocessinginfo[i]->position); 
+      preprocessinginfo[i]->print(indent, fp); 
+    }
+  }
+}
+
+
+chillAST_SourceFile::chillAST_SourceFile::chillAST_SourceFile() { 
+  SourceFileName = strdup("No Source File");
+  asttype = CHILLAST_NODETYPE_SOURCEFILE;
+  parent = NULL; // top node
+  metacomment = NULL;
+  global_symbol_table = NULL;
+  global_typedef_table = NULL;
+  FileToWrite = NULL;
+  frontend = strdup("unknown"); 
+  isFromSourceFile = true;
+  filename = NULL; 
+};
+
+chillAST_SourceFile::chillAST_SourceFile(const char *filename ) { 
+  SourceFileName = strdup(filename); 
+  asttype = CHILLAST_NODETYPE_SOURCEFILE;  
+  parent = NULL; // top node
+  metacomment = NULL;
+  global_symbol_table = NULL;
+  global_typedef_table = NULL;
+  FileToWrite = NULL; 
+  frontend = strdup("unknown"); 
+  isFromSourceFile = true;
+  filename = NULL; 
+};
+
+void chillAST_SourceFile::print( int indent, FILE *fp ) { 
+  //fprintf(stderr, "chillAST_SourceFile::print()\n"); 
+  fflush(fp);
+  fprintf(fp, "\n// this source derived from CHILL AST originally from file '%s' as parsed by frontend compiler %s\n\n", SourceFileName, frontend); 
+  std::vector< char * > includedfiles; 
+  int sofar = 0; 
+
+  //fprintf(fp, "#define __rose_lt(x,y) ((x)<(y)?(x):(y))\n#define __rose_gt(x,y) ((x)>(y)?(x):(y))\n"); // help diff figure out what's going on
+
+  int numchildren = children.size();
+  //fprintf(stderr, "// sourcefile has %d children\n", numchildren);
+  //fprintf(stderr, "they are\n");
+  //for (int i=0; i<numchildren; i++) {
+  //  fprintf(stderr, "%s  ", children[i]->getTypeString());
+  //  if (children[i]->isFunctionDecl()) {  
+  //    fprintf(stderr, "%s  ", ((chillAST_FunctionDecl *)children[i])->functionName);
+  //  }
+  //  fprintf(stderr, "\n"); 
+  //}  
+
+  for (int i=0; i<numchildren; i++) {
+    //fprintf(fp,  "\n// child %d of type %s:\n", i, children[i]->getTypeString());
+    if (children[i]->isFromSourceFile) { 
+      if (children[i]->isFunctionDecl()) { 
+        fprintf(stderr, "\nchild %d function %s\n",i,((chillAST_FunctionDecl *)children[i])->functionName); 
+      } 
+      //fprintf(stderr, "child %d IS from source file\n", i); 
+      //if (children[i]->isMacroDefinition()) fprintf(fp, "\n"); fflush(fp);
+      children[i]->print( indent, fp );
+      if (children[i]->isVarDecl()) fprintf(fp, ";\n"); fflush(fp);  // top level vardecl\n"); 
+    }
+    else { 
+      //fprintf(stderr, "child %d is not from source file\n", i); 
+      // this should all go away 
+
+#ifdef NOPE 
+      if (children[i]->filename // not null and not empty string 
+          //&&  0 != strlen(children[i]->filename)
+          ) { // should not be necessary 
+        //fprintf(fp, "// need an include for %s\n", children[i]->filename); 
+        bool rddid = false;
+        sofar = includedfiles.size(); 
+        
+        for (int j=0; j<sofar; j++) {
+          //fprintf(stderr, "comparing %s and %s\n",  includedfiles[j], children[i]->filename ); 
+          if (!strcmp( includedfiles[j], children[i]->filename) ) { // this file has already been included
+            rddid = true;
+            //fprintf(stderr, "already did that one\n"); 
+          }
+        }
+        
+        if (false == rddid) { // we need to include it now
+          fprintf(fp, "#include \"%s\"\n", children[i]->filename);
+          includedfiles.push_back(strdup(  children[i]->filename ));
+        }
+        //else { 
+        //  fprintf(fp, "already did\n"); 
+        //} 
+      }
+#endif // NOPE 
+
+
+    }
+  } 
+
+  fflush(fp); 
+
+  //fprintf(fp, "\n\n// functions??\n"); 
+  //for (int i=0; i<functions.size(); i++) { 
+  //  fprintf(fp, "\n\n"); functions[i]->print(0,fp); fflush(fp); 
+  //} 
+};
+ 
+
+
+
+void chillAST_SourceFile::printToFile( char *filename ) {
+  char fn[1024];
+
+  if (NULL == filename)  {  // build up a filename using original name and frontend if known
+    if (FileToWrite) { 
+      strcpy( fn, FileToWrite ); 
+    }
+    else { 
+      // input name with name of frontend compiler prepended
+      if (frontend) sprintf(fn, "%s_%s\0", frontend, SourceFileName);
+      else sprintf(fn, "UNKNOWNFRONTEND_%s\0", SourceFileName); // should never happen
+    }
+  }
+  else strcpy( fn, filename );
+
+  FILE *fp = fopen(fn, "w");
+  if (!fp) { 
+    fprintf(stderr, "can't open file '%s' for writing\n", fn);
+    exit(-1);
+  }
+  
+  //fprintf(fp, "\n\n");
+  //dump(0, fp); 
+  fprintf(fp, "\n\n");
+  print(0, fp);
+  
+}
+
+
+
+void chillAST_SourceFile::dump( int indent, FILE *fp ) { 
+  fflush(fp); 
+  fprintf(fp, "\n//CHILL AST originally from file '%s'\n", SourceFileName); 
+  int numchildren = children.size();
+  for (int i=0; i<numchildren; i++) {
+    children[i]->dump( indent, fp );
+  }
+  fflush(fp); 
+};
+
+
+
+chillAST_MacroDefinition * chillAST_SourceFile::findMacro( const char *name ) {
+  //fprintf(stderr, "chillAST_SourceFile::findMacro( %s )\n", name );
+  
+  int numMacros = macrodefinitions.size();
+  for (int i=0; i<numMacros; i++) { 
+    if (!strcmp( macrodefinitions[i]->macroName, name )) return macrodefinitions[i];
+  }
+  return NULL; // not found
+}
+
+
+chillAST_FunctionDecl * chillAST_SourceFile::findFunction( const char *name ) {
+  //fprintf(stderr, "chillAST_SourceFile::findMacro( %s )\n", name );
+  
+  int numFuncs = functions.size();
+  for (int i=0; i<numFuncs; i++) { 
+    if ( !strcmp( functions[i]->functionName, name )) return functions[i];
+  }
+  return NULL;
+}
+
+
+chillAST_node *chillAST_SourceFile::findCall( const char *name ) {
+  chillAST_MacroDefinition *macro = findMacro( name );
+  if (macro) return (chillAST_node *)macro;
+  chillAST_FunctionDecl *func =findFunction( name ); 
+  return func;
+}
+
+
+chillAST_VarDecl * chillAST_SourceFile::findVariableNamed( const char *name ) { 
+  fprintf(stderr, "SOURCEFILE SPECIAL %s  findVariableNamed( %s )\n", getTypeString(), name );
+  if (hasSymbolTable()) { // look in my symbol table if I have one
+    fprintf(stderr, "%s has a symbol table\n",  getTypeString()); 
+    chillAST_VarDecl *vd = symbolTableFindVariableNamed( getSymbolTable(), name);
+    if (vd) {
+      fprintf(stderr, "found it\n"); 
+      return vd; // found locally
+    }
+    fprintf(stderr, "%s has a symbol table but couldn't find %s\n", getTypeString(),  name ); 
+  }
+
+  fprintf(stderr, "looking for %s in SourceFile global_symbol_table\n", name);
+  chillAST_VarDecl *vd = symbolTableFindVariableNamed( global_symbol_table, name );
+  if (vd) {
+    fprintf(stderr, "found it\n"); 
+    return vd; // found locally
+  }
+
+  if (!parent) {
+    fprintf(stderr, "%s has no parent\n", getTypeString());
+    return NULL; // no more recursion available
+  }
+  // recurse upwards
+  //fprintf(stderr, "recursing from %s up to parent %p\n", getTypeString(), parent);
+  fprintf(stderr, "recursing from %s up to parent\n", getTypeString());
+  return parent->findVariableNamed( name ); 
+}
+
+
+
+chillAST_TypedefDecl::chillAST_TypedefDecl() { 
+  underlyingtype = newtype = arraypart = NULL; 
+  asttype = CHILLAST_NODETYPE_TYPEDEFDECL; 
+  parent = NULL;
+  metacomment = NULL;
+  isStruct = isUnion = false;
+  structname = NULL; 
+  rd = NULL; 
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_TypedefDecl::chillAST_TypedefDecl(char *t, char *nt, chillAST_node *par) { 
+  //fprintf(stderr, "chillAST_TypedefDecl::chillAST_TypedefDecl( underlying type %s, newtype %s )\n", t, nt); 
+  underlyingtype = strdup(t); 
+  newtype = strdup(nt);
+  arraypart = NULL; 
+  asttype = CHILLAST_NODETYPE_TYPEDEFDECL;
+  parent = NULL; 
+  metacomment = NULL;
+  isStruct = isUnion = false;
+  structname = NULL; 
+  rd = NULL; 
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_TypedefDecl::chillAST_TypedefDecl(char *t, char *a, char *p, chillAST_node *par) { 
+  underlyingtype = strdup(t); 
+  //fprintf(stderr, "chillAST_TypedefDecl::chillAST_TypedefDecl( underlying type %s )\n", underlyingtype); 
+  newtype = strdup(a);  // the new named type ??
+
+  arraypart = strdup(p);  // array (p)art? 
+  // splitarraypart(); // TODO 
+
+  asttype = CHILLAST_NODETYPE_TYPEDEFDECL; 
+  parent = par;
+  metacomment = NULL;
+  isStruct = isUnion = false;
+  structname = NULL; 
+  rd = NULL; 
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+
+
+void chillAST_TypedefDecl::print(  int indent,  FILE *fp ) {
+  //fprintf(fp, "typedefdecl->print()\n"); 
+
+  printPreprocBEFORE(indent, fp); 
+
+  if (isStruct) { 
+    fprintf(fp, "\n/* A typedef STRUCT */\n"); chillindent(indent, fp);
+  }
+
+  chillindent(indent, fp);
+  fprintf(fp, "typedef "); fflush(fp); 
+  
+  if (rd) { 
+    rd->print(indent, fp);   // needs to not print the ending semicolon ?? 
+  }  
+  
+  else if (isStruct) {   
+    fprintf(stderr, "/* no rd */\n"); 
+    
+    //fprintf(fp, "struct %s\n", structname);
+    chillindent(indent, fp);
+    fprintf(fp, "{\n");
+    for (int i=0; i<subparts.size(); i++) { 
+      //fprintf(fp, "a %s\n", subparts[i]->getTypeString()); 
+      subparts[i]->print(indent+1, fp);
+      fprintf(fp, ";\n");
+    }
+    fprintf(fp, "};\n");
+  }
+  else { 
+    fprintf(fp, "/* NOT A STRUCT */ typedef %s  %s%s;\n",  underlyingtype, newtype, arraypart ); 
+    dump(); printf("\n\n"); fflush(stdout); 
+  }
+  
+    // then the newname 
+  fprintf(fp, "%s;\n", newtype); 
+  fflush(fp); 
+  printPreprocAFTER(indent, fp); 
+
+  return;
+}
+
+
+chillAST_VarDecl *chillAST_TypedefDecl::findSubpart( const char *name ) {
+  //fprintf(stderr, "chillAST_TypedefDecl::findSubpart( %s )\n", name);
+  //fprintf(stderr, "typedef %s  %s\n", structname, newtype); 
+
+  if (rd) { // we have a record decl look there
+    chillAST_VarDecl *sub = rd->findSubpart( name );
+    //fprintf(stderr, "rd found subpart %p\n", sub); 
+    return sub; 
+  }
+
+  // can this ever happen now ??? 
+  int nsub = subparts.size();
+  //fprintf(stderr, "%d subparts\n", nsub); 
+  for (int i=0; i<nsub; i++) { 
+    if ( !strcmp( name, subparts[i]->varname )) return subparts[i];
+  }
+  //fprintf(stderr, "subpart not found\n"); 
+
+  
+  return NULL; 
+}
+
+
+chillAST_RecordDecl * chillAST_TypedefDecl::getStructDef() { 
+  if (rd) return rd;
+  return NULL;  
+}
+
+
+
+chillAST_RecordDecl::chillAST_RecordDecl() { 
+  asttype = CHILLAST_NODETYPE_RECORDDECL;
+  name = strdup("unknown"); // ?? 
+  originalname = NULL;      // ?? 
+  isStruct = isUnion = false;
+  parent = NULL; 
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+}
+
+chillAST_RecordDecl::chillAST_RecordDecl( const char *nam, chillAST_node *p ) { 
+  //fprintf(stderr, "chillAST_RecordDecl::chillAST_RecordDecl()\n");
+  asttype = CHILLAST_NODETYPE_RECORDDECL;
+  parent = p; 
+  if (nam) name = strdup(nam);
+  else name = strdup("unknown"); // ?? 
+  originalname = NULL;      // ??   // make them do it manually?
+  isStruct = isUnion = false;
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+}
+
+chillAST_RecordDecl::chillAST_RecordDecl( const char *nam, const char *orig, chillAST_node *p ) { 
+  fprintf(stderr, "chillAST_RecordDecl::chillAST_RecordDecl( %s, ( AKA %s ) )\n", nam, orig); 
+  asttype = CHILLAST_NODETYPE_RECORDDECL;
+  parent = p; 
+  if (p) p->addChild( this );
+  
+  if (nam) name = strdup(nam);
+  else name = strdup("unknown"); // ?? 
+  
+  originalname = NULL;   
+  if (orig) originalname = strdup(orig);
+  
+  isStruct = isUnion = false;
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+}
+
+
+
+chillAST_VarDecl * chillAST_RecordDecl::findSubpart( const char *nam ){
+  //fprintf(stderr, "chillAST_RecordDecl::findSubpart( %s )\n", nam);
+  int nsub = subparts.size();
+  //fprintf(stderr, "%d subparts\n", nsub);
+  for (int i=0; i<nsub; i++) { 
+    //fprintf(stderr, "comparing to '%s' to '%s'\n", nam, subparts[i]->varname);
+    if ( !strcmp( nam, subparts[i]->varname )) return subparts[i];
+  }
+  fprintf(stderr, "chillAST_RecordDecl::findSubpart() couldn't find member NAMED %s in ", nam); print(); printf("\n\n"); fflush(stdout); 
+
+  return NULL;   
+}
+
+
+chillAST_VarDecl * chillAST_RecordDecl::findSubpartByType( const char *typ ){
+  //fprintf(stderr, "chillAST_RecordDecl::findSubpart( %s )\n", nam);
+  int nsub = subparts.size();
+  //fprintf(stderr, "%d subparts\n", nsub);
+  for (int i=0; i<nsub; i++) { 
+    //fprintf(stderr, "comparing '%s' to '%s'\n", typ, subparts[i]->vartype);
+    if ( !strcmp( typ, subparts[i]->vartype )) return subparts[i];
+  }
+  //fprintf(stderr, "chillAST_RecordDecl::findSubpart() couldn't find member of TYPE %s in ", typ); print(); printf("\n\n"); fflush(stdout); 
+
+  return NULL;   
+}
+
+
+void chillAST_RecordDecl::print( int indent,  FILE *fp ) {
+  //fprintf(fp, "chillAST_RecordDecl::print()\n");
+  if (isUnnamed) return; 
+  
+  printPreprocBEFORE(indent, fp); 
+
+  chillindent(indent, fp);  
+  if (isStruct) { 
+    //fprintf(fp, "\n/* A Record Decl STRUCT */\n"); chillindent(indent, fp);
+    fprintf(fp, "struct ");
+    if ( strncmp( "unnamed", name, 7) ) fprintf(fp, "%s\n", name);
+    
+    chillindent(indent, fp);
+    fprintf(fp, "{\n");
+    for (int i=0; i<subparts.size(); i++) { 
+      //fprintf(fp, "a %s\n", subparts[i]->getTypeString()); 
+      subparts[i]->print(indent+1, fp);
+      fprintf(fp, ";\n");
+    }
+    fprintf(fp, "} ");
+    fprintf(fp, "\n");  // TODO need semicolon when defining struct. can't have it when part of a typedef. One of the following lines is correct in each case. 
+    //fprintf(fp, ";\n");
+  }
+  else { 
+    fprintf(fp, "/* UNKNOWN RECORDDECL print() */  ");
+    exit(-1);
+  }
+  printPreprocAFTER(indent, fp); 
+  fflush(fp); 
+}
+
+
+chillAST_SymbolTable * chillAST_RecordDecl::addVariableToSymbolTable( chillAST_VarDecl *vd ){ 
+  // for now, just bail. or do we want the struct to have an actual symbol table?
+  //fprintf(stderr, "chillAST_RecordDecl::addVariableToSymbolTable() ignoring struct member %s vardecl\n", vd->varname); 
+  return NULL; // damn, I hope nothing uses this! 
+}
+
+void chillAST_RecordDecl::printStructure( int indent,  FILE *fp ) {
+  //fprintf(stderr, "chillAST_RecordDecl::printStructure()\n"); 
+  chillindent(indent, fp);  
+  if (isStruct) { 
+    fprintf(fp, "struct { ", name);
+    for (int i=0; i<subparts.size(); i++) { 
+      subparts[i]->print( 0, fp); // ?? TODO indent level 
+      fprintf(fp, "; ");
+    }
+    fprintf(fp, "} ");
+  }
+  else { 
+    fprintf(fp, "/* UNKNOWN RECORDDECL printStructure() */  ");
+    exit(-1);
+  }
+  fflush(fp); 
+}
+
+
+
+void chillAST_RecordDecl::dump( int indent,  FILE *fp ) {
+  chillindent(indent, fp);  
+  
+}
+
+
+chillAST_FunctionDecl::chillAST_FunctionDecl() { 
+  functionName = strdup("YouScrewedUp"); 
+  asttype = CHILLAST_NODETYPE_FUNCTIONDECL; 
+  forwarddecl = externfunc = builtin = false; 
+  uniquePtr = (void *) NULL;
+  this->setFunctionCPU(); 
+  parent = NULL;
+  metacomment = NULL;
+  //symbol_table = NULL;   // eventually, pointing to body's symbol table
+  typedef_table = NULL;
+  body = new chillAST_CompoundStmt();
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_FunctionDecl::chillAST_FunctionDecl(const char *rt, const char *fname, chillAST_node *par) { 
+  returnType = strdup(rt);
+  functionName = strdup(fname);
+  this->setFunctionCPU(); 
+  //fprintf(stderr, "functionName %s\n", functionName); 
+  forwarddecl = externfunc = builtin = false; 
+
+  asttype = CHILLAST_NODETYPE_FUNCTIONDECL; 
+  parent = par;
+  metacomment = NULL;
+  if (par) par->getSourceFile()->addFunc( this );
+  // symbol_table = NULL; //use body's instead
+  typedef_table = NULL;
+  body = new chillAST_CompoundStmt();
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_FunctionDecl::chillAST_FunctionDecl(const char *rt, const char *fname, chillAST_node *par, void *unique) {
+  fprintf(stderr, "chillAST_FunctionDecl::chillAST_FunctionDecl with unique %p\n", unique); 
+  returnType = strdup(rt);
+  functionName = strdup(fname);
+  this->setFunctionCPU(); 
+  //fprintf(stderr, "functionName %s\n", functionName); 
+  forwarddecl = externfunc = builtin = false; 
+
+  body = new chillAST_CompoundStmt();
+  asttype = CHILLAST_NODETYPE_FUNCTIONDECL; 
+  uniquePtr = unique; // a quick way to check equivalence. DO NOT ACCESS THROUGH THIS 
+  parent = par;
+  metacomment = NULL;
+  if (par) par->getSourceFile()->addFunc( this );
+  //symbol_table = NULL; // use body's 
+  typedef_table = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+void chillAST_FunctionDecl::addParameter( chillAST_VarDecl *p) {
+  fprintf(stderr, "%s chillAST_FunctionDecl::addParameter( 0x%x  param %s)   total of %d parameters\n", functionName, p, p->varname, 1+parameters.size()); 
+
+  if (symbolTableHasVariableNamed( &parameters, p->varname)) { // NOT recursive. just in FunctionDecl
+    fprintf(stderr, "chillAST_FunctionDecl::addParameter( %s ), parameter already exists?\n", p->varname);
+    // exit(-1); // ?? 
+    return; // error? 
+  }
+
+  parameters.push_back(p);
+  //addSymbolToTable( parameters, p );
+  fprintf(stderr, "setting %s isAParameter\n", p->varname); 
+  p->isAParameter = true;  
+  
+  p->setParent( this ); // ??  unclear TODO 
+  //p->dump(); printf("\naddparameter done\n\n"); fflush(stdout); 
+}
+
+
+
+void chillAST_FunctionDecl::addDecl( chillAST_VarDecl *vd) { // to symbol table ONLY 
+  fprintf(stderr, "chillAST_FunctionDecl::addDecl( %s )\n", vd->varname);
+  if (!body) {  
+    //fprintf(stderr, "had no body\n"); 
+    body = new chillAST_CompoundStmt();
+    
+    //body->symbol_table = symbol_table;   // probably wrong if this ever does something
+  }
+
+  //fprintf(stderr, "before body->addvar(), func symbol table had %d entries\n", symbol_table->size()); 
+  //fprintf(stderr, "before body->addvar(), body symbol table was %p\n", body->symbol_table); 
+  //fprintf(stderr, "before body->addvar(), body symbol table had %d entries\n", body->symbol_table->size()); 
+  //adds to body symbol table, and makes sure function has a copy. probably dumb
+  body->symbol_table = body->addVariableToSymbolTable( vd ); 
+  //fprintf(stderr, "after body->addvar(), func symbol table had %d entries\n", symbol_table->size()); 
+}
+
+chillAST_VarDecl *chillAST_FunctionDecl::hasParameterNamed( const char *name ) { 
+  int numparams = parameters.size();
+  for (int i=0; i<numparams; i++) { 
+    if (!strcmp(name, parameters[i]->varname)) return parameters[i];  // need to check type? 
+  }
+  return NULL; 
+}
+
+
+// similar to symbolTableHasVariableNamed() but returns the variable definition
+chillAST_VarDecl *chillAST_FunctionDecl::funcHasVariableNamed( const char *name ) { // NOT recursive
+  //fprintf(stderr, "chillAST_FunctionDecl::funcHasVariableNamed( %s )\n", name );
+
+  // first check the parameters
+  int numparams = parameters.size();
+  for (int i=0; i<numparams; i++) { 
+    chillAST_VarDecl *vd = parameters[i];
+    if (!strcmp(name, vd->varname)) { 
+      //fprintf(stderr, "yep, it's parameter %d\n", i); 
+      return vd;  // need to check type? 
+    }
+  }
+  //fprintf(stderr, "no parameter named %s\n", name); 
+
+  chillAST_SymbolTable *st = getSymbolTable(); 
+  if (!st) {
+    fprintf(stderr,"and no symbol_table, so no variable named %s\n", name);
+    return NULL; // no symbol table so no variable by that name 
+  }
+
+  
+  int numvars =  st->size();
+  //fprintf(stderr, "checking against %d variables\n", numvars); 
+  for (int i=0; i<numvars; i++) { 
+    chillAST_VarDecl *vd = (*st)[i];
+    //fprintf(stderr, "comparing '%s' to '%s'\n", name, vd->varname); 
+    if (!strcmp(name, vd->varname)) {
+      //fprintf(stderr, "yep, it's variable %d\n", i); 
+      fprintf(stderr, "%s was already defined in the function body\n", vd->varname); 
+      return vd;  // need to check type? 
+    }
+  }
+  fprintf(stderr, "not a parameter or variable named %s\n", name); 
+  return NULL; 
+}
+
+
+
+
+void chillAST_FunctionDecl::setBody( chillAST_node * bod ) {
+  //fprintf(stderr, "%s chillAST_FunctionDecl::setBody( 0x%x )   total of %d children\n", functionName, bod, 1+children.size()); 
+  if (bod->isCompoundStmt())   body = (chillAST_CompoundStmt *)bod;
+  else { 
+    body = new chillAST_CompoundStmt();
+    body->addChild( bod ); 
+  }
+  //symbol_table = body->getSymbolTable(); 
+  //addChild(bod);
+  bod->setParent( this );  // well, ... 
+}
+
+
+void chillAST_FunctionDecl::insertChild(int i, chillAST_node* node) { 
+  fprintf(stderr, "chillAST_FunctionDecl::insertChild()  "); node->print(0,stderr); fprintf(stderr, "\n\n"); 
+  body->insertChild( i, node ); 
+
+  if (node->isVarDecl()) { 
+    chillAST_VarDecl *vd = ((chillAST_VarDecl *) node);
+    fprintf(stderr, "functiondecl %s inserting a VarDecl named %s\n", functionName, vd->varname);
+    chillAST_SymbolTable *st = getSymbolTable();
+    if (!st) { 
+      fprintf(stderr, "symbol table is NULL!\n"); 
+    }
+    else { 
+      fprintf(stderr, "%d entries in the symbol table\n", st->size()); 
+      printSymbolTable( getSymbolTable() );
+    }
+    fprintf(stderr, "\n\n"); 
+  }
+}
+
+void chillAST_FunctionDecl::addChild(chillAST_node* node) { 
+  fprintf(stderr, "chillAST_FunctionDecl::addChild( )  "); node->print(0,stderr); fprintf(stderr, "\n\n"); 
+  if (node->isVarDecl()) { 
+    chillAST_VarDecl *vd = ((chillAST_VarDecl *) node);
+    fprintf(stderr, "functiondecl %s adding a VarDecl named %s\n", functionName, vd->varname);
+  }
+
+  body->addChild( node ); 
+  node->parent = this; // this, or body?? 
+}
+
+
+void  chillAST_FunctionDecl::printParameterTypes( FILE *fp ) {  // also prints names
+  //fprintf(stderr, "\n\n%s chillAST_FunctionDecl::printParameterTypes()\n", functionName); 
+  fprintf(fp, "( "); 
+  int numparameters = parameters.size(); 
+  for (int i=0; i<numparameters; i++) {
+    if (i!=0) fprintf(fp, ", "); 
+    chillAST_VarDecl *p = parameters[i];
+    p->print(0, fp); // note: no indent, as this is in the function parens
+  }
+  fprintf(fp, " )"); // end of input parameters
+
+}
+
+
+
+
+void chillAST_FunctionDecl::print(  int indent,  FILE *fp ) {
+  //fprintf(fp, "\n// functiondecl %p    \n", this); 
+  //chillindent(indent, fp); 
+  //fprintf(fp, "//(functiondecl)  %d parameters\n", numparameters);
+
+  printPreprocBEFORE(indent, fp); 
+
+  fprintf(fp, "\n");
+  chillindent(indent, fp); 
+
+  if (externfunc)  fprintf(fp, "extern ");
+
+  if (function_type == CHILL_FUNCTION_GPU) fprintf(fp, "__global__ "); 
+  fprintf(fp, "%s %s",  returnType, functionName );
+  printParameterTypes(fp); 
+
+
+  
+  // non-parameter variables  (now must have explicit vardecl in the body) 
+  //int numvars = symbol_table.size();
+  //for (int i=0; i<numvars; i++) { 
+  //  symbol_table[i]->print(1,fp);
+  //  fprintf(fp, ";\n"); 
+  //} 
+
+  // now the body 
+  if (!(externfunc || forwarddecl)) { 
+    if (body) { 
+      fprintf(fp, "\n{\n"); 
+      //chillindent(indent+1, fp); fprintf(fp, "//body\n"); fflush(fp); 
+      body->print( indent+1, fp);
+      fprintf(fp, "\n"); 
+      //chillindent(indent+1, fp); fprintf(fp, "//END body\n"); fflush(fp); 
+    
+      // tidy up
+      chillindent(indent, fp); 
+      fprintf(fp, "}\n");
+    } // if body 
+    else { 
+      fprintf(fp, "{}\n"); // should never happen, but not external and no body 
+    }
+  }
+  else { // extern func or forward decl.   just end forward declaration 
+    fprintf(fp, "; // fwd decl\n");
+  }
+  
+  printPreprocAFTER(indent, fp); 
+
+  fflush(fp); 
+}
+ 
+
+
+void chillAST_FunctionDecl::dump(  int indent,  FILE *fp ) {
+  fprintf(fp, "\n"); 
+  fprintf(fp, "// isFromSourceFile ");
+  if (filename) fprintf(fp, "%s  ", filename); 
+  if (isFromSourceFile) fprintf(fp, "true\n"); 
+  else fprintf(fp, "false\n"); 
+  chillindent(indent, fp); 
+  fprintf(fp, "(FunctionDecl %s %s(",  returnType, functionName );
+  
+  int numparameters = parameters.size(); 
+  for (int i=0; i<numparameters; i++) {
+    if (i!=0) fprintf(fp, ", "); 
+    chillAST_VarDecl *p = parameters[i];
+    //fprintf(stderr, "param type %s  vartype %s\n", p->getTypeString(), p->vartype); 
+    p->print(0, fp); // note: no indent, as this is in the function parens, ALSO print, not dump
+  }
+  fprintf(fp, ")\n"); // end of input parameters
+  
+  // now the body - 
+  if (body) body->dump( indent+1 , fp); 
+
+  // tidy up
+  chillindent(indent, fp); 
+  fprintf(fp, ")\n");
+  fflush(fp); 
+}
+ 
+
+
+
+
+
+void chillAST_FunctionDecl::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_FunctionDecl::gatherVarDecls()\n"); 
+  //if (0 < children.size()) fprintf(stderr, "functiondecl has %d children\n", children.size()); 
+  //fprintf(stderr, "functiondecl has %d parameters\n", numParameters());
+  for (int i=0; i<numParameters(); i++) parameters[i]->gatherVarDecls( decls );   
+  //fprintf(stderr, "after parms, %d decls\n", decls.size()); 
+  for (int i=0; i<children.size(); i++) children[i]->gatherVarDecls( decls ); 
+  //fprintf(stderr, "after children, %d decls\n", decls.size()); 
+  body->gatherVarDecls( decls );  // todo, figure out if functiondecl has actual children
+  //fprintf(stderr, "after body, %d decls\n", decls.size()); 
+  //for (int d=0; d<decls.size(); d++) {
+  //  decls[d]->print(0,stderr); fprintf(stderr, "\n"); 
+  //} 
+}
+
+
+void chillAST_FunctionDecl::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //if (0 < children.size()) fprintf(stderr, "functiondecl has %d children\n", children.size()); 
+  
+  for (int i=0; i<numParameters(); i++) parameters[i]->gatherScalarVarDecls( decls );   
+  for (int i=0; i<children.size(); i++) children[i]->gatherScalarVarDecls( decls ); 
+  body->gatherScalarVarDecls( decls );  // todo, figure out if functiondecl has actual children
+}
+
+
+void chillAST_FunctionDecl::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //if (0 < children.size()) fprintf(stderr, "functiondecl has %d children\n", children.size()); 
+  
+  for (int i=0; i<numParameters(); i++) parameters[i]->gatherArrayVarDecls( decls );   
+  for (int i=0; i<children.size(); i++) children[i]->gatherArrayVarDecls( decls ); 
+  body->gatherArrayVarDecls( decls );  // todo, figure out if functiondecl has actual children
+}
+
+
+chillAST_VarDecl *chillAST_FunctionDecl::findArrayDecl( const char *name ) { 
+  //fprintf(stderr, "chillAST_FunctionDecl::findArrayDecl( %s )\n", name );
+  chillAST_VarDecl *p = hasParameterNamed( name ); 
+  //if (p) fprintf(stderr, "function %s has parameter named %s\n", functionName, name );
+  if (p && p->isArray()) return p;
+
+  chillAST_VarDecl *v = funcHasVariableNamed ( name ); 
+  //if (v) fprintf(stderr, "function %s has symbol table variable named %s\n", functionName, name );
+  if (v && v->isArray()) return v;
+
+  // declared variables that may not be in symbol table but probably should be
+  vector<chillAST_VarDecl*> decls ;
+  gatherArrayVarDecls( decls );
+  for (int i=0; i<decls.size(); i++) { 
+    chillAST_VarDecl *vd = decls[i]; 
+    if (0 == strcmp(vd->varname, name ) && vd->isArray()) return vd;
+  }
+
+  //fprintf(stderr, "can't find array named %s in function %s \n", name, functionName); 
+  return NULL; 
+}
+
+
+void chillAST_FunctionDecl::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherVarUsage( decls ); 
+  body->gatherVarUsage( decls );  // todo, figure out if functiondecl has actual children
+}
+
+
+void chillAST_FunctionDecl::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherDeclRefExprs( refs ); 
+  body->gatherDeclRefExprs( refs );  // todo, figure out if functiondecl has actual children
+}
+
+
+
+void chillAST_FunctionDecl::cleanUpVarDecls() {  
+  //fprintf(stderr, "\ncleanUpVarDecls() for function %s\n", functionName); 
+  vector<chillAST_VarDecl*> used;
+  vector<chillAST_VarDecl*> defined;
+  vector<chillAST_VarDecl*> deletethese;
+
+  gatherVarUsage( used ); 
+  gatherVarDecls( defined ); 
+
+  //fprintf(stderr, "\nvars used: \n"); 
+  //for ( int i=0; i< used.size(); i++) { 
+  //used[i]->print(0, stderr);  fprintf(stderr, "\n"); 
+  //} 
+  //fprintf(stderr, "\n"); 
+  //fprintf(stderr, "\nvars defined: \n"); 
+  //for ( int i=0; i< defined.size(); i++) { 
+  //  defined[i]->print(0, stderr);  fprintf(stderr, "\n"); 
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  for ( int j=0; j < defined.size(); j++) { 
+    //fprintf(stderr, "j %d  defined %s\n", j, defined[j]->varname); 
+    bool definedandused = false;
+    for ( int i=0; i < used.size(); i++) {
+      if (used[i] == defined[j]) { 
+        //fprintf(stderr, "i %d used %s\n", i, used[i]->varname); 
+        //fprintf(stderr, "\n");
+        definedandused = true;
+        break;
+      }
+    }
+
+    if (!definedandused) { 
+      if ( defined[j]->isParmVarDecl() ) { 
+        //fprintf(stderr, "we'd remove %s except that it's a parameter. Maybe someday\n", defined[j]->varname); 
+      }
+      else { 
+        //fprintf(stderr, "we can probably remove the definition of %s\n", defined[j]->varname); 
+        deletethese.push_back(  defined[j] ); 
+      }
+    }
+  }
+
+
+  //fprintf(stderr, "deleting %d vardecls\n", deletethese.size()); 
+  for (int i=0; i<deletethese.size(); i++) { 
+    //fprintf(stderr, "deleting varDecl %s\n",  deletethese[i]->varname); 
+    chillAST_node *par =  deletethese[i]->parent; 
+    par->removeChild( par->findChild( deletethese[i] )); 
+  }
+
+
+  //fprintf(stderr, "\n\nnow check for vars used but not defined\n"); 
+  // now check for vars used but not defined?
+  for ( int j=0; j < used.size(); j++) { 
+    //fprintf(stderr, "%s is used\n", used[j]->varname); 
+    bool definedandused = false;
+    for ( int i=0; i < defined.size(); i++) {
+      if (used[j] == defined[i]) { 
+        //fprintf(stderr, "%s is defined\n", defined[i]->varname); 
+        definedandused = true;
+        break;
+      }
+    }
+    if (!definedandused) { 
+      //fprintf(stderr, "%s is used but not defined?\n", used[j]->varname); 
+      // add it to the beginning of the function
+      insertChild(0, used[j]); 
+    }
+  }
+  
+}
+
+//void chillAST_FunctionDecl::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl ) {
+//  for (int i=0; i<children.size(); i++) children[i]->replaceVarDecls( olddecl, newdecl ); 
+//} 
+
+
+bool chillAST_FunctionDecl::findLoopIndexesToReplace(  chillAST_SymbolTable *symtab, bool forcesync ) { 
+  if (body) body->findLoopIndexesToReplace( symtab, false ); 
+  return false;
+}
+
+
+
+ chillAST_node *chillAST_FunctionDecl::constantFold() { 
+   //fprintf(stderr, "chillAST_FunctionDecl::constantFold()\n");
+   // parameters can't have constants?
+   int numparameters = parameters.size(); 
+   for (int i=0; i<numparameters; i++) {
+     parameters[i]->constantFold();
+   }
+   if (body) body = (chillAST_CompoundStmt *)body->constantFold(); 
+   return this;
+ }
+
+
+chillAST_MacroDefinition::chillAST_MacroDefinition() { 
+  macroName = strdup("UNDEFINEDMACRO");
+  rhsString = NULL;
+  asttype = CHILLAST_NODETYPE_MACRODEFINITION; 
+  parent  = NULL;
+  metacomment = NULL;
+  symbol_table = NULL;
+  //rhsideString = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_MacroDefinition::chillAST_MacroDefinition(const char *mname, chillAST_node *par) { 
+  macroName = strdup(mname);
+  rhsString = NULL;
+  asttype = CHILLAST_NODETYPE_MACRODEFINITION; 
+  parent = par;
+  metacomment = NULL;
+  symbol_table = NULL;
+  //rhsideString = NULL;
+
+  if (par) par->getSourceFile()->addMacro( this );
+
+  //fprintf(stderr, "chillAST_MacroDefinition::chillAST_MacroDefinition( %s, ", mname); 
+  //if (par) fprintf(stderr, " parent NOT NULL);\n");
+  //else fprintf(stderr, " parent NULL);\n");
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_MacroDefinition::chillAST_MacroDefinition(const char *mname, const char *rhs, chillAST_node *par) { 
+  macroName = strdup(mname);
+  rhsString = strdup(rhs);
+  asttype = CHILLAST_NODETYPE_MACRODEFINITION; 
+  parent = par;
+  metacomment = NULL;
+  symbol_table = NULL;
+
+  if (par) par->getSourceFile()->addMacro( this );
+
+  //fprintf(stderr, "chillAST_MacroDefinition::chillAST_MacroDefinition( %s, ", mname); 
+  //if (par) fprintf(stderr, " parent NOT NULL);\n");
+  //else fprintf(stderr, " parent NULL);\n");
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+};
+
+
+chillAST_node* chillAST_MacroDefinition::clone() {
+
+  // TODO ?? cloning a macro makes no sense
+  return this;
+#ifdef CONFUSED 
+
+  //fprintf(stderr, "chillAST_MacroDefinition::clone() for %s\n", macroName); 
+  chillAST_MacroDefinition *clo = new chillAST_MacroDefinition( macroName, parent); 
+  for (int i=0; i<parameters.size(); i++) clo->addParameter( parameters[i] );
+  clo->setBody( body->clone() );
+  return clo; 
+#endif 
+
+}
+
+
+void chillAST_MacroDefinition::setBody( chillAST_node * bod ) {
+  fprintf(stderr, "%s chillAST_MacroDefinition::setBody( 0x%x )\n", macroName, bod); 
+  body = bod;
+  fprintf(stderr, "body is:\n"); body->print(0,stderr); fprintf(stderr, "\n\n");
+  rhsString = body->stringRep(); 
+  bod->setParent( this );  // well, ... 
+}
+
+
+void chillAST_MacroDefinition::addParameter( chillAST_VarDecl *p) {
+  //fprintf(stderr, "%s chillAST_MacroDefinition::addParameter( 0x%x )   total of %d children\n", functionName, p, 1+children.size()); 
+  parameters.push_back(p);
+  fprintf(stderr, "macro setting %s isAParameter\n", p->varname); 
+  p->isAParameter = true; 
+  p->setParent( this );
+
+  addVariableToSymbolTable( p );
+}
+
+
+chillAST_VarDecl *chillAST_MacroDefinition::hasParameterNamed( const char *name ) { 
+  int numparams = parameters.size();
+  for (int i=0; i<numparams; i++) { 
+    if (!strcmp(name, parameters[i]->varname)) return parameters[i];  // need to check type? 
+  }
+  return NULL; 
+}
+
+
+void chillAST_MacroDefinition::insertChild(int i, chillAST_node* node) { 
+  body->insertChild( i, node ); 
+}
+
+void chillAST_MacroDefinition::addChild(chillAST_node* node) { 
+  body->addChild( node ); 
+  node->parent = this; // this, or body?? 
+}
+
+
+void chillAST_MacroDefinition::dump(  int indent,  FILE *fp ) {
+  fprintf(fp, "\n"); 
+  chillindent(indent, fp); 
+  fprintf(fp, "(MacroDefinition %s(", macroName);
+  for (int i=0; i<numParameters(); i++) { 
+    fprintf(fp, "\n");
+    chillindent(indent+1, fp);
+    fprintf(fp, "(%s)", parameters[i]->varname); 
+  }
+  fprintf(fp, ")\n"); 
+  body->dump( indent+1, fp);
+  if (rhsString) fprintf(fp, " (aka %s)"); 
+  fprintf(fp, "\n"); 
+  fflush(fp);
+}
+
+
+void chillAST_MacroDefinition::print(  int indent,  FILE *fp ) {  // UHOH   TODO 
+  //fprintf(fp, "\n"); // ignore indentation
+  //fprintf(stderr, "macro has %d parameters\n", numParameters()); 
+
+  printPreprocBEFORE(indent, fp); 
+
+  fprintf(fp, "#define %s", macroName);
+  if (0 != numParameters()) { 
+    fprintf(fp, "(");
+    for (int i=0; i<numParameters(); i++) { 
+      if (i) fprintf(fp, ",");
+      fprintf(fp, "%s", parameters[i]->varname); 
+    }
+    fprintf(fp, ")  ");
+  }
+
+  if (body) body->print(0, fp); // TODO should force newlines out of multiline macros 
+  fprintf(fp, "\n"); 
+} 
+
+
+
+
+chillAST_ForStmt::chillAST_ForStmt() {
+  init = cond = incr = NULL;
+  body = new chillAST_CompoundStmt();
+
+  asttype = CHILLAST_NODETYPE_LOOP;  // breaking with tradition, this was CHILL_AST_FORSTMT
+  conditionoperator = IR_COND_UNKNOWN;
+  parent = NULL;
+  metacomment = NULL;
+  symbol_table = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+}
+
+
+chillAST_ForStmt::chillAST_ForStmt(  chillAST_node *ini, chillAST_node *con, chillAST_node *inc, chillAST_node *bod, chillAST_node *par) {
+  parent = par; 
+  metacomment = NULL;
+  init = ini;
+  cond = con;
+  incr = inc;
+  body = bod;
+  init->setParent( this ); 
+  cond->setParent( this ); 
+  incr->setParent( this ); 
+  
+  //fprintf(stderr, "chillAST_ForStmt::chillAST_ForStmt() bod %p\n", bod); 
+
+  if (body) body->setParent( this );  // not sure this should be legal 
+  
+  asttype = CHILLAST_NODETYPE_LOOP;  // breaking with tradition, this was CHILL_AST_FORSTMT  
+
+  if (!cond->isBinaryOperator()) { 
+    fprintf(stderr, "ForStmt conditional is of type %s. Expecting a BinaryOperator\n", cond->getTypeString());
+    exit(-1); 
+  }
+  chillAST_BinaryOperator *bo = (chillAST_BinaryOperator *)cond;
+  char *condstring = bo->op; 
+  if (!strcmp(condstring, "<"))       conditionoperator = IR_COND_LT;
+  else if (!strcmp(condstring, "<=")) conditionoperator = IR_COND_LE;
+  else if (!strcmp(condstring, ">"))  conditionoperator = IR_COND_GT;
+  else if (!strcmp(condstring, ">=")) conditionoperator = IR_COND_GE;
+  else { 
+    fprintf(stderr, "ForStmt, illegal/unhandled end condition \"%s\"\n", condstring);
+    fprintf(stderr, "currently can only handle <, >, <=, >=\n");
+    exit(1);
+  }
+  isFromSourceFile = true; // default 
+  filename = NULL; 
+}
+
+
+bool chillAST_ForStmt::lowerBound( int &l ) { // l is an output (passed as reference)
+  
+  // above, cond must be a binaryoperator ... ??? 
+  if (conditionoperator == IR_COND_LT || 
+      conditionoperator == IR_COND_LE ) { 
+    
+    // lower bound is rhs of init 
+    if (!init->isBinaryOperator()) { 
+      fprintf(stderr, "chillAST_ForStmt::lowerBound() init is not a chillAST_BinaryOperator\n");
+      exit(-1);
+    }
+    
+    chillAST_BinaryOperator *bo = (chillAST_BinaryOperator *)init;
+    if (!init->isAssignmentOp()) { 
+      fprintf(stderr, "chillAST_ForStmt::lowerBound() init is not an assignment chillAST_BinaryOperator\n");
+      exit(-1);
+    }
+    
+    //fprintf(stderr, "rhs "); bo->rhs->print(0,stderr);  fprintf(stderr, "   "); 
+    l = bo->rhs->evalAsInt(); // float could be legal I suppose
+    //fprintf(stderr, "   %d\n", l); 
+    return true; 
+  }
+  else if (conditionoperator == IR_COND_GT || 
+           conditionoperator == IR_COND_GE ) {  // decrementing 
+    // lower bound is rhs of cond (not init)
+    chillAST_BinaryOperator *bo = (chillAST_BinaryOperator *)cond;
+    l = bo->rhs->evalAsInt(); // float could be legal I suppose
+    return true; 
+  }
+  
+  // some case we don't handle ?? 
+  fprintf(stderr, "chillAST_ForStmt::lowerBound() can't find lower bound of "); 
+  print(0,stderr); 
+  fprintf(stderr, "\n\n"); 
+  return false;      // or exit ???
+}
+
+
+bool chillAST_ForStmt::upperBound( int &u ) { // u is an output (passed as reference)
+  
+  // above, cond must be a binaryoperator ... ??? 
+  if (conditionoperator == IR_COND_GT || 
+      conditionoperator == IR_COND_GE ) {  // decrementing 
+
+    // upper bound is rhs of init 
+    if (!init->isBinaryOperator()) { 
+      fprintf(stderr, "chillAST_ForStmt::upperBound() init is not a chillAST_BinaryOperator\n");
+      exit(-1);
+    }
+
+    chillAST_BinaryOperator *bo = (chillAST_BinaryOperator *)init;
+    if (!init->isAssignmentOp()) { 
+      fprintf(stderr, "chillAST_ForStmt::upperBound() init is not an assignment chillAST_BinaryOperator\n");
+      exit(-1);
+    }
+
+    u = bo->rhs->evalAsInt(); // float could be legal I suppose
+    return true; 
+  }
+  else if (conditionoperator == IR_COND_LT || 
+           conditionoperator == IR_COND_LE ) { 
+    //fprintf(stderr, "upper bound is rhs of cond   ");
+    // upper bound is rhs of cond (not init)
+    chillAST_BinaryOperator *bo = (chillAST_BinaryOperator *)cond;
+    //bo->rhs->print(0,stderr);
+    u = bo->rhs->evalAsInt(); // float could be legal I suppose
+
+    if (conditionoperator == IR_COND_LT) u -= 1;  
+
+    //fprintf(stderr, "    %d\n", u);
+    return true; 
+  }
+
+  // some case we don't handle ?? 
+  fprintf(stderr, "chillAST_ForStmt::upperBound() can't find upper bound of "); 
+  print(0,stderr); 
+  fprintf(stderr, "\n\n"); 
+  return false;      // or exit ???
+}
+
+
+
+
+void chillAST_ForStmt::printControl( int in, FILE *fp ) {
+  chillindent(in, fp);
+  fprintf(fp, "for (");
+  init->print(0, fp);
+  fprintf(fp, "; ");
+  cond->print(0, fp);
+  fprintf(fp, "; ");
+  incr->print(0, fp);
+  fprintf(fp, ")");
+  fflush(fp); 
+}
+
+
+void chillAST_ForStmt::print( int indent, FILE *fp ) {
+  printPreprocBEFORE(indent, fp); 
+  //fprintf(fp, "chillAST_ForStmt::print()\n"); 
+  if (metacomment) { 
+    chillindent(indent, fp);
+    //for(int i=0; i<indent; i++) fprintf(fp, ".."); 
+    fprintf(fp, "// %s\n", metacomment);
+  }
+
+  printControl(indent, fp);  // does not do a newline or bracket 
+  fprintf(fp, " {\n"); 
+
+
+  // I have no idea what made me do this next bit. 
+  // A forstmt with compounds inside compounds ??? 
+  // this should probably all go away 
+
+  chillAST_node *b = body;
+  //fprintf(fp, "b children %d\n", b->getNumChildren()); 
+  //fprintf(fp, "body child 0 of type %s\n", b->children[0]->getTypeString()); 
+  //fprintf(stderr, "forstmt body type %s\n", Chill_AST_Node_Names[b->asttype] ); 
+  // deal with a tree of compound statements, in an ugly way. leave the ugliness
+  while (1 == b->getNumChildren() && b->children[0]->isCompoundStmt()) { 
+    b = b->children[0]; 
+  }
+
+
+  // this was to sometimes not enclose in a bracket. stupid. always enclose in a bracket.
+  //if (1 == b->getNumChildren() && b->children[0]->isForStmt()) fprintf(fp, ") {\n" );
+  //else if (1 == b->getNumChildren() ) fprintf(fp, ") { ?? \n" ); // to allow for() for( ) to not have open bracket?
+  //else { 
+    //fprintf(fp, ")\n");
+    //chillindent(in, fp);
+    //fprintf(fp, "{\n" );
+
+    //fprintf(fp, ")");
+  //}
+
+  b->print(indent+1, fp );
+
+  // I think this can't happen any more. body is always a compound statement 
+  if (b->asttype ==  CHILLAST_NODETYPE_BINARYOPERATOR) { // a single assignment statement
+    fprintf(fp, ";\n"); 
+  }
+
+  // always print brackets 
+
+  //if ((1 == b->getNumChildren() && b->children[0]->isForStmt()) || 
+  //    (1 != b->getNumChildren() )) {
+  chillindent(indent, fp);
+  fprintf(fp, "}\n" );  
+  //}
+
+  printPreprocAFTER(indent, fp); 
+  fflush(fp); //
+}
+
+void chillAST_ForStmt::dump( int indent, FILE *fp ) {
+  chillindent(indent, fp);
+  fprintf(fp, "(ForStmt \n");
+
+  init->dump(indent+1, fp);
+  cond->dump(indent+1, fp);
+  incr->dump(indent+1, fp);
+  body->dump(indent+1, fp);
+
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+}
+ 
+chillAST_node *chillAST_ForStmt::constantFold() { 
+   init = init->constantFold(); 
+   cond = cond->constantFold(); 
+   incr = incr->constantFold(); 
+   body = body->constantFold(); 
+   return this; 
+ }
+
+
+ chillAST_node *chillAST_ForStmt::clone() { 
+  chillAST_ForStmt *fs = new chillAST_ForStmt( init->clone(), cond->clone(), incr->clone(), body->clone(), parent); 
+  fs->isFromSourceFile = isFromSourceFile;
+  if (filename) fs->filename = strdup(filename);
+  return fs;
+ }
+
+void chillAST_ForStmt::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ForStmt::gatherVarDecls()\n"); 
+  //fprintf(stderr, "chillAST_ForStmt::gatherVarDecls()  before %d\n", decls.size());
+  // TODO clear a loop_var_decls variable and then walk it ? 
+  init->gatherVarDecls( decls ); 
+  cond->gatherVarDecls( decls ); 
+  incr->gatherVarDecls( decls ); 
+  body->gatherVarDecls( decls ); 
+  //fprintf(stderr, "after %d\n", decls.size()); 
+}
+
+void chillAST_ForStmt::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ForStmt::gatherScalarVarDecls()  before %d\n", decls.size());
+  init->gatherScalarVarDecls( decls ); 
+  cond->gatherScalarVarDecls( decls ); 
+  incr->gatherScalarVarDecls( decls ); 
+  body->gatherScalarVarDecls( decls ); 
+}
+
+void chillAST_ForStmt::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ForStmt::gatherArrayVarDecls()  before %d\n", decls.size());
+  init->gatherArrayVarDecls( decls ); 
+  cond->gatherArrayVarDecls( decls ); 
+  incr->gatherArrayVarDecls( decls ); 
+  body->gatherArrayVarDecls( decls ); 
+}
+
+void chillAST_ForStmt::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) { 
+  init->gatherArrayRefs( refs, 0 );  // 0 ??
+  cond->gatherArrayRefs( refs, 0 );  // 0 ??
+  incr->gatherArrayRefs( refs, 0 );  // 0 ??
+  body->gatherArrayRefs( refs, 0 );  // 0 ??
+}
+
+void chillAST_ForStmt::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  init->gatherScalarRefs( refs, 0 );  // 0 ??
+  cond->gatherScalarRefs( refs, 0 );  // 0 ??
+  incr->gatherScalarRefs( refs, 0 );  // 0 ??
+  body->gatherScalarRefs( refs, 0 );  // 0 ??
+} 
+
+void chillAST_ForStmt::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  init->gatherDeclRefExprs( refs ); 
+  cond->gatherDeclRefExprs( refs ); 
+  incr->gatherDeclRefExprs( refs ); 
+  body->gatherDeclRefExprs( refs ); 
+}
+
+
+
+void chillAST_ForStmt::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  init->gatherVarUsage( decls ); 
+  cond->gatherVarUsage( decls ); 
+  incr->gatherVarUsage( decls ); 
+  body->gatherVarUsage( decls ); 
+}
+
+void chillAST_ForStmt::gatherStatements(std::vector<chillAST_node*> &statements ){
+  
+  // for completeness, should do all 4. Maybe someday
+  //init->gatherStatements( statements ); 
+  //cond->gatherStatements( statements ); 
+  //incr->gatherStatements( statements ); 
+  body->gatherStatements( statements ); 
+}
+
+
+
+void chillAST_ForStmt::addSyncs() {
+  //fprintf(stderr, "\nchillAST_ForStmt::addSyncs()  "); 
+  //fprintf(stderr, "for (");
+  //init->print(0, stderr);
+  //fprintf(stderr, "; ");
+  //cond->print(0, stderr);
+  //fprintf(stderr, "; ");
+  //incr->print(0, stderr);
+  //fprintf(stderr, ")\n"); 
+  
+  if (!parent) { 
+    fprintf(stderr, "uhoh, chillAST_ForStmt::addSyncs() ForStmt has no parent!\n");
+    fprintf(stderr, "for (");
+    init->print(0, stderr);
+    fprintf(stderr, "; ");
+    cond->print(0, stderr);
+    fprintf(stderr, "; ");
+    incr->print(0, stderr);
+    fprintf(stderr, ")\n"); 
+
+    return; // exit? 
+  }
+
+  if (parent->isCompoundStmt()) { 
+    //fprintf(stderr, "ForStmt parent is CompoundStmt 0x%x\n", parent);
+    vector<chillAST_node*> chillin = parent->getChildren();
+    int numc = chillin.size();
+    //fprintf(stderr, "ForStmt parent is CompoundStmt 0x%x with %d children\n", parent, numc);
+    for (int i=0; i<numc; i++) { 
+      if (this == parent->getChild(i)) { 
+        //fprintf(stderr, "forstmt 0x%x is child %d of %d\n", this, i, numc); 
+        chillAST_CudaSyncthreads *ST = new chillAST_CudaSyncthreads();
+        parent->insertChild(i+1, ST);  // corrupts something ... 
+        //fprintf(stderr, "Create a call to __syncthreads() 2\n"); 
+        //parent->addChild(ST);  // wrong, but safer   still kills 
+      }
+    }
+
+    chillin = parent->getChildren();
+    int nowc = chillin.size();
+    //fprintf(stderr, "old, new number of children = %d %d\n", numc, nowc); 
+    
+  }
+  else { 
+    fprintf(stderr, "chillAST_ForStmt::addSyncs() unhandled parent type %s\n", parent->getTypeString()); 
+    exit(-1); 
+  }
+
+  //fprintf(stderr, "leaving addSyncs()\n"); 
+}
+
+
+
+
+void chillAST_ForStmt::removeSyncComment() { 
+  //fprintf(stderr, "chillAST_ForStmt::removeSyncComment()\n"); 
+  if (metacomment && strstr(metacomment, "~cuda~") && strstr(metacomment, "preferredIdx: ")) { 
+    char *ptr =  strlen( "preferredIdx: " ) + strstr(metacomment, "preferredIdx: ");
+    *ptr = '\0'; 
+  }
+}
+
+
+bool chillAST_ForStmt::findLoopIndexesToReplace(chillAST_SymbolTable *symtab, bool forcesync ) { 
+  fprintf(stderr, "\nchillAST_ForStmt::findLoopIndexesToReplace( force = %d )\n", forcesync); 
+  //if (metacomment) fprintf(stderr, "metacomment '%s'\n", metacomment); 
+
+  bool force = forcesync;
+  bool didasync = false;
+  if (forcesync) { 
+    //fprintf(stderr, "calling addSyncs() because PREVIOUS ForStmt in a block had preferredIdx\n"); 
+    addSyncs();
+    didasync = true; 
+  }
+  
+  //fprintf(stderr, "chillAST_ForStmt::findLoopIndexesToReplace()\n"); 
+  if (metacomment && strstr(metacomment, "~cuda~") && strstr(metacomment, "preferredIdx: ")) { 
+    //fprintf(stderr, "metacomment '%s'\n", metacomment); 
+    
+    char *copy = strdup(metacomment); 
+    char *ptr  = strstr(copy, "preferredIdx: ");
+    char *vname = ptr + strlen( "preferredIdx: " );
+    char *space = strstr(vname, " "); // TODO index()
+    if (space) { 
+      //fprintf(stderr, "vname = '%s'\n", vname); 
+      force = true; 
+    }
+
+    if ((!didasync) && force ) { 
+      //fprintf(stderr, "calling addSyncs() because ForStmt metacomment had preferredIdx '%s'\n", vname); 
+      addSyncs();
+      removeSyncComment(); 
+      didasync = true; 
+    }
+
+    if (space)   *space = '\0'; // if this is multiple words, grab the first one
+    //fprintf(stderr, "vname = '%s'\n", vname); 
+    
+    //fprintf(stderr, "\nfor (");
+    //init->print(0, stderr);
+    //fprintf(stderr, "; ");
+    //cond->print(0, stderr);
+    //fprintf(stderr, "; ");
+    //incr->print(0, stderr);
+    //fprintf(stderr, ")    %s\n", metacomment );
+    //fprintf(stderr, "prefer '%s'\n", vname );
+    
+    vector<chillAST_VarDecl*> decls;
+    init->gatherVarLHSUsage( decls ); 
+    //cond->gatherVarUsage( decls ); 
+    //incr->gatherVarUsage( decls ); 
+    //fprintf(stderr, "forstmt has %d vardecls in init, cond, inc\n", decls.size()); 
+
+    if ( 1 != decls.size()) { 
+      fprintf(stderr, "uhoh, preferred index in for statement, but multiple variables used\n");
+      print(0,stderr);
+      fprintf(stderr, "\nvariables are:\n"); 
+      for (int i=0; i<decls.size(); i++) { 
+        decls[i]->print(0,stderr); fprintf(stderr, "\n"); 
+      }
+      exit(0); 
+    }
+    chillAST_VarDecl* olddecl = decls[0];
+
+    // RIGHT NOW, change all the references that this loop wants swapped out 
+    // find vardecl for named preferred index.  it has to already exist
+    fprintf(stderr, "RIGHT NOW, change all the references that this loop wants swapped out \n"); 
+
+    chillAST_VarDecl *newguy = findVariableNamed( vname ); // recursive
+    if (!newguy) { 
+      fprintf(stderr, "there was no variable named %s anywhere I could find\n", vname);
+    }
+
+    // wrong - this only looks at variables defined in the forstmt, not 
+    // in parents of the forstmt
+    //int numsym = symtab->size(); 
+    //fprintf(stderr, "%d symbols\n", numsym);
+    //for (int i=0; i<numsym; i++) { 
+    //  fprintf(stderr, "sym %d is '%s'\n", i, (*symtab)[i]->varname);
+    //  if (!strcmp(vname,  (*symtab)[i]->varname)) { 
+    //    newguy = (*symtab)[i];
+    // }
+    //}
+    if (!newguy) { 
+      fprintf(stderr, "chillAST_ForStmt::findLoopIndexesToReplace() there is no defined variable %s\n", vname); 
+
+      // make one ??  seems like this should never happen 
+      newguy = new chillAST_VarDecl( olddecl->vartype, vname, ""/*?*/, NULL );
+      // insert actual declaration in code location?   how?
+
+      // find parent of the ForStmt?
+      // find parent^n of the ForStmt that is not a Forstmt?
+      // find parent^n of the Forstmt that is a FunctionDecl?
+      chillAST_node *contain = findContainingNonLoop();
+      if (contain == NULL) { 
+        fprintf(stderr, "nothing but loops all the way up?\n");
+        exit(0);
+      }
+      fprintf(stderr, "containing non-loop is a %s\n", contain->getTypeString()); 
+
+      contain->print(0,stderr);
+      contain->insertChild( 0, newguy ); // ugly order TODO
+      contain->addVariableToSymbolTable( newguy ); // adds to first enclosing symbolTable
+      
+      if (!  symbolTableHasVariableNamed( contain->getSymbolTable(), vname )) { 
+        fprintf(stderr, "container doesn't have a var names %s afterwards???\n", vname); 
+        exit(-1); 
+      }
+    }
+
+
+    // swap out old for new in init, cond, incr, body 
+    if (newguy) { 
+      fprintf(stderr, "\nwill replace %s with %s in init, cond, incr\n", olddecl->varname, newguy->varname); 
+      fprintf(stderr, "was: for (");
+      init->print(0, stderr);
+      fprintf(stderr, "; ");
+      cond->print(0, stderr);
+      fprintf(stderr, "; ");
+      incr->print(0, stderr);
+      fprintf(stderr, ")\n");
+      
+      
+      init->replaceVarDecls( olddecl, newguy ); 
+      cond->replaceVarDecls( olddecl, newguy ); 
+      incr->replaceVarDecls( olddecl, newguy ); 
+
+      fprintf(stderr, " is: for (");
+      init->print(0, stderr);
+      fprintf(stderr, "; ");
+      cond->print(0, stderr);
+      fprintf(stderr, "; ");
+      incr->print(0, stderr);
+      fprintf(stderr, ")\n\n");
+
+      fprintf(stderr,"recursing to ForStmt body of type %s\n", body->getTypeString()); 
+      body->replaceVarDecls( olddecl, newguy ); 
+
+      fprintf(stderr, "\nafter recursing to body, this loop is   (there should be no %s)\n", olddecl->varname);
+      print(0, stderr); fprintf(stderr, "\n"); 
+      
+    }
+    
+    //if (!space) // there was only one preferred
+    //fprintf(stderr, "removing metacomment\n"); 
+    metacomment = NULL; // memleak
+
+  }
+
+  // check for more loops.  We may have already swapped variables out in body (right above here)
+  body->findLoopIndexesToReplace( symtab, false ) ; 
+
+  return force; 
+}
+
+void chillAST_ForStmt::replaceChild( chillAST_node *old, chillAST_node *newchild ){
+  //fprintf(stderr, "chillAST_ForStmt::replaceChild()  REALLY CALLING BODY->ReplaceCHILD\n"); 
+  body->replaceChild( old, newchild );
+}
+
+
+
+void chillAST_ForStmt::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  // logic problem  if my loop var is olddecl! 
+
+  //fprintf(stderr, "chillAST_ForStmt::replaceVarDecls( old %s,  new %s )\n", olddecl->varname, newdecl->varname);
+
+  // this is called for inner loops!
+  init->replaceVarDecls( olddecl, newdecl ); 
+  cond->replaceVarDecls( olddecl, newdecl ); 
+  incr->replaceVarDecls( olddecl, newdecl ); 
+  body->replaceVarDecls( olddecl, newdecl ); 
+}
+
+
+void chillAST_ForStmt::gatherLoopIndeces( std::vector<chillAST_VarDecl*> &indeces ) { 
+  //fprintf(stderr, "chillAST_ForStmt::gatherLoopIndeces()\nloop is:\n"); print(0,stderr); 
+
+  vector<chillAST_VarDecl*> decls;
+  init->gatherVarLHSUsage( decls ); 
+  cond->gatherVarLHSUsage( decls ); 
+  incr->gatherVarLHSUsage( decls ); 
+  // note: NOT GOING INTO BODY OF THE LOOP
+
+  int numdecls = decls.size(); 
+  //fprintf(stderr, "gatherLoopIndeces(), %d lhs vardecls for this ForStmt\n", numdecls);
+
+  for (int i=0; i<decls.size(); i++)  {
+    //fprintf(stderr, "%s %p\n", decls[i]->varname, decls[i] );
+    indeces.push_back( decls[i] ); 
+  }
+  
+  // Don't forget to keep heading upwards!
+  if (parent) {
+    //fprintf(stderr, "loop %p has parent of type %s\n", this, parent->getTypeString()); 
+    parent->gatherLoopIndeces( indeces );
+  }
+  //else fprintf(stderr, "this loop has no parent???\n");
+
+}
+
+
+void chillAST_ForStmt::gatherLoopVars(  std::vector<std::string> &loopvars ) {
+  //fprintf(stderr, "gathering loop vars for loop   for (");
+  //init->print(0, stderr);
+  //fprintf(stderr, "; ");
+  //cond->print(0, stderr);
+  //fprintf(stderr, "; ");
+  //incr->print(0, stderr);
+  //fprintf(stderr, ")\n" );
+
+  //init->dump(0, stderr); 
+
+
+  vector<chillAST_VarDecl*> decls;
+  init->gatherVarLHSUsage( decls ); 
+  cond->gatherVarLHSUsage( decls ); 
+  incr->gatherVarLHSUsage( decls ); 
+  // note: NOT GOING INTO BODY OF THE LOOP
+  
+  for (int i=0; i<decls.size(); i++)  loopvars.push_back( strdup( decls[i]->varname )); 
+
+}
+
+
+void chillAST_ForStmt::loseLoopWithLoopVar( char *var ) { 
+
+  //fprintf(stderr, "\nchillAST_ForStmt::loseLoopWithLoopVar(  %s )\n", var ); 
+
+  // now recurse (could do first, I suppose) 
+  // if you DON'T do this first, you may have already replaced yourself with this loop body
+  // the body will no longer have this forstmt as parent, it will have the forstmt's parent as its parent
+  //fprintf(stderr, "forstmt 0x%x, recursing loseLoop to body 0x%x of type %s with parent 0x%x of type %s\n", this, body,  body->getTypeString(), body->parent, body->parent->getTypeString()); 
+  body->loseLoopWithLoopVar( var ) ; 
+
+
+
+
+  // if *I* am a loop to be replaced, tell my parent to replace me with my loop body
+
+  std::vector<std::string> loopvars;
+  gatherLoopVars( loopvars );
+  
+  if (loopvars.size() != 1) { 
+    fprintf(stderr, "uhoh, loop has more than a single loop var and trying to loseLoopWithLoopVar()\n");
+    print(0,stderr);
+    fprintf(stderr, "\nvariables are:\n"); 
+    for (int i=0; i<loopvars.size(); i++) { 
+      fprintf(stderr, "%s\n", loopvars[i].c_str()); 
+    }
+    
+    exit(-1); 
+  }
+  
+  //fprintf(stderr, "my loop var %s, looking for %s\n", loopvars[0].c_str(), var );
+  if (!strcmp(var,  loopvars[0].c_str())) { 
+    //fprintf(stderr, "OK, trying to lose myself!    for (");
+    //init->print(0, stderr);
+    //fprintf(stderr, "; ");
+    //cond->print(0, stderr);
+    //fprintf(stderr, "; ");
+    //incr->print(0, stderr);
+    //fprintf(stderr, ")\n" );   
+
+    if (!parent) { 
+      fprintf(stderr, "chillAST_ForStmt::loseLoopWithLoopVar()  I have no parent!\n");
+      exit(-1);
+    }
+
+    vector<chillAST_VarDecl*> decls;
+    init->gatherVarLHSUsage( decls );   // this can fail if init is outside the loop
+    cond->gatherVarLHSUsage( decls ); 
+    incr->gatherVarLHSUsage( decls ); 
+    if (decls.size() > 1) { 
+      fprintf(stderr, "chill_ast.cc multiple loop variables confuses me\n");
+      exit(-1); 
+    }
+    chillAST_node *newstmt = body; 
+
+    // ACTUALLY, if I am being replaced, and my loop conditional is a min (Ternary), then wrap my loop body in an if statement
+    if (cond->isBinaryOperator()) { // what else could it be?
+      chillAST_BinaryOperator *BO = (chillAST_BinaryOperator *) cond;
+      if (BO->rhs->isTernaryOperator()) { 
+
+        chillAST_TernaryOperator *TO = (chillAST_TernaryOperator *)BO->rhs;
+        chillAST_BinaryOperator *C =  (chillAST_BinaryOperator *)TO->condition;
+        
+        //fprintf(stderr, "loop condition RHS  is ternary\nCondition RHS");
+        C->print(); printf("\n"); fflush(stdout); 
+        chillAST_node *l = C->lhs;
+        if (l->isParenExpr()) l = ((chillAST_ParenExpr *)l)->subexpr; 
+        chillAST_node *r = C->rhs;
+        if (r->isParenExpr()) r = ((chillAST_ParenExpr *)r)->subexpr; 
+
+        //fprintf(stderr, "lhs is %s     rhs is %s\n", l->getTypeString(), r->getTypeString()); 
+        
+        chillAST_node *ifcondrhs = NULL; 
+        if (!(l->isConstant())) ifcondrhs = l;
+        else if (!(r->isConstant())) ifcondrhs = r;
+        else { 
+          // should never happen. 2 constants. infinite loop
+          fprintf(stderr, "chill_ast.cc INIFNITE LOOP?\n"); 
+          this->print(0,stderr); fprintf(stderr, "\n\n");
+          exit(-1);
+        }
+        
+        // wrap the loop body in an if
+        chillAST_DeclRefExpr *DRE = new chillAST_DeclRefExpr( decls[0] ); 
+        chillAST_BinaryOperator *ifcond = new chillAST_BinaryOperator( DRE, "<=", ifcondrhs ); 
+        chillAST_IfStmt *ifstmt = new chillAST_IfStmt( ifcond, body, NULL, NULL ); 
+        
+        newstmt = ifstmt; 
+      }
+    }
+
+    //fprintf(stderr, "forstmt 0x%x has parent 0x%x  of type %s\n", this, parent, parent->getTypeString()); 
+    //fprintf(stderr, "forstmt will be replaced by\n");
+    //newstmt->print(0,stderr); fprintf(stderr, "\n\n"); 
+
+    parent->replaceChild( this, newstmt );
+  }
+
+
+}
+
+
+
+
+
+chillAST_BinaryOperator::chillAST_BinaryOperator() {
+  //fprintf(stderr, "chillAST_BinaryOperator::chillAST_BinaryOperator()  %p   no parent\n", this);
+  fprintf(stderr, "chillAST_BinaryOperator::chillAST_BinaryOperator()  no parent\n");
+  lhs = rhs = NULL;
+  op = NULL;
+  asttype = CHILLAST_NODETYPE_BINARYOPERATOR; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+chillAST_BinaryOperator::chillAST_BinaryOperator(chillAST_node *l, const char *oper, chillAST_node *r, chillAST_node *par) { 
+  //fprintf(stderr, "chillAST_BinaryOperator::chillAST_BinaryOperator( l %p  %s  r %p,   parent %p)  this %p\n", l, oper, r, par, this); 
+  fprintf(stderr, "chillAST_BinaryOperator::chillAST_BinaryOperator( l  %s  r )\n", oper); 
+
+  //if (l && r ) { 
+  //  fprintf(stderr, "("); l->print(0,stderr); fprintf(stderr, ") %s (", oper); r->print(0,stderr); fprintf(stderr, ")\n\n"); 
+  //} 
+
+  lhs = l;
+  rhs = r;
+  parent = par;
+  
+  if (lhs) lhs->setParent( this );  
+  if (rhs) rhs->setParent( this );  // may only have part of the lhs and rhs when binop is created
+  op = strdup(oper);
+  asttype = CHILLAST_NODETYPE_BINARYOPERATOR; 
+
+  // if this writes to lhs and lhs type has an 'imwrittento' concept, set that up
+  if (isAssignmentOp()) { 
+    if (lhs && lhs->isArraySubscriptExpr()) {
+      ((chillAST_ArraySubscriptExpr*)lhs)->imwrittento = true;
+      //fprintf(stderr, "chillAST_BinaryOperator, op '=', lhs is an array reference  LVALUE\n"); 
+    }
+  }
+  if (isAugmentedAssignmentOp()) {  // +=  etc 
+    //fprintf(stderr, "isAugmentedAssignmentOp()  "); print(); fflush(stdout); 
+    if (lhs && lhs->isArraySubscriptExpr()) { 
+      //fprintf(stderr, "lhs is also read from  ");  lhs->print(); fflush(stdout); 
+      ((chillAST_ArraySubscriptExpr*)lhs)->imreadfrom = true; // note will ALSO have imwrittento true
+    }
+  }
+
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+int chillAST_BinaryOperator::evalAsInt() { 
+  // very limited. allow +-*/ and integer literals ...
+  if (isAssignmentOp()) return rhs->evalAsInt();  // ?? ignores/loses lhs info 
+
+  if (!strcmp("+", op)) { 
+    //fprintf(stderr, "chillAST_BinaryOperator::evalAsInt()   %d + %d\n", lhs->evalAsInt(), rhs->evalAsInt()); 
+    return lhs->evalAsInt() + rhs->evalAsInt(); 
+  }
+  if (!strcmp("-", op)) return lhs->evalAsInt() - rhs->evalAsInt(); 
+  if (!strcmp("*", op)) return lhs->evalAsInt() * rhs->evalAsInt(); 
+  if (!strcmp("/", op)) return lhs->evalAsInt() / rhs->evalAsInt(); 
+  
+  fprintf(stderr, "chillAST_BinaryOperator::evalAsInt() unhandled op '%s'\n", op); 
+  segfault(); 
+}
+
+chillAST_IntegerLiteral *chillAST_BinaryOperator::evalAsIntegerLiteral() { 
+  return new chillAST_IntegerLiteral( evalAsInt() ); // ?? 
+}
+
+void chillAST_BinaryOperator::dump( int indent, FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(BinaryOperator '%s'\n", op);
+
+  if (lhs) lhs->dump(indent+1, fp); // lhs could be null
+  else { chillindent(indent+1, fp); fprintf(fp, "(NULL)\n"); } 
+  fflush(fp); 
+
+  if (rhs) rhs->dump(indent+1, fp); // rhs could be null
+  else { chillindent(indent+1, fp); fprintf(fp, "(NULL)\n"); } 
+  fflush(fp); 
+
+  chillindent(indent, fp); 
+  fprintf(fp, ")\n");
+  fflush(fp); 
+}
+
+void chillAST_BinaryOperator::print( int indent, FILE *fp ) {   // TODO this needparens logic is wrong
+  printPreprocBEFORE(indent, fp); 
+
+  chillindent( indent, fp ); 
+  bool needparens = false;
+  if (lhs) { 
+    if (lhs->isImplicitCastExpr()) { 
+      //  fprintf(stderr, "\nlhs 0x%x isImplicitCastExpr()\n", lhs);
+      //  fprintf(stderr, "lhs subexpr 0x%x\n", ((chillAST_ImplicitCastExpr*)lhs)->subexpr);
+      //  fprintf(stderr, "lhs subexpr type %s\n", ((chillAST_ImplicitCastExpr*)lhs)->subexpr->getTypeString());
+      //   
+      if (((chillAST_ImplicitCastExpr*)lhs)->subexpr->isNotLeaf()) needparens = true;
+    } 
+    else if (lhs->isNotLeaf())  { 
+      if      (isMinusOp()     && lhs->isPlusOp())     needparens = false;
+      else if (isPlusMinusOp() && lhs->isMultDivOp())  needparens = false;
+      else needparens = true;
+    }
+  }
+
+  //fprintf(stderr, "\n\nbinop    "); 
+  //lhs->printonly(0,stderr); 
+  //fprintf(stderr," %s ",op); 
+  //rhs->printonly(0,stderr); 
+  //fprintf(stderr,"\n"); 
+  //fprintf(stderr, "op is %s   lhs %s   rhs %s\n", op, lhs->getTypeString(), rhs->getTypeString());
+  //fprintf(stderr, "lhs "); lhs->printonly(0, stderr); fprintf(stderr, "    "); 
+  //fprintf(stderr, "lhs needparens = %d\n", needparens); 
+
+
+  if (needparens) fprintf(fp, "(");
+  if (lhs) lhs->print( 0, fp );
+  else fprintf(fp, "(NULL)"); 
+  if (needparens) fprintf(fp, ")"); 
+
+  fprintf( fp, " %s ", op);
+
+  needparens = false;
+  //fprintf(stderr, "binop rhs is of type %s\n", rhs->getTypeString()); 
+  if (rhs) { 
+    if (rhs->isImplicitCastExpr()) { 
+      if (((chillAST_ImplicitCastExpr*)rhs)->subexpr->isNotLeaf()) needparens = true;
+    } 
+    //else if (rhs->isNotLeaf()) needparens = true; // too many parens. test too simple
+    else if (rhs->isNotLeaf()) { 
+      // really need the precedence ordering, and check relative of op and rhs op
+      if      (isMinusOp() ) needparens = true;    // safer.  perhaps complicated thing on rhs of a minus
+      else if (isPlusMinusOp() && rhs->isMultDivOp())  needparens = false;
+      else needparens = true;
+    }
+  }
+  //fprintf(stderr, "rhs "); rhs->printonly(0, stderr); fprintf(stderr, "    "); 
+  //fprintf(stderr, "rhs needparens = %d\n\n", needparens); 
+  //if (!needparens) fprintf(stderr, "rhs isNotLeaf() = %d\n", rhs->isNotLeaf()); 
+
+  if (needparens) fprintf(fp, "(");
+  if (rhs) rhs->print( 0, fp );
+  else fprintf(fp, "(NULL)"); 
+  if (needparens) fprintf(fp, ")"); 
+  fflush(fp); 
+  printPreprocAFTER(indent, fp); 
+
+}
+
+
+char *chillAST_BinaryOperator::stringRep(int indent ) { 
+  std::string s = string( lhs->stringRep() ) + " " + op + " " +  string(lhs->stringRep() );
+  return strdup( s.c_str() ); 
+}
+
+
+
+void chillAST_BinaryOperator::printonly( int indent, FILE *fp ) {
+
+  lhs->printonly( indent, fp );
+  fprintf( fp, " %s ", op);
+  rhs->printonly( 0, fp );
+  fflush(fp); 
+
+
+
+}
+
+
+class chillAST_node* chillAST_BinaryOperator::constantFold() { 
+  //fprintf(stderr, "\nchillAST_BinaryOperator::constantFold()  ");
+  //print(0,stderr); fprintf(stderr, "\n");
+
+  lhs = lhs->constantFold();
+  rhs = rhs->constantFold();
+  
+  chillAST_node *returnval = this;
+
+  if (lhs->isConstant() && rhs->isConstant() ) { 
+    //fprintf(stderr, "binop folding constants\n"); print(0,stderr); fprintf(stderr, "\n");
+
+    if (streq(op, "+") || streq(op, "-") || streq(op, "*")) { 
+      if (lhs->isIntegerLiteral() && rhs->isIntegerLiteral()) {
+        chillAST_IntegerLiteral *l = (chillAST_IntegerLiteral *)lhs;
+        chillAST_IntegerLiteral *r = (chillAST_IntegerLiteral *)rhs;
+        chillAST_IntegerLiteral *I;
+        
+        if (streq(op, "+")) I = new chillAST_IntegerLiteral(l->value+r->value, parent);
+        if (streq(op, "-")) I = new chillAST_IntegerLiteral(l->value-r->value, parent);
+        if (streq(op, "*")) I = new chillAST_IntegerLiteral(l->value*r->value, parent);
+
+        returnval = I;
+        //fprintf(stderr, "%d %s %d becomes %d\n", l->value,op, r->value, I->value);
+      }
+      else { // at least one is a float
+
+        // usually don't want to do this for floats or doubles
+        // could probably check for special cases like 0.0/30.0  or X/X  or X/1.0 
+#ifdef FOLDFLOATS
+        float lval, rval;
+        if (lhs->isIntegerLiteral()) { 
+          lval = (float) ((chillAST_IntegerLiteral *)lhs)->value; 
+        }
+        else { 
+          lval = ((chillAST_FloatingLiteral *)lhs)->value; 
+        }
+
+        if (rhs->isIntegerLiteral()) { 
+          rval = (float) ((chillAST_IntegerLiteral *)rhs)->value; 
+        }
+        else { 
+          rval = ((chillAST_FloatingLiteral *)rhs)->value; 
+        }
+
+        chillAST_FloatingLiteral *F;
+        if (streq(op, "+")) F = new chillAST_FloatingLiteral(lval + rval, parent);
+        if (streq(op, "-")) F = new chillAST_FloatingLiteral(lval - rval, parent);
+        if (streq(op, "*")) F = new chillAST_FloatingLiteral(lval * rval, parent);
+
+        returnval = F;
+#endif
+
+      }
+    }
+    //else fprintf(stderr, "can't fold op '%s' yet\n", op); 
+  }
+
+  //fprintf(stderr, "returning "); returnval->print(0,stderr); fprintf(stderr, "\n"); 
+  return returnval;
+}
+
+
+class chillAST_node* chillAST_BinaryOperator::clone() { 
+  //fprintf(stderr, "chillAST_BinaryOperator::clone() "); print(); printf("\n"); fflush(stdout); 
+
+  chillAST_node* l = lhs->clone();
+  chillAST_node* r = rhs->clone();
+  chillAST_BinaryOperator *bo =  new chillAST_BinaryOperator( l, op, r, parent ); 
+  l->setParent( bo );
+  r->setParent( bo );
+  bo->isFromSourceFile = isFromSourceFile;
+  if (filename) bo->filename = strdup(filename); 
+  return bo;
+}
+
+void chillAST_BinaryOperator::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*>  &refs, bool w ) {
+  //fprintf(stderr, "chillAST_BinaryOperator::gatherArrayRefs()\n"); 
+  //print(); fflush(stdout); fprintf(stderr, "\n"); 
+  //if (isAugmentedAssignmentOp()) { 
+  //  fprintf(stderr, "%s  is augmented assignment\n", op);
+  //}
+
+  //if (isAssignmentOp()) { 
+  //  fprintf(stderr, "%s  is assignment\n", op);
+  //}
+
+  //if (isAugmentedAssignmentOp()) { // lhs is ALSO on the RHS, NOT as a write
+  //  if (lhs->isArraySubscriptExpr()) { // probably some case where this fails
+  //    ((chillAST_ArraySubscriptExpr *) lhs)->imreadfrom = true;  
+  //    //lhs->&gatherArrayRefs( refs, 0 );
+  //  }
+  //} 
+
+  //fprintf(stderr, "in chillAST_BinaryOperator::gatherArrayRefs(), %d &arrayrefs before\n", refs.size());  
+  lhs->gatherArrayRefs( refs, isAssignmentOp() );
+  //fprintf(stderr, "in chillAST_BinaryOperator::gatherArrayRefs(), %d &arrayrefs after lhs\n", refs.size());  
+  rhs->gatherArrayRefs( refs, 0 );
+  //fprintf(stderr, "in chillAST_BinaryOperator::gatherArrayRefs(), %d &refs\n", refs.size()); 
+  
+  //for (int i=0; i<refs.size(); i++) { 
+  //  fprintf(stderr, "%s\n", (*refs)[i]->basedecl->varname); 
+  //} 
+
+}
+
+void chillAST_BinaryOperator::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  lhs->gatherScalarRefs( refs, isAssignmentOp() );
+  rhs->gatherScalarRefs( refs, 0 );
+} 
+
+
+void chillAST_BinaryOperator::replaceChild( chillAST_node *old, chillAST_node *newchild ) {
+  //fprintf(stderr, "\nbinop::replaceChild( old 0x%x, new )    lhs 0x%x   rhd 0x%x\n", old, lhs, rhs);
+
+  // will pointers match??
+  if      (lhs == old) setLHS( newchild ); 
+  else if (rhs == old) setRHS( newchild ); 
+  
+  // silently ignore? 
+  //else { 
+  //  fprintf(stderr, "\nERROR chillAST_BinaryOperator::replaceChild( old 0x%x, new )    lhs 0x%x   rhd 0x%x\n", old, lhs, rhs);
+  //  fprintf(stderr, "old is not a child of this BinaryOperator\n");
+  //  print();
+  //  dump();
+  //  exit(-1); 
+  //} 
+}
+
+
+
+void chillAST_BinaryOperator::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_BinaryOperator::gatherVarDecls()\n"); 
+
+  //fprintf(stderr, "chillAST_BinaryOperator::gatherVarDecls()  before %d\n", decls.size()); 
+  //print(0,stderr); fprintf(stderr, "\n"); 
+  //fprintf(stderr, "lhs is %s\n", lhs->getTypeString()); 
+  if (lhs) lhs->gatherVarDecls( decls ); // 'if' to deal with partially formed
+  if (rhs) rhs->gatherVarDecls( decls );
+  //fprintf(stderr, "after %d\n", decls.size()); 
+}
+
+
+void chillAST_BinaryOperator::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_BinaryOperator::gatherScalarVarDecls()  before %d\n", decls.size()); 
+  //fprintf(stderr, "lhs is %s\n", lhs->getTypeString()); 
+  lhs->gatherScalarVarDecls( decls );
+  rhs->gatherScalarVarDecls( decls );
+  //fprintf(stderr, "after %d\n", decls.size()); 
+}
+
+
+void chillAST_BinaryOperator::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_BinaryOperator::gatherArrayVarDecls()  before %d\n", decls.size()); 
+  //fprintf(stderr, "lhs is %s\n", lhs->getTypeString()); 
+  lhs->gatherArrayVarDecls( decls );
+  rhs->gatherArrayVarDecls( decls );
+  //fprintf(stderr, "after %d\n", decls.size()); 
+}
+
+
+
+void chillAST_BinaryOperator::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  lhs->gatherDeclRefExprs( refs );
+  rhs->gatherDeclRefExprs( refs );
+}
+
+
+void chillAST_BinaryOperator::gatherStatements(std::vector<chillAST_node*> &statements ){
+  
+  // what's legit?
+  if (isAssignmentOp()) { 
+    statements.push_back( this );
+  }
+
+}
+
+
+
+
+void chillAST_BinaryOperator::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  lhs->gatherVarUsage( decls );
+  rhs->gatherVarUsage( decls );
+}
+
+void chillAST_BinaryOperator::gatherVarLHSUsage( vector<chillAST_VarDecl*> &decls ) {
+  lhs->gatherVarUsage( decls );
+}
+
+ void chillAST_BinaryOperator::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl) { 
+   //if (!strcmp(op, "<=")) { 
+   //  fprintf(stderr, "chillAST_BinaryOperator::replaceVarDecls( old %s, new %s)\n", olddecl->varname, newdecl->varname );
+   //  print(); printf("\n"); fflush(stdout); 
+   //  fprintf(stderr, "binaryoperator, lhs is of type %s\n", lhs->getTypeString()); 
+   //  fprintf(stderr, "binaryoperator, rhs is of type %s\n", rhs->getTypeString()); 
+   //} 
+   lhs->replaceVarDecls( olddecl, newdecl ); 
+   rhs->replaceVarDecls( olddecl, newdecl ); 
+   //if (!strcmp(op, "<=")) { 
+   //  print(); printf("\n\n"); fflush(stdout); 
+   //} 
+ }
+
+
+bool chillAST_BinaryOperator::isSameAs( chillAST_node *other ){
+  if (!other->isBinaryOperator()) return false;
+  chillAST_BinaryOperator *o = (chillAST_BinaryOperator *)other;
+  if (strcmp(op, o->op))  return false; // different operators 
+  return lhs->isSameAs( o->lhs ) && rhs->isSameAs( o->rhs ); // recurse
+}
+
+
+
+
+chillAST_TernaryOperator::chillAST_TernaryOperator() {
+  op = strdup("?"); // the only one so far
+  condition = lhs = rhs = NULL;
+  asttype = CHILLAST_NODETYPE_TERNARYOPERATOR; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_TernaryOperator::chillAST_TernaryOperator(const char *oper, chillAST_node *c, chillAST_node *l, chillAST_node *r, chillAST_node *par) {
+  
+  op = strdup(oper);
+  condition = c;        condition->setParent( this ); 
+  lhs = l;              lhs->setParent( this ); 
+  rhs = r;              rhs->setParent( this ); 
+  asttype = CHILLAST_NODETYPE_TERNARYOPERATOR; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_TernaryOperator::dump( int indent, FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(TernaryOperator '%s'\n", op);
+  condition->dump(indent+1, fp);
+  lhs->dump(indent+1, fp);
+  rhs->dump(indent+1, fp);
+  chillindent(indent, fp); 
+  fprintf(fp, ")\n");
+  fflush(fp);
+}
+
+void chillAST_TernaryOperator::print( int indent, FILE *fp ) {
+  printPreprocBEFORE(indent, fp); 
+  chillindent(indent, fp);
+  fprintf(fp, "(");
+  condition->print(0,fp);
+  fprintf(fp, "%s", op); 
+  lhs->print(0,fp);
+  fprintf(fp, ":");
+  rhs->print(0,fp);
+  fprintf(fp, ")");
+  fflush(fp);
+}
+
+void chillAST_TernaryOperator::replaceChild( chillAST_node *old, chillAST_node *newchild ) {
+  //fprintf(stderr, "\nbinop::replaceChild( old 0x%x, new )    lhs 0x%x   rhd 0x%x\n", old, lhs, rhs);
+
+  // will pointers match??
+  if      (lhs == old) setLHS( newchild ); 
+  else if (rhs == old) setRHS( newchild ); 
+  else if (condition == old) setCond( newchild );
+
+  // silently ignore? 
+  //else { 
+  //}
+}
+
+
+void chillAST_TernaryOperator::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  condition->gatherVarDecls( decls );
+  lhs->gatherVarDecls( decls );
+  rhs->gatherVarDecls( decls );
+}
+
+void chillAST_TernaryOperator::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  condition->gatherScalarVarDecls( decls );
+  lhs->gatherScalarVarDecls( decls );
+  rhs->gatherScalarVarDecls( decls );
+}
+
+
+void chillAST_TernaryOperator::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  condition->gatherArrayVarDecls( decls );
+  lhs->gatherArrayVarDecls( decls );
+  rhs->gatherArrayVarDecls( decls );
+}
+
+
+
+void chillAST_TernaryOperator::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  condition->gatherDeclRefExprs( refs );
+  lhs->gatherDeclRefExprs( refs );
+  rhs->gatherDeclRefExprs( refs );
+}
+
+
+
+void chillAST_TernaryOperator::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  condition->gatherVarUsage( decls );
+  lhs->gatherVarUsage( decls );
+  rhs->gatherVarUsage( decls );
+}
+
+void chillAST_TernaryOperator::gatherVarLHSUsage( vector<chillAST_VarDecl*> &decls ) {
+  // this makes no sense for ternary ?? 
+}
+
+void chillAST_TernaryOperator::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl) { 
+  condition->replaceVarDecls( olddecl, newdecl ); 
+  lhs->replaceVarDecls( olddecl, newdecl ); 
+  rhs->replaceVarDecls( olddecl, newdecl ); 
+}
+
+void chillAST_TernaryOperator::printonly( int indent, FILE *fp ) {
+  fprintf(fp, "(");
+  condition->printonly(0,fp);
+  fprintf(fp, "%s", op); 
+  lhs->printonly(0,fp);
+  fprintf(fp, ":");
+  rhs->printonly(0,fp);
+  fprintf(fp, ")");
+  fflush(fp);
+}
+
+
+class chillAST_node* chillAST_TernaryOperator::constantFold() { 
+  condition = condition->constantFold();
+  lhs = lhs->constantFold();
+  rhs = rhs->constantFold();
+  
+  chillAST_node *returnval = this;
+
+  if (condition->isConstant())  { 
+    //fprintf(stderr, "ternop folding constants\n");
+    //print(0,stderr);
+    //fprintf(stderr, "\n");
+
+    // assume op is "?"
+    // TODO 
+    /* 
+    
+    if (streq(op, "+") || streq(op, "-") || streq(op, "*")) { 
+      if (lhs->isIntegerLiteral() && rhs->isIntegerLiteral()) {
+        chillAST_IntegerLiteral *l = (chillAST_IntegerLiteral *)lhs;
+        chillAST_IntegerLiteral *r = (chillAST_IntegerLiteral *)rhs;
+        chillAST_IntegerLiteral *I;
+        
+        if (streq(op, "+")) I = new chillAST_IntegerLiteral(l->value+r->value, parent);
+        if (streq(op, "-")) I = new chillAST_IntegerLiteral(l->value-r->value, parent);
+        if (streq(op, "*")) I = new chillAST_IntegerLiteral(l->value*r->value, parent);
+
+        returnval = I;
+        //fprintf(stderr, "%d %s %d becomes %d\n", l->value,op, r->value, I->value);
+      }
+      else { // at least one is a float
+        float lval, rval;
+        if (lhs->isIntegerLiteral()) { 
+          lval = (float) ((chillAST_IntegerLiteral *)lhs)->value; 
+        }
+        else { 
+          lval = ((chillAST_FloatingLiteral *)lhs)->value; 
+        }
+        if (rhs->isIntegerLiteral()) { 
+          rval = (float) ((chillAST_IntegerLiteral *)rhs)->value; 
+        }
+        else { 
+          rval = ((chillAST_FloatingLiteral *)rhs)->value; 
+        }
+
+        chillAST_FloatingLiteral *F;
+        if (streq(op, "+")) F = new chillAST_FloatingLiteral(lval + rval, parent);
+        if (streq(op, "-")) F = new chillAST_FloatingLiteral(lval - rval, parent);
+        if (streq(op, "*")) F = new chillAST_FloatingLiteral(lval * rval, parent);
+
+        returnval = F;
+      }
+    }
+    else fprintf(stderr, "can't fold op '%s' yet\n", op); 
+    */
+  }
+
+  return returnval;
+}
+
+class chillAST_node* chillAST_TernaryOperator::clone() { 
+  chillAST_node* c = condition->clone();
+  chillAST_node* l = lhs->clone();
+  chillAST_node* r = rhs->clone();
+  chillAST_TernaryOperator *to =  new chillAST_TernaryOperator( op, l, r, parent ); 
+  c->setParent( to ); 
+  l->setParent( to );
+  r->setParent( to );
+  to->isFromSourceFile = isFromSourceFile;
+  filename = NULL;
+  return to;
+}
+
+void chillAST_TernaryOperator::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*>  &refs, bool w ) {
+  condition->gatherArrayRefs( refs, isAssignmentOp() );
+  lhs->gatherArrayRefs( refs, isAssignmentOp() );
+  rhs->gatherArrayRefs( refs, 0 );
+}
+
+void chillAST_TernaryOperator::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  condition->gatherScalarRefs( refs, isAssignmentOp() );
+  lhs->gatherScalarRefs( refs, isAssignmentOp() );
+  rhs->gatherScalarRefs( refs, 0 );
+} 
+
+
+
+
+
+
+
+chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() { 
+  //fprintf(stderr, "\n%p chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 0\n", this); 
+  asttype = CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR; 
+  base = index = NULL;
+  basedecl = NULL; //fprintf(stderr, "setting basedecl NULL for ASE %p\n", this); 
+  imwrittento = false; // ?? 
+  imreadfrom  = false; // ?? 
+  parent = NULL;
+  metacomment = NULL;
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr()  NEED TO FAKE A LOCATION\n");
+  isFromSourceFile = true; // default 
+  filename = NULL;
+  //fprintf(stderr, "\nASE %p is empty\n", this); 
+}
+
+
+
+chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr( chillAST_node *bas, chillAST_node *indx, chillAST_node *par, void *unique ) { 
+
+  //fprintf(stderr, "\nchillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 1\n");
+  //fprintf(stderr, "ASE index %p ", indx); indx->print(0,stderr); fprintf(stderr, "\n"); 
+  asttype = CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR; 
+  bas->setParent( this );
+  if (bas->isImplicitCastExpr()) base = ((chillAST_ImplicitCastExpr*)bas)->subexpr; // probably wrong
+  else   base = bas;
+  if (indx->isImplicitCastExpr()) index = ((chillAST_ImplicitCastExpr*)indx)->subexpr; // probably wrong
+  else index = indx;
+
+  base->setParent( this );
+  index->setParent( this );
+
+  imwrittento = false; // ?? 
+  imreadfrom  = false; // ?? 
+  uniquePtr = (void *) unique;
+  //fprintf(stderr,"chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() original = 0x%x\n", uniquePtr); 
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 1 calling multibase()\n"); 
+  basedecl = multibase();//fprintf(stderr, "%p  ASE 1 basedecl = %p\n",this,basedecl); 
+  //basedecl->print(); printf("\n");
+  //basedecl->dump(); printf("\n"); fflush(stdout); 
+  //fprintf(stderr, "basedecl varname %s\n", basedecl->varname); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+  //fprintf(stderr, "\nASE %p   parent %p  ", this, parent); print(0,stderr); fprintf(stderr, "\n\n"); 
+}
+
+
+
+chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr( chillAST_node *bas, chillAST_node *indx, bool writtento, chillAST_node *par, void  *unique ) {
+  //fprintf(stderr, "\nchillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 2  parent %p\n", par ); 
+  //fprintf(stderr, "ASE %p   index %p ", this, indx); indx->print(0,stderr); fprintf(stderr, "\n"); 
+  
+  asttype = CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR; 
+  bas->setParent( this );
+  if (bas->isImplicitCastExpr()) base = ((chillAST_ImplicitCastExpr*)bas)->subexpr; // probably wrong
+  else base = bas;
+
+  if (indx->isImplicitCastExpr()) index = ((chillAST_ImplicitCastExpr*)indx)->subexpr; // probably wrong
+  else index = indx;
+  
+  //fprintf(stderr, "setting parent of base  %p to %p\n", base, this);
+  //fprintf(stderr, "setting parent of index %p to %p\n", index, this);
+  base->setParent( this );
+  index->setParent( this ); 
+  
+  imwrittento = writtento; // ?? 
+  //fprintf(stderr, "ASE %p   imwrittento %d\n", this, imwrittento);
+  imreadfrom  = false; // ??  
+
+  uniquePtr = (void *) unique;
+  //fprintf(stderr,"chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() original = 0x%x\n", uniquePtr); 
+
+  basedecl = multibase(); 
+
+  //fprintf(stderr, "%p  ASE 2 basedecl = %p\n", this, basedecl); 
+  //printf("basedecl is  "); fflush(stdout); basedecl->print(); printf("\n"); fflush(stdout); 
+  //basedecl->dump(); printf("\n"); fflush(stdout);
+  //fprintf(stderr, "basedecl varname %s\n", basedecl->varname); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 2 DONE\n");
+  //print(0,stderr); fprintf(stderr, "\n\n"); 
+  //fprintf(stderr, "\nASE %p   parent %p  ", this, parent); print(0,stderr); fprintf(stderr, "\n\n"); 
+ }
+
+
+
+chillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr( chillAST_VarDecl *v, std::vector<chillAST_node *> indeces,  chillAST_node *par) {
+  //fprintf(stderr, "\nchillAST_ArraySubscriptExpr::chillAST_ArraySubscriptExpr() 4\n"); 
+  //fprintf(stderr,"chillAST_ArraySubscriptExpr( chillAST_VarDecl *v, std::vector<int> indeces)\n");
+  asttype = CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR; 
+  parent = par;
+  //if (parent == NULL) { 
+  //  fprintf(stderr, "dammit.  ASE %p has no parent\n", this); 
+  //} 
+
+
+  int numindeces = indeces.size();
+  for (int i=0; i<numindeces; i++) { 
+    fprintf(stderr, "ASE index %d  ", i); indeces[i]->print(0,stderr); fprintf(stderr, "\n"); 
+  //  printf("[");
+  //  indeces[i]->print();
+  //  printf("]");
+  } 
+  //fflush(stdout); 
+  //fprintf(stderr, "\n");
+  
+  chillAST_DeclRefExpr *DRE = new chillAST_DeclRefExpr( v->vartype, v->varname, v, NULL);
+  basedecl = v; // ?? 
+  //fprintf(stderr, "%p  ASE 3 basedecl = %p   ", this, basedecl); 
+  //fprintf(stderr, "of type %s\n", basedecl->getTypeString()); 
+  //basedecl->print(); printf("\n");
+  //basedecl->dump(); printf("\n"); fflush(stdout); 
+  //fprintf(stderr, "basedecl varname %s\n", basedecl->varname); 
+  
+  chillAST_ArraySubscriptExpr *rent = this; // parent for subnodes
+  
+  // these are on the top level ASE that we're creating here 
+  base = (chillAST_node *) DRE;
+  index = indeces[ numindeces-1];
+
+  base->setParent( this );
+  index->setParent(this); 
+
+  for (int i=numindeces-2; i>=0; i--) {
+    
+    chillAST_ArraySubscriptExpr *ASE = new  chillAST_ArraySubscriptExpr( DRE, indeces[i], rent, 0); 
+    rent->base = ASE; // 
+    rent = ASE;
+  }
+  
+  imwrittento = false;
+  imreadfrom = false; 
+  //fprintf(stderr, "ASE is "); print(); printf("\n\n"); fflush(stdout); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+  //fprintf(stderr, "\nASE %p   parent %p  ", this, parent); print(0,stderr); fprintf(stderr, "\n\n"); 
+}
+
+
+
+chillAST_node *chillAST_node::getEnclosingStatement( int level ) {  // TODO do for subclasses?
+
+  //fprintf(stderr, "chillAST_node::getEnclosingStatement( level %d ) node type %s\n", level, getTypeString());
+  //print(); printf("\n"); fflush(stdout);
+
+  // so far, user will ONLY call this directly on an array subscript expression
+  if (isArraySubscriptExpr()) return parent->getEnclosingStatement( level+1); 
+
+  if (level != 0) { 
+    if (isBinaryOperator()    || 
+        isUnaryOperator()     || 
+        isTernaryOperator()   || 
+        isReturnStmt()        ||
+        isCallExpr()
+        ) return this;
+    
+
+    // things that are not endpoints. recurse through parent 
+    if (isMemberExpr())       return parent->getEnclosingStatement( level+1 ); 
+    if (isImplicitCastExpr()) return parent->getEnclosingStatement( level+1 ); 
+    if (isSizeof())           return parent->getEnclosingStatement( level+1 );  
+    if (isCStyleCastExpr())   return parent->getEnclosingStatement( level+1 );  
+    return NULL;
+  }
+
+  fprintf(stderr, "getEnclosingStatement() level %d type %s, returning NULL\n", level, getTypeString()); 
+  segfault(); 
+
+  return NULL;
+}
+
+
+
+void chillAST_ArraySubscriptExpr::gatherIndeces(std::vector<chillAST_node*>&ind) { 
+  if (base->isArraySubscriptExpr()) ((chillAST_ArraySubscriptExpr *)base)->gatherIndeces( ind ); 
+  ind.push_back( index );
+}
+
+
+
+void chillAST_ArraySubscriptExpr::dump( int indent, FILE *fp ) {
+//  fprintf(stderr, "\n%p chillAST_ArraySubscriptExpr::dump()  basedecl %p\n", basedecl);
+  
+  char *local;
+  if (basedecl && basedecl->vartype) {
+    local = strdup( basedecl->vartype );
+  }
+  else { 
+    fprintf(stderr, "%p chillAST_ArraySubscriptExpr::dump(), no basedecl ???\n",this);
+    local = strdup("");
+    //fprintf(stderr, "base is "); base->dump(); printf("\n"); base->print(); printf("\n"); fflush(stdout); 
+    //print(); printf("\n"); fflush(stdout);
+  }
+
+
+  char *space = rindex(local, ' ');  // can't use index because it's a class member!
+  if (space) *space = '\0';  // turn "float *" into "float"
+
+  chillindent(indent, fp);
+  //fprintf(fp, "(ArraySubscriptExpr '%s' ", local);
+  if (basedecl)  { 
+    //fprintf(stderr, " chillAST_ArraySubscriptExpr::dump() basedecl is of type %s\n",   basedecl->getTypeString()); 
+    fprintf(fp, "(ArraySubscriptExpr (%s) '%s' ", basedecl->varname, local); 
+  }
+  else fprintf(stderr, " chillAST_ArraySubscriptExpr::dump() has no basedecl\n"); 
+  free(local);
+
+  if (imwrittento) { 
+    if (imreadfrom) fprintf(fp, "lvalue AND rvalue\n"); 
+    else            fprintf(fp, "lvalue\n");
+  }
+  else fprintf(fp, "rvalue\n"); 
+  base->dump( indent+1, fp );
+  index->dump(indent+1, fp); 
+
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+  fflush(fp); 
+}
+
+
+
+void chillAST_ArraySubscriptExpr::print( int indent, FILE *fp ) {
+  base->print( indent, fp );
+  fprintf(fp, "[");
+  index->print(0, fp); 
+  fprintf(fp, "]");
+  fflush(fp); 
+}
+
+char *chillAST_ArraySubscriptExpr::stringRep(int indent ) { 
+  fprintf(stderr, "chillAST_ArraySubscriptExpr::stringRep\n"); 
+
+  char *blurb;
+  char *b = base->stringRep(0); 
+  char *i = index->stringRep(0); 
+  // combine.  shoudl be using strings. much cleaner  TODO
+  std::string s = string(b) + "[" + string(i) + "]";
+  fprintf(stderr, "ASE stringrep %s\n", s.c_str()); 
+  return strdup( s.c_str()); 
+  
+
+}
+
+
+void chillAST_ArraySubscriptExpr::printonly( int indent, FILE *fp ) {
+  base->printonly( indent, fp );
+  fprintf(fp, "[");
+  index->printonly(0, fp); 
+  fprintf(fp, "]");
+  fflush(fp); 
+}
+
+
+void chillAST_ArraySubscriptExpr::print( int indent, FILE *fp ) const {
+  base->print( indent, fp );
+  fprintf(fp, "[");
+  index->print(0, fp); 
+  fprintf(fp, "]");
+  fflush(fp); 
+};
+
+
+chillAST_VarDecl *chillAST_ArraySubscriptExpr::multibase() { 
+  // return the VARDECL of the thing the subscript is an index into
+  //this should probably be a chillAST_node function instead of having all these ifs
+  //print(); printf("\n"); fflush(stdout); 
+  //base->print();  printf("\n"); fflush(stdout); 
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::multibase()  base of type %s\n", base->getTypeString()); 
+  
+  return base->multibase();  
+
+  // this will be used to SET basedecl
+  //basedecl = NULL; // do this so we don't confuse ourselves looking at uninitialized basedecl
+
+  chillAST_node *b = base; 
+  //fprintf(stderr, "base is of type %s\n", b->getTypeString());
+
+  if (!b) return NULL; // just in case ??
+
+  if (base->asttype == CHILLAST_NODETYPE_IMPLICITCASTEXPR) { // bad coding
+    b = ((chillAST_ImplicitCastExpr*)b)->subexpr;
+  }
+
+  if (b->asttype == CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR) { // multidimensional array!
+    // recurse
+    return ((chillAST_ArraySubscriptExpr *)b)->multibase();
+  }
+
+  if (b->asttype == CHILLAST_NODETYPE_DECLREFEXPR) return(((chillAST_DeclRefExpr*)b)->getVarDecl());
+
+  
+  if (b->isBinaryOperator()) { 
+    // presumably a dot or pointer ref that resolves to an array
+    chillAST_BinaryOperator *BO = (chillAST_BinaryOperator *) b;
+    if ( strcmp(BO->op, ".") ) { 
+      fprintf(stderr, "chillAST_ArraySubscriptExpr::multibase(), UNHANDLED case:\n");
+      fprintf(stderr, "base is binary operator, of type %s\n", BO->op); 
+      exit(-1);
+    }
+
+    chillAST_node *l = BO->lhs;
+    chillAST_node *r = BO->rhs;
+    printf("L %s\nR %s\n", l->getTypeString(), r->getTypeString()); 
+    exit(-1); 
+
+    return NULL; // TODO do checks?
+  }
+
+  if (b->isMemberExpr()) { 
+    //c.i[c.count]    we want i member of inspector
+
+    chillAST_MemberExpr *ME = (chillAST_MemberExpr *) b;
+    //fprintf(stderr, "multibase() Member Expression "); ME->print(); printf("\n"); fflush(stdout); 
+
+    chillAST_node *n = ME->base; //  WRONG   want the MEMBER
+    //fprintf(stderr, "chillAST_ArraySubscriptExpr::multibase()  Member Expression base of type %s\n", n->getTypeString());
+    //fprintf(stderr, "base is "); ME->base->dump(); 
+
+    // NEED to be able to get lowest level recorddecl or typedef from this base
+
+    fprintf(stderr, "chillast.cc, L2315, bailing??\n"); 
+    exit(0); 
+
+    if (!n->isDeclRefExpr()) { 
+      fprintf(stderr, "MemberExpr member is not chillAST_DeclRefExpr\n");
+      exit(-1);
+    }
+    chillAST_DeclRefExpr *DRE = (chillAST_DeclRefExpr *)n;
+    n = DRE->decl;
+    //fprintf(stderr, "DRE decl is of type %s\n", n->getTypeString()); 
+    assert( n->isVarDecl() );
+    chillAST_VarDecl *vd = (chillAST_VarDecl *) n;
+    vd->print(); printf("\n"); fflush(stdout); 
+
+    chillAST_TypedefDecl *tdd = vd->typedefinition; 
+    chillAST_RecordDecl  *rd  = vd->vardef; 
+    //fprintf(stderr, "tdd %p    rd %p\n", tdd, rd); 
+    
+    print(); printf("\n"); 
+    dump();  printf("\n"); fflush(stdout);
+
+    assert( tdd != NULL || rd != NULL );
+    
+    chillAST_VarDecl *sub;
+    if (tdd) sub = tdd->findSubpart( ME->member ); 
+    if (rd)  sub =  rd->findSubpart( ME->member ); 
+
+    //fprintf(stderr, "subpart is "); sub->print(); printf("\n"); fflush(stdout); 
+    
+    return sub; // what if the sub is an array ??  TODO 
+  }
+
+
+  fprintf(stderr, "chillAST_ArraySubscriptExpr::multibase(), UNHANDLED case %s\n", 
+          b->getTypeString()); 
+  print(); printf("\n"); fflush(stdout);
+  fprintf(stderr, "base is: "); b->print(); printf("\n"); fflush(stdout);
+  segfault(); 
+}
+
+
+chillAST_node *chillAST_ArraySubscriptExpr::getIndex(int dim) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::getIndex( %d )\n", dim); 
+
+  chillAST_node *b = base; 
+
+  int depth = 0;
+  std::vector<chillAST_node*> ind;
+  chillAST_node *curindex = index;
+  for (;;) { 
+    if (b->asttype == CHILLAST_NODETYPE_IMPLICITCASTEXPR) b = ((chillAST_ImplicitCastExpr*)b)->subexpr;
+    else if (b->asttype == CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR) {
+      //fprintf(stderr, "base  "); b->print(); fprintf(stderr, "\n"); 
+      //fprintf(stderr, "index "); curindex->print(); fprintf(stderr, "\n"); 
+      ind.push_back(curindex);
+      curindex = ((chillAST_ArraySubscriptExpr*)b)->index;
+      b = ((chillAST_ArraySubscriptExpr*)b)->base; 
+      depth++;
+    }
+    else { 
+      //fprintf(stderr, "base  "); b->print(); fprintf(stderr, "\n"); 
+      //fprintf(stderr, "index "); curindex->print(); fprintf(stderr, "\n"); 
+      //fprintf(stderr, "stopping at base type %s\n", b->getTypeString());
+      ind.push_back(curindex);
+      break; 
+    }
+  }
+  //fprintf(stderr, "depth %d\n", depth );
+  //for (int i=0; i<ind.size(); i++) { ind[i]->print(); fprintf(stderr, "\n"); } 
+
+  return ind[ depth - dim ]; 
+  /* 
+  if (dim == 0) return index; // single dimension 
+  fprintf(stderr, "DIM NOT 0\n"); 
+  // multidimension 
+  chillAST_node *b = base; 
+  if (base->asttype == CHILLAST_NODETYPE_IMPLICITCASTEXPR) { // bad coding
+    b = ((chillAST_ImplicitCastExpr*)b)->subexpr;
+  }
+  if (b->asttype == CHILLAST_NODETYPE_IMPLICITCASTEXPR) { // bad coding
+    b = ((chillAST_ImplicitCastExpr*)b)->subexpr;
+  }
+  
+  b->print(); printf("\n"); fflush(stdout);
+  if (b->asttype == CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR) {
+    return ((chillAST_ArraySubscriptExpr *)b)->getIndex(dim-1);
+  }
+
+  fprintf(stderr, "chillAST_ArraySubscriptExpr::getIndex() failed\n");
+  */ 
+  exit(-1); 
+}
+
+
+
+
+class chillAST_node* chillAST_ArraySubscriptExpr::constantFold() { 
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::constantFold()\n"); 
+  base  =  base->constantFold();
+  index = index->constantFold();
+  return this;
+}
+
+class chillAST_node* chillAST_ArraySubscriptExpr::clone() { 
+  //fprintf(stderr,"chillAST_ArraySubscriptExpr::clone() old imwrittento %d\n", imwrittento);
+  //fprintf(stderr, "cloning ASE %p ", this); print(0,stderr); printf(" with parent %p\n", parent); fflush(stdout);
+  //fprintf(stderr, "base %p  base->parent %p     index %p  index->parent %p\n", base, base->parent, index, index->parent);  
+
+  //fprintf(stderr, "old base   "); base->print();  printf("\n"); fflush(stdout);
+  //fprintf(stderr, "old base   "); base->dump();  printf("\n"); fflush(stdout);
+  if (base->isDeclRefExpr()) { 
+    chillAST_VarDecl *vd = (chillAST_VarDecl *)(((chillAST_DeclRefExpr *)base)->decl); 
+    //fprintf(stderr, "old decl   "); vd->print();  printf("\n");fflush(stdout);
+    //fprintf(stderr, "old decl   "); vd->dump();   printf("\n");fflush(stdout);
+  }
+  chillAST_node *b =  base->clone();
+  //fprintf(stderr, "new base   "); b->print();  printf("\n"); fflush(stdout);
+  //fprintf(stderr, "new base   "); b->dump();  printf("\n"); fflush(stdout);
+
+  chillAST_node *i = index->clone();
+  //fprintf(stderr, "new index  "); i->print();  printf("\n"); fflush(stdout);
+
+  
+  //if (!index->parent) { 
+  //  fprintf(stderr, "ASE %p SOURCE OF CLONE INDEX %p of type %s HAS NO PARENT\n", this, index, index->getTypeString());
+  //  fprintf(stderr, "ASE SOURCE IS  "); print(0,stderr); fprintf(stderr, "\n\n");
+  //} 
+  //fprintf(stderr, "cloning AST %p, after cloning base and index, creating a new ASE\n", this); 
+  chillAST_ArraySubscriptExpr *ASE = new chillAST_ArraySubscriptExpr( b, i, imwrittento, parent, uniquePtr /* ?? */ ); 
+  //fprintf(stderr, "cloned AST will be %p with parent %p and base %p  index %p\n", ASE, parent, b, i); 
+
+  ASE->imreadfrom = false; // don't know this yet
+  //ASE->imreadfrom = imreadfrom; // ?? 
+  //if (ASE->imreadfrom) { 
+  //  fprintf(stderr, "in chillAST_ArraySubscriptExpr::clone(), imreadfrom is being set. \n");
+  //  ASE->print(); fflush(stdout); fprintf(stderr, "\n"); 
+  //} 
+
+  //fprintf(stderr, "cloned result "); ASE->print(); printf("\n\n\n"); fflush(stdout);
+  //fprintf(stderr, "ASE clone()  this 0x%x    clone 0x%x\n", this, ASE); 
+  ASE->isFromSourceFile = isFromSourceFile;
+  if (filename) ASE->filename = strdup(filename); 
+  return ASE;
+}
+
+void chillAST_ArraySubscriptExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::gatherArrayRefs setting imwrittento %d for ", writtento); 
+//fprintf(stderr, "%s ", base->getTypeString()); 
+//base->print(); printf("\n"); fflush(stdout); 
+
+  //fprintf(stderr, "found an array subscript. &refs 0x%x   ", refs);
+  if (!imwrittento) imwrittento = writtento;   // may be both written and not for += 
+  fflush(stdout); 
+
+  //fprintf(stderr, "recursing on index ");  index->print(0,stderr); fprintf(stderr, "\n");
+  index->gatherArrayRefs( refs, 0 ); // recurse first
+  //fprintf(stderr, "adding this "); print(0,stderr); fprintf(stderr, "\n"); 
+  //fprintf(stderr, "refs[%d] = 0x%x  = ", refs.size(), this); print(); fflush(stdout);   
+  refs.push_back( this );
+
+  //fprintf(stderr, " size now %d\n", refs.size()); 
+
+}
+
+void chillAST_ArraySubscriptExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  index->gatherScalarRefs( refs, 0 ); 
+} 
+
+void chillAST_ArraySubscriptExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::gatherVarDecls()\n"); 
+
+  base->gatherVarDecls( decls );
+  index->gatherVarDecls( decls );
+}
+
+
+void chillAST_ArraySubscriptExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::gatherScalarVarDecls()\n");
+  //fprintf(stderr, "base %s   index %s\n", base->getTypeString(), index->getTypeString()); 
+  base->gatherScalarVarDecls( decls );
+  index->gatherScalarVarDecls( decls );
+}
+
+
+void chillAST_ArraySubscriptExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::gatherArrayVarDecls()\n");
+  //fprintf(stderr, "base %s   index %s\n", base->getTypeString(), index->getTypeString()); 
+  base->gatherArrayVarDecls( decls );
+  index->gatherArrayVarDecls( decls );
+}
+
+
+void chillAST_ArraySubscriptExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  base->gatherDeclRefExprs( refs );
+  index->gatherDeclRefExprs( refs );
+}
+
+
+void chillAST_ArraySubscriptExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  base->gatherVarUsage( decls );
+  index->gatherVarUsage( decls );
+}
+
+
+void chillAST_ArraySubscriptExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  base->replaceVarDecls( olddecl, newdecl );
+  index->replaceVarDecls( olddecl, newdecl );
+}
+
+
+void chillAST_ArraySubscriptExpr::replaceChild( chillAST_node *old, chillAST_node *newchild ) { 
+  //fprintf(stderr,"chillAST_ArraySubscriptExpr::replaceChild()\n"); 
+
+  // arraysubscriptexpression doesn t really have children (should it?)
+  // try index ???
+  if (old == index) { 
+    //fprintf(stderr, "old is index\n");
+    index = newchild;
+    index->parent = this;
+    return;
+  }
+  
+  // try base ??? unclear if this makes sense  TODO 
+  if (old == base) { 
+    //fprintf(stderr, "old is base\n");
+    base = newchild;
+    base->parent = this;
+    return;
+  }
+  
+  fprintf(stderr, "chillAST_ArraySubscriptExpr::replaceChild() old is not base or index\n"); 
+  print(0,stderr); fprintf(stderr, "\nchild: ");
+  if (!old) fprintf(stderr, "oldchild NULL!\n");
+  old->print(0,stderr); fprintf(stderr, "\nnew: "); 
+  newchild->print(0,stderr); fprintf(stderr, "\n"); 
+  segfault(); // make easier for gdb
+};
+
+
+bool chillAST_ArraySubscriptExpr::operator!=( const chillAST_ArraySubscriptExpr &other) {
+  bool opposite = *this == other;
+  return !opposite;
+}
+
+
+
+bool chillAST_ArraySubscriptExpr::operator==( const chillAST_ArraySubscriptExpr &other) {
+  //fprintf(stderr, "chillAST_ArraySubscriptExpr::operator==\n");
+  //fprintf(stderr, "this->basedecl 0x%x     other.basedecl 0x%x\n", this->basedecl, other.basedecl);
+  //this->basedecl->print(); printf("\n\n");
+  //other.basedecl->print(); printf("\n"); fflush(stdout);
+
+  //this->print(); printf(" 0x%x  == 0x%x ",this->uniquePtr, other.uniquePtr ); other.print(); printf(" ??  "); fflush(stdout); 
+  //if ( this->uniquePtr == other.uniquePtr) fprintf(stderr, "t\n"); 
+  //else fprintf(stderr, "f\n"); 
+  return this->uniquePtr == other.uniquePtr; 
+}
+
+
+
+
+
+chillAST_MemberExpr::chillAST_MemberExpr() { 
+  asttype = CHILLAST_NODETYPE_MEMBEREXPR; 
+  base = NULL;
+  member = NULL;
+  parent = NULL;
+  metacomment = NULL;
+  exptype = CHILL_MEMBER_EXP_DOT; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_MemberExpr::chillAST_MemberExpr( chillAST_node *bas, const char *mem, chillAST_node *p, void *unique, CHILL_MEMBER_EXP_TYPE t ) { 
+  asttype = CHILLAST_NODETYPE_MEMBEREXPR; 
+  base = bas;
+  if (base)   base->setParent( this ); 
+  if (mem)    member = strdup( mem );
+  parent = p;
+  metacomment = NULL;
+  uniquePtr = unique;
+  exptype = t;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+  return;  // ignore tests below ?? TODO ?? 
+
+
+  // base needs to RESOLVE to a decl ref expr but may not BE one
+  //   A.b . c   lhs is a binop or memberexpr
+
+  if (bas->isBinaryOperator()) { 
+    //fprintf(stderr, "checking binop to see if it resolved to a declrefexpr\n");
+    // cheat for now or just remove the check below
+    return; 
+  }
+
+  if (! ( bas->isDeclRefExpr() || bas->isArraySubscriptExpr() )) { 
+    fprintf(stderr, "chillAST_MemberExpr::chillAST_MemberExpr(), base is of type %s\n", bas->getTypeString());
+    fprintf(stderr, "chillAST_MemberExpr::chillAST_MemberExpr(), base is not DeclRefExpr\n");
+    
+    base->print();  printf(".%s\n", mem); fflush(stdout);  
+    segfault(); 
+  }
+}
+
+
+void chillAST_MemberExpr::dump( int indent, FILE *fp ) {
+  chillindent(indent, fp);
+  fprintf(fp, "(MemberExpr \n"); 
+
+  base->dump( indent+1, fp );
+  chillindent(indent+1, fp);
+  if (exptype == CHILL_MEMBER_EXP_ARROW) fprintf(fp, "->");
+  else fprintf(fp, "."); 
+  
+  fprintf(fp, "%s\n", member); 
+
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+}
+
+
+void chillAST_MemberExpr::print( int indent, FILE *fp ) {
+  if (base) base->print( indent, fp );
+  else {
+    chillindent( indent, fp );
+    fprintf(fp, "(NULL)"); 
+  }
+  if (exptype == CHILL_MEMBER_EXP_ARROW) fprintf(fp, "->");
+  else fprintf(fp, "."); 
+  if (member) fprintf(fp, "%s", member);
+  else fprintf(fp, "(NULL)"); 
+  fflush(fp); 
+}
+
+
+void chillAST_MemberExpr::printonly( int indent, FILE *fp ) {
+  base->print( indent, fp );
+  if (exptype == CHILL_MEMBER_EXP_ARROW) fprintf(fp, "->");
+  else fprintf(fp, "."); 
+  fprintf(fp, "%s", member);
+  fflush(fp); 
+}
+
+char *chillAST_MemberExpr::stringRep( int indent ) { // char pointer to what we'd print
+  fprintf(stderr, "*chillAST_MemberExpr::stringRep()\n"); 
+  if (base->isDeclRefExpr()) { // 
+    chillAST_VarDecl *vd =  (chillAST_VarDecl *) ((chillAST_DeclRefExpr *)base)->decl;
+    char *leak = (char *)malloc(128);
+    if (exptype == CHILL_MEMBER_EXP_ARROW) sprintf(leak, "%s->%s", vd->varname, member);
+    else sprintf(leak, "%s.%s", vd->varname, member);
+    printstring = leak; 
+    return leak;
+  }
+
+
+  // else 
+    // TODO
+    return strdup("chillAST_MemberExpr::getStringRep()hadanerror");
+}
+
+
+class chillAST_node* chillAST_MemberExpr::constantFold() { 
+  base  =  base->constantFold();
+  //member = member->constantFold();
+  return this;
+}
+
+class chillAST_node* chillAST_MemberExpr::clone() { 
+  chillAST_node *b =  base->clone();
+  char *m = strdup( member ); // ?? 
+  chillAST_MemberExpr *ME = new chillAST_MemberExpr( b, m, parent, uniquePtr /* ?? */ ); 
+  ME->isFromSourceFile = isFromSourceFile;
+  if (filename) ME->filename = strdup(filename); 
+  return ME;
+}
+
+void chillAST_MemberExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {
+  fprintf(stderr, "chillAST_MemberExpr::gatherArrayRefs()   "); print(0,stderr); fprintf(stderr, "\n"); 
+  fprintf(stderr, "base of of type %s\n", base->getTypeString()); 
+  base->gatherArrayRefs( refs, writtento ); // 
+  
+}
+
+void chillAST_MemberExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  base->gatherScalarRefs( refs, writtento );
+} 
+
+void chillAST_MemberExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  base->gatherVarDecls( decls );
+}
+
+void chillAST_MemberExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  base->gatherScalarVarDecls( decls );
+}
+
+
+void chillAST_MemberExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  base->gatherArrayVarDecls( decls );
+}
+
+
+void chillAST_MemberExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  base->gatherDeclRefExprs( refs );
+}
+
+
+void chillAST_MemberExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  base->gatherVarUsage( decls );
+}
+
+
+void chillAST_MemberExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  base->replaceVarDecls( olddecl, newdecl );
+}
+
+bool chillAST_MemberExpr::operator!=( const chillAST_MemberExpr &other) {
+  bool opposite = *this == other;
+  return !opposite;
+}
+
+bool chillAST_MemberExpr::operator==( const chillAST_MemberExpr &other) {
+  return this->uniquePtr == other.uniquePtr; 
+}
+
+
+void chillAST_MemberExpr::replaceChild( chillAST_node *old, chillAST_node *newchild ) {
+  //printf("\nMemberExpr::replaceChild(  )\n");
+  //printf("old: "); 
+  //old->print(); 
+  //printf("\nnew: "); 
+  //newchild->print(); 
+  //printf("\n"); fflush(stdout); 
+
+  // will pointers match??
+  if (base == old) { 
+    //fprintf(stderr, "old matches base of MemberExpr\n"); 
+    base = newchild; 
+  }
+  else { 
+    base->replaceChild( old, newchild ); 
+  }
+} 
+
+chillAST_node  *chillAST_MemberExpr::multibase2() {  /*fprintf(stderr, "ME MB2\n" );*/ return (chillAST_node *)this; } 
+
+chillAST_VarDecl* chillAST_MemberExpr::getUnderlyingVarDecl() { 
+  fprintf(stderr, "chillAST_MemberExpr:getUnderlyingVarDecl()\n");
+  print(); printf("\n"); fflush(stdout);
+  exit(-1); 
+  // find the member with the correct name
+  
+}
+
+
+
+
+chillAST_VarDecl *chillAST_MemberExpr::multibase() {
+  //c.i[c.count]    we want i member of c 
+  //fprintf(stderr, "ME MB\n" ); 
+
+  //fprintf(stderr, "chillAST_MemberExpr::multibase()\n");
+  //print(); printf("\n"); fflush(stdout);
+  //fprintf(stderr, "MemberExpr base is type %s,  member %s\n", base->getTypeString(), member);
+  
+  //chillAST_VarDecl *vd = base->getUnderlyingVarDecl(); // this is the only thing that ever calls this ??? 
+  chillAST_VarDecl *vd = base->multibase(); // ?? 
+
+
+  //fprintf(stderr, "vd "); vd->print(); printf("\n"); fflush(stdout);
+    
+  chillAST_RecordDecl *rd = vd->getStructDef();
+  if (!rd) { 
+    fprintf(stderr, "chillAST_MemberExpr::multibase() vardecl is not a struct??\n");
+    fprintf(stderr, "vd "); vd->print(); printf("\n"); fflush(stdout);
+    fprintf(stderr, "vd "); vd->dump();  printf("\n"); fflush(stdout);
+    exit(-1);
+  }
+
+  // OK, we have the recorddecl that defines the structure
+  // now find the member with the correct name
+  chillAST_VarDecl *sub = rd->findSubpart( member );
+  //fprintf(stderr, "sub %s:\n", member);
+  if (!sub) { 
+    fprintf(stderr, "can't find member %s in \n", member);
+    rd->print(); 
+  }
+  //sub->print(); printf("\n");  fflush(stdout);
+  //sub->dump() ; printf("\n");  fflush(stdout);
+
+  return sub; 
+  //find vardecl of member in def of base
+
+  
+}
+
+
+
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr() { 
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup("UNKNOWN"); 
+  declarationName = strdup("NONE");
+  decl = NULL; 
+  parent = NULL;
+  metacomment = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr( const char *varname, chillAST_node *par ) { 
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup("UNKNOWN"); 
+  declarationName = strdup(varname); 
+  decl = NULL; 
+  parent = par; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr( const char *vartype, const char *varname, chillAST_node *par) {
+  //fprintf(stderr, "DRE::DRE 0x%x   %s %s\n", this, vartype, varname ); 
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup(vartype); 
+  declarationName = strdup(varname); 
+  decl = NULL; 
+  parent = par; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr( const char *vartype, const char *varname, chillAST_node *d, chillAST_node *par ) {
+  //fprintf(stderr, "DRE::DRE2 0x%x   %s %s  0x%x\n", this, vartype, varname, d ); 
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup(vartype); 
+  declarationName = strdup(varname); 
+  decl = d; 
+  parent = par; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr( chillAST_VarDecl *vd, chillAST_node *par ){ // variable def
+  //fprintf(stderr, "DRE::DRE3 (VD)  0x%x   %s %s  0x%x\n", this, vd->vartype, vd->varname, vd ); 
+  
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup(vd->vartype); 
+  declarationName = strdup(vd->varname); 
+  decl = vd; 
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+chillAST_DeclRefExpr::chillAST_DeclRefExpr( chillAST_FunctionDecl *fd, chillAST_node *par ){ // function def 
+  asttype = CHILLAST_NODETYPE_DECLREFEXPR; 
+  declarationType = strdup(fd->returnType); 
+  declarationName = strdup(fd->functionName); 
+  decl = fd; 
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+
+chillAST_DeclRefExpr *buildDeclRefExpr( chillAST_VarDecl  *vd) { 
+  chillAST_DeclRefExpr *dre = new chillAST_DeclRefExpr( vd, NULL );
+  
+}
+
+void chillAST_DeclRefExpr::print( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  //fprintf(fp, "%s %s", declarationType, declarationName);  // this is printing  float *A 
+  fprintf(fp, "%s", declarationName);  // this is printing  A 
+  fflush(fp); 
+}
+
+
+char *chillAST_DeclRefExpr::stringRep( int indent ) { 
+  return strdup( declarationName ); 
+}
+
+
+void chillAST_DeclRefExpr::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(DeclRefExpr '%s' ", declarationType);  
+  chillAST_VarDecl *vd = getVarDecl();
+  if (vd) { 
+    if (vd->isAParameter) fprintf(fp, "ParmVar  ");
+    else fprintf(fp, "Var  ");
+  }
+  fprintf(fp, "'%s' ", declarationName);  // variable or function name 
+
+  if (chillAST_FunctionDecl *fd = getFunctionDecl()) { 
+    // print parameter types for functions 
+    fd->printParameterTypes( fp );
+  }
+          
+  fprintf(fp, ")\n"); 
+  fflush(fp); 
+}
+
+class chillAST_node* chillAST_DeclRefExpr::constantFold() {  // can never do anything?
+  return this;
+}
+
+class chillAST_node* chillAST_DeclRefExpr::clone() { 
+  //fprintf(stderr, "chillAST_DeclRefExpr::clone()\n"); 
+  chillAST_DeclRefExpr *DRE =  new chillAST_DeclRefExpr( declarationType, declarationName, decl, parent ); 
+  DRE->isFromSourceFile = isFromSourceFile;
+  if (filename) DRE->filename = strdup(filename); 
+  return DRE;
+}
+
+
+void chillAST_DeclRefExpr::gatherVarDeclsMore( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_DeclRefExpr::gatherVarDeclsMore()\n"); 
+  decl->gatherVarDeclsMore( decls ); 
+}
+
+
+void chillAST_DeclRefExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_DeclRefExpr::gatherScalarVarDecls()\n"); 
+  decl->gatherScalarVarDecls(decls); 
+  //fprintf(stderr, "now %d scalar vardecls\n", decls.size()); 
+}
+
+
+void chillAST_DeclRefExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_DeclRefExpr::gatherArrayVarDecls()\n"); 
+  decl->gatherArrayVarDecls(decls); 
+  //fprintf(stderr, "now %d Array vardecls\n", decls.size()); 
+}
+
+
+void chillAST_DeclRefExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  refs.push_back(this); 
+}
+
+void chillAST_DeclRefExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  refs.push_back(this); 
+} 
+
+void chillAST_DeclRefExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_DeclRefExpr::gatherVarUsage()\n"); 
+  for (int i=0; i<decls.size(); i++) { 
+    if (decls[i] == decl) { 
+      //fprintf(stderr, "decl was already there\n");
+      return;
+    }
+    if (streq(declarationName, decls[i]->varname)) { 
+      if (streq(declarationType, decls[i]->vartype)) { 
+        //fprintf(stderr, "decl was already there\n");
+        return;
+      }
+    }
+  }
+  chillAST_VarDecl *vd = getVarDecl();  // null for functiondecl
+  if (vd) decls.push_back( vd ); 
+
+}
+
+
+
+
+void chillAST_DeclRefExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  //fprintf(stderr, "chillAST_DeclRefExpr::replaceVarDecls()\n"); 
+  if (decl == olddecl) { 
+    //fprintf(stderr, "replacing old %s with %s\n", olddecl->varname, newdecl->varname);
+    //fprintf(stderr, "DRE was "); print(); 
+    decl = newdecl; 
+    declarationType = strdup(newdecl->vartype); 
+    declarationName = strdup(newdecl->varname); 
+    //fprintf(stderr, "\nDRE  is "); print(); fprintf(stderr, "\n\n"); 
+  }
+  else { 
+    if (!strcmp(olddecl->varname, declarationName)) { 
+      //fprintf(stderr, "uhoh, chillAST_DeclRefExpr::replaceVarDecls()\n"); 
+      decl = newdecl; 
+      declarationType = strdup(newdecl->vartype); 
+      declarationName = strdup(newdecl->varname); 
+    }
+  }
+}
+
+chillAST_VarDecl *chillAST_ImplicitCastExpr::multibase() {
+  return subexpr->multibase();
+}
+
+
+chillAST_VarDecl *chillAST_DeclRefExpr::multibase() {
+  // presumably, this is being called because this DRE is the base of an ArraySubscriptExpr
+  return getVarDecl();
+}
+
+
+
+
+
+
+
+
+
+void chillAST_VarDecl::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_VarDecl::gatherVarDecls()\n"); 
+  for (int i=0; i<decls.size(); i++) { 
+    if (decls[i] == this) { 
+      //fprintf(stderr, "decl was already there\n");
+      return;
+    }
+    if (streq(decls[i]->varname, varname)) { 
+      if (streq(decls[i]->vartype, vartype)) { 
+        //fprintf(stderr, "VarDecl (direct) decl was already there\n");
+        return;
+      }
+    }
+  }
+  decls.push_back( this ); 
+}
+
+
+void chillAST_VarDecl::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_VarDecl::gatherScalarVarDecls(), %s numdimensions %d\n", varname, numdimensions); 
+
+  if (numdimensions != 0) return; // not a scalar
+  
+  for (int i=0; i<decls.size(); i++) { 
+    if (decls[i] == this) { 
+      //fprintf(stderr, "decl was already there\n");
+      return;
+    }
+
+    if (streq(decls[i]->varname, varname)) {      // wrong. scoping.  TODO
+      if (streq(decls[i]->vartype, vartype)) { 
+        //fprintf(stderr, "VarDecl (direct) decl was already there\n");
+        return;
+      }
+    }
+  }
+  //fprintf(stderr, "adding vardecl for %s to decls\n", varname); 
+  decls.push_back( this ); 
+}
+
+
+void chillAST_VarDecl::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_VarDecl::gatherScalarVarDecls(), %s numdimensions %d\n", varname, numdimensions); 
+
+  if (numdimensions == 0) return; // not an array
+  
+  for (int i=0; i<decls.size(); i++) { 
+    if (decls[i] == this) { 
+      //fprintf(stderr, "decl was already there\n");
+      return;
+    }
+
+    if (streq(decls[i]->varname, varname)) {      // wrong. scoping.  TODO
+      if (streq(decls[i]->vartype, vartype)) { 
+        //fprintf(stderr, "VarDecl (direct) decl was already there\n");
+        return;
+      }
+    }
+  }
+  //fprintf(stderr, "adding vardecl for %s to decls\n", varname); 
+  decls.push_back( this ); 
+}
+
+
+
+chillAST_node *chillAST_VarDecl::constantFold() {  return this; }
+
+chillAST_node* chillAST_VarDecl::clone() {
+  fprintf(stderr, "\nchillAST_VarDecl::clone()  cloning vardecl for %s\n", varname); 
+  if (isAParameter) fprintf(stderr, "old vardecl IS a parameter\n");
+  //else  fprintf(stderr, "old vardecl IS NOT a parameter\n");
+
+  chillAST_VarDecl *vd  = new chillAST_VarDecl( vartype, strdup(varname), arraypart, NULL);  // NULL so we don't add the variable AGAIN to the (presumably) function 
+  
+  vd->typedefinition = typedefinition;
+  vd->vardef = vardef; // perhaps should not do this     TODO 
+  //vd->isStruct = (vardef != NULL); // ??
+  
+  vd->underlyingtype = strdup(underlyingtype); 
+
+  vd->arraysizes = NULL;
+  vd->knownArraySizes = knownArraySizes; 
+  vd->numdimensions = numdimensions;
+  vd->arraypointerpart = NULL;
+
+  if (arraypart != NULL && NULL!=arraysizes) {  // !strcmp(arraypart, "")) { 
+    //fprintf(stderr, "in chillAST_VarDecl::clone(), cloning the array info\n");
+    //fprintf(stderr, "numdimensions %d     arraysizes 0x%x\n", numdimensions, arraysizes) ;
+    vd->numdimensions = numdimensions;
+
+    if (arraysizes) { 
+      vd->arraysizes = (int *)malloc( sizeof(int *) * numdimensions ); 
+      for (int i=0; i< numdimensions; i++) { 
+        //fprintf(stderr, "i %d\n", i); 
+        vd->arraysizes[i] = arraysizes[i]; 
+      }
+    }
+  }
+
+  if ( arraypointerpart ) { 
+    //fprintf(stderr, "copying arraypointerpart\n"); 
+    vd->arraypointerpart = strdup( arraypointerpart);
+  }
+
+  vd->isStruct = this->isStruct; 
+  //vd->insideAStruct =  this->insideAStruct; 
+
+  //if (vd->isStruct)  fprintf(stderr, "vardecl::clone()  %s is a struct\n", varname); 
+  //else fprintf(stderr, "vardecl::clone()  %s is NOT a struct\n", varname); 
+
+
+  vd->knownArraySizes = this->knownArraySizes; 
+  vd->isFromSourceFile = isFromSourceFile;
+  if (filename) vd->filename = strdup(filename); 
+  return vd;
+}
+
+
+void chillAST_VarDecl::splitarraypart() { 
+  fprintf(stderr, "chillAST_VarDecl::splitarraypart()  ");
+  //fprintf(stderr, "%p  ", arraypart);
+  if (arraypart) fprintf(stderr, "%s", arraypart); 
+  fprintf(stderr, "\n");
+
+  // split arraypart into  (leading??) asterisks and known sizes [1][2][3]
+  if (!arraypart ||  // NULL 
+      (arraypart && (*arraypart == '\0'))) { // or empty string
+
+    // parts are both empty string
+    if (arraypointerpart) free(arraypointerpart);
+    arraypointerpart = strdup("");
+    if (arraysetpart) free(arraysetpart);
+    arraysetpart = strdup(""); 
+    return;
+  }
+
+  // arraypart exists and is not empty
+  int asteriskcount = 0;
+  int fixedcount = 0;
+  for ( int i=0; i<strlen(arraypart); i++) {
+    if (arraypart[i] == '*') { 
+      if (fixedcount) {
+        fprintf(stderr, "illegal vardecl arraypart: '%s'\n", arraypart);
+        segfault(); 
+        exit(-1);
+      }
+      asteriskcount++;
+    }
+    else { // remainder is fixed? 
+      fixedcount++; 
+      // check for brackets and digits only?   TODO
+    }
+  }
+  arraypointerpart = (char *) calloc( asteriskcount+1, sizeof(char));
+  arraysetpart     = (char *) calloc( fixedcount+1,    sizeof(char));
+  char *ptr = arraypart;
+  for ( int i=0; i<asteriskcount; i++)  arraypointerpart[i] = *ptr++;
+  for ( int i=0; i<fixedcount; i++)     arraysetpart[i]   = *ptr++;
+
+  //fprintf(stderr, "%s = %s + %s\n", arraypart, arraypointerpart, arraysetpart); 
+}
+
+
+
+
+
+
+chillAST_IntegerLiteral::chillAST_IntegerLiteral(int val, chillAST_node *par){
+  value = val; 
+  asttype = CHILLAST_NODETYPE_INTEGERLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_IntegerLiteral::print( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "%d", value);
+  fflush(fp); 
+}
+
+void chillAST_IntegerLiteral::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(IntegerLiteral 'int' %d)\n", value);
+  fflush(fp); 
+}
+
+
+
+class chillAST_node* chillAST_IntegerLiteral::constantFold() { return this; } // can never do anything
+
+
+class chillAST_node* chillAST_IntegerLiteral::clone() { 
+  
+  chillAST_IntegerLiteral *IL = new  chillAST_IntegerLiteral( value, parent ); 
+  IL->isFromSourceFile = isFromSourceFile; 
+  if (filename) IL->filename = strdup(filename); 
+  return IL; 
+
+}
+  
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(float val, chillAST_node *par){
+  value = val; 
+  precision = 1;
+  float0double1 = 0; // which is live! 
+  allthedigits = NULL; 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(double val, chillAST_node *par){
+  doublevalue = val; 
+  precision = 2;
+  float0double1 = 1; // which is live! 
+  allthedigits = NULL; 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(float val, int precis, chillAST_node *par){
+  value = val; 
+  precision = 1;
+  float0double1 = 0; // which is live! 
+  precision = precis; // 
+  allthedigits = NULL; 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(double val, int precis, chillAST_node *par){
+  doublevalue = val; 
+  float0double1 = 1; // which is live! 
+  precision = precis; // 
+  allthedigits = NULL; 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(float val, const char *printthis, chillAST_node *par){
+  value = val; 
+  float0double1 = 0; // which is live! 
+  precision = 1;
+  allthedigits = NULL;
+  if (printthis) allthedigits = strdup( printthis ); 
+  //fprintf(stderr, "\nfloatingliteral allthedigits = '%s'\n", allthedigits); 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral(float val, int precis, const char *printthis, chillAST_node *par){
+  value = val; 
+  float0double1 = 0; // which is live! 
+  precision = precis; // but value is a float??  TODO 
+  allthedigits = NULL;
+  if (printthis) { 
+    //fprintf(stderr, "\nchillAST_FloatingLiteral constructor, printthis "); 
+    //fprintf(stderr, "%p\n", printthis); 
+    allthedigits = strdup( printthis ); 
+  }
+  //fprintf(stderr, "\nfloatingliteral allthedigits = '%s'\n", allthedigits); 
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+chillAST_FloatingLiteral::chillAST_FloatingLiteral( chillAST_FloatingLiteral *old ) {
+  //fprintf(stderr, "chillAST_FloatingLiteral::chillAST_FloatingLiteral( old ) allthedigits %p\n", old->allthedigits); 
+
+  asttype = CHILLAST_NODETYPE_FLOATINGLITERAL;
+  value          = old->value;
+  doublevalue    = old->doublevalue; 
+  float0double1  = old->float0double1;
+  allthedigits = NULL;
+  if (old->allthedigits) allthedigits = strdup(old->allthedigits); 
+  precision      = old->precision;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+
+void chillAST_FloatingLiteral::print( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  //fprintf(fp, "%f", value);
+  // attempt to be more like rose output
+  char output[1024]; // warning, hardcoded 
+
+  if (allthedigits != NULL) {
+    strcpy(output, allthedigits ); // if they have specified 100 digits of pi, give 'em 100 digits 
+    //fprintf(stderr, "floatingliteral allthedigits = '%s'\n", allthedigits); 
+  }
+  else {
+    if (float0double1 == 0)     sprintf(output, "%f", value);
+    else sprintf(output, "%f", doublevalue);
+    
+    // next part to avoid printing 123.4560000000000000000000000000
+    char *dot = index(output, '.');
+    if (dot) { 
+      char *end = output + strlen(output);
+      char *onechar;
+      char *lastnonzero = dot;
+      for (onechar = output; onechar < end; onechar ++) { 
+        if (*onechar != '0') lastnonzero = onechar;
+      }
+      
+      if (lastnonzero == dot) 
+        lastnonzero[2] = '\0';    // may be after end of string, but that should be OK
+      else lastnonzero[1] = '\0'; // may be after end of string, but that should be OK
+    }
+  }
+  if (precision == 1) { 
+    int len = strlen(output);
+    output[len] = 'f'; // explicit single precision
+    output[len+1] = '\0';
+  }
+
+  fprintf(fp, "%s", output); 
+  fflush(fp); 
+}
+
+void chillAST_FloatingLiteral::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  // 2x2 cases ???
+  if (precision == 1) 
+    fprintf(fp, "(FloatingLiteral 'float' "); 
+  else fprintf(fp, "(FloatingLiteral 'double' "); 
+
+  if (float0double1 == 0) fprintf(fp, "%f)\n", value);  // %f gives enough digits 
+  else fprintf(fp, "%f)\n", doublevalue);  // %f gives enough digits 
+  fflush(fp); 
+}
+
+
+chillAST_node* chillAST_FloatingLiteral::constantFold() { return this; }; // NOOP
+
+chillAST_node* chillAST_FloatingLiteral::clone() { 
+  //fprintf(stderr, "chillAST_FloatingLiteral::clone()  "); 
+  //fprintf(stderr, "allthedigits %p \n", allthedigits); 
+  chillAST_FloatingLiteral *newone = new  chillAST_FloatingLiteral( this ); 
+
+  newone->isFromSourceFile = isFromSourceFile; 
+  if (filename) newone->filename = strdup(filename); 
+  //print(); printf("  "); newone->print(); printf("\n"); fflush(stdout); 
+  return newone;
+}
+  
+bool chillAST_FloatingLiteral::isSameAs( chillAST_node *other ){
+  if (!other->isFloatingLiteral()) return false;
+  chillAST_FloatingLiteral *o = (chillAST_FloatingLiteral *)other;
+  // should we care about single vs double precision?
+  if (float0double1 != o->float0double1) return false;
+  if (float0double1 == 0) { 
+    return value == o->value; // WARNING, comparing floats with ==
+  }
+  return doublevalue == o->doublevalue; // WARNING, comparing doubless with ==
+} 
+
+
+
+
+
+chillAST_UnaryOperator::chillAST_UnaryOperator( const char *oper, bool pre, chillAST_node *sub, chillAST_node *par ) { 
+  op = strdup(oper);
+  prefix = pre;
+  subexpr = sub; 
+  subexpr->setParent( this );
+  asttype = CHILLAST_NODETYPE_UNARYOPERATOR; 
+  parent = par; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_UnaryOperator::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*>  &refs, bool w ) {
+  subexpr->gatherArrayRefs( refs, isAssignmentOp()); // 
+}
+
+
+
+void chillAST_UnaryOperator::print( int indent, FILE *fp) {
+  bool needparens = false;
+  if (subexpr->isNotLeaf()) needparens = true; // may get more complicated
+
+  chillindent( indent, fp); // will this ever be invoked?
+  if (prefix) fprintf(fp, "%s", op); 
+  if (needparens) fprintf(fp, "(");
+  subexpr->print( 0, fp );
+  if (needparens) fprintf(fp, ")"); 
+  if (!prefix) fprintf(fp, "%s", op); 
+  fflush(fp); 
+}
+
+
+void chillAST_UnaryOperator::dump( int indent, FILE *fp) {
+  chillindent( indent, fp);
+  fprintf(fp, "(UnaryOperator ");
+  if (prefix) fprintf(fp, "prefix "); 
+  else fprintf(fp, "postfix ");
+  fprintf(fp, "%s\n", op);
+  subexpr->dump(indent+1, fp); 
+
+  chillindent( indent, fp);
+  fprintf(fp, ")\n");
+}
+
+
+void chillAST_UnaryOperator::gatherVarLHSUsage( vector<chillAST_VarDecl*> &decls ) {
+  if ((!strcmp("++", op)) || (!strcmp("--", op))) {
+    subexpr->gatherVarUsage( decls ); // do all unary modify the subexpr? (no, - ) 
+  }
+}
+
+
+
+chillAST_node* chillAST_UnaryOperator::constantFold() { 
+  //fprintf(stderr, "chillAST_UnaryOperator::constantFold() ");
+  //print(); fprintf(stderr, "\n"); 
+
+  subexpr = subexpr->constantFold();
+  chillAST_node *returnval = this;
+  if (subexpr->isConstant()) {
+    //fprintf(stderr, "unary op folding constants\n");
+    //print(0,stderr); fprintf(stderr, "\n");
+    
+    if (streq(op, "-")) { 
+      if (subexpr->isIntegerLiteral()) {
+        int intval = ((chillAST_IntegerLiteral*)subexpr)->value;
+        chillAST_IntegerLiteral *I = new chillAST_IntegerLiteral( -intval, parent);
+        returnval = I;
+        //fprintf(stderr, "integer -%d becomes %d\n", intval, I->value);
+      }
+      else { 
+        chillAST_FloatingLiteral *FL = (chillAST_FloatingLiteral*)subexpr;
+        chillAST_FloatingLiteral *F = new chillAST_FloatingLiteral( FL ); // clone
+        F->parent = FL->parent;
+
+        F->value = -F->value;
+        F->doublevalue = -F->doublevalue;
+        
+        F->print(); fprintf(stderr, "\n"); 
+        
+        returnval = F;
+      }
+    }
+    else fprintf(stderr, "can't fold op '%s' yet\n", op); 
+  }    
+  return returnval;
+}
+
+
+class chillAST_node* chillAST_UnaryOperator::clone() { 
+  chillAST_UnaryOperator *UO = new chillAST_UnaryOperator( op, prefix, subexpr->clone(), parent );
+  UO->isFromSourceFile = isFromSourceFile; 
+  if (filename) UO->filename = strdup(filename); 
+  return UO; 
+}
+
+
+void chillAST_UnaryOperator::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_UnaryOperator::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_UnaryOperator::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_UnaryOperator::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  subexpr->gatherDeclRefExprs( refs ); 
+}
+
+
+void chillAST_UnaryOperator::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarUsage( decls ); 
+}
+
+ void chillAST_UnaryOperator::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl) { 
+   subexpr->replaceVarDecls( olddecl, newdecl ); 
+ }
+
+
+int chillAST_UnaryOperator::evalAsInt() { 
+  if (!strcmp("+", op)) return subexpr->evalAsInt();
+  if (!strcmp("-", op)) return -subexpr->evalAsInt();
+  if (!strcmp("++", op)) return 1 + subexpr->evalAsInt();
+  if (!strcmp("--", op)) return subexpr->evalAsInt() - 1;
+
+  fprintf(stderr, "chillAST_UnaryOperator::evalAsInt() unhandled op '%s'\n", op); 
+  segfault(); 
+
+}
+
+bool chillAST_UnaryOperator::isSameAs( chillAST_node *other ){
+  if (!other->isUnaryOperator()) return false;
+  chillAST_UnaryOperator *o = (chillAST_UnaryOperator *)other;
+  if (strcmp(op, o->op))  return false; // different operators 
+  return subexpr->isSameAs( o->subexpr ); // recurse
+}
+
+
+chillAST_ImplicitCastExpr::chillAST_ImplicitCastExpr( chillAST_node *sub, chillAST_node *par ) {
+  subexpr = sub;
+  subexpr->setParent( this );
+  asttype = CHILLAST_NODETYPE_IMPLICITCASTEXPR; 
+  parent = par; 
+  //fprintf(stderr, "ImplicitCastExpr 0x%x  has subexpr 0x%x", this, subexpr);
+  //fprintf(stderr, " of type %s\n", subexpr->getTypeString()); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_ImplicitCastExpr::print(  int indent, FILE *fp) {
+  // No need to print anything, simply forward to the sub expression.
+  subexpr->print( indent, fp );
+  fflush(fp); 
+};
+
+void chillAST_ImplicitCastExpr::printonly(  int indent, FILE *fp) {
+  // No need to print anything, simply forward to the sub expression.
+  subexpr->printonly( indent, fp );
+  fflush(fp); 
+};
+
+void chillAST_ImplicitCastExpr::replaceChild( chillAST_node *old, chillAST_node *newchild ){
+  if (subexpr == old) { // should be the case for this to get called
+    subexpr = newchild;
+    subexpr->setParent( this );
+    //old->parent = NULL;
+    return;
+  }
+
+  fprintf(stderr, "chillAST_ImplicitCastExpr::replaceChild() called with bad 'old'\n");
+  exit(-1);  // ?? 
+}
+
+class chillAST_node* chillAST_ImplicitCastExpr::constantFold() { 
+  chillAST_node *child = subexpr->constantFold();
+  child->setParent( parent ) ; // remove myself !! probably a bad idea. TODO 
+  return child; 
+}
+
+
+class chillAST_node* chillAST_ImplicitCastExpr::clone() { 
+  chillAST_ImplicitCastExpr *ICE = new chillAST_ImplicitCastExpr( subexpr->clone(), parent); 
+  ICE->isFromSourceFile = isFromSourceFile; 
+  if (filename) ICE->filename = strdup(filename); 
+  return ICE; 
+}
+
+
+void chillAST_ImplicitCastExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {
+  subexpr->gatherArrayRefs( refs, w );
+}
+
+void chillAST_ImplicitCastExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  subexpr->gatherScalarRefs( refs, writtento );
+} 
+
+void chillAST_ImplicitCastExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_ImplicitCastExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_ImplicitCastExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_ImplicitCastExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  subexpr->gatherDeclRefExprs( refs ); 
+}
+
+
+void chillAST_ImplicitCastExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarUsage( decls ); 
+}
+
+
+
+chillAST_CStyleCastExpr::chillAST_CStyleCastExpr( const char *to, chillAST_node *sub, chillAST_node *par ) {
+
+  //fprintf(stderr, "chillAST_CStyleCastExpr::chillAST_CStyleCastExpr( %s, ...)\n", to); 
+  towhat = strdup(to);
+  subexpr = sub;
+  if (subexpr) subexpr->setParent( this );
+  asttype = CHILLAST_NODETYPE_CSTYLECASTEXPR; 
+  parent = par; 
+  //fprintf(stderr, "chillAST_CStyleCastExpr (%s)   sub 0x%x\n", towhat, sub ); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_CStyleCastExpr::replaceChild( chillAST_node *old, chillAST_node *newchild ){
+  if (subexpr == old) { // should be the case for this to get called
+    subexpr = newchild;
+    subexpr->setParent( this );
+    //old->parent = NULL;
+    return;
+  }
+
+  fprintf(stderr, "chillAST_CStyleCastExpr::replaceChild() called with bad 'old'\n");
+  exit(-1);  // ?? 
+}
+
+ void chillAST_CStyleCastExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl) { 
+   subexpr->replaceVarDecls( olddecl, newdecl);
+ }
+
+void chillAST_CStyleCastExpr::print(  int indent, FILE *fp) {
+  //fprintf(stderr, "CStyleCastExpr::print()\n"); 
+  chillindent(indent, fp); 
+
+  // special cases? should probably walk the AST and change the literal itself
+  if ( !strcmp("float", towhat)  && subexpr->isIntegerLiteral()) { // (float) 3 => 3.0f 
+    subexpr->print( 0, fp ); fprintf(fp, ".0f");
+  }
+  else if ( !strcmp("double", towhat)  && subexpr->isIntegerLiteral()) { // (double) 3 => 3.0
+    subexpr->print( 0, fp ); fprintf(fp, ".0");
+  }
+  else if ( !strcmp("float", towhat)  && subexpr->isFloatingLiteral()) { // (float) 3.0 => 3.0f 
+    subexpr->print( 0, fp ); fprintf(fp, "f");
+  }
+  else { // general case 
+    fprintf(fp, "((%s) ", towhat); 
+    //fprintf(fp, "\ntowhat '%s'\n", towhat ); 
+    
+    if (subexpr->isVarDecl()) fprintf(fp, "%s", ((chillAST_VarDecl *)subexpr)->varname); 
+    else subexpr->print( indent, fp );
+    //fprintf(fp, "subexpr '%s' ", subexpr->getTypeString()); 
+    fprintf(fp, ")"); 
+  }
+  fflush(fp); 
+};
+
+
+void chillAST_CStyleCastExpr::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(CStyleCastExpr  (%s) \n", towhat);
+  subexpr->dump( indent+1, fp );
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+  fflush(fp); 
+}
+
+class chillAST_node* chillAST_CStyleCastExpr::constantFold() { 
+  subexpr = subexpr->constantFold();
+  return this; 
+}
+
+
+class chillAST_node* chillAST_CStyleCastExpr::clone() { 
+  chillAST_CStyleCastExpr *CSCE = new chillAST_CStyleCastExpr( towhat, subexpr->clone(), parent ); 
+  CSCE->isFromSourceFile = isFromSourceFile; 
+  if (filename) CSCE->filename = strdup(filename); 
+  return CSCE;
+}
+
+void chillAST_CStyleCastExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {
+  subexpr->gatherArrayRefs( refs, w );
+}
+
+void chillAST_CStyleCastExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  subexpr->gatherScalarRefs( refs, writtento );
+} 
+
+
+void chillAST_CStyleCastExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_CStyleCastExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_CStyleCastExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_CStyleCastExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  subexpr->gatherDeclRefExprs( refs ); 
+}
+
+
+void chillAST_CStyleCastExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarUsage( decls ); 
+}
+
+
+
+
+chillAST_CStyleAddressOf::chillAST_CStyleAddressOf( chillAST_node *sub, chillAST_node *par ) {
+  subexpr = sub;
+  subexpr->setParent( this );
+  asttype = CHILLAST_NODETYPE_CSTYLEADDRESSOF; 
+  parent = par; 
+  //fprintf(stderr, "chillAST_CStyleCastExpr (%s)   sub 0x%x\n", towhat, sub ); 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_CStyleAddressOf::print(  int indent, FILE *fp) {
+  //fprintf(stderr, "CStyleAddressOf::print()\n"); 
+  chillindent(indent, fp); 
+  fprintf(fp, "(&"); 
+  subexpr->print( 0, fp );
+  fprintf(fp, ")"); 
+  fflush(fp); 
+};
+
+void chillAST_CStyleAddressOf::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(CStyleAddressOf \n");
+  subexpr->print( indent+1, fp );
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+  fflush(fp); 
+}
+
+class chillAST_node* chillAST_CStyleAddressOf::constantFold() { 
+  subexpr = subexpr->constantFold();
+  return this; 
+}
+
+class chillAST_node* chillAST_CStyleAddressOf::clone() { 
+  chillAST_CStyleAddressOf *CSAO = new chillAST_CStyleAddressOf( subexpr->clone(), parent ); 
+  CSAO->isFromSourceFile = isFromSourceFile; 
+  if (filename) CSAO->filename = strdup(filename); 
+  return CSAO;
+}
+
+void chillAST_CStyleAddressOf::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {
+  subexpr->gatherArrayRefs( refs, w );
+}
+
+void chillAST_CStyleAddressOf::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  subexpr->gatherScalarRefs( refs, writtento );
+} 
+
+void chillAST_CStyleAddressOf::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarDecls( decls ); 
+}
+
+void chillAST_CStyleAddressOf::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_CStyleAddressOf::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_CStyleAddressOf::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  subexpr->gatherDeclRefExprs( refs ); 
+}
+
+
+void chillAST_CStyleAddressOf::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarUsage( decls ); 
+}
+
+
+
+
+chillAST_Malloc::chillAST_Malloc(chillAST_node *size, chillAST_node *p) {
+  thing = NULL;
+  sizeexpr = size;  // probably a multiply like   sizeof(int) * 1024
+  asttype = CHILLAST_NODETYPE_MALLOC;
+  parent = p;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+};  
+
+chillAST_Malloc::chillAST_Malloc(char *thething, chillAST_node *numthings, chillAST_node *p) {
+  thing = strdup(thething);   // "int" or "float" or "struct widget"
+  sizeexpr = numthings;  
+  asttype = CHILLAST_NODETYPE_MALLOC;
+  parent = p;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+};  
+
+chillAST_node* chillAST_Malloc::constantFold() {
+  sizeexpr->constantFold(); 
+}
+
+chillAST_node* chillAST_Malloc::clone() { 
+  chillAST_Malloc *M = new chillAST_Malloc( thing, sizeexpr, parent); // the general version 
+  M->isFromSourceFile = isFromSourceFile; 
+  if (filename) M->filename = strdup(filename); 
+  return M;
+}; 
+
+void chillAST_Malloc::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {
+  sizeexpr->gatherArrayRefs( refs, writtento );
+};
+
+
+void chillAST_Malloc::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  sizeexpr->gatherScalarRefs( refs, writtento );
+};
+
+void chillAST_Malloc::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  sizeexpr->gatherVarDecls(decls); 
+};
+
+void chillAST_Malloc::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ){
+  sizeexpr->gatherScalarVarDecls(decls); 
+};
+
+void chillAST_Malloc::gatherArrayVarDecls ( vector<chillAST_VarDecl*> &decls ) {
+  sizeexpr->gatherArrayVarDecls(decls); 
+};
+
+void chillAST_Malloc::gatherVarUsage( vector<chillAST_VarDecl*> &decls ){
+  sizeexpr->gatherVarUsage(decls); 
+};
+
+
+
+void chillAST_Malloc::print( int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "malloc("); 
+  
+  if (thing) {
+    fprintf(fp, " sizeof(%s) * ", thing );
+  }
+  sizeexpr->print(0,fp);
+  fprintf(fp, ")");
+  fflush(fp); 
+};  
+
+
+void chillAST_Malloc::dump(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(Malloc \n"); 
+  sizeexpr->dump( indent+1, fp );
+  chillindent(indent, fp); 
+  fprintf(fp, ")\n");
+  fflush(fp); 
+};
+
+
+
+chillAST_CudaMalloc::chillAST_CudaMalloc(chillAST_node *devmemptr, chillAST_node *size, chillAST_node *p) {
+  devPtr = devmemptr; 
+  sizeinbytes = size;  // probably a multiply like   sizeof(int) * 1024
+  asttype = CHILLAST_NODETYPE_CUDAMALLOC;
+  parent = p;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+};  
+
+void chillAST_CudaMalloc::print(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "cudaMalloc("); 
+  devPtr->print( 0, fp );
+  fprintf(fp, ",");
+  sizeinbytes->print( 0, fp );
+  fprintf(fp, ")");
+  fflush(fp); 
+};
+
+void chillAST_CudaMalloc::dump(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(CudaMalloc \n"); 
+  devPtr->dump( indent+1, fp );
+  fprintf(fp, "\n");
+  sizeinbytes->dump( indent+1, fp );
+  fprintf(fp, ")\n");
+  fflush(fp); 
+};
+
+class chillAST_node* chillAST_CudaMalloc::constantFold() { 
+  devPtr = devPtr->constantFold();
+  return this; 
+}
+
+class chillAST_node* chillAST_CudaMalloc::clone() { 
+  chillAST_CudaMalloc *CM = new chillAST_CudaMalloc( devPtr->clone(), sizeinbytes->clone(), parent ); 
+  CM->isFromSourceFile = isFromSourceFile; 
+  if (filename) CM->filename = strdup(filename); 
+  return CM; 
+}
+
+void chillAST_CudaMalloc::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {
+  devPtr->gatherArrayRefs( refs, false );
+  sizeinbytes->gatherArrayRefs( refs, false );
+}
+
+void chillAST_CudaMalloc::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  devPtr->gatherScalarRefs( refs, false );
+  sizeinbytes->gatherScalarRefs( refs, false );
+}
+
+void chillAST_CudaMalloc::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  devPtr->gatherVarDecls( decls ); 
+  sizeinbytes->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_CudaMalloc::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  devPtr->gatherScalarVarDecls( decls ); 
+  sizeinbytes->gatherScalarVarDecls( decls ); 
+}
+
+
+
+void chillAST_CudaMalloc::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  devPtr->gatherArrayVarDecls( decls ); 
+  sizeinbytes->gatherArrayVarDecls( decls ); 
+}
+
+
+
+void chillAST_CudaMalloc::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  devPtr->gatherVarUsage( decls ); 
+  sizeinbytes->gatherVarUsage( decls ); 
+}
+
+
+
+chillAST_CudaFree::chillAST_CudaFree(chillAST_VarDecl *var, chillAST_node *p) {
+  variable = var; 
+  parent = p;
+  asttype = CHILLAST_NODETYPE_CUDAFREE;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+};  
+
+void chillAST_CudaFree::print(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "cudaFree(%s)", variable->varname); 
+  fflush(fp); 
+};
+
+void chillAST_CudaFree::dump(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(CudaFree %s )\n", variable->varname); 
+  fflush(fp); 
+};
+
+class chillAST_node* chillAST_CudaFree::constantFold() { 
+  return this; 
+}
+
+class chillAST_node* chillAST_CudaFree::clone() { 
+  chillAST_CudaFree *CF = new chillAST_CudaFree( variable, parent ); 
+  CF->isFromSourceFile = isFromSourceFile; 
+  if (filename) CF->filename = strdup(filename); 
+  return CF; 
+}
+
+void chillAST_CudaFree::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {}
+void chillAST_CudaFree::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {}
+
+void chillAST_CudaFree::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  variable->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_CudaFree::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  variable->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_CudaFree::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  variable->gatherArrayVarDecls( decls ); 
+}
+
+
+
+void chillAST_CudaFree::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  variable->gatherVarUsage( decls ); 
+}
+
+
+
+
+
+
+
+
+
+chillAST_CudaMemcpy::chillAST_CudaMemcpy(chillAST_VarDecl *d, chillAST_VarDecl *s, chillAST_node *siz, char *kind, chillAST_node *par) { 
+  dest = d;
+  src = s;
+  //fprintf(stderr, "chillAST_CudaMemcpy::chillAST_CudaMemcpy( dest %s, src %s, ...)\n", d->varname, s->varname ); 
+  size = siz;
+  cudaMemcpyKind = kind;
+  asttype = CHILLAST_NODETYPE_CUDAMEMCPY;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+  parent = par;
+}; 
+
+void chillAST_CudaMemcpy::print(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "cudaMemcpy(%s,%s,", dest->varname, src->varname); 
+  //dest->print( 0, fp );
+  //fprintf(fp, ",");
+  // src->print( 0, fp );  just want the src NAME, not name and array info 
+  //fprintf(fp, ",");
+  size->print( 0, fp );
+  fprintf(fp, ",%s)", cudaMemcpyKind);
+  fflush(fp); 
+};
+
+void chillAST_CudaMemcpy::dump(  int indent,  FILE *fp ) {
+  chillindent(indent, fp); 
+  fprintf(fp, "(CudaMemcpy \n"); 
+  dest->dump( indent+1, fp );
+  src->dump( indent+1, fp );
+  size->dump( indent+1, fp );
+  chillindent(indent+1, fp); 
+  fprintf(fp, ",%s\n", cudaMemcpyKind);
+  fflush(fp); 
+};
+
+class chillAST_node* chillAST_CudaMemcpy::constantFold() { 
+  dest = (chillAST_VarDecl *)dest->constantFold();
+  src  = (chillAST_VarDecl *)src->constantFold();
+  size = size->constantFold();
+  return this; 
+}
+
+class chillAST_node* chillAST_CudaMemcpy::clone() { 
+  chillAST_CudaMemcpy *CMCPY = new chillAST_CudaMemcpy((chillAST_VarDecl *)(dest->clone()),(chillAST_VarDecl *)(src->clone()), size->clone(), strdup(cudaMemcpyKind), parent ); 
+  CMCPY->isFromSourceFile = isFromSourceFile; 
+  if (filename) CMCPY->filename = strdup(filename); 
+  return CMCPY;
+}
+
+void chillAST_CudaMemcpy::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool w ) {
+  dest->gatherArrayRefs( refs, false );
+  src ->gatherArrayRefs( refs, false );
+  size->gatherArrayRefs( refs, false );
+}
+
+void chillAST_CudaMemcpy::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  dest->gatherScalarRefs( refs, false );
+  src ->gatherScalarRefs( refs, false );
+  size->gatherScalarRefs( refs, false );
+} 
+
+void chillAST_CudaMemcpy::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  dest->gatherVarDecls( decls ); 
+  src ->gatherVarDecls( decls ); 
+  size->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_CudaMemcpy::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  dest->gatherScalarVarDecls( decls ); 
+  src ->gatherScalarVarDecls( decls ); 
+  size->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_CudaMemcpy::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  dest->gatherArrayVarDecls( decls ); 
+  src ->gatherArrayVarDecls( decls ); 
+  size->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_CudaMemcpy::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  dest->gatherVarUsage( decls ); 
+  src ->gatherVarUsage( decls ); 
+  size->gatherVarUsage( decls ); 
+}
+
+
+
+chillAST_CudaSyncthreads::chillAST_CudaSyncthreads( chillAST_node *par) { 
+  asttype = CHILLAST_NODETYPE_CUDASYNCTHREADS;
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+} 
+ 
+ void chillAST_CudaSyncthreads::print( int indent,  FILE *fp ) {
+   chillindent(indent, fp); 
+   fprintf(fp, "__syncthreads()"); 
+   fflush(fp); 
+ }
+ 
+ void chillAST_CudaSyncthreads::dump( int indent,  FILE *fp ) {
+   chillindent(indent, fp); 
+   fprintf(fp, "(syncthreads)\n"); 
+   fflush(fp); 
+ }
+ 
+
+
+
+
+
+
+
+
+
+chillAST_ReturnStmt::chillAST_ReturnStmt( chillAST_node *retval, chillAST_node *par ) {
+  asttype = CHILLAST_NODETYPE_RETURNSTMT; 
+  returnvalue = retval;
+  if (returnvalue) returnvalue->setParent( this );
+  parent = par; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+void chillAST_ReturnStmt::print( int indent, FILE *fp) {
+  printPreprocBEFORE(indent, fp); 
+  chillindent(indent, fp);
+  if (returnvalue != NULL) {
+    fprintf(fp, "return(");
+    returnvalue->print( 0, fp );
+    fprintf(fp, ")" ); // parent will add ";\n" ?? 
+  }
+  else { 
+    fprintf(fp, "return");
+  }
+  fflush(fp); 
+}
+
+
+void chillAST_ReturnStmt::dump( int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(ReturnStmt");
+  if (returnvalue) {
+    fprintf(fp, "\n");
+    returnvalue->dump(indent+1,fp);
+    chillindent(indent, fp);
+  }
+  fprintf(fp, ")\n"); 
+}
+
+
+class chillAST_node* chillAST_ReturnStmt::constantFold() { 
+  if (returnvalue) returnvalue = returnvalue->constantFold(); 
+  return this;
+}
+
+
+
+class chillAST_node* chillAST_ReturnStmt::clone() { 
+  chillAST_node *val = NULL; 
+  if ( returnvalue ) val = returnvalue->clone();
+  chillAST_ReturnStmt *RS = new chillAST_ReturnStmt( val, parent );
+  RS->isFromSourceFile = isFromSourceFile; 
+  if (filename) RS->filename = strdup(filename); 
+  return RS;
+}
+
+
+void chillAST_ReturnStmt::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (returnvalue) returnvalue->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_ReturnStmt::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (returnvalue) returnvalue->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_ReturnStmt::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (returnvalue) returnvalue->gatherArrayVarDecls( decls ); 
+}
+
+
+
+void chillAST_ReturnStmt::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  if (returnvalue) returnvalue->gatherDeclRefExprs( refs ); 
+}
+
+
+
+void chillAST_ReturnStmt::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  if (returnvalue) returnvalue->gatherVarUsage( decls ); 
+}
+
+
+
+
+chillAST_CallExpr::chillAST_CallExpr(chillAST_node *c, chillAST_node *par) { //, int numofargs, chillAST_node **theargs ) {
+  
+  //fprintf(stderr, "chillAST_CallExpr::chillAST_CallExpr  callee type %s\n", c->getTypeString()); 
+  asttype = CHILLAST_NODETYPE_CALLEXPR;
+  callee = c;
+  //callee->setParent( this ); // ?? 
+  numargs = 0;
+  parent = par; 
+  grid = block = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+
+void chillAST_CallExpr::addArg( chillAST_node *a ) {
+  args.push_back( a );
+  a->setParent( this );
+  numargs += 1;
+}
+
+
+void chillAST_CallExpr::print(  int indent, FILE *fp) {
+  printPreprocBEFORE(indent, fp); 
+  chillindent(indent, fp);
+  chillAST_FunctionDecl *FD = NULL;
+  chillAST_MacroDefinition *MD = NULL;
+
+  if (callee->isDeclRefExpr()) { 
+    chillAST_DeclRefExpr *DRE = (chillAST_DeclRefExpr *) callee; 
+    //fprintf(stderr, "DRE decl is 0x%x\n", DRE->decl); 
+    if (!DRE->decl) { 
+      // a macro? 
+      fprintf(fp, "%s ", DRE->declarationName); 
+      return; // ?? 
+    }
+
+    //fprintf(stderr, "DRE decl of type %s\n", DRE->decl->getTypeString()); 
+    if ( (DRE->decl)->isFunctionDecl()) FD = (chillAST_FunctionDecl *)DRE->decl; 
+    else { 
+      fprintf(stderr, "chillAST_CallExpr::print() DRE decl of type %s\n", DRE->decl->getTypeString()); 
+      exit(-1);
+    }
+  }
+  else if (callee->isFunctionDecl()) FD = (chillAST_FunctionDecl *) callee;
+  else if (callee->isMacroDefinition()) { 
+    MD = (chillAST_MacroDefinition *) callee;
+    fprintf(fp, "%s(", MD->macroName); 
+  }
+  else { 
+    fprintf(stderr, "\nchillAST_CallExpr::print() callee of unhandled type %s\n", callee->getTypeString()); 
+    callee->dump();
+    exit(-1); 
+  }
+  
+  if (FD) { 
+    fprintf(fp, "%s", FD->functionName ); fflush(fp); 
+    if (grid && block) {
+      fprintf(fp, "<<<%s,%s>>>(", grid->varname, block->varname);    // a
+    }
+    else fprintf(fp, "(");
+  }
+
+
+  //callee->print( indent, fp);
+  for (int i=0; i<args.size(); i++) { 
+    if (i!=0) fprintf(fp, ", "); 
+    args[i]->print(0, fp); 
+  }
+  fprintf(fp, ")");                                                //a
+  fflush(fp); 
+}
+
+void chillAST_CallExpr::dump(  int indent, FILE *fp) {
+  chillindent(indent, fp);
+  fprintf(fp, "(CallExpr ");
+  //fprintf(stderr, "callee type %s\n", callee->getTypeString()); 
+  chillAST_FunctionDecl *fd = NULL;
+  if (callee->isDeclRefExpr()) { // always?
+    chillAST_DeclRefExpr *dre = (chillAST_DeclRefExpr *)callee;
+    fd = dre->getFunctionDecl(); // if NULL, we've got a Vardecl instead
+    if (fd) {
+      //fd->print(); 
+      fprintf(fp, "%s\n", fd->returnType);
+    }
+
+    callee->dump(indent+1, fp);
+    if (fd) { 
+      int numparams = fd->parameters.size();
+      for (int i=0; i<numparams; i++) fd->parameters[i]->dump(indent+1, fp);
+    }
+  }
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+}
+
+void chillAST_CallExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherArrayRefs( refs, writtento ); 
+  }
+}
+void chillAST_CallExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherScalarRefs( refs, writtento ); 
+  }
+} 
+
+
+void chillAST_CallExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherVarDecls( decls ); 
+  }
+}
+
+
+void chillAST_CallExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherScalarVarDecls( decls ); 
+  }
+}
+
+
+void chillAST_CallExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherArrayVarDecls( decls ); 
+  }
+}
+
+
+void chillAST_CallExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherDeclRefExprs( refs ); 
+  }
+}
+
+void chillAST_CallExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  for (int i=0; i<args.size(); i++) args[i]->replaceVarDecls( olddecl, newdecl ); 
+}
+
+void chillAST_CallExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<args.size(); i++) { 
+    args[i]->gatherVarUsage( decls ); 
+  }
+}
+
+
+chillAST_node* chillAST_CallExpr::constantFold() { 
+  numargs = args.size(); // wrong place for this 
+  for (int i=0; i<numargs; i++) { 
+    args[i] = args[i]->constantFold(); 
+  }
+  return this; 
+}
+
+chillAST_node* chillAST_CallExpr::clone() { 
+  //fprintf(stderr, "chillAST_CallExpr::clone()\n");
+  //print(0, stderr); fprintf(stderr, "\n"); 
+
+  chillAST_CallExpr *CE = new chillAST_CallExpr( callee->clone(), NULL );
+  for (int i=0; i<args.size(); i++) CE->addArg( args[i]->clone() ); 
+  CE->isFromSourceFile = isFromSourceFile; 
+  if (filename) CE->filename = strdup(filename); 
+  return CE; 
+}
+
+
+
+
+chillAST_VarDecl::chillAST_VarDecl() { 
+  //fprintf(stderr, "0chillAST_VarDecl::chillAST_VarDecl()  %p\n", this); 
+  fprintf(stderr, "0chillAST_VarDecl::chillAST_VarDecl()\n"); 
+  vartype = underlyingtype = varname = arraypart = arraypointerpart = arraysetpart = NULL;
+  typedefinition = NULL; 
+
+  //fprintf(stderr, "setting underlying type NULL\n" ); 
+  init = NULL;
+  numdimensions=0; arraysizes = NULL; 
+  asttype = CHILLAST_NODETYPE_VARDECL;  // 
+  parent = NULL;
+  metacomment = NULL;
+
+  vardef  = NULL;
+  isStruct = false;
+  
+  //insideAStruct = false; 
+  isAParameter = false; 
+  byreference = false;
+  isABuiltin = false; 
+  isRestrict = isDevice = isShared = false; // fprintf(stderr, "RDS = false\n"); 
+  knownArraySizes = false;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}; 
+
+
+
+chillAST_VarDecl::chillAST_VarDecl( const char *t,  const char *n, const char *a, chillAST_node *par) { 
+  //fprintf(stderr, "1chillAST_VarDecl::chillAST_VarDecl( type %s, name %s, arraypart %s,  parent %p)  %p\n", t, n, a, par, this); 
+  fprintf(stderr, "1chillAST_VarDecl::chillAST_VarDecl( type %s, name %s, arraypart %s)\n", t, n, a); 
+  vartype   = strdup(t); 
+  typedefinition = NULL;
+
+  underlyingtype = parseUnderlyingType( vartype ); 
+  //fprintf(stderr, "setting underlying type %s from %s\n",  underlyingtype, vartype ); 
+  varname   = strdup(n); 
+  arraypointerpart = arraysetpart = NULL;
+  if (a) arraypart = strdup(a);
+  else arraypart = strdup(""); 
+  splitarraypart();
+
+  init = NULL;
+  numdimensions=0; arraysizes = NULL; 
+  uniquePtr = NULL;
+  asttype = CHILLAST_NODETYPE_VARDECL;
+  parent = par;
+
+
+
+  knownArraySizes = false; 
+  //fprintf(stderr, "arraypart len %d\n", strlen(a)); 
+  for (int i=0; i<strlen(a); i++) { 
+    if (a[i] == '[') { numdimensions++; knownArraySizes = true; } 
+    if (!knownArraySizes && a[i] == '*') numdimensions++;
+  }
+  
+  vardef  = NULL;
+  isStruct = false;
+  
+  //insideAStruct = false; 
+  isAParameter = false; 
+  byreference = false;
+  isABuiltin = false; 
+  isRestrict = isDevice = isShared = false; // fprintf(stderr, "RDS = false\n"); 
+
+  if (parent) { 
+    //fprintf(stderr, "chillAST_VarDecl::chillAST_VarDecl( %s ), adding to symbol table???\n", varname); 
+    parent->addVariableToSymbolTable( this ); // should percolate up until something has a symbol table 
+    
+  }
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}; 
+
+
+
+chillAST_VarDecl::chillAST_VarDecl( chillAST_RecordDecl *astruct, const char *nam, const char *array, chillAST_node *par) {
+  // define a variable whose type is a struct!
+  
+  fprintf(stderr, "3chillAST_VarDecl::chillAST_VarDecl( %s  %p struct ", nam, this );
+  const char *type = astruct->getName(); 
+  fprintf (stderr, "%s, name %s, arraypart %s parent ) %p\n", type, nam, array, this); // , par);
+
+  vartype = strdup(type);
+
+  // these always go together  ?? 
+  vardef  = astruct;// pointer to the thing that says what is inside the struct
+  isStruct = true;  // ?? wrong if it's a union  ?? TODO 
+  
+    //insideAStruct = false; 
+  //fprintf(stderr, "setting vardef of %s to %p\n", nam, vardef); 
+  
+  underlyingtype = parseUnderlyingType( vartype ); 
+  //fprintf(stderr, "setting underlying type %s from %s\n",  underlyingtype, vartype ); 
+  varname   = strdup(nam); 
+  arraypart = strdup(array);
+  arraypointerpart = arraysetpart = NULL;
+  splitarraypart(); 
+
+  init = NULL;
+  numdimensions=0; arraysizes = NULL; 
+  uniquePtr = NULL;
+  asttype = CHILLAST_NODETYPE_VARDECL;
+  parent = par;
+
+  knownArraySizes = false; 
+  //fprintf(stderr, "arraypart len %d\n", strlen(a)); 
+  for (int i=0; i<strlen(array); i++) { 
+    if (array[i] == '[') { numdimensions++; knownArraySizes = true; } 
+    if (!knownArraySizes && array[i] == '*') numdimensions++;
+  }
+  
+  isAParameter = false;
+  fprintf(stderr, "%s is NOT a parameter\n", nam); 
+  byreference = false;
+  isABuiltin = false; 
+  isRestrict = isDevice = isShared = false; // fprintf(stderr, "RDS = false\n"); 
+  typedefinition = NULL;
+
+  //fprintf(stderr, "chillAST_VarDecl::chillAST_VarDecl( chillAST_RecordDecl *astruct, ...) MIGHT add struct to some symbol table\n"); 
+  //if (parent) fprintf(stderr, "yep, adding it\n"); 
+
+  if (parent) parent->addVariableToSymbolTable( this ); // should percolate up until something has a symbol table 
+
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+}; 
+
+
+
+
+
+chillAST_VarDecl::chillAST_VarDecl( chillAST_TypedefDecl *tdd,  const char *n, const char *a, chillAST_node *par) { 
+  fprintf(stderr, "4chillAST_VarDecl::chillAST_VarDecl( %s  typedef ", n);
+  const char *type = tdd->getStructName();
+  //fprintf (stderr, "%s, name %s, arraypart %s parent ) %p\n", type, n, a,this); // , par);
+  typedefinition = tdd;
+  vartype   = strdup(type); 
+  underlyingtype = parseUnderlyingType( vartype ); 
+  //fprintf(stderr, "setting underlying type %s from %s\n",  underlyingtype, vartype ); 
+  varname   = strdup(n); 
+  arraypart = strdup(a);
+  arraypointerpart = arraysetpart = NULL;
+  splitarraypart(); 
+
+  init = NULL;
+  numdimensions=0; arraysizes = NULL; 
+  uniquePtr = NULL;
+  asttype = CHILLAST_NODETYPE_VARDECL;
+  parent = par;
+
+  knownArraySizes = false; 
+  //fprintf(stderr, "arraypart len %d\n", strlen(a)); 
+  for (int i=0; i<strlen(a); i++) { 
+    if (a[i] == '[') { numdimensions++; knownArraySizes = true; } 
+    if (!knownArraySizes && a[i] == '*') numdimensions++;
+  }
+
+  isStruct = tdd->isAStruct();
+  
+  //insideAStruct = false; 
+  
+  vardef  = NULL;
+
+
+  isAParameter = false; 
+  byreference = false;
+  isABuiltin = false; 
+  isRestrict = isDevice = isShared = false; // //fprintf(stderr, "RDS = false\n"); 
+  if (parent) parent->addVariableToSymbolTable( this ); // should percolate up until something has a symbol table 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}; 
+
+
+
+
+
+chillAST_VarDecl::chillAST_VarDecl( const char *t,  const char *n, const char *a, void *ptr, chillAST_node *par) { 
+  fprintf(stderr, "2chillAST_VarDecl::chillAST_VarDecl( type %s, name %s, arraypart '%s' ) %p\n", t, n, a, this); 
+  //fprintf(stderr, "2chillAST_VarDecl::chillAST_VarDecl( type %s, name %s, arraypart %s, ptr 0x%x, parent 0x%x )\n", t, n, a, ptr, par); 
+
+
+  vartype   = strdup(t); 
+  typedefinition = NULL;
+  underlyingtype = parseUnderlyingType( vartype ); 
+  //fprintf(stderr, "setting underlying type %s from %s\n",  underlyingtype, vartype ); 
+  varname   = strdup(n); 
+
+  vardef = NULL;  // not a struct
+  isStruct = false;
+  isAParameter = false; 
+  
+  if (a) arraypart = strdup(a);
+  else arraypart = strdup(""); // should catch this earlier
+  arraypointerpart = arraysetpart = NULL;
+  splitarraypart(); 
+
+  init = NULL;
+  numdimensions=0; arraysizes = NULL; 
+  uniquePtr = ptr;
+  asttype = CHILLAST_NODETYPE_VARDECL;
+  parent = par;
+  knownArraySizes = false; 
+
+  if (par) par->addChild(this); // ??
+  
+  //fprintf(stderr, "name arraypart len %d\n", strlen(a)); 
+  //fprintf(stderr, "arraypart '%s'\n", arraypart); 
+  for (int i=0; i<strlen(a); i++) { 
+    if (a[i] == '[') { numdimensions++; knownArraySizes = true; } 
+    if (!knownArraySizes && a[i] == '*') numdimensions++; // fails for  a[4000 * 4] 
+  }  
+  //if (0 == strlen(a) && numdimensions == 0) { 
+  //  for (int i=0; i<strlen(t); i++) {   // handle float * x 
+  //    if (t[i] == '[') numdimensions++;
+  //    if (t[i] == '*') numdimensions++;
+  //  }  
+  //} 
+  //fprintf(stderr, "2name %s numdimensions %d\n", n, numdimensions); 
+
+
+
+
+  // this is from ir_clang.cc ConvertVarDecl(), that got executed AFTER the vardecl was constructed. dumb
+  int numdim = 0;
+  //knownArraySizes = true;
+  //if (index(vartype, '*')) knownArraySizes = false;  // float *a;   for example
+  //if (index(arraypart, '*'))  knownArraySizes = false;
+  
+  // note: vartype here, arraypart in next code..    is that right?
+  if (index(vartype, '*')) { 
+    for (int i = 0; i<strlen(vartype); i++) if (vartype[i] == '*') numdim++;
+    //fprintf(stderr, "numd %d\n", numd);
+    numdimensions = numdim; 
+  }
+  
+  if (index(arraypart, '[')) {  // JUST [12][34][56]  no asterisks
+    char *dupe = strdup(arraypart);
+
+    int len = strlen(arraypart);
+    for (int i=0; i<len; i++) if (dupe[i] == '[') numdim++;
+    
+    //fprintf(stderr, "numdim %d\n", numdim);
+    
+    numdimensions = numdim; 
+    int *as =  (int *)malloc(sizeof(int *) * numdim );
+    if (!as) { 
+      fprintf(stderr, "can't malloc array sizes in ConvertVarDecl()\n");
+      exit(-1);
+    }
+    arraysizes = as; // 'as' changed later!
+    
+    
+    char *ptr = dupe;
+    //fprintf(stderr, "dupe '%s'\n", ptr);
+    while (ptr = index(ptr, '[')) {                   // this fails for float a[4000*4]
+      ptr++;
+      char *leak = strdup(ptr);
+      char *close = index(leak, ']');
+      if (close) *close = '\0'; 
+
+      int l = strlen(leak);
+      bool justdigits = true;
+      bool justmath = true;
+      for (int i=0; i<l; i++) { 
+        char c = leak[i]; 
+        if (!isdigit(c)) justdigits = false;
+        if (!( isdigit(c) ||
+               isblank(c) ||
+               ((c == '+') || (c == '*')  || (c == '*')  || (c == '*')) || // math
+               ((c == '(') || (c == ')')))
+               ) { 
+          //fprintf(stderr, " not justmath because '%c'\n", c); 
+          justmath = false; 
+        }
+            
+      }
+
+      //fprintf(stderr, "tmp '%s'\n", leak);
+      if (justdigits) { 
+        int dim;
+        sscanf(ptr, "%d", &dim);
+        //fprintf(stderr, "dim %d\n", dim);
+        *as++ = dim; 
+      }
+      else { 
+        if (justmath) fprintf(stderr, "JUST MATH\n");
+        fprintf(stderr, "need to evaluate %s, faking with hardcoded 16000\n", leak); 
+        *as++ = 16000; // temp TODO DFL 
+      }
+      free (leak); 
+
+      ptr =  index(ptr, ']');
+      //fprintf(stderr, "bottom of loop, ptr = '%s'\n", ptr); 
+    }
+    free(dupe);
+    //for (int i=0; i<numdim; i++) { 
+    //  fprintf(stderr, "dimension %d = %d\n", i,  arraysizes[i]); 
+    //} 
+    
+    //fprintf(stderr, "need to handle [] array to determine num dimensions\n");
+    //exit(-1); 
+  }
+  
+  
+  //insideAStruct = false; 
+  byreference = false;
+  isABuiltin = false; 
+  isRestrict = isDevice = isShared = false; // fprintf(stderr, "RDS = false\n"); 
+  
+  //print(); printf("\n"); fflush(stdout); 
+
+  // currently this is bad, because a struct does not have a symbol table, so the 
+  // members of a struct are passed up to the func or sourcefile. 
+  if (parent) parent->addVariableToSymbolTable( this ); // should percolate up until something has a symbol table 
+
+
+  isFromSourceFile = true; // default 
+  filename = NULL;
+
+  fprintf(stderr, "2chillAST_VarDecl::chillAST_VarDecl LEAVING\n");
+  //parent->print(); fprintf(stderr, "\n\n");
+
+
+}; 
+
+
+void chillAST_VarDecl::print( int indent, FILE *fp ) {
+  //fprintf(fp, "chillAST_VarDecl::print()\n");
+  
+  printPreprocBEFORE(indent, fp); 
+
+  //fprintf(fp, "VarDecl vartype '%s'    varname %s   ", vartype, varname); 
+  //if (isAStruct()) fprintf(fp, "isAStruct()\n");
+  //else  fprintf(fp, "NOT A Struct\n");
+
+  // fprintf(fp, "\n");  fflush(fp); dump(0,fp); fflush(fp);  // debug
+
+  chillindent(indent, fp);
+  //fprintf(fp, "vardecl->print  vartype '%s'\n", vartype); 
+  if (isDevice) fprintf(fp, "__device__ "); 
+  if (isShared) fprintf(fp, "__shared__ "); 
+  
+  //if (isAStruct()) fprintf(fp, "/* isAStruct() */  ");
+  //else fprintf(fp, "/* NOT A Struct() */  ");
+  //if (vardef)      fprintf(fp, "/* vardef */  "); 
+  //else  fprintf(fp, "/* NOT vardef */  "); 
+
+
+  //fprintf(stderr, "chillAST_VarDecl::print()  %s\n", varname ); 
+  //if (isParmVarDecl()) fprintf(stderr, "%s is a parameter\n", varname); 
+  //if (isAStruct()) fprintf(stderr, "%s is a struct\n", varname); 
+  //else fprintf(stderr, "%s is NOT a struct\n", varname); 
+  //if (!parent) fprintf(stderr, "VARDECL HAS NO PARENT\n");
+  //else fprintf(stderr, "parent of %s is type %s\n", varname, parent->getTypeString()); 
+
+  // this logic is probably wrong (what about pointer to struct? )
+
+  //fprintf(stderr, "checking for unnamed only used here\n");
+
+  if ((!isAParameter) && isAStruct() && vardef) { // an unnamed  struct used only here ??
+    
+    //fprintf(fp, "i%s sAStruct() && vardef ??   vardecl of type UNNAMED ONLY USED HERE \n", varname );
+    // print the internals of the struct and then the name 
+    vardef->printStructure( 0, fp );
+    fprintf(fp, "%s", varname );
+    
+    return;
+  }
+  
+  //fprintf(fp, "ugly logic\n"); 
+  // ugly logic TODO
+  
+  if (typedefinition && typedefinition->isAStruct()) fprintf(fp, "struct "); 
+
+  if (isAParameter) {
+    //fprintf(fp, "%s isaparameter\n", varname); 
+    //if (isAStruct())  fprintf(fp, "struct "); 
+    //fprintf(fp, "(param) nd %d", numdimensions ); 
+    //dump(); 
+    if (numdimensions > 0) {
+      if (knownArraySizes) {  // just [12][34][56] 
+        fprintf(fp, "%s ", vartype);
+        if (byreference) fprintf(fp, "&");
+        fprintf(fp, "%s", varname);
+        for (int n=0; n< (numdimensions); n++) fprintf(fp, "[%d]", arraysizes[n]); 
+      }
+      else {  // some unknown array part    float *a;  or float **a;  or float (*)a[1234] 
+
+        //fprintf(fp, "\nsome unknown\n");
+        //fprintf(fp, "arraypointerpart '%s'\n", arraypointerpart);
+        //fprintf(fp, "arraysetpart '%s'\n", arraysetpart);
+        
+        if (numdimensions == 1) { 
+          //fprintf(fp, "\nnd1, vartype %s\n", vartype); 
+          
+          // TODO this if means I have probably made a mistake somewhere
+          if (!index(vartype, '*')) fprintf(fp, "%s *%s",   vartype, varname ); // float *x
+          else fprintf(fp, "%s%s", vartype, varname); // float *a;
+
+          
+        }
+        else { // more than one dimension
+
+          if ( !strcmp("", arraysetpart) ) { // no known dimensions   float ***a;
+            fprintf(fp, "%s %s%s", vartype, arraypointerpart, varname); 
+          }
+          else if ( !strcmp("", arraypointerpart)) { // ALL known  float a[2][7];
+            fprintf(fp, "%s %s", vartype, varname); 
+            for (int n=0; n< numdimensions; n++)  fprintf(fp, "[%d]", arraysizes[n]);
+          }
+          else { //   float (*)a[1234] 
+            // this seems really wrong 
+            //     float (*)a[1234] 
+            fprintf(fp, "%s (", vartype); 
+            for (int n=0; n< (numdimensions-1); n++) fprintf(fp, "*");
+            fprintf(fp, "%s)", varname);
+            fprintf(fp, "[%d]", arraysizes[numdimensions-1]);
+          }
+          
+        }
+      }
+    } // if numdimensions > 0
+    else { // parameter float x
+        fprintf(fp, "%s ", vartype);
+        if (byreference) fprintf(fp, "&");
+        fprintf(fp, "%s", varname);
+    }
+  } // end parameter 
+
+  else { // NOT A PARAMETER
+    //fprintf(fp, "NOT A PARAM ... vartype '%s'\n", vartype); 
+    //if (isArray()) fprintf(stderr, "an array, numdimensions %d\n", numdimensions);
+    //fprintf(stderr, "arraysizes %p\n", arraysizes);
+    
+    
+    
+    //if (isArray() && arraysizes == NULL) { 
+    //    // we just know the number of dimensions but no sizes
+    //    // int ***something
+    //    fprintf(fp, "%s ", vartype);   // "int "
+    //    for (int i=0; i<numdimensions; i++) fprintf(fp, "*"); // ***
+    //    fprintf(fp, "%s", varname); // variable name 
+    //  }
+    //  else 
+    
+    fprintf(fp, "%s %s",   vartype, arraypointerpart); 
+    if (isRestrict) fprintf(fp, " __restrict__ ");  // wrong place
+    fprintf(fp, "%s%s", varname, arraysetpart );  
+    if (init) { 
+      fprintf(fp, " = ");  fflush(fp); 
+      init->print(0, fp);
+    }
+  }
+  fflush(fp); 
+  //fprintf(stderr, "numdimensions %d    arraysizes address 0x%x\n",  numdimensions, arraysizes); 
+  //if (!isAParameter) fprintf(fp, ";\n",   vartype, varname, arraypart );  
+};
+
+
+
+
+void chillAST_VarDecl::printName( int in, FILE *fp ) {
+  chillindent(in, fp);
+  fprintf(fp, "%s", varname);
+};
+
+
+
+
+void chillAST_VarDecl::dump( int indent, FILE *fp ) {
+  chillindent(indent, fp);
+  fprintf(fp, "(VarDecl \"'%s' '%s' '%s'\"  n_dim %d  )  ",  vartype, varname, arraypart, numdimensions);
+  
+  //fprintf(fp, "vardef %p\n", vardef);
+  //if (vardef) fprintf(fp, "(typedef or struct!)\n"); 
+  //fprintf(fp, "typedefinition %p\n", typedefinition);
+  //if (isStruct) fprintf(fp, "isStruct\n"); 
+  
+  //if (isAParameter) fprintf(fp, "PARAMETER\n");
+  //else fprintf(fp, "NOT PARAMETER\n");
+  fflush(fp); 
+
+  //segfault();  // see what called this 
+};
+
+
+chillAST_RecordDecl * chillAST_VarDecl::getStructDef() { 
+  if (vardef) return vardef;
+  if (typedefinition) return typedefinition->getStructDef();
+  return NULL; 
+}
+
+
+
+
+
+chillAST_CompoundStmt::chillAST_CompoundStmt() {
+  //fprintf(stderr, "chillAST_CompoundStmt::chillAST_CompoundStmt() %p\n", this); 
+  asttype = CHILLAST_NODETYPE_COMPOUNDSTMT; 
+  parent = NULL; 
+  symbol_table = new chillAST_SymbolTable;
+  typedef_table = NULL;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}; 
+
+
+void  chillAST_CompoundStmt::print( int indent,  FILE *fp ) { 
+  printPreprocBEFORE(indent, fp); 
+  int numchildren = children.size();
+  //fprintf(stderr, "NUMCHILDREN %d\n", numchildren); sleep(1); 
+  for (int i=0; i<numchildren; i++) {
+    children[i]->print(indent, fp);
+    if (children[i]->asttype != CHILLAST_NODETYPE_FORSTMT  
+        && children[i]->asttype != CHILLAST_NODETYPE_IFSTMT
+        && children[i]->asttype != CHILLAST_NODETYPE_COMPOUNDSTMT
+        //&& children[i]->asttype != CHILLAST_NODETYPE_VARDECL   // vardecl does its own ";\n"
+        ) 
+      {
+        fprintf(fp, ";\n");  // probably wrong 
+      }
+  }
+  fflush(fp); 
+}
+
+void chillAST_CompoundStmt::replaceChild( chillAST_node *old, chillAST_node *newchild ){
+  //fprintf(stderr, "chillAST_CompoundStmt::replaceChild( old %s, new %s)\n", old->getTypeString(), newchild->getTypeString() ); 
+   vector<chillAST_node*> dupe = children; 
+   int numdupe = dupe.size();
+  int any = 0; 
+  
+  for (int i=0; i<numdupe; i++) { 
+
+    //fprintf(stderr, "\ni %d\n",i); 
+    //for (int j=0; j<numdupe; j++) { 
+    //  fprintf(stderr, "this 0x%x   children[%d/%d] = 0x%x type %s\n", this, j, children.size(), children[j], children[j]->getTypeString()); 
+    //}
+
+
+    if (dupe[i] == old) { 
+      //fprintf(stderr, "replacing child %d of %d\n", i, numdupe); 
+      //fprintf(stderr, "was \n"); print();
+      children[i] = newchild;
+      newchild->setParent( this );
+      //fprintf(stderr, "is  \n");  print(); fprintf(stderr, "\n\n"); 
+      // old->parent = NULL; 
+      any = 1;
+    }
+  }
+
+  if (!any) { 
+    fprintf(stderr, "chillAST_CompoundStmt::replaceChild(), could not find old\n");
+    exit(-1); 
+  }
+}
+
+
+void chillAST_CompoundStmt::loseLoopWithLoopVar( char *var ) { 
+  //fprintf(stderr, "chillAST_CompoundStmt::loseLoopWithLoopVar( %s )\n", var); 
+
+  //fprintf(stderr, "CompoundStmt 0x%x has parent 0x%x  ", this, this->parent);
+  //fprintf(stderr, "%s\n", parent->getTypeString()); 
+
+  
+  //fprintf(stderr, "CompoundStmt node has %d children\n", children.size()); 
+  //fprintf(stderr, "before doing a damned thing, \n"); 
+  //print();
+  //dump(); fflush(stdout);
+  //fprintf(stderr, "\n\n"); 
+
+#ifdef DAMNED
+  for (int j=0; j<children.size(); j++) { 
+    fprintf(stderr, "j %d/%d  ", j, children.size()); 
+    fprintf(stderr, "subnode %d 0x%x  ", j, children[j] );
+    fprintf(stderr, "asttype %d  ", children[j]->asttype); 
+    fprintf(stderr, "%s    ", children[j]->getTypeString());
+    if (children[j]->isForStmt()) { 
+      chillAST_ForStmt *FS = ((chillAST_ForStmt *)  children[j]); 
+      fprintf(stderr, "for (");
+      FS->init->print(0, stderr);
+      fprintf(stderr, "; ");
+      FS->cond->print(0, stderr);
+      fprintf(stderr, "; ");
+      FS->incr->print(0, stderr);
+      fprintf(stderr, ")  with %d statements in body 0x%x\n",  FS->body->getNumChildren(), FS->body );   
+    }
+    else fprintf(stderr, "\n"); 
+  }
+#endif
+
+
+  vector<chillAST_node*> dupe = children; // simple enough?
+  for (int i=0; i<dupe.size(); i++) { 
+    //for (int j=0; j<dupe.size(); j++) { 
+    //  fprintf(stderr, "j %d/%d\n", j, dupe.size()); 
+    //  fprintf(stderr, "subnode %d %s    ", j, children[j]->getTypeString());
+    //  if (children[j]->isForStmt()) { 
+    //    chillAST_ForStmt *FS = ((chillAST_ForStmt *)  children[j]); 
+    //    fprintf(stderr, "for (");
+    //     FS->init->print(0, stderr);
+    //    fprintf(stderr, "; ");
+    //    FS->cond->print(0, stderr);
+    //    fprintf(stderr, "; ");
+    //    FS->incr->print(0, stderr);
+    //    fprintf(stderr, ")  with %d statements in body 0x%x\n",  FS->body->getNumChildren(), FS->body );   
+    //} 
+    //else fprintf(stderr, "\n"); 
+    //}
+    
+    //fprintf(stderr, "CompoundStmt 0x%x recursing to child %d/%d\n", this, i, dupe.size()); 
+    dupe[i]->loseLoopWithLoopVar( var );
+  }
+  //fprintf(stderr, "CompoundStmt node 0x%x done recursing\n", this ); 
+}
+
+
+
+void chillAST_CompoundStmt::dump(  int indent,  FILE *fp ) { 
+  chillindent(indent, fp); 
+  fprintf(fp, "(CompoundStmt \n" );
+  int numchildren = children.size();
+
+  //for (int i=0; i<numchildren; i++)  { 
+  //  fprintf(fp, "%d %s 0x%x\n",  i, children[i]->getTypeString(), children[i]); 
+  //} 
+  //fprintf(fp, "\n"); 
+
+  for (int i=0; i<numchildren; i++)  { 
+    children[i]->dump(indent+1, fp);
+    fprintf(fp, "\n"); // ???
+    fflush(fp);
+  }
+  chillindent(indent, fp); 
+  fprintf(fp, ")\n"); 
+};
+
+
+
+chillAST_node*  chillAST_CompoundStmt::constantFold(){ 
+  //fprintf(stderr, "chillAST_CompoundStmt::constantFold()\n"); 
+  for (int i=0; i<children.size(); i++) children[i] =  children[i]->constantFold();
+  return this;
+}
+
+
+chillAST_node*  chillAST_CompoundStmt::clone(){ 
+  chillAST_CompoundStmt *cs = new chillAST_CompoundStmt();
+  for (int i=0; i<children.size(); i++) cs->addChild( children[i]->clone() );
+  cs->setParent( parent ); 
+  cs->isFromSourceFile = isFromSourceFile; 
+  if (filename) cs->filename = strdup(filename); 
+  return cs;
+}
+
+
+void chillAST_CompoundStmt::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  //fprintf(stderr, "chillAST_CompoundStmt::gatherVarDecls()\n"); 
+  for (int i=0; i<children.size(); i++) children[i]->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_CompoundStmt::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_CompoundStmt::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_CompoundStmt::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherDeclRefExprs( refs ); 
+}
+
+
+void chillAST_CompoundStmt::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherVarUsage( decls ); 
+}
+
+
+void chillAST_CompoundStmt::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) { 
+  for (int i=0; i<children.size(); i++) children[i]->gatherArrayRefs( refs, 0); 
+}
+
+void chillAST_CompoundStmt::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  for (int i=0; i<children.size(); i++) children[i]->gatherScalarRefs( refs, 0); 
+} 
+  
+void chillAST_CompoundStmt::gatherStatements(std::vector<chillAST_node*> &statements ){
+  for (int i=0; i<children.size(); i++) children[i]->gatherStatements( statements ); 
+} 
+ 
+
+
+void chillAST_CompoundStmt::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  for (int i=0; i<children.size(); i++) children[i]->replaceVarDecls( olddecl, newdecl ); 
+}
+
+
+bool chillAST_CompoundStmt::findLoopIndexesToReplace(  chillAST_SymbolTable *symtab, bool forcesync ) { 
+
+  // see how many elements we currently have
+  int sofar = children.size(); 
+
+  // make big enough to add a sync after each statement. wasteful. TODO
+  // this prevents inserts happening at the forstmt::addSync() from causing a 
+  // reallocation, which screwsup the loop below here 
+  children.reserve( 2 * sofar );
+  //fprintf(stderr, "sofar %d   reserved %d\n", sofar, 2*sofar); 
+
+  bool force = false;
+  for (int i=0; i<children.size(); i++) {  // children.size() to see it gain each time
+    if (children.size() > sofar ) { 
+      //fprintf(stderr, "HEY! CompoundStmt::findLoopIndexesToReplace() noticed that children increased from %d to %d\n", sofar, children.size()); 
+      sofar = children.size(); 
+    }
+
+    //fprintf(stderr, "compound child %d of type %s force %d\n", i, children[i]->getTypeString(), force ); 
+    bool thisforces = children[i]->findLoopIndexesToReplace( symtab, force );
+    force = force || thisforces; // once set, always
+  }
+
+  return false; 
+
+/* 
+  vector<chillAST_node*> childrencopy;
+  for (int i=0; i<children.size(); i++) childrencopy.push_back( children[i] ); 
+  bool force = false;
+  
+  char *origtypes[64]; 
+  int origsize = children.size(); 
+  for (int i=0; i<children.size(); i++) { 
+    fprintf(stderr, "ORIGINAL compound child %d of type %s\n", i, children[i]->getTypeString() ); 
+    origtypes[i] = strdup( children[i]->getTypeString() ); 
+    fprintf(stderr, "ORIGINAL compound child %d of type %s\n", i, children[i]->getTypeString() ); 
+  }
+    
+  for (int i=0; i<childrencopy.size(); i++) { 
+    fprintf(stderr, "compound child %d of type %s force %d\n", i, childrencopy[i]->getTypeString(), force ); 
+    force = force || childrencopy[i]->findLoopIndexesToReplace( symtab, force ); // once set, always
+  }
+
+  fprintf(stderr, "\n"); 
+  for (int i=0; i<origsize; i++) { 
+    fprintf(stderr, "BEFORE compound child %d/%d of type %s\n",  i, origsize, origtypes[i]); 
+  }
+  for (int i=0; i<children.size(); i++) { 
+    fprintf(stderr, "AFTER  compound child %d/%d of type %s\n", i, children.size(), children[i]->getTypeString() ); 
+  }
+
+  return false;
+*/ 
+}
+
+
+
+
+
+chillAST_ParenExpr::chillAST_ParenExpr(  chillAST_node *sub, chillAST_node *par ){
+  subexpr = sub;
+  subexpr->setParent( this );
+  asttype = CHILLAST_NODETYPE_PARENEXPR; 
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_ParenExpr::print(  int indent,  FILE *fp ) { 
+  //fprintf(stderr, "chillAST_ParenExpr::print()\n"); 
+  chillindent(indent, fp); // hard to believe this will ever do anything
+  fprintf(fp, "(" ); 
+  subexpr->print( 0, fp ); 
+  fprintf(fp, ")" ); 
+  fflush(fp); 
+}
+
+void chillAST_ParenExpr::dump(  int indent,  FILE *fp ) { 
+   chillindent(indent, fp);
+   fprintf(fp, "(ParenExpr \n"); 
+   subexpr->dump( indent+1, fp );
+   chillindent(indent, fp);
+   fprintf(fp, ")\n");
+}
+
+
+void chillAST_ParenExpr::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {
+   subexpr->gatherArrayRefs( refs, writtento );
+}
+
+void chillAST_ParenExpr::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+   subexpr->gatherScalarRefs( refs, writtento );
+} 
+
+
+
+chillAST_node* chillAST_ParenExpr::constantFold() {
+  subexpr = subexpr->constantFold();
+  return this; 
+}
+
+
+chillAST_node* chillAST_ParenExpr::clone() {
+  chillAST_ParenExpr *PE = new chillAST_ParenExpr( subexpr->clone(), NULL ); 
+  PE->isFromSourceFile = isFromSourceFile; 
+  if (filename) PE->filename = strdup(filename); 
+  return PE; 
+}
+
+void chillAST_ParenExpr::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarDecls( decls ); 
+}
+
+
+void chillAST_ParenExpr::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherScalarVarDecls( decls ); 
+}
+
+
+void chillAST_ParenExpr::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherArrayVarDecls( decls ); 
+}
+
+
+void chillAST_ParenExpr::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  subexpr->gatherDeclRefExprs( refs ); 
+}
+
+void chillAST_ParenExpr::replaceVarDecls( chillAST_VarDecl *olddecl, chillAST_VarDecl *newdecl){
+  subexpr->replaceVarDecls( olddecl, newdecl ); 
+}
+
+void chillAST_ParenExpr::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  subexpr->gatherVarUsage( decls ); 
+}
+
+
+
+chillAST_Sizeof::chillAST_Sizeof( char *athing, chillAST_node *par ){
+  thing = strdup( athing ); // memory leak
+  parent = par;
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_Sizeof::print(  int indent,  FILE *fp ) { 
+  //fprintf(stderr, "chillAST_Sizeof::print()\n"); 
+  chillindent(indent, fp); // hard to believe this will ever do anything
+  fprintf(fp, "sizeof(" ); 
+  fprintf(fp, "%s)", thing ); 
+  fflush(fp); 
+}
+
+
+void chillAST_Sizeof::dump(  int indent,  FILE *fp ) { 
+   chillindent(indent, fp);
+   fprintf(fp, "(Sizeof  %s )\n", thing); 
+}
+
+void chillAST_Sizeof::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) {} 
+void chillAST_Sizeof::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {}
+
+chillAST_node* chillAST_Sizeof::constantFold() {
+  return this; 
+}
+
+chillAST_node* chillAST_Sizeof::clone() {
+  chillAST_Sizeof *SO = new chillAST_Sizeof( thing, NULL ); 
+  SO->isFromSourceFile = isFromSourceFile; 
+  if (filename) SO->filename = strdup(filename); 
+  return SO; 
+}
+
+void chillAST_Sizeof::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {  // TODO 
+}
+
+
+void chillAST_Sizeof::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {  // TODO 
+}
+
+
+void chillAST_Sizeof::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {  // TODO 
+}
+
+
+void chillAST_Sizeof::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  // TODO 
+}
+
+
+void chillAST_Sizeof::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+}
+
+
+void insertNewDeclAtLocationOfOldIfNeeded( chillAST_VarDecl *newdecl, chillAST_VarDecl *olddecl) {
+  //fprintf(stderr, "insertNewDeclAtLocationOfOldIfNeeded( new 0x%x  old 0x%x\n", newdecl, olddecl );
+
+  if (newdecl == NULL || olddecl == NULL) {
+    fprintf(stderr, "chill_ast.cc insertNewDeclAtLocationOfOldIfNeeded() NULL decl\n");
+    exit(-1);
+  }
+
+  if (newdecl == olddecl) return;
+
+  newdecl->vartype = strdup(olddecl->vartype);
+
+  chillAST_node *newparent = newdecl->parent;
+  chillAST_node *oldparent = olddecl->parent;
+  //fprintf(stderr, "newparent 0x%x   oldparent 0x%x\n", newparent, oldparent ); 
+  if (newparent == oldparent) return;
+
+  if (newparent != NULL) 
+    //fprintf(stderr, "chill_ast.cc insertNewDeclAtLocationOfOldIfNeeded() new decl already has parent??  probably wrong\n");
+  newdecl->parent = oldparent;  // will be true soon 
+
+  // find actual location of old decl and insert new one there
+  //fprintf(stderr, "oldparent is of type %s\n", oldparent->getTypeString()); // better be compoundstmt ??
+  vector<chillAST_node*> children = oldparent->getChildren();
+  
+  int numchildren = children.size(); 
+  //fprintf(stderr, "oldparent has %d children\n", numchildren); 
+  
+  if (numchildren == 0) {
+    fprintf(stderr, "chill_ast.cc insertNewDeclAtLocationOfOldIfNeeded() impossible number of oldparent children (%d)\n", numchildren); 
+    exit(-1);
+  }
+
+  bool newalreadythere = false;
+  int index = -1;
+  //fprintf(stderr, "olddecl is 0x%x\n", olddecl); 
+  //fprintf(stderr, "I know of %d variables\n", numchildren);
+  for (int i=0; i<numchildren; i++) { 
+    chillAST_node *child = oldparent->getChild(i); 
+    //fprintf(stderr, "child %d @ 0x%x is of type %s\n", i, child, child->getTypeString()); 
+    if (children[i] == olddecl) { 
+      index = i;
+      //fprintf(stderr, "found old decl at index %d\n", index); 
+    }
+    if (children[i] == newdecl) {  
+      newalreadythere = true; 
+      //fprintf(stderr, "new already there @ index %d\n", i); 
+    }
+  }
+  if (index == -1) { 
+    fprintf(stderr, "chill_ast.cc insertNewDeclAtLocationOfOldIfNeeded() can't find old decl for %s\n", olddecl->varname);
+    exit(-1);
+  }
+
+  if (!newalreadythere) oldparent->insertChild( index, newdecl );
+
+}
+
+
+void gatherVarDecls( vector<chillAST_node*> &code, vector<chillAST_VarDecl*> &decls) {
+  //fprintf(stderr, "gatherVarDecls()\n");
+
+  int numcode = code.size();
+  //fprintf(stderr, "%d top level statements\n", numcode);
+  for (int i=0; i<numcode; i++) {
+    chillAST_node *statement = code[i];
+    statement->gatherVarDecls( decls );
+  }
+
+}
+
+
+void gatherVarUsage( vector<chillAST_node*> &code, vector<chillAST_VarDecl*> &decls) {
+  //fprintf(stderr, "gatherVarUsage()\n");
+
+  int numcode = code.size();
+  //fprintf(stderr, "%d top level statements\n", numcode);
+  for (int i=0; i<numcode; i++) {
+    chillAST_node *statement = code[i];
+    statement->gatherVarUsage( decls );
+  }
+
+}
+
+
+
+
+chillAST_IfStmt::chillAST_IfStmt() { 
+  cond     = thenpart = elsepart = NULL;
+  asttype = CHILLAST_NODETYPE_IFSTMT; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+chillAST_IfStmt::chillAST_IfStmt(chillAST_node *c, chillAST_node *t, chillAST_node *e, chillAST_node *p){
+  cond = c;
+  if (cond) cond->setParent( this );
+  thenpart = t;
+  if (thenpart) thenpart->setParent( this ); 
+  elsepart = e;
+  if (elsepart) elsepart->setParent( this ); 
+  parent = p;
+  asttype = CHILLAST_NODETYPE_IFSTMT; 
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}
+
+void chillAST_IfStmt::gatherVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (cond)         cond->gatherVarDecls( decls );
+  if (thenpart) thenpart->gatherVarDecls( decls );
+  if (elsepart) elsepart->gatherVarDecls( decls );
+}
+
+
+void chillAST_IfStmt::gatherScalarVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (cond)         cond->gatherScalarVarDecls( decls );
+  if (thenpart) thenpart->gatherScalarVarDecls( decls );
+  if (elsepart) elsepart->gatherScalarVarDecls( decls );
+}
+
+
+void chillAST_IfStmt::gatherArrayVarDecls( vector<chillAST_VarDecl*> &decls ) {
+  if (cond)         cond->gatherArrayVarDecls( decls );
+  if (thenpart) thenpart->gatherArrayVarDecls( decls );
+  if (elsepart) elsepart->gatherArrayVarDecls( decls );
+}
+
+
+void chillAST_IfStmt::gatherDeclRefExprs( vector<chillAST_DeclRefExpr *>&refs ) {
+  if (cond)         cond->gatherDeclRefExprs( refs );
+  if (thenpart) thenpart->gatherDeclRefExprs( refs );
+  if (elsepart) elsepart->gatherDeclRefExprs( refs );
+}
+
+
+void chillAST_IfStmt::gatherVarUsage( vector<chillAST_VarDecl*> &decls ) {
+  if (cond)         cond->gatherVarUsage( decls );
+  if (thenpart) thenpart->gatherVarUsage( decls );
+  if (elsepart) elsepart->gatherVarUsage( decls );
+}
+
+
+void chillAST_IfStmt::gatherArrayRefs( std::vector<chillAST_ArraySubscriptExpr*> &refs, bool writtento ) { 
+  cond->gatherArrayRefs( refs, 0 );  // 0 ??
+  thenpart->gatherArrayRefs( refs, 0 );  // 0 ??
+  if (elsepart) elsepart->gatherArrayRefs( refs, 0 );  // 0 ??
+}
+
+void chillAST_IfStmt::gatherScalarRefs( std::vector<chillAST_DeclRefExpr*> &refs, bool writtento ) {
+  cond->gatherScalarRefs( refs, 0 );  // 0 ??
+  thenpart->gatherScalarRefs( refs, 0 );  // 0 ??
+  if (elsepart) elsepart->gatherScalarRefs( refs, 0 );  // 0 ??
+} 
+
+
+chillAST_node *chillAST_IfStmt::constantFold() { 
+  if (cond) cond = cond->constantFold();
+  if (thenpart) thenpart = thenpart->constantFold();
+  if (elsepart) elsepart = elsepart->constantFold();
+  return this; 
+}
+
+void chillAST_IfStmt::gatherStatements(std::vector<chillAST_node*> &statements ){
+
+  //print(); printf("\n"); fflush(stdout); 
+  thenpart->gatherStatements( statements );
+  //fprintf(stderr, "ifstmt, after then, %d statements\n", statements.size()); 
+  if (elsepart){ 
+    //fprintf(stderr, "there is an elsepart of type %s\n", elsepart->getTypeString()); 
+    elsepart->gatherStatements( statements );
+  }
+  //fprintf(stderr, "ifstmt, after else, %d statements\n", statements.size()); 
+}
+
+
+
+chillAST_node *chillAST_IfStmt::clone() { 
+  chillAST_node *c, *t, *e; 
+  c = t = e = NULL; 
+  if (cond) c = cond->clone(); // has to be one, right? 
+  if (thenpart) t = thenpart->clone();
+  if (elsepart) e = elsepart->clone();
+
+  chillAST_IfStmt *IS = new chillAST_IfStmt( c, t, e, parent); 
+  IS->isFromSourceFile = isFromSourceFile;
+  if (filename) IS->filename = strdup(filename); 
+  return IS;
+} 
+
+
+
+void  chillAST_IfStmt::dump(  int indent,  FILE *fp ) { 
+  chillindent(indent, fp);
+  fprintf(fp, "(if ");
+  fprintf(fp, "\n");
+
+  cond->dump(indent+1, fp); 
+  fprintf(fp, "\n");
+
+  thenpart->dump(indent+1, fp); 
+  fprintf(fp, "\n"); 
+
+  if (elsepart) { 
+    elsepart->dump(indent+1, fp); 
+    fprintf(fp, "\n");
+  }
+  chillindent(indent, fp);
+  fprintf(fp, ")\n");
+}
+
+
+
+void chillAST_IfStmt::print(int indent, FILE *fp ) { 
+  printPreprocBEFORE(indent, fp); 
+  chillindent(indent, fp);
+  fprintf(fp, "if ("); 
+  if (cond) cond->print(0, fp);
+  else fprintf(fp, "(NULL cond)"); 
+
+  bool needbracket = true; 
+  if (thenpart) { 
+    if (thenpart->isBinaryOperator()) needbracket = false;
+    if (thenpart->isCompoundStmt()) { // almost always true
+      chillAST_CompoundStmt *CS = (chillAST_CompoundStmt*) thenpart;
+      if (CS->children.size() == 1  && CS->children[0]->isBinaryOperator()) needbracket = false;
+    }    
+    
+    if(needbracket)  fprintf(fp, ") {\n"); 
+    else fprintf(fp, ")\n"); 
+    
+    thenpart->print(indent+1, fp); // end of line 
+  
+    if(needbracket)  {
+      //fprintf(fp, "\n"); 
+      chillindent(indent, fp);
+      fprintf(fp, "}\n"); 
+    }
+  }
+  else fprintf(fp, "(NULL thenpart)");
+
+  
+  needbracket = true;
+  if (elsepart) { 
+    if (elsepart->isBinaryOperator()) needbracket = false;
+    if (elsepart->isCompoundStmt()) { // almost always true
+      chillAST_CompoundStmt *CS = (chillAST_CompoundStmt*) elsepart;
+      
+      if (CS->children.size() == 1  && CS->children[0]->isBinaryOperator()) needbracket = false;
+      
+    }    
+    
+    fprintf(fp, "\n"); 
+    chillindent(indent, fp);
+    
+    if (needbracket) fprintf(fp, "else {\n"); 
+    else fprintf(fp, "else\n"); 
+    
+    elsepart->print(indent+1, fp);
+    
+    if(needbracket)  {
+      fprintf(fp, "\n"); 
+      chillindent(indent, fp);
+      fprintf(fp, "}\n"); 
+    }
+  }
+  //else fprintf(fp, "else { /* NOTHING */ }"); 
+}
+
+
+ 
+bool chillAST_IfStmt::findLoopIndexesToReplace(  chillAST_SymbolTable *symtab, bool forcesync ) { 
+  thenpart->findLoopIndexesToReplace( symtab ); 
+  elsepart->findLoopIndexesToReplace( symtab ); 
+  return false; // ?? 
+}
+
+  
+
+chillAST_node *lessthanmacro( chillAST_node *left, chillAST_node *right) { 
+
+  chillAST_ParenExpr *lp1 = new chillAST_ParenExpr( left  );
+  chillAST_ParenExpr *rp1 = new chillAST_ParenExpr( right );
+  chillAST_BinaryOperator *cond = new chillAST_BinaryOperator( lp1, "<", rp1 );
+
+  chillAST_ParenExpr *lp2 = new chillAST_ParenExpr( left  );
+  chillAST_ParenExpr *rp2 = new chillAST_ParenExpr( right );
+  
+  chillAST_TernaryOperator *t = new chillAST_TernaryOperator("?", cond, lp2, rp2);
+  
+  return t; 
+} 
+
+
+
+
+// look for function declaration with a given name, in the tree with root "node"
+void findFunctionDeclRecursive( chillAST_node *node, const char *procname, vector<chillAST_FunctionDecl*>& funcs )
+{
+  //fprintf(stderr, "findmanually()                CHILL AST node of type %s\n", node->getTypeString()); 
+  
+  if (node->isFunctionDecl()) { 
+    char *name = ((chillAST_FunctionDecl *) node)->functionName; // compare name with desired name
+    //fprintf(stderr, "node name 0x%x  ", name);
+    //fprintf(stderr, "%s     procname ", name); 
+    //fprintf(stderr, "0x%x  ", procname);
+    //fprintf(stderr, "%s\n", procname); 
+    if (!strcmp( name, procname)) {
+      //fprintf(stderr, "found procedure %s\n", procname ); 
+      funcs.push_back( (chillAST_FunctionDecl*) node );  // this is it 
+      // quit recursing. probably not correct in some horrible case
+      return; 
+    }
+    //else fprintf(stderr, "this is not the function we're looking for\n"); 
+  }
+
+
+  // this is where the children can be used effectively. 
+  // we don't really care what kind of node we're at. We just check the node itself
+  // and then its children is needed. 
+
+  int numc = node->children.size();  
+  fprintf(stderr, "(top)node has %d children\n", numc);
+
+  for (int i=0; i<numc; i++) {
+    if (node->isSourceFile()) { 
+      fprintf(stderr, "node of type %s is recursing to child %d of type %s\n",  node->getTypeString(), i,  node->children[i]->getTypeString()); 
+      if (node->children[i]->isFunctionDecl()) { 
+        chillAST_FunctionDecl *fd = (chillAST_FunctionDecl*) node->children[i];
+        fprintf(stderr, "child %d is functiondecl %s\n", i, fd->functionName); 
+      }
+    }
+    findFunctionDeclRecursive( node->children[i], procname, funcs );
+    
+  }
+  return; 
+}
+
+
+chillAST_FunctionDecl *findFunctionDecl( chillAST_node *node, const char *procname)
+{
+  vector<chillAST_FunctionDecl*> functions;
+  findFunctionDeclRecursive( node, procname, functions );  
+
+  if ( functions.size() == 0 ) { 
+    fprintf(stderr, "could not find function named '%s'\n", procname);
+    exit(-1);
+  }
+  
+  if ( functions.size() > 1 ) { 
+    fprintf(stderr, "oddly, found %d functions named '%s'\n", functions.size(), procname);
+    fprintf(stderr, "I am unsure what to do\n"); 
+
+    for (int f = 0; f < functions.size(); f++) { 
+      fprintf(stderr, "function %d  %p   %s\n", f, functions[f], functions[f]->functionName); 
+    }
+    exit(-1);
+  }
+  
+  //fprintf(stderr, "found the procedure named %s\n", procname); 
+  return functions[0];
+}
+
+
+chillAST_SymbolTable *addSymbolToTable(  chillAST_SymbolTable *st, chillAST_VarDecl *vd ) // definition
+{
+  chillAST_SymbolTable *s = st;
+  if (!s) s = new chillAST_SymbolTable; 
+ 
+  int tablesize = s->size();
+  
+  for (int i=0; i<tablesize; i++) { 
+    if ((*s)[i] == vd) { 
+      //fprintf(stderr, "the exact same symbol, not just the same name, was already there\n"); 
+      return s; // already there 
+    }
+  }
+
+  for (int i=0; i<tablesize; i++) { 
+    //fprintf(stderr, "name %s vs name %s\n", (*s)[i]->varname, vd->varname); 
+    if (!strcmp( (*s)[i]->varname, vd->varname)) { 
+      //fprintf(stderr, "symbol with the same name was already there\n"); 
+      return s; // already there 
+    }
+  }
+
+  //fprintf(stderr, "adding %s %s to a symbol table that didn't already have it\n", vd->vartype, vd->varname); 
+
+  //printf("before:\n"); 
+  //printSymbolTable( s ); fflush(stdout); 
+
+  s->push_back(vd); // add it 
+
+  //printf("after:\n"); 
+  //printSymbolTable( s ); fflush(stdout); 
+  return s;
+}
+
+
+chillAST_TypedefTable *addTypedefToTable(  chillAST_TypedefTable *tdt, chillAST_TypedefDecl *td )
+{
+
+  chillAST_TypedefTable *t = tdt;
+  if (!t) t = new chillAST_TypedefTable;
+
+  int tablesize = t->size();
+  
+  for (int i=0; i<tablesize; i++) {
+    if ((*t)[i] == td) return t; // already there 
+  }
+  t->push_back(td); // add it 
+  return t;
+}
+
+
+chillAST_NoOp::chillAST_NoOp( chillAST_node *p ) { 
+  parent = p;   
+  isFromSourceFile = true; // default 
+  filename = NULL;
+}; // so we have SOMETHING for NoOp in the cc file ???
+
+
+chillAST_Preprocessing::chillAST_Preprocessing() { 
+  position = CHILL_PREPROCESSING_POSITIONUNKNOWN;
+  pptype   = CHILL_PREPROCESSING_TYPEUNKNOWN;
+  blurb = strdup("");  // never use null. ignore the leak ??
+}
+
+
+ chillAST_Preprocessing::chillAST_Preprocessing(CHILL_PREPROCESSING_POSITION pos, 
+                                                CHILL_PREPROCESSING_TYPE t, 
+                                                char *text )
+ {
+   position = pos;
+   pptype = t;
+   blurb = strdup( text ); 
+ }
+  
+void chillAST_Preprocessing::print( int indent, FILE *fp ) {  // probably very wrong
+   if (position == CHILL_PREPROCESSING_LINEAFTER ) {
+     fprintf(fp, "\n");
+     chillindent(indent, fp);
+   }
+   if (position ==  CHILL_PREPROCESSING_LINEBEFORE) {  // ???
+     //fprintf(fp, "\n");
+     chillindent(indent, fp);
+   }
+   
+   fprintf(fp, "%s", blurb); 
+
+   if (position ==  CHILL_PREPROCESSING_TOTHERIGHT) {
+      fprintf(fp, "\n");
+   }
+
+
+   if (position ==  CHILL_PREPROCESSING_LINEBEFORE) {
+     //fprintf(fp, "\n"); // comment seems to have \n at the end already
+     //chillindent(indent, fp);
+   }
+
+
+   //if (pptype != CHILL_PREPROCESSING_IMMEDIATELYBEFORE && pptype != CHILL_PREPROCESSING_UNKNOWN) fprint(fp, "\n");
+       
+ }
diff --git a/src/chillmodule.cc b/src/chillmodule.cc
index b347570..291cb51 100644
--- a/src/chillmodule.cc
+++ b/src/chillmodule.cc
@@ -10,7 +10,6 @@
 #include <omega.h>
 #include "loop.hh"
 #include "ir_code.hh"
-#include "ir_rose.hh"
 
 #include "chillmodule.hh"
 
@@ -81,11 +80,6 @@ static void init_loop(int loop_num_start, int loop_num_end) {
   }
   else {
     if (ir_code == NULL) {
-      if (procedure_name.empty())
-        procedure_name = "main";
-        
-      ir_code = new IR_roseCode(source_filename.c_str(), procedure_name.c_str());
-          
       IR_Block *block = ir_code->GetCode();
       ir_controls = ir_code->FindOneLevelControlStructure(block);
       for (int i = 0; i < ir_controls.size(); i++) {
diff --git a/src/dep.cc b/src/dep.cc
index 39f2d17..e47d7aa 100644
--- a/src/dep.cc
+++ b/src/dep.cc
@@ -37,15 +37,22 @@ std::ostream& operator<<(std::ostream &os, const DependenceVector &d) {
   
   switch (d.type) {
   case DEP_W2R:
-    os << "true";
+    os << "flow";
+    // Check for reduction implemetation correctness
     if (d.is_reduction)
       os << "_reduction";
     break;
   case DEP_R2W:
     os << "anti";
+    // TODO: Remove Check for reduction implemetation correctness
+    if (d.is_reduction)
+      os << "_reduction";
     break;
   case DEP_W2W:
     os << "output";
+    // TODO: Remove Check for reduction implemetation correctness
+    if (d.is_reduction)
+      os << "_reduction";
     break;
   case DEP_R2R:
     os << "input";
@@ -94,6 +101,13 @@ std::ostream& operator<<(std::ostream &os, const DependenceVector &d) {
   return os;
 }
 
+// DependenceVector::DependenceVector(int size):
+//   lbounds(std::vector<coef_t>(size, 0)),
+//   ubounds(std::vector<coef_t>(size, 0)) {
+//   src = NULL;
+//   dst = NULL;
+// }
+
 DependenceVector::DependenceVector(const DependenceVector &that) {
   if (that.sym != NULL)
     this->sym = that.sym->clone();
@@ -105,6 +119,7 @@ DependenceVector::DependenceVector(const DependenceVector &that) {
   quasi = that.quasi;
   is_scalar_dependence = that.is_scalar_dependence;
   is_reduction = that.is_reduction;
+  is_reduction_cand = that.is_reduction_cand; // Manu
 }
 
 DependenceVector &DependenceVector::operator=(const DependenceVector &that) {
@@ -120,6 +135,7 @@ DependenceVector &DependenceVector::operator=(const DependenceVector &that) {
     quasi = that.quasi;
     is_scalar_dependence = that.is_scalar_dependence;
     is_reduction = that.is_reduction;
+    is_reduction_cand = that.is_reduction_cand;
   }
   return *this;
 }
@@ -128,12 +144,18 @@ DependenceType DependenceVector::getType() const {
 }
 
 bool DependenceVector::is_data_dependence() const {
-  return (type == DEP_W2R || type == DEP_R2W || type == DEP_W2W
-      || type == DEP_R2R);
+  if (type == DEP_W2R || type == DEP_R2W || type == DEP_W2W
+      || type == DEP_R2R)
+    return true;
+  else
+    return false;
 }
 
 bool DependenceVector::is_control_dependence() const {
-  return type == DEP_CONTROL;
+  if (type == DEP_CONTROL)
+    return true;
+  else
+    return false;
 }
 
 bool DependenceVector::has_negative_been_carried_at(int dim) const {
@@ -147,7 +169,10 @@ bool DependenceVector::has_negative_been_carried_at(int dim) const {
     if (lbounds[i] > 0 || ubounds[i] < 0)
       return false;
   
-  return lbounds[dim] < 0;
+  if (lbounds[dim] < 0)
+    return true;
+  else
+    return false;
 }
 
 
@@ -162,7 +187,10 @@ bool DependenceVector::has_been_carried_at(int dim) const {
     if (lbounds[i] > 0 || ubounds[i] < 0)
       return false;
   
-  return (lbounds[dim] != 0)  || (ubounds[dim] !=0);
+  if ((lbounds[dim] != 0)  || (ubounds[dim] !=0))
+    return true;
+  
+  return false;
 }
 
 bool DependenceVector::has_been_carried_before(int dim) const {
@@ -243,14 +271,22 @@ bool DependenceVector::hasPositive(int dim) const {
   if (dim >= lbounds.size())
     throw std::invalid_argument("invalid dependence dimension");
   
-  return lbounds[dim] > 0;
+  if (lbounds[dim] > 0)
+    //av: changed from ubounds to lbounds may have side effects
+    return true;
+  else
+    return false;
 }
 
 bool DependenceVector::hasNegative(int dim) const {
   if (dim >= lbounds.size())
     throw std::invalid_argument("invalid dependence dimension");
   
-  return ubounds[dim] < 0;
+  if (ubounds[dim] < 0)
+    //av: changed from lbounds to ubounds may have side effects
+    return true;
+  else
+    return false;
 }
 
 bool DependenceVector::isCarried(int dim, omega::coef_t distance) const {
@@ -269,13 +305,18 @@ bool DependenceVector::isCarried(int dim, omega::coef_t distance) const {
   if (dim >= lbounds.size())
     return true;
   
-  return lbounds[dim] >= -distance && ubounds[dim] <= distance;
+  if (lbounds[dim] > distance)
+    return false;
+  else if (ubounds[dim] < -distance)
+    return false;
+  
+  return true;
 }
 
 bool DependenceVector::canPermute(const std::vector<int> &pi) const {
   if (pi.size() != lbounds.size())
     throw std::invalid_argument(
-      "permute dimensionality do not match dependence space");
+                                "permute dimensionality do not match dependence space");
   
   for (int i = 0; i < pi.size(); i++) {
     if (lbounds[pi[i]] > 0)
@@ -316,10 +357,10 @@ std::vector<DependenceVector> DependenceVector::normalize() const {
 }
 
 std::vector<DependenceVector> DependenceVector::permute(
-  const std::vector<int> &pi) const {
+                                                        const std::vector<int> &pi) const {
   if (pi.size() != lbounds.size())
     throw std::invalid_argument(
-      "permute dimensionality do not match dependence space");
+                                "permute dimensionality do not match dependence space");
   
   const int n = lbounds.size();
   
@@ -370,6 +411,60 @@ DependenceVector DependenceVector::reverse() const {
   return dv;
 }
 
+// std::vector<DependenceVector> DependenceVector::matrix(const std::vector<std::vector<int> > &M) const {
+//   if (M.size() != lbounds.size())
+//     throw std::invalid_argument("(non)unimodular transformation dimensionality does not match dependence space");
+
+//   const int n = lbounds.size();
+//   DependenceVector dv;
+//   if (sym != NULL)
+//     dv.sym = sym->clone();
+//   else
+//     dv.sym = NULL;
+//   dv.type = type;
+
+//   for (int i = 0; i < n; i++) {
+//     assert(M[i].size() == n+1 || M[i].size() == n);
+
+//     omega::coef_t lb, ub;
+//     if (M[i].size() == n+1)
+//       lb = ub = M[i][n];
+//     else
+//       lb = ub = 0;
+
+//     for (int j = 0; j < n; j++) {
+//       int c = M[i][j];
+//       if (c == 0)
+//         continue;
+
+//       if (c > 0) {
+//         if (lbounds[j] == -posInfinity)
+//           lb = -posInfinity;
+//         else if (lb != -posInfinity)
+//           lb += c * lbounds[j];
+//         if (ubounds[j] == posInfinity)
+//           ub = posInfinity;
+//         else if (ub != posInfinity)
+//           ub += c * ubounds[j];
+//       }
+//       else {
+//         if (ubounds[j] == posInfinity)
+//           lb = -posInfinity;
+//         else if (lb != -posInfinity)
+//           lb += c * ubounds[j];
+//         if (lbounds[j] == -posInfinity)
+//           ub = posInfinity;
+//         else if (ub != posInfinity)
+//           ub += c * lbounds[j];
+//       }
+//     }
+//     dv.lbounds.push_back(lb);
+//     dv.ubounds.push_back(ub);
+//   }
+//   dv.is_reduction = is_reduction;
+
+//   return dv.normalize();
+// }
 
 //-----------------------------------------------------------------------------
 // Class: DependenceGraph
@@ -411,6 +506,20 @@ DependenceGraph DependenceGraph::permute(const std::vector<int> &pi,
   return g;
 }
 
+// DependenceGraph DependenceGraph::matrix(const std::vector<std::vector<int> > &M) const {
+//   DependenceGraph g;
+
+//   for (int i = 0; i < vertex.size(); i++)
+//     g.insert(vertex[i].first);
+
+//   for (int i = 0; i < vertex.size(); i++)
+//     for (EdgeList::const_iterator j = vertex[i].second.begin(); j != vertex[i].second.end(); j++)
+//       for (int k = 0; k < j->second.size(); k++)
+//         g.connect(i, j->first, j->second[k].matrix(M));
+
+//   return g;
+// }
+
 DependenceGraph DependenceGraph::subspace(int dim) const {
   DependenceGraph g;
   
diff --git a/src/ir_clang.cc b/src/ir_clang.cc
new file mode 100755
index 0000000..ba11ac5
--- /dev/null
+++ b/src/ir_clang.cc
@@ -0,0 +1,3239 @@
+
+
+/*****************************************************************************
+  Copyright (C) 2009-2010 University of Utah
+  All Rights Reserved.
+
+Purpose:
+CHiLL's CLANG interface.
+convert from CLANG AST to chill AST
+
+Notes:
+Array supports mixed pointer and array type in a single declaration.
+
+History:
+12/10/2010 LLVM/CLANG Interface created by Saurav Muralidharan.
+ *****************************************************************************/
+
+#include <typeinfo>
+#include <sstream>
+#include "ir_clang.hh"
+#include "loop.hh"
+#include "chill_error.hh"
+
+#define DUMPFUNC(x, y) std::cerr << "In function " << x << "\n"; y->dump(); 
+
+#include "clang/Frontend/FrontendActions.h"
+#include <clang/CodeGen/CodeGenAction.h>
+#include <clang/Frontend/CompilerInstance.h>
+#include <clang/Frontend/CompilerInvocation.h>
+#include <clang/Basic/DiagnosticOptions.h>
+#include <clang/Frontend/TextDiagnosticPrinter.h>
+#include <clang/AST/ASTContext.h>
+#include <clang/AST/RecordLayout.h>
+#include <clang/AST/Decl.h>
+#include <clang/Parse/ParseAST.h>
+#include <clang/Basic/TargetInfo.h>
+
+#include <llvm/ADT/IntrusiveRefCntPtr.h>
+#include <llvm/Support/Host.h>
+
+#include "code_gen/CG_chillRepr.h"
+#include "code_gen/CG_chillBuilder.h"
+#include <vector>
+
+#include "chill_ast.hh"
+
+// TODO move to ir_clang.hh
+// fwd declarations 
+chillAST_node * ConvertVarDecl( clang::VarDecl *D, chillAST_node * );
+chillAST_node * ConvertTypeDefDecl( clang::TypedefDecl *TDD, chillAST_node * );
+chillAST_node * ConvertRecordDecl( clang::RecordDecl *D, chillAST_node * );
+chillAST_node * ConvertDeclStmt( clang::DeclStmt *clangDS, chillAST_node * );
+chillAST_node * ConvertCompoundStmt( clang::CompoundStmt *clangCS, chillAST_node * );
+chillAST_node * ConvertFunctionDecl( clang::FunctionDecl *D , chillAST_node *);
+chillAST_node * ConvertForStmt( clang::ForStmt *clangFS, chillAST_node * );
+chillAST_node * ConvertUnaryOperator( clang::UnaryOperator * clangU, chillAST_node *O ); 
+chillAST_node * ConvertBinaryOperator( clang::BinaryOperator * clangBO, chillAST_node *B );
+chillAST_node * ConvertArraySubscriptExpr( clang::ArraySubscriptExpr *clangASE, chillAST_node * ); 
+chillAST_node * ConvertDeclRefExpr( clang::DeclRefExpr * clangDRE, chillAST_node * );
+chillAST_node * ConvertIntegerLiteral( clang::IntegerLiteral *clangIL, chillAST_node * );
+chillAST_node * ConvertFloatingLiteral( clang::FloatingLiteral *clangFL, chillAST_node * );
+chillAST_node * ConvertImplicitCastExpr( clang::ImplicitCastExpr *clangICE, chillAST_node * );
+chillAST_node * ConvertCStyleCastExpr( clang::CStyleCastExpr *clangICE, chillAST_node * );
+chillAST_node * ConvertReturnStmt( clang::ReturnStmt *clangRS, chillAST_node * );
+chillAST_node * ConvertCallExpr( clang::CallExpr *clangCE , chillAST_node *);
+chillAST_node * ConvertIfStmt( clang::IfStmt *clangIS , chillAST_node *);
+chillAST_node * ConvertMemberExpr( clang::MemberExpr *clangME , chillAST_node *);
+
+
+chillAST_node * ConvertTranslationUnit(  clang::TranslationUnitDecl *TUD, char *filename );
+chillAST_node * ConvertGenericClangAST( clang::Stmt *s, chillAST_node *  );
+
+
+std::vector<chillAST_VarDecl *> VariableDeclarations;
+std::vector<chillAST_FunctionDecl *> FunctionDeclarations;
+
+using namespace clang;
+using namespace clang::driver;
+using namespace omega;
+using namespace std;
+
+
+static string binops[] = {
+  " ", " ",             // BO_PtrMemD, BO_PtrMemI,       // [C++ 5.5] Pointer-to-member operators.
+  "*", "/", "%",        // BO_Mul, BO_Div, BO_Rem,       // [C99 6.5.5] Multiplicative operators.
+  "+", "-",             // BO_Add, BO_Sub,               // [C99 6.5.6] Additive operators.
+  "<<", ">>",           // BO_Shl, BO_Shr,               // [C99 6.5.7] Bitwise shift operators.
+  "<", ">", "<=", ">=", // BO_LT, BO_GT, BO_LE, BO_GE,   // [C99 6.5.8] Relational operators.
+  "==", "!=",           // BO_EQ, BO_NE,                 // [C99 6.5.9] Equality operators.
+  "&",                  // BO_And,                       // [C99 6.5.10] Bitwise AND operator.
+  "??",                 // BO_Xor,                       // [C99 6.5.11] Bitwise XOR operator.
+  "|",                  // BO_Or,                        // [C99 6.5.12] Bitwise OR operator.
+  "&&",                 // BO_LAnd,                      // [C99 6.5.13] Logical AND operator.
+  "||",                 // BO_LOr,                       // [C99 6.5.14] Logical OR operator.
+  "=", "*=",            // BO_Assign, BO_MulAssign,      // [C99 6.5.16] Assignment operators.
+  "/=", "%=",           // BO_DivAssign, BO_RemAssign,
+  "+=", "-=",           // BO_AddAssign, BO_SubAssign,
+  "???", "???",         // BO_ShlAssign, BO_ShrAssign,
+  "&&=", "???",         // BO_AndAssign, BO_XorAssign,
+  "||=",                // BO_OrAssign,
+  ","};                 // BO_Comma                      // [C99 6.5.17] Comma operator.
+
+
+static string unops[] = {
+  "++", "--",           // [C99 6.5.2.4] Postfix increment and decrement
+  "++", "--",           // [C99 6.5.3.1] Prefix increment and decrement
+  "@",  "*",            // [C99 6.5.3.2] Address and indirection
+  "+", "-",             // [C99 6.5.3.3] Unary arithmetic
+  "~", "!",             // [C99 6.5.3.3] Unary arithmetic
+  "__real", "__imag",   // "__real expr"/"__imag expr" Extension.
+  "__extension"          // __extension__ marker.
+};
+
+// forward defs
+SourceManager * globalSRCMAN;  // ugly. shame. 
+
+char *splitTypeInfo( char *underlyingtype );
+void printsourceline( const char *filename, int line  );
+void printlines(  SourceLocation &S, SourceLocation &E, SourceManager *SRCMAN );
+
+void PrintBinaryOperator(  Stmt *s,         SourceManager *SRCMAN, int level );
+void PrintDeclStmt(        Stmt *s,         SourceManager *SRCMAN, int level );
+void PrintALoop(            Stmt *L,        SourceManager *SRCMAN, int level );
+void PrintAUnaryOperator(   Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintAnIfStmt(         Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintCompoundStmt(     Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintDeclRefExpr(      Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintImplicitCastExpr( Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintReturnStmt(       Stmt *s,        SourceManager *SRCMAN, int level );
+void PrintStmt(             Stmt *s,        SourceManager *SRCMAN, int level );
+
+void PrintAnIntegerLiteral( Stmt *I );
+void PrintAFloatingLiteral( Stmt *s );
+
+void PrintFunctionDecl( FunctionDecl *D, SourceManager *SRCMAN, int level );
+void PrintTypeDefDecl(  TypedefDecl *D,  SourceManager *SRCMAN, int level );
+void PrintVarDecl(      VarDecl *D,      SourceManager *SRCMAN, int level );
+
+
+
+
+
+void printlines(  SourceLocation &S, SourceLocation &E, SourceManager *SRCMAN ) {
+  unsigned int startlineno = SRCMAN->getPresumedLineNumber( S );
+  unsigned int   endlineno = SRCMAN->getPresumedLineNumber( E );
+  const char     *filename = SRCMAN->getBufferName( S );
+  fprintf(stderr, "\n");
+  for (int l=startlineno; l<= endlineno; l++) printsourceline( filename, l);
+}
+
+
+void Indent( int level ) {
+  for (int i=0; i<level; i++) fprintf(stderr, "    ");
+}
+
+
+// really slow and bad. but I'm debugging
+void printsourceline( const char *filename, int line  )
+{
+  FILE *fp = fopen (filename, "r");
+
+  // Now read lines up to and including the line we want.
+  char buf[10240];
+  int l = 0;
+  while (l < line) {
+    if (fgets (buf, sizeof(buf), fp))
+      ++l;
+    else
+      break;
+  }
+  fclose(fp);
+
+  fprintf(stderr, "*  %s", buf);
+}
+
+
+
+void PrintBinaryOperator( Stmt *s, SourceManager *SRCMAN, int level ) {  // SOMETIMES SHOULD HAVE ; + return
+  //rintf(stderr, "\nBinaryOperator(%d) ", level); 
+  BinaryOperator *b = cast<BinaryOperator>(s);
+
+  BinaryOperator::Opcode op = b->getOpcode();
+  Expr *lhs = b->getLHS();
+  Expr *rhs = b->getRHS();
+
+  //fprintf(stderr, "binaryoperator lhs has type %s\n",   lhs->getStmtClassName());
+  //fprintf(stderr, "binaryoperator rhs has type %s\n\n", rhs->getStmtClassName()); 
+
+  PrintStmt( lhs, SRCMAN, level+1 );
+  fprintf(stderr, " %s ",  binops[op].c_str());
+  PrintStmt( rhs, SRCMAN, level+1);
+  if (level == 1) fprintf(stderr, ";\n");
+}
+
+
+
+void PrintDeclStmt( Stmt *s, SourceManager *SRCMAN, int level ) {
+  fprintf(stderr, "\nDeclaration Statement(%d)", level); 
+  DeclStmt *D = cast<DeclStmt>(s);
+
+      //QualType QT = D->getType();
+      //string TypeStr = QT.getAsString();
+      //fprintf(stderr, "type %s\n", TypeStr,c_str()); 
+
+      //SourceLocation S = D->getStartLoc();
+      //SourceLocation E = D->getEndLoc();
+      //printlines(S, E, SRCMAN); 
+
+      if (D->isSingleDecl()) {
+        fprintf(stderr, "this is a single definition\n");
+        Decl *d = D->getSingleDecl();
+      }
+      else {
+        fprintf(stderr, "this is NOT a single definition\n");
+        DeclGroupRef dg = D->getDeclGroup();
+      }
+
+      for (DeclStmt::decl_iterator DI = D->decl_begin(), DE = D->decl_end(); DI != DE; ++DI) {
+        //fprintf(stderr, "a def\n"); 
+        Decl *d = *DI;
+        //fprintf(stderr, "\nstatement of type %s\n", d->getStmtClassName()); 
+        //std::cout << (void *) d << "?";
+        if (ValueDecl *VD = dyn_cast<ValueDecl>(d)) {
+          if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
+            if (V->getStorageClass() != SC_None) {
+              fprintf(stderr, "%s ", VarDecl::getStorageClassSpecifierString(V->getStorageClass()));
+            }
+            // else fprintf(stderr, "no storage class? "); 
+
+            QualType T = V->getType();
+            string TypeStr = T.getAsString();
+            std::string Name = VD->getNameAsString();
+            //VD->getType().getAsStringInternal(Name,
+            //                                  PrintingPolicy(VD->getASTContext().getLangOpts()));
+            fprintf(stderr,"%s %s ", TypeStr.c_str(), Name.c_str());
+            // If this is a vardecl with an initializer, emit it.
+            if (Expr *E = V->getInit()) {
+              fprintf(stderr, " = ");
+
+              Stmt *s = dyn_cast<Stmt>(E);
+              PrintStmt(s, SRCMAN, level+1);
+              //fprintf(stderr, ";\n"); 
+
+            }
+
+          }
+
+        }
+        if (level <= 1) fprintf(stderr, ";\n");           // TODO wrong
+
+      } // for each actual declaration 
+}
+
+
+
+
+
+
+void PrintAFloatingLiteral( Stmt *s ) {
+  FloatingLiteral *F = dyn_cast<FloatingLiteral>(s);
+  fprintf(stderr, "%f", F->getValueAsApproximateDouble()); // TODO approximate? 
+}
+
+
+
+
+void PrintALoop( Stmt *L, SourceManager *SRCMAN, int level ) {
+  //fprintf(stderr, "\nA LOOP L=0x%x  SRCMAN 0x%x", L, &SRCMAN); 
+  ForStmt *ForStatement = cast<ForStmt>(L);
+
+  SourceLocation srcloc = ForStatement->getForLoc();
+  unsigned int lineno   = SRCMAN->getPresumedLineNumber( srcloc );
+  const char *filename  = SRCMAN->getBufferName( srcloc );
+  //fprintf(stderr, " in file %s  at line %d   ", filename, lineno); 
+  //printsourceline( filename, lineno); 
+
+  Stmt *init = ForStatement->getInit();
+  Expr *cond = ForStatement->getCond();
+  Expr *incr = ForStatement->getInc();
+  Stmt *body = ForStatement->getBody();
+
+  fprintf(stderr, "for (");
+  PrintStmt(init, SRCMAN, 0);
+  fprintf(stderr, "; ");
+  PrintStmt(cond, SRCMAN, 0);
+  fprintf(stderr, "; ");
+  PrintStmt(incr, SRCMAN, 0);
+  fprintf(stderr, " )\n");
+  Indent(level); 
+  fprintf(stderr, "{\n");
+  PrintStmt(body, SRCMAN, level+1);
+  fprintf(stderr, "}\n\n");
+
+}
+
+
+void PrintAUnaryOperator( Stmt *s, SourceManager *SRCMAN, int level ) {
+  //fprintf(stderr, "UnaryOperator  "); 
+  UnaryOperator *u = cast<UnaryOperator>(s);
+
+  const char *op = unops[u->getOpcode()].c_str();
+
+  if (u->isPrefix()) {
+    fprintf(stderr, "%s", op );
+  }
+
+  PrintStmt( u->getSubExpr(), SRCMAN, level+1 );
+
+  if (u->isPostfix()) {
+    fprintf(stderr, "%s", op );
+  }
+}
+
+
+
+void PrintAnIfStmt( Stmt *s, SourceManager *SRCMAN, int level ) {
+  //fprintf(stderr, "an IF statement\n"); 
+  //    SourceLocation S = s->getLocStart();
+  //    SourceLocation E = s->getLocEnd();
+  //    printlines( S, E, SRCMAN);
+
+  IfStmt *IfStatement = cast<IfStmt>(s);
+
+  Stmt *Cond = IfStatement->getCond();
+  Stmt *Then = IfStatement->getThen();
+  Stmt *Else = IfStatement->getElse();
+
+  fprintf(stderr, "if (");
+  PrintStmt(Cond, SRCMAN, level+1);
+  fprintf(stderr, ") {\n");
+  PrintStmt(Then, SRCMAN, level+1);
+  fprintf(stderr, "\n}\nelse\n{\n");
+  PrintStmt(Else, SRCMAN, level+1);
+  fprintf(stderr, "\n}\n\n");
+}
+
+
+
+void PrintAnIntegerLiteral(   Stmt *s ) {
+  IntegerLiteral *I = dyn_cast<IntegerLiteral>(s);
+  bool isSigned = I->getType()->isSignedIntegerType();
+  fprintf(stderr, "%s", I->getValue().toString(10, isSigned).c_str());
+}
+
+
+
+void PrintArraySubscriptExpr( Stmt *s,  SourceManager *SRCMAN, int level ) {
+  ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(s);
+
+  Expr *Base = ASE->getBase();
+  Expr *Index = ASE->getIdx();
+
+  PrintStmt(Base, SRCMAN, level+1);
+  fprintf(stderr, "[");
+  PrintStmt(Index, SRCMAN, level+1);
+  fprintf(stderr, "]");
+}
+
+
+void PrintCompoundStmt(  Stmt *s, SourceManager *SRCMAN, int level ) {
+  //fprintf(stderr, "\nCompoundStmt(%d)", level);
+  CompoundStmt *cs = dyn_cast<CompoundStmt>(s);
+    int numchildren=cs->size();
+    //fprintf(stderr, "CompoundStmt has %d children\n", numchildren);
+
+
+#ifdef DEBUGGING    
+BUH 
+    for (Stmt::child_range I = cs->children(); I; ++I) {
+      const char *classname =  I->getStmtClassName();
+      if (!strcmp(classname, "BinaryOperator")) {
+        BinaryOperator *b = cast<BinaryOperator>(*I);
+        BinaryOperator::Opcode op = b->getOpcode();
+        if (op == BO_Assign)  {
+          fprintf(stderr, "compound statement has child of type ASSIGNMENT STATEMENT  ");
+          SourceLocation S = I->getLocStart();
+          SourceLocation E = I->getLocEnd();
+          unsigned int startlineno = SRCMAN->getPresumedLineNumber( S );
+          unsigned int   endlineno = SRCMAN->getPresumedLineNumber( E );
+          fprintf(stderr, "(%d-%d)\n", startlineno, endlineno ); 
+        }
+        else
+          fprintf(stderr, "compound statement has child of type %s\n", I->getStmtClassName());
+      }
+      else
+        fprintf(stderr, "compound statement has child of type %s\n", I->getStmtClassName());
+    }
+#endif   // debugging 
+
+
+
+    for (auto I = cs->child_begin(); I!=cs->child_end(); ++I) {
+      Stmt *child = *I;
+      PrintStmt( child, SRCMAN, level   );   // NOTE not level + 1
+      
+      fprintf(stderr, "\n"); // ***\n\n"); 
+    }
+    
+}
+
+
+
+
+void PrintDeclRefExpr( Stmt *s,  SourceManager *SRCMAN, int level ) {
+  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(s);
+
+  //if (NestedNameSpecifier *Qualifier = DRE->getQualifier())
+  //  Qualifier->print( raw_ostream nonstandard of course ); 
+  DeclarationNameInfo DNI = DRE->getNameInfo();
+  DeclarationName DN = DNI.getName();
+  fprintf(stderr, "%s", DN.getAsString().c_str()); 
+
+}
+
+
+
+void PrintFunctionDecl( FunctionDecl *D, SourceManager *SRCMAN, int level ) {
+  //rintf(stderr, "\nFunctionDecl(%d)  %s\n", level,  D->getNameInfo().getAsString().c_str()); 
+  // Type name as string
+  QualType QT = D->getReturnType();
+  string TypeStr = QT.getAsString();
+
+  // Function name
+  DeclarationName DeclName = D->getNameInfo().getName();
+  string FuncName = DeclName.getAsString();
+  //fprintf(stderr, "function %s has type %s ", FuncName.c_str(),  TypeStr.c_str()); 
+
+
+  fprintf(stderr, "\n%s %s(",TypeStr.c_str(), FuncName.c_str());
+
+  int numparams = D->getNumParams();
+  //fprintf(stderr, "and %d parameters\n", numparams);
+  for (int i=0; i<numparams; i++) {
+    if (i) fprintf(stderr, ", ");
+    ParmVarDecl *clangVardecl = D->getParamDecl(i);
+
+    // from  DeclPrinter::VisitVarDecl(VarDecl *D)
+    StorageClass SCAsWritten = clangVardecl->getStorageClass();
+    if (SCAsWritten != SC_None) {
+      fprintf(stderr, "%s ", VarDecl::getStorageClassSpecifierString(SCAsWritten));
+    } 
+    //else fprintf(stderr, "(no storage class?) ");
+
+    QualType T = clangVardecl->getType();
+    if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(clangVardecl))
+      T = Parm->getOriginalType();
+
+    string Name    = clangVardecl->getName();
+    char *td = strdup(T.getAsString().c_str());
+    fprintf(stderr, "td = '%s'\n", td); 
+    char *arraypart = splitTypeInfo(td);
+    fprintf(stderr, "%s %s%s ", td, Name.c_str(), arraypart);
+
+  }
+
+  fprintf(stderr, ")\n{\n"); // beginning of function body 
+
+  Stmt *body = D->getBody();
+  PrintStmt( body, SRCMAN, level+1);
+  fprintf(stderr, "}\n\n");   // end of function body
+}
+
+
+void PrintImplicitCastExpr( Stmt *s,  SourceManager *SRCMAN, int level ) {
+  ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(s);
+  PrintStmt( ICE->getSubExpr(), SRCMAN, level+1);
+}
+
+
+
+void PrintReturnStmt( Stmt *s,  SourceManager *SRCMAN, int level ) {
+  ReturnStmt *r = dyn_cast<ReturnStmt>(s);
+
+  fprintf(stderr, "return");
+  if (r->getRetValue()) {
+    fprintf(stderr, " ");
+    PrintStmt( r->getRetValue(), SRCMAN, level+1);
+  }
+  fprintf(stderr, ";\n");
+}
+
+
+void PrintStmt( Stmt *s,  SourceManager *SRCMAN, int level ) {
+  //fprintf(stderr, "\nprint statement 0x%x of type %s\n", s, s->getStmtClassName()); 
+
+
+  //fprintf(stderr, "*"); 
+  //SourceLocation srcloc = s->getStartLoc();
+  //unsigned int lineno = SRCMAN->getPresumedLineNumber( srcloc ); 
+  //const char *filename = SRCMAN->getBufferName( srcloc );
+
+  //StmtClass getStmtClass() 
+  if (isa<DeclStmt>(s))                  {          PrintDeclStmt(s, SRCMAN, level);
+  } else if (isa<FloatingLiteral>(s))    {  PrintAFloatingLiteral(s               );
+  } else if (isa<IntegerLiteral>(s))     {  PrintAnIntegerLiteral(s               );
+  } else if (isa<UnaryOperator>(s))      {    PrintAUnaryOperator(s, SRCMAN, level);
+  } else if (isa<BinaryOperator>(s))     {   PrintBinaryOperator(s, SRCMAN, level);
+  } else if (isa<ForStmt>(s))            {             PrintALoop(s, SRCMAN, level);
+  } else if (isa<IfStmt>(s))             {          PrintAnIfStmt(s, SRCMAN, level);
+  } else if (isa<CompoundStmt>(s))       {      PrintCompoundStmt(s, SRCMAN, level);
+  } else if (isa<ImplicitCastExpr>(s))   {  PrintImplicitCastExpr(s, SRCMAN, level);
+  } else if (isa<DeclRefExpr>(s))        {       PrintDeclRefExpr(s, SRCMAN, level); 
+  } else if (isa<ArraySubscriptExpr>(s)) {PrintArraySubscriptExpr(s, SRCMAN, level);
+  } else if (isa<ReturnStmt>(s))         {        PrintReturnStmt(s, SRCMAN, level);
+  } else  { 
+    fprintf(stderr, "\nPrintStmt() UNHANDLED statement of type %s\n", s->getStmtClassName());
+    exit(-1); 
+  }
+  //int numchildren=0;
+  //for (Stmt::child_range I = s->children(); I; ++I, numchildren++) ;
+  //if (numchildren) fprintf(stderr, "has %d children\n", numchildren);
+  //if (numchildren) {
+  //  for (Stmt::child_range I = s->children(); I; ++I
+  //}
+}
+
+
+void PrintTranslationUnit(  TranslationUnitDecl *TUD,  ASTContext &CTX ) {
+  // TUD derived from Decl and DeclContext
+  static DeclContext *DC = TUD->castToDeclContext( TUD );
+  //SourceManager  SM =  CTX.getSourceManager();
+
+  for (DeclContext::decl_iterator DI = DC->decls_begin(), DE = DC->decls_end(); DI != DE; ++DI) {
+    Decl *D = *DI;
+
+    if (isa<FunctionDecl>(D))  { //fprintf(stderr, "FunctionDecl\n");
+      PrintFunctionDecl( dyn_cast<FunctionDecl>(D), &CTX.getSourceManager(), 0);
+    }
+    else if (isa<VarDecl>(D)) { //fprintf(stderr, "VarDecl\n"); 
+      PrintVarDecl( dyn_cast<VarDecl>(D), &CTX.getSourceManager(), 0 );
+    }
+    else if (isa<TypedefDecl>(D)) { //fprintf(stderr, "TypedefDecl\n"); 
+      PrintTypeDefDecl( dyn_cast<TypedefDecl>(D), &CTX.getSourceManager(), 0 );
+    }
+    else if (isa<TypeAliasDecl>(D)) { fprintf(stderr, "TypeAliasDecl\n");
+    }
+    else { 
+      fprintf(stderr, "\na declaration of type %s (%d) which I have no idea how to handle\n",   D->getDeclKindName(), D->getKind());
+      exit(-1);
+    }
+      
+    //else if (isa<TypedefNameDecl>(D)) { fprintf(stderr, "TypedefNameDecl\n");}
+  }
+}
+
+
+void PrintTypeDefDecl( TypedefDecl *D, SourceManager *SRCMAN, int level ) {
+
+  /* internal typedefs do not have a source file and this will die!
+  SourceLocation S = D->getLocStart();  // NOT getStartLoc(), that's class DeclStmt
+  SourceLocation E = D->getLocEnd();
+  unsigned int startlineno = SRCMAN->getPresumedLineNumber( S ); 
+  unsigned int   endlineno = SRCMAN->getPresumedLineNumber( E ); 
+  const char *filename = SRCMAN-> etBufferName( S );
+  fprintf(stderr, " in file %s  at lines %d-%d", filename, startlineno, endlineno); 
+  for (int l=startlineno; l<= endlineno; l++) printsourceline( filename, l);
+  */
+
+  // arrays suck
+  char *td =  strdup( D->getUnderlyingType().getAsString().c_str());
+  //fprintf(stderr, "td = '%s'\n", td); 
+  char *arraypart = splitTypeInfo(td);
+  fprintf(stderr, "typedef %s %s%s;\n", td, D->getName().str().c_str(), arraypart);
+
+  free(td);
+  free(arraypart);
+}
+
+
+
+void PrintVarDecl( VarDecl *D, SourceManager *SRCMAN, int level ) {
+  // arrays suck
+  char *td =  strdup( D->getType().getAsString().c_str());  // leak 
+  //fprintf(stderr, "td = '%s'\n", td); 
+  char *arraypart = splitTypeInfo(td);
+  fprintf(stderr, "%s %s%s", td,  D->getName().str().c_str(), arraypart);
+
+  Expr *Init = D->getInit();
+  if (Init) {
+    //fprintf(stderr," = (TODO)");
+    PrintStmt( Init, SRCMAN, level+1);
+  }
+  fprintf(stderr, ";\n");
+
+  free(td);
+  free(arraypart);
+} //PrintVarDecl
+
+
+
+
+
+
+
+
+chillAST_node * ConvertVarDecl( VarDecl *D, chillAST_node *p ) {
+  //fprintf(stderr, "\nConvertVarDecl()\n"); 
+  //fprintf(stderr, "Decl has type %s\n", D->getDeclKindName()); 
+  //PrintVarDecl( D, globalSRCMAN, 0 );
+
+   bool isParm = false; 
+
+   QualType T0 = D->getType();
+   QualType T  = T0;
+   if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) { // My GOD clang stinks
+     T = Parm->getOriginalType();
+     isParm = true;
+   }
+
+  // arrays suck
+  char *vartype =  strdup( T.getAsString().c_str());  
+  //fprintf(stderr, "vartype = '%s'   T0  '%s\n", vartype, T0.getAsString().c_str() ); 
+  char *arraypart = splitTypeInfo(vartype);
+  //fprintf(stderr, "arraypart = '%s'\n", arraypart);
+
+
+  char *varname = strdup(D->getName().str().c_str()); 
+  //fprintf(stderr, "VarDecl (clang 0x%x) for %s %s%s\n", D, vartype,  varname, arraypart);
+  
+  chillAST_VarDecl * chillVD = new chillAST_VarDecl( vartype,  varname, arraypart, (void *)D, p /* , initializer */ );
+
+  chillVD->isAParameter = isParm; 
+  //fprintf(stderr, "\nthis is the vardecl\n"); 
+  //chillVD->print();  printf("\n\n"); fflush(stdout); 
+
+  //clang::QualType qtyp = D->getType(); 
+  //clang::Expr *e = D->getInit();
+  //fprintf(stderr, "e 0x%x\n", e); 
+
+  //if (qtyp->isPointerType()) { 
+  //  fprintf(stderr, "pointer type\n"); 
+  //  clang::QualType ptyp = qtyp->getPointeeType(); 
+  //  fprintf(stderr, "%s\n", ptyp.getAsString().c_str());  
+  //} 
+
+  //if (qtyp->isArrayType()) fprintf(stderr, "Array type\n"); 
+  //if (qtyp->isConstantArrayType()) fprintf(stderr, "constant array type\n"); 
+
+  //const clang::Type *typ = qtyp.getTypePtr(); 
+  //clang::Expr *e = ((clang::VariableArrayType *)typ)->getSizeExpr();
+  //e->dump(); 
+
+
+  int numdim = 0;
+  chillVD-> knownArraySizes = true;
+  if (index(vartype, '*')) chillVD->knownArraySizes = false;  // float *a;   for example
+  if (index(arraypart, '*'))  chillVD->knownArraySizes = false;
+  
+  // note: vartype here, arraypart in next code..    is that right?
+  if (index(vartype, '*')) { 
+    for (int i = 0; i<strlen(vartype); i++) if (vartype[i] == '*') numdim++;
+    //fprintf(stderr, "numd %d\n", numd);
+    chillVD->numdimensions = numdim; 
+  }
+
+  if (index(arraypart, '[')) {  // JUST [12][34][56]  no asterisks
+    char *dupe = strdup(arraypart);
+
+    int len = strlen(arraypart);
+    for (int i=0; i<len; i++) if (dupe[i] == '[') numdim++;
+
+    //fprintf(stderr, "numdim %d\n", numdim);
+
+    chillVD->numdimensions = numdim; 
+    int *as =  (int *)malloc(sizeof(int *) * numdim );
+    if (!as) { 
+      fprintf(stderr, "can't malloc array sizes in ConvertVarDecl()\n");
+      exit(-1);
+    }
+    chillVD->arraysizes = as; // 'as' changed later!
+
+    
+    char *ptr = dupe;
+    //fprintf(stderr, "dupe '%s'\n", ptr);
+    while (ptr = index(ptr, '[')) { 
+      ptr++;
+      //fprintf(stderr, "tmp '%s'\n", ptr);
+      int dim;
+      sscanf(ptr, "%d", &dim);
+      //fprintf(stderr, "dim %d\n", dim);
+      *as++ = dim; 
+      
+      ptr =  index(ptr, ']');
+      //fprintf(stderr, "bottom of loop, ptr = '%s'\n", ptr); 
+    }
+    free(dupe);
+    //for (int i=0; i<numdim; i++) { 
+    //  fprintf(stderr, "dimension %d = %d\n", i,  chillVD->arraysizes[i]); 
+    //} 
+    
+    //fprintf(stderr, "need to handle [] array to determine num dimensions\n");
+    //exit(-1); 
+  }
+  
+  Expr *Init = D->getInit();
+  if (Init) {
+    fprintf(stderr," = VARDECL HAS INIT.  (TODO) (RIGHT NOW)"); exit(-1); 
+  }
+  //fprintf(stderr, ";\n");
+  
+
+  //fprintf(stderr, "calling chillVD->print()\n"); 
+  //chillVD->print();  // debugging only
+
+  free (vartype);
+  free (varname);
+
+  // store this away for declrefexpr that references it! 
+  VariableDeclarations.push_back(chillVD);
+  return chillVD;
+}
+
+
+
+chillAST_node * ConvertRecordDecl( clang::RecordDecl *RD, chillAST_node *p ) { // for structs and unions
+
+  //fprintf(stderr, "ConvertRecordDecl(  )\n\nclang sees\n");
+  //RD->dump();
+  //fflush(stdout); 
+  //fprintf(stderr, "\n"); 
+  
+  //fprintf(stderr, "%s with name %s\n", ((clang::Decl *)RD)->getDeclKindName(), RD->getNameAsString().c_str());  
+  //const clang::ASTRecordLayout RL = RD->getASTContext().getASTRecordLayout( RD );
+  //RD->getASTContext().DumpRecordLayout( RD , cout ); 
+
+  int count = 0;
+  for (clang::RecordDecl::field_iterator fi = RD->field_begin(); fi != RD->field_end(); fi++) count++; 
+  //fprintf(stderr, "%d fields in this struct/union\n", count); 
+
+  char blurb[128];
+  sprintf(blurb, "struct %s", RD->getNameAsString().c_str()); 
+  fprintf(stderr, "blurb is '%s'\n", blurb); 
+
+  chillAST_TypedefDecl *astruct = new chillAST_TypedefDecl( blurb, "", p);
+  astruct->setStruct( true ); 
+  astruct->setStructName( RD->getNameAsString().c_str() );
+
+  for (clang::RecordDecl::field_iterator fi = RD->field_begin(); fi != RD->field_end(); fi++) { 
+    clang::FieldDecl *FD = (*fi);
+    FD->dump(); printf(";\n"); fflush(stdout); 
+    string TypeStr = FD->getType().getAsString(); 
+
+    const char *typ  = TypeStr.c_str();
+    const char *name = FD->getNameAsString().c_str();
+    fprintf(stderr, "(typ) %s (name) %s\n", typ, name);
+
+    chillAST_VarDecl *VD = NULL;
+    // very clunky and incomplete
+    VD = new chillAST_VarDecl( typ, name, "", astruct ); // can't handle arrays yet 
+    
+    astruct->subparts.push_back(VD); 
+  }
+
+
+  fprintf(stderr, "I just defined a struct\n"); 
+  astruct->print(0, stderr); 
+
+  return astruct; 
+}
+
+
+
+
+
+
+
+chillAST_node * ConvertTypeDefDecl( TypedefDecl *TDD, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertTypedefDecl(  ) \n");
+  //fprintf(stderr, "TDD has type %s\n", TDD->getDeclKindName()); 
+  //TDD->dump(); fprintf(stderr, "\n"); 
+
+  char *under =  strdup( TDD->getUnderlyingType().getAsString().c_str());
+  //fprintf(stderr, "under = '%s'\n", under); 
+  char *arraypart = splitTypeInfo(under);
+  //fprintf(stderr, "typedef %s %s%s;\n", under, TDD->getName().str().c_str(), arraypart);
+  //  fprintf(stderr, "len arraypart = %d\n", strlen(arraypart)); 
+  char *alias = strdup(TDD->getName().str().c_str());
+
+  //fprintf(stderr, "underlying type %s  arraypart '%s'  name %s\n", under, arraypart, TDD->getName().str().c_str() ); 
+  chillAST_TypedefDecl *CTDD = new chillAST_TypedefDecl( under, alias, arraypart, p ); 
+
+  free(under);        
+  free(arraypart);   
+
+  return CTDD; 
+}
+
+
+
+chillAST_node * ConvertDeclStmt( DeclStmt *clangDS, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertDeclStmt()\n"); 
+
+  chillAST_VarDecl *chillvardecl; // the thing we'll return if this is a single declaration
+  
+  bool multiples = !clangDS->isSingleDecl();
+  if ( multiples) { 
+    //fprintf(stderr, "ir_clang.cc  multiple declarations in a single CLANG DeclStmt  not really handled! (??)\n"); 
+    // for now, try to make the multiple decls into a compoundstmt with them inside.
+    // if we don't get scoping problems, this might work
+  }
+  
+  DeclGroupRef dgr = clangDS->getDeclGroup();
+  clang::DeclGroupRef::iterator DI = dgr.begin();
+  clang::DeclGroupRef::iterator DE = dgr.end();
+  
+  for ( ; DI != DE; ++DI) {
+    Decl *D = *DI;
+    const char *declty =  D->getDeclKindName();
+    //fprintf(stderr, "a decl of type %s\n", D->getDeclKindName()); 
+    
+    if (!strcmp("Var", declty)) {
+      VarDecl *V = dyn_cast<VarDecl>(D);
+      // ValueDecl *VD = dyn_cast<ValueDecl>(D); // not needed? 
+      std::string Name = V->getNameAsString();
+      char *varname = strdup( Name.c_str()); 
+      
+      //fprintf(stderr, "variable named %s\n", Name.c_str()); 
+      QualType T = V->getType();
+      string TypeStr = T.getAsString();
+      char *vartype =  strdup( TypeStr.c_str());
+      
+      //fprintf(stderr, "%s %s\n", td, varname); 
+      char *arraypart = splitTypeInfo( vartype );
+      
+      chillvardecl = new chillAST_VarDecl(vartype, varname, arraypart, (void *)D, p );
+      //fprintf(stderr, "DeclStmt (clang 0x%x) for %s %s%s\n", D, vartype,  varname, arraypart);
+
+      // store this away for declrefexpr that references it! 
+      VariableDeclarations.push_back(chillvardecl);
+      
+      if (multiples) p->addChild( chillvardecl ); 
+
+      // TODO 
+      if (V->hasInit()) { 
+        fprintf(stderr, " ConvertDeclStmt()  UNHANDLED initialization\n");
+        exit(-1); 
+      }
+    }
+  }  // for each of possibly multiple decls 
+  
+  if (multiples) return NULL;    // multiple decls added themselves already
+  return chillvardecl;  // OR a single decl
+}
+
+
+
+chillAST_node * ConvertCompoundStmt( CompoundStmt *clangCS, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertCompoundStmt(  )\n");
+  int numchildren= clangCS->size();
+  //fprintf(stderr, "clang CompoundStmt has %d children\n", numchildren);
+
+  // make an empty CHILL compound statement 
+  chillAST_CompoundStmt *chillCS = new chillAST_CompoundStmt; 
+  chillCS->setParent( p );
+
+  // for each clang child
+  for (auto I = clangCS->child_begin(); I!=clangCS->child_end(); ++I)  { // ?? loop looks WRONG
+    // create the chill ast for each child
+    Stmt *child = *I;
+    chillAST_node *n =  ConvertGenericClangAST( child, chillCS );
+    // usually n will be a statement. We just add it as a child.
+    // SOME DeclStmts have multiple declarations. They will add themselves and return NULL
+    if (n) chillCS->addChild( n ); 
+  }
+  
+  return chillCS;
+}
+
+
+
+
+chillAST_node * ConvertFunctionDecl( FunctionDecl *D, chillAST_node *p ) {
+  //fprintf(stderr, "\nConvertFunctionDecl(  )\n");
+  QualType QT = D->getReturnType();
+  string ReturnTypeStr = QT.getAsString();
+
+  // Function name
+  DeclarationName DeclName = D->getNameInfo().getName();
+  string FuncName = DeclName.getAsString();
+  //fprintf(stderr, "function %s has type %s ", FuncName.c_str(),  ReturnTypeStr.c_str()); 
+  //fprintf(stderr, "\n%s %s()\n", ReturnTypeStr.c_str(), FuncName.c_str());
+
+  chillAST_FunctionDecl *chillFD = new chillAST_FunctionDecl( ReturnTypeStr.c_str(),  FuncName.c_str(), p, D);
+  
+
+  int numparams = D->getNumParams();
+
+  //fprintf(stderr, "\nand %d parameters\n", numparams);
+  for (int i=0; i<numparams; i++) {
+    if (i) fprintf(stderr, ", ");
+    VarDecl *clangvardecl = D->getParamDecl(i);  // the ith parameter  (CLANG)
+    ParmVarDecl *pvd = D->getParamDecl(i); 
+    QualType T = pvd->getOriginalType();
+    fprintf(stderr, "OTYPE %s\n", T.getAsString().c_str()); 
+
+    chillAST_VarDecl *chillPVD = (chillAST_VarDecl *)ConvertVarDecl( clangvardecl, chillFD ) ; 
+    //chillPVD->print();  fflush(stdout); 
+
+    //chillPVD->isAParameter = 1;
+    VariableDeclarations.push_back(chillPVD); 
+    
+    chillFD->addParameter(chillPVD); 
+    fprintf(stderr, "chillAST ParmVarDecl for %s from chill location 0x%x\n",chillPVD->varname, clangvardecl); 
+  } // for each parameter 
+
+
+
+  //fprintf(stderr, ")\n{\n"); // beginning of function body 
+  //if (D->isExternC())    { chillFD->setExtern();  fprintf(stderr, "%s is extern\n", FuncName.c_str()); }; 
+  if (D->getBuiltinID()) { chillFD->setExtern();  fprintf(stderr, "%s is builtin (extern)\n", FuncName.c_str()); }; 
+
+  Stmt *clangbody = D->getBody();
+  if (clangbody) { // may just be fwd decl or external, without an actual body 
+    //fprintf(stderr, "body of type %s\n", clangbody->getStmtClassName()); 
+    //chillAST_node *CB = ConvertCompoundStmt(  dyn_cast<CompoundStmt>(clangbody) ); // always a compound statement?
+    chillAST_node *CB = ConvertGenericClangAST( clangbody, chillFD ); 
+    //fprintf(stderr, "FunctionDecl body = 0x%x of type %s\n", CB, CB->getTypeString());
+    chillFD->setBody ( CB ); 
+  }
+
+  //fprintf(stderr, "adding function %s  0x%x to FunctionDeclarations\n", chillFD->functionName, chillFD); 
+  FunctionDeclarations.push_back(chillFD); 
+  return  chillFD; 
+}
+
+
+chillAST_node * ConvertForStmt( ForStmt *clangFS, chillAST_node *p ) {
+
+  Stmt *init = clangFS->getInit();
+  Expr *cond = clangFS->getCond();
+  Expr *incr = clangFS->getInc();
+  Stmt *body = clangFS->getBody();
+
+  chillAST_node *ini = ConvertGenericClangAST( init, NULL ); 
+  chillAST_node *con = ConvertGenericClangAST( cond, NULL); 
+  chillAST_node *inc = ConvertGenericClangAST( incr, NULL); 
+  chillAST_node *bod = ConvertGenericClangAST( body, NULL); 
+  if (bod->asttype != CHILLAST_NODETYPE_COMPOUNDSTMT) { 
+    //fprintf(stderr, "ForStmt body of type %s\n", bod->getTypeString()); 
+    // make single statement loop bodies loop like other loops
+    chillAST_CompoundStmt *cs = new chillAST_CompoundStmt( );
+    cs->addChild( bod );
+    bod = cs;
+  }
+
+
+  chillAST_ForStmt *chill_loop = new  chillAST_ForStmt( ini, con, inc, bod, p ); 
+  ini->setParent( chill_loop );
+  con->setParent( chill_loop );
+  inc->setParent( chill_loop );
+  bod->setParent( chill_loop );
+
+  return chill_loop; 
+}
+
+
+chillAST_node * ConvertIfStmt( IfStmt *clangIS, chillAST_node *p ) {
+  Expr *cond = clangIS->getCond();
+  Stmt *thenpart = clangIS->getThen();
+  Stmt *elsepart = clangIS->getElse();
+  
+  chillAST_node *con = ConvertGenericClangAST( cond, NULL);
+  chillAST_node *thn = NULL;
+  if (thenpart) thn = ConvertGenericClangAST( thenpart, NULL);
+  chillAST_node *els = NULL;
+  if (elsepart) els = ConvertGenericClangAST( elsepart, NULL);
+  
+  chillAST_IfStmt *ifstmt = new chillAST_IfStmt( con, thn, els, NULL);
+  return ifstmt; 
+}
+
+
+
+chillAST_node * ConvertUnaryOperator( UnaryOperator * clangUO, chillAST_node *p ) {
+  const char *op = unops[clangUO->getOpcode()].c_str();
+  bool pre = clangUO->isPrefix();
+  chillAST_node *sub = ConvertGenericClangAST( clangUO->getSubExpr(), NULL ); 
+
+  chillAST_UnaryOperator *chillUO = new chillAST_UnaryOperator( op, pre, sub, p ); 
+  sub->setParent( chillUO );
+  return chillUO; 
+}
+
+
+chillAST_node * ConvertBinaryOperator( BinaryOperator * clangBO, chillAST_node *p ) {
+
+  // get the clang parts
+  Expr *lhs = clangBO->getLHS();
+  Expr *rhs = clangBO->getRHS();
+  BinaryOperator::Opcode op = clangBO->getOpcode(); // this is CLANG op, not CHILL op
+
+
+  // convert to chill equivalents
+  chillAST_node *l = ConvertGenericClangAST( lhs, NULL ); 
+  const char *opstring = binops[op].c_str();
+  chillAST_node *r = ConvertGenericClangAST( rhs, NULL ); 
+  // TODO chill equivalent for numeric op. 
+
+  // build up the chill Binary Op AST node
+  chillAST_BinaryOperator * binop = new chillAST_BinaryOperator( l, opstring, r, p );
+  l->setParent( binop );
+  r->setParent( binop );
+
+  return binop; 
+}
+
+
+
+
+chillAST_node * ConvertArraySubscriptExpr( ArraySubscriptExpr *clangASE, chillAST_node *p ) { 
+
+  Expr *clangbase  = clangASE->getBase();
+  Expr *clangindex = clangASE->getIdx();
+  //fprintf(stderr, "clang base: "); clangbase->dump(); fprintf(stderr, "\n"); 
+
+  chillAST_node *bas  = ConvertGenericClangAST( clangbase, NULL ); 
+  chillAST_node *indx = ConvertGenericClangAST( clangindex, NULL ); 
+  
+  chillAST_ArraySubscriptExpr * chillASE = new chillAST_ArraySubscriptExpr( bas, indx, p, clangASE);
+  bas->setParent( chillASE );
+  indx->setParent( chillASE );
+  return chillASE; 
+}
+
+
+
+chillAST_node * ConvertDeclRefExpr( DeclRefExpr * clangDRE, chillAST_node *p ) { 
+  DeclarationNameInfo DNI = clangDRE->getNameInfo();
+
+  ValueDecl *vd = static_cast<ValueDecl *>(clangDRE->getDecl()); // ValueDecl ?? VarDecl ??
+
+  QualType QT = vd->getType();
+  string TypeStr = QT.getAsString();
+  //fprintf(stderr, "\n\n*** type %s ***\n\n", TypeStr.c_str()); 
+  //fprintf(stderr, "kind %s\n", vd->getDeclKindName()); 
+
+  DeclarationName DN = DNI.getName();
+  const char *varname = DN.getAsString().c_str() ; 
+  chillAST_DeclRefExpr * chillDRE = new chillAST_DeclRefExpr(TypeStr.c_str(),  varname, p ); 
+
+  //fprintf(stderr, "clang DeclRefExpr refers to declaration of %s @ 0x%x\n", varname, vd);
+  //fprintf(stderr, "clang DeclRefExpr refers to declaration of %s of kind %s\n", varname, vd->getDeclKindName()); 
+  
+  // find the definition (we hope)
+  if ( (!strcmp("Var",  vd->getDeclKindName())) || (!strcmp("ParmVar",  vd->getDeclKindName()))) { 
+    // it's a variable reference 
+    int numvars = VariableDeclarations.size();
+    chillAST_VarDecl *chillvd = NULL;
+    for (int i=0; i<numvars; i++) { 
+      if (VariableDeclarations[i]->uniquePtr == vd) {
+        chillvd = VariableDeclarations[i];
+        //fprintf(stderr, "found it at variabledeclaration %d of %d\n", i, numvars);
+      }
+    }
+    if (!chillvd) { 
+      fprintf(stderr, "\nWARNING, ir_clang.cc clang DeclRefExpr %s refers to a declaration I can't find! at ox%x\n", varname, vd); 
+      fprintf(stderr, "variables I know of are:\n");
+      for (int i=0; i<numvars; i++) { 
+        chillAST_VarDecl *adecl = VariableDeclarations[i];
+        if (adecl->isParmVarDecl()) fprintf(stderr, "(parameter) ");
+        fprintf(stderr, "%s %s at location 0x%x\n", adecl->vartype, adecl->varname, adecl->uniquePtr); 
+      }  
+      fprintf(stderr, "\n"); 
+    }
+    
+    if (chillvd == NULL) { fprintf(stderr, "chillDRE->decl = 0x%x\n", chillvd); exit(-1); }
+
+    chillDRE->decl = (chillAST_node *)chillvd; // start of spaghetti pointers ...
+  }
+  else  if (!strcmp("Function",  vd->getDeclKindName())) { 
+    //fprintf(stderr, "declrefexpr of type Function\n");
+    int numfuncs = FunctionDeclarations.size();
+    chillAST_FunctionDecl *chillfd = NULL;
+    for (int i=0; i<numfuncs; i++) { 
+      if (FunctionDeclarations[i]->uniquePtr == vd) {
+        chillfd = FunctionDeclarations[i];
+        //fprintf(stderr, "found it at functiondeclaration %d of %d\n", i, numfuncs);
+      }
+    }
+    if (chillfd == NULL) { fprintf(stderr, "chillDRE->decl = 0x%x\n", chillfd); exit(-1); }
+
+    chillDRE->decl = (chillAST_node *)chillfd; // start of spaghetti pointers ...
+    
+  }
+  else { 
+  fprintf(stderr, "clang DeclRefExpr refers to declaration of %s of kind %s\n", varname, vd->getDeclKindName()); 
+    fprintf(stderr, "chillDRE->decl = UNDEFINED\n"); 
+    exit(-1); 
+  }
+
+  //fprintf(stderr, "%s\n", DN.getAsString().c_str()); 
+  return chillDRE; 
+}
+
+
+
+chillAST_node * ConvertIntegerLiteral( IntegerLiteral *clangIL, chillAST_node *p ) { 
+  bool isSigned = clangIL->getType()->isSignedIntegerType();
+  //int val = clangIL->getIntValue();
+  const char *printable = clangIL->getValue().toString(10, isSigned).c_str(); 
+  int val = atoi( printable ); 
+  //fprintf(stderr, "int value %s  (%d)\n", printable, val); 
+  chillAST_IntegerLiteral  *chillIL = new chillAST_IntegerLiteral( val, p );
+  return chillIL; 
+}
+
+
+chillAST_node * ConvertFloatingLiteral( FloatingLiteral *clangFL, chillAST_node *p ) { 
+  //fprintf(stderr, "\nConvertFloatingLiteral()\n"); 
+  float val = clangFL->getValueAsApproximateDouble(); // TODO approx is a bad idea!
+  string WHAT; 
+  SmallString<16> Str;
+  clangFL->getValue().toString( Str );
+  const char *printable = Str.c_str(); 
+  //fprintf(stderr, "literal %s\n", printable); 
+
+  SourceLocation sloc = clangFL->getLocStart();
+  SourceLocation eloc = clangFL->getLocEnd();
+
+  std::string start = sloc.printToString( *globalSRCMAN ); 
+  std::string end   = eloc.printToString( *globalSRCMAN ); 
+  //fprintf(stderr, "literal try2 start %s end %s\n", start.c_str(), end.c_str()); 
+  //printlines( sloc, eloc, globalSRCMAN ); 
+  unsigned int startlineno = globalSRCMAN->getPresumedLineNumber( sloc );
+  unsigned int   endlineno = globalSRCMAN->getPresumedLineNumber( eloc ); ;
+  const char     *filename = globalSRCMAN->getBufferName( sloc );
+
+  std::string  fname = globalSRCMAN->getFilename( sloc );
+  //fprintf(stderr, "fname %s\n", fname.c_str()); 
+
+  if (filename && strlen(filename) > 0) {} // fprintf(stderr, "literal file '%s'\n", filename);
+  else { 
+    fprintf(stderr, "\nConvertFloatingLiteral() filename is NULL?\n"); 
+
+    //sloc =  globalSRCMAN->getFileLoc( sloc );  // should get spelling loc? 
+    sloc =  globalSRCMAN->getSpellingLoc( sloc );  // should get spelling loc? 
+    //eloc =  globalSRCMAN->getFileLoc( eloc );
+
+    start = sloc.printToString( *globalSRCMAN ); 
+    //end   = eloc.printToString( *globalSRCMAN );  
+    //fprintf(stderr, "literal try3 start %s end %s\n", start.c_str(), end.c_str()); 
+   
+    startlineno = globalSRCMAN->getPresumedLineNumber( sloc );
+    //endlineno = globalSRCMAN->getPresumedLineNumber( eloc ); ;    
+    //fprintf(stderr, "start, end line numbers %d %d\n", startlineno, endlineno); 
+    
+    filename = globalSRCMAN->getBufferName( sloc );
+
+    //if (globalSRCMAN->isMacroBodyExpansion( sloc )) { 
+    //  fprintf(stderr, "IS MACRO\n");
+    //} 
+  }
+  
+  unsigned int  offset = globalSRCMAN->getFileOffset( sloc );
+  //fprintf(stderr, "literal file offset %d\n", offset); 
+
+  FILE *fp = fopen (filename, "r");
+  fseek(fp, offset, SEEK_SET); // go to the part of the file where the float is defined
+  
+  char buf[10240];
+  fgets (buf, sizeof(buf), fp); // read a line starting where the float starts
+  fclose(fp);
+
+  // buf has the line we want   grab the float constant out of it
+  //fprintf(stderr, "\nbuf '%s'\n", buf);
+  char *ptr = buf;
+  if (*ptr == '-') ptr++; // ignore possible minus sign
+  int len = strspn(ptr, ".-0123456789f"); 
+  buf[len] = '\0';
+  //fprintf(stderr, "'%s'\n", buf);
+
+  chillAST_FloatingLiteral  *chillFL = new chillAST_FloatingLiteral( val, buf, p );
+  
+  //chillFL->print(); printf("\n"); fflush(stdout); 
+  return chillFL; 
+}
+
+
+chillAST_node * ConvertImplicitCastExpr( ImplicitCastExpr *clangICE, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertImplicitCastExpr()\n"); 
+  CastExpr *CE = dyn_cast<ImplicitCastExpr>(clangICE);
+  //fprintf(stderr, "implicit cast of type %s\n", CE->getCastKindName());
+  chillAST_node * sub = ConvertGenericClangAST( clangICE->getSubExpr(), p );
+  chillAST_ImplicitCastExpr *chillICE = new chillAST_ImplicitCastExpr( sub, p ); 
+  
+  //sub->setParent( chillICE ); // these 2 lines work
+  //return chillICE; 
+
+  //sub->setParent(p);         // ignore the ImplicitCastExpr !!  TODO (probably a bad idea) 
+  return sub; 
+
+}
+
+
+
+
+chillAST_node * ConvertCStyleCastExpr( CStyleCastExpr *clangCSCE, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertCStyleCastExpr()\n"); 
+  //fprintf(stderr, "C Style cast of kind ");
+  CastExpr *CE = dyn_cast<CastExpr>(clangCSCE);
+  //fprintf(stderr, "%s\n", CE->getCastKindName());
+  
+  //clangCSCE->getTypeAsWritten().getAsString(Policy)
+  const char * towhat = strdup( clangCSCE->getTypeAsWritten().getAsString().c_str() );
+  //fprintf(stderr, "before sub towhat (%s)\n", towhat);
+
+  chillAST_node * sub = ConvertGenericClangAST( clangCSCE->getSubExprAsWritten(), NULL );
+  //fprintf(stderr, "after sub towhat (%s)\n", towhat);
+  chillAST_CStyleCastExpr *chillCSCE = new chillAST_CStyleCastExpr( towhat, sub, p ); 
+  //fprintf(stderr, "after CSCE towhat (%s)\n", towhat);
+  sub->setParent( chillCSCE );
+  return chillCSCE; 
+}
+
+
+
+
+chillAST_node * ConvertReturnStmt( ReturnStmt *clangRS, chillAST_node *p ) {
+  chillAST_node * retval = ConvertGenericClangAST( clangRS->getRetValue(), NULL ); // NULL is handled
+  //if (retval == NULL) fprintf(stderr, "return stmt returns nothing\n");
+
+  chillAST_ReturnStmt * chillRS = new chillAST_ReturnStmt( retval, p );
+  if (retval) retval->setParent( chillRS );
+  return chillRS; 
+}
+
+
+chillAST_node * ConvertCallExpr( CallExpr *clangCE, chillAST_node *p ) {
+  //fprintf(stderr, "ConvertCallExpr()\n"); 
+
+  chillAST_node *callee = ConvertGenericClangAST( clangCE->getCallee(), NULL ); 
+  //fprintf(stderr, "callee is of type %s\n", callee->getTypeString()); 
+
+  //chillAST_node *next = ((chillAST_ImplicitCastExpr *)callee)->subexpr;
+  //fprintf(stderr, "callee is of type %s\n", next->getTypeString()); 
+
+  chillAST_CallExpr *chillCE = new chillAST_CallExpr( callee, p ); 
+  callee->setParent( chillCE );
+
+  int numargs = clangCE->getNumArgs();
+  //fprintf(stderr, "CallExpr has %d args\n", numargs);
+  Expr **clangargs =  clangCE->getArgs(); 
+  for (int i=0; i<numargs; i++) { 
+    chillCE->addArg( ConvertGenericClangAST( clangargs[i], chillCE ) );
+  }
+  
+  return chillCE; 
+}
+
+
+chillAST_node * ConvertParenExpr( ParenExpr *clangPE, chillAST_node *p ) {
+  chillAST_node *sub = ConvertGenericClangAST( clangPE->getSubExpr(), NULL);
+  chillAST_ParenExpr *chillPE = new chillAST_ParenExpr( sub, p); 
+  sub->setParent( chillPE );
+
+  return chillPE; 
+}
+
+
+chillAST_node * ConvertTranslationUnit(  TranslationUnitDecl *TUD, char *filename ) {
+  //fprintf(stderr, "ConvertTranslationUnit( filename %s )\n\n", filename); 
+  // TUD derived from Decl and DeclContext
+  static DeclContext *DC = TUD->castToDeclContext( TUD );
+
+
+  // TODO this was to get the filename without having to pass it in
+  //ASTContext CTX = TUD->getASTContext (); 
+  //SourceManager  SM =  CTX.getSourceManager();
+  //SourceLocation srcloc = ForStatement->getForLoc();
+  //unsigned int lineno   = SRCMAN->getPresumedLineNumber( srcloc );
+  //const char *filename  = SRCMAN->getBufferName( srcloc ); 
+
+
+  chillAST_SourceFile * topnode = new chillAST_SourceFile( filename  ); 
+  topnode->setFrontend("clang"); 
+  topnode->chill_array_counter  = 1;
+  topnode->chill_scalar_counter = 0;
+
+  // now recursively build clang AST from the children of TUD
+  //for (DeclContext::decl_iterator DI = DC->decls_begin(), DE = DC->decls_end(); DI != DE; ++DI)
+  DeclContext::decl_iterator start = DC->decls_begin();
+  DeclContext::decl_iterator end   = DC->decls_end();
+  for (DeclContext::decl_iterator DI=start; DI != end; ++DI) { 
+    Decl *D = *DI;
+       
+    if (isa<FunctionDecl>(D))  { //fprintf(stderr, "\nTUD FunctionDecl\n");
+      topnode->addChild( ConvertFunctionDecl( dyn_cast<FunctionDecl>(D), topnode )); 
+    }
+    else if (isa<VarDecl>(D)) { //fprintf(stderr, "\nTUD VarDecl\n");  
+      topnode->addChild( ConvertVarDecl( dyn_cast<VarDecl>(D), topnode ));
+      //fflush(stdout);  fprintf(stderr, "\nTUD VarDecl DONE\n");  
+    }
+    else if (isa<TypedefDecl>(D)) { //fprintf(stderr, "\nTUD TypedefDecl\n");  
+      topnode->addChild( ConvertTypeDefDecl( dyn_cast<TypedefDecl>(D), topnode )); 
+    }
+    else if (isa<RecordDecl>(D)) { fprintf(stderr, "\nTUD RecordDecl\n");  
+      topnode->addChild( ConvertRecordDecl( dyn_cast<RecordDecl>(D), topnode )); 
+    }
+    else if (isa<TypeAliasDecl>(D)) { fprintf(stderr, "TUD TypeAliasDecl  TODO \n");   exit(-1); 
+    }
+    else { 
+      fprintf(stderr, "\nTUD a declaration of type %s (%d) which I can't handle\n",   D->getDeclKindName(), D->getKind());
+      exit(-1);
+    }
+  }
+  //fflush(stdout);  fprintf(stderr, "leaving ConvertTranslationUnit()\n\n");
+
+  //fprintf(stderr, "in ConvertTranslationUnit(), dumping the file\n");  
+  //topnode->dump();
+  return ( chillAST_node *)  topnode;
+}
+
+
+
+ chillAST_node * ConvertGenericClangAST( Stmt *s, chillAST_node *p ) {
+   
+   if (s == NULL) return NULL;
+   //fprintf(stderr, "\nConvertGenericClangAST() Stmt of type %d (%s)\n", s->getStmtClass(),s->getStmtClassName()); 
+   Decl *D = (Decl *) s;
+   //if (isa<Decl>(D)) fprintf(stderr, "Decl of kind %d (%s)\n",  D->getKind(),D->getDeclKindName() );
+   
+
+   chillAST_node *ret = NULL;
+
+   if (isa<CompoundStmt>(s))              {ret = ConvertCompoundStmt( dyn_cast<CompoundStmt>(s),p); 
+   } else if (isa<DeclStmt>(s))           {ret = ConvertDeclStmt(dyn_cast<DeclStmt>(s),p); 
+   } else if (isa<ForStmt>(s))            {ret = ConvertForStmt(dyn_cast<ForStmt>(s),p);
+   } else if (isa<BinaryOperator>(s))     {ret = ConvertBinaryOperator(dyn_cast<BinaryOperator>(s),p);
+   } else if (isa<ArraySubscriptExpr>(s)) {ret = ConvertArraySubscriptExpr(dyn_cast<ArraySubscriptExpr>(s),p);
+   } else if (isa<DeclRefExpr>(s))        {ret = ConvertDeclRefExpr(dyn_cast<DeclRefExpr>(s),p); 
+   } else if (isa<FloatingLiteral>(s))    {ret = ConvertFloatingLiteral(dyn_cast<FloatingLiteral>(s),p);
+   } else if (isa<IntegerLiteral>(s))     {ret = ConvertIntegerLiteral(dyn_cast<IntegerLiteral>(s),p);
+   } else if (isa<UnaryOperator>(s))      {ret = ConvertUnaryOperator(dyn_cast<UnaryOperator>(s),p);
+   } else if (isa<ImplicitCastExpr>(s))   {ret = ConvertImplicitCastExpr(dyn_cast<ImplicitCastExpr>(s),p);
+   } else if (isa<CStyleCastExpr>(s))     {ret = ConvertCStyleCastExpr(dyn_cast<CStyleCastExpr>(s),p);
+   } else if (isa<ReturnStmt>(s))         {ret = ConvertReturnStmt(dyn_cast<ReturnStmt>(s),p); 
+   } else if (isa<CallExpr>(s))           {ret = ConvertCallExpr(dyn_cast<CallExpr>(s),p); 
+   } else if (isa<ParenExpr>(s))          {ret = ConvertParenExpr(dyn_cast<ParenExpr>(s),p); 
+   } else if (isa<IfStmt>(s))             {ret = ConvertIfStmt(dyn_cast<IfStmt>(s),p);
+   } else if (isa<MemberExpr>(s))         {ret = ConvertMemberExpr(dyn_cast<MemberExpr>(s),p);
+
+
+     // these can only happen at the top level? 
+     //   } else if (isa<FunctionDecl>(D))       { ret = ConvertFunctionDecl( dyn_cast<FunctionDecl>(D)); 
+     //} else if (isa<VarDecl>(D))            { ret =      ConvertVarDecl( dyn_cast<VarDecl>(D) ); 
+     //} else if (isa<TypedefDecl>(D))        { ret =  ConvertTypeDefDecl( dyn_cast<TypedefDecl>(D)); 
+     //  else if (isa<TranslationUnitDecl>(s))  // need filename 
+
+
+
+
+     //   } else if (isa<>(s))                  {         Convert ( dyn_cast<>(s)); 
+
+     /*
+     */
+
+   } else {
+     // more work to do 
+     fprintf(stderr, "ir_clang.cc ConvertGenericClangAST() UNHANDLED ");
+     //if (isa<Decl>(D)) fprintf(stderr, "Decl of kind %s\n",  D->getDeclKindName() );
+     if (isa<Stmt>(s))fprintf(stderr, "Stmt of type %s\n", s->getStmtClassName()); 
+     exit(-1); 
+   }
+   
+   return ret; 
+ }
+
+
+
+
+
+
+
+
+
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillScalarSymbol
+// ----------------------------------------------------------------------------
+ 
+std::string IR_chillScalarSymbol::name() const {
+  //return vd_->getNameAsString();   CLANG
+  //fprintf(stderr, "IR_chillScalarSymbol::name() %s\n", chillvd->varname); 
+  return std::string(chillvd->varname);  // CHILL 
+}
+ 
+
+// Return size in bytes
+int IR_chillScalarSymbol::size() const {
+  //return (vd_->getASTContext().getTypeSize(vd_->getType())) / 8;    // ??
+  fprintf(stderr, "IR_chillScalarSymbol::size()  probably WRONG\n"); 
+  return (8); // bytes?? 
+}
+
+
+bool IR_chillScalarSymbol::operator==(const IR_Symbol &that) const {
+  //fprintf(stderr, "IR_xxxxScalarSymbol::operator==  probably WRONG\n"); 
+  if (typeid(*this) != typeid(that))
+    return false;
+  
+  const IR_chillScalarSymbol *l_that = static_cast<const IR_chillScalarSymbol *>(&that);
+  return this->chillvd == l_that->chillvd;
+}
+
+IR_Symbol *IR_chillScalarSymbol::clone() const {
+  return new IR_chillScalarSymbol(ir_, chillvd );  // clone
+}
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillArraySymbol
+// ----------------------------------------------------------------------------
+
+std::string IR_chillArraySymbol::name() const {
+  return std::string( strdup( chillvd ->varname)); 
+}
+
+
+int IR_chillArraySymbol::elem_size() const {
+  fprintf(stderr, "IR_chillArraySymbol::elem_size()  TODO\n");  exit(-1); 
+  return 8;  // TODO 
+  //const ArrayType *at = dyn_cast<ArrayType>(vd_->getType()); 
+  //if(at) {
+  //  return (vd_->getASTContext().getTypeSize(at->getElementType())) / 8;
+  //} else
+  //  throw ir_error("Symbol is not an array!");
+  //return 0;
+}
+
+
+int IR_chillArraySymbol::n_dim() const {
+  //fprintf(stderr, "IR_chillArraySymbol::n_dim()\n");
+  //fprintf(stderr, "variable %s %s %s\n", chillvd->vartype, chillvd->varname, chillvd->arraypart);
+  //fprintf(stderr, "IR_chillArraySymbol::n_dim() %d\n", chillvd->numdimensions); 
+  //fprintf(stderr, "IR_chillArraySymbol::n_dim()  TODO \n"); exit(-1); 
+  return chillvd->numdimensions; 
+}
+
+
+// TODO
+omega::CG_outputRepr *IR_chillArraySymbol::size(int dim) const {
+  fprintf(stderr, "IR_chillArraySymbol::n_size()  TODO \n"); exit(-1); 
+  return NULL;
+}
+
+
+bool IR_chillArraySymbol::operator!=(const IR_Symbol &that) const {
+  //fprintf(stderr, "IR_xxxxArraySymbol::operator!=   NOT EQUAL\n"); 
+  //chillAST_VarDecl *chillvd;
+  return chillvd != ((IR_chillArraySymbol*)&that)->chillvd ; 
+}
+
+bool IR_chillArraySymbol::operator==(const IR_Symbol &that) const {
+  //fprintf(stderr, "IR_xxxxArraySymbol::operator==   EQUAL\n"); 
+  //chillAST_VarDecl *chillvd;
+  return chillvd == ((IR_chillArraySymbol*)&that)->chillvd ; 
+  /*
+  if (typeid(*this) != typeid(that))
+    return false;
+  
+  const IR_chillArraySymbol *l_that = static_cast<const IR_chillArraySymbol *>(&that);
+  return this->vd_ == l_that->vd_ && this->offset_ == l_that->offset_;
+  */
+}
+
+
+IR_Symbol *IR_chillArraySymbol::clone() const {
+  return new IR_chillArraySymbol(ir_, chillvd, offset_);
+}
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillConstantRef
+// ----------------------------------------------------------------------------
+
+bool IR_chillConstantRef::operator==(const IR_Ref &that) const {
+  if (typeid(*this) != typeid(that))
+    return false;
+  
+  const IR_chillConstantRef *l_that = static_cast<const IR_chillConstantRef *>(&that);
+  
+  if (this->type_ != l_that->type_)
+    return false;
+  
+  if (this->type_ == IR_CONSTANT_INT)
+    return this->i_ == l_that->i_;
+  else
+    return this->f_ == l_that->f_;
+}
+
+
+omega::CG_outputRepr *IR_chillConstantRef::convert() {
+  //assert(astContext_ != NULL);
+  if (type_ == IR_CONSTANT_INT) {
+
+    fprintf(stderr, "IR_chillConstantRef::convert() unimplemented\n");  exit(-1); 
+    
+    // TODO 
+    /*
+    BuiltinType *bint = new BuiltinType(BuiltinType::Int);
+    IntegerLiteral *ilit = new (astContext_)IntegerLiteral(*astContext_, llvm::APInt(32, i_), bint->desugar(), SourceLocation());
+    omega::CG_chillRepr *result = new omega::CG_chillRepr(ilit);
+    delete this;
+    return result;
+    */
+  }
+  else
+    throw ir_error("constant type not supported");
+}
+
+
+IR_Ref *IR_chillConstantRef::clone() const {
+  if (type_ == IR_CONSTANT_INT)
+    return new IR_chillConstantRef(ir_, i_);
+  else if (type_ == IR_CONSTANT_FLOAT)
+    return new IR_chillConstantRef(ir_, f_);
+  else
+    throw ir_error("constant type not supported");
+}
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillScalarRef
+// ----------------------------------------------------------------------------
+
+bool IR_chillScalarRef::is_write() const {
+  return op_pos_ ==  OP_DEST; // 2 other alternatives: OP_UNKNOWN, OP_SRC
+}
+
+
+IR_ScalarSymbol *IR_chillScalarRef::symbol() const {
+  //VarDecl *vd = static_cast<VarDecl *>(vs_->getDecl());
+  //fprintf(stderr, "ir_clang.cc  IR_chillScalarRef::symbol()\n"); //exit(-1);
+  chillAST_VarDecl *vd = NULL;
+  if (chillvd) vd = chillvd; 
+  return new IR_chillScalarSymbol(ir_, vd); // IR_chillScalarRef::symbol()
+}
+
+
+bool IR_chillScalarRef::operator==(const IR_Ref &that) const {
+  if (typeid(*this) != typeid(that))
+    return false;
+  
+  const IR_chillScalarRef *l_that = static_cast<const IR_chillScalarRef *>(&that);
+  
+  return this->chillvd == l_that->chillvd;
+}
+
+
+omega::CG_outputRepr *IR_chillScalarRef::convert() {
+  //fprintf(stderr, "IR_chillScalarRef::convert() unimplemented\n"); exit(-1); 
+  if (!dre) fprintf(stderr, "IR_chillScalarRef::convert()   CLANG SCALAR REF has no dre\n"); 
+  omega::CG_chillRepr *result = new omega::CG_chillRepr(dre);
+  delete this;
+  return result;
+}
+
+IR_Ref * IR_chillScalarRef::clone() const {
+  if (dre) return new IR_chillScalarRef(ir_, dre); // use declrefexpr if it exists
+  return new IR_chillScalarRef(ir_, chillvd); // uses vardecl
+}
+
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillArrayRef
+// ----------------------------------------------------------------------------
+
+bool IR_chillArrayRef::is_write() const {
+  
+  return (iswrite); // TODO 
+}
+
+
+// TODO
+omega::CG_outputRepr *IR_chillArrayRef::index(int dim) const {
+  fprintf(stderr, "IR_xxxxArrayRef::index( %d )  \n", dim); 
+  //chillASE->print(); printf("\n"); fflush(stdout); 
+  //chillASE->getIndex(dim)->print(); printf("\n"); fflush(stdout); 
+  return new omega::CG_chillRepr( chillASE->getIndex(dim) );
+}
+
+
+IR_ArraySymbol *IR_chillArrayRef::symbol() const {
+  //fprintf(stderr, "IR_chillArrayRef::symbol()\n"); 
+  //chillASE->print(); printf("\n"); fflush(stdout); 
+  //fprintf(stderr, "base:  ");  chillASE->base->print();  printf("\n"); fflush(stdout); 
+
+  
+  chillAST_node *mb = chillASE->multibase(); 
+  chillAST_VarDecl *vd = (chillAST_VarDecl*)mb;
+  //fprintf(stderr, "symbol: '%s'\n", vd->varname);
+
+  //fprintf(stderr, "IR_chillArrayRef symbol: '%s%s'\n", vd->varname, vd->arraypart); 
+  //fprintf(stderr, "numdimensions %d\n", vd->numdimensions); 
+  IR_ArraySymbol *AS =  new IR_chillArraySymbol(ir_, vd); 
+  //fprintf(stderr, "ir_clang.cc returning IR_chillArraySymbol 0x%x\n", AS); 
+  return  AS;
+/*
+  chillAST_node *b = chillASE->base;
+  fprintf(stderr, "base of type %s\n", b->getTypeString()); 
+  //b->print(); printf("\n"); fflush(stdout); 
+  if (b->asttype == CHILLAST_NODETYPE_IMPLICITCASTEXPR) {
+    b = ((chillAST_ImplicitCastExpr*)b)->subexpr;
+    fprintf(stderr, "base of type %s\n", b->getTypeString()); 
+  }
+  
+  if (b->asttype == CHILLAST_NODETYPE_DECLREFEXPR)  {
+    if (NULL == ((chillAST_DeclRefExpr*)b)->decl) { 
+      fprintf(stderr, "IR_chillArrayRef::symbol()  var decl = 0x%x\n", ((chillAST_DeclRefExpr*)b)->decl); 
+      exit(-1); 
+    }
+    return new IR_chillArraySymbol(ir_, ((chillAST_DeclRefExpr*)b)->decl); // -> decl?
+  }
+  if (b->asttype ==  CHILLAST_NODETYPE_ARRAYSUBSCRIPTEXPR)  { // multidimensional array
+    return (
+  }
+  fprintf(stderr, "IR_chillArrayRef::symbol() can't handle\n");
+  fprintf(stderr, "base of type %s\n", b->getTypeString()); 
+  exit(-1); 
+  return NULL; 
+*/
+}
+
+
+bool IR_chillArrayRef::operator!=(const IR_Ref &that) const {
+  //fprintf(stderr, "IR_xxxxArrayRef::operator!=\n"); 
+  bool op = (*this) == that; // opposite
+  return !op;
+}
+  
+void IR_chillArrayRef::Dump() const { 
+  //fprintf(stderr, "IR_chillArrayRef::Dump()  this 0x%x  chillASE 0x%x\n", this, chillASE); 
+  chillASE->print(); printf("\n");fflush(stdout);
+}
+
+
+bool IR_chillArrayRef::operator==(const IR_Ref &that) const {
+  //fprintf(stderr, "IR_xxxxArrayRef::operator==\n"); 
+  //printf("I am\n"); chillASE->print(); printf("\n"); 
+  const IR_chillArrayRef *l_that = static_cast<const IR_chillArrayRef *>(&that);
+  const chillAST_ArraySubscriptExpr* thatASE = l_that->chillASE;
+  //printf("other is:\n");  thatASE->print(); printf("\n"); fflush(stdout);
+  //fprintf(stderr, "addresses are 0x%x  0x%x\n", chillASE, thatASE ); 
+  return (*chillASE) == (*thatASE);
+  /*
+
+  if (typeid(*this) != typeid(that))
+    return false;
+  
+  const IR_chillArrayRef *l_that = static_cast<const IR_chillArrayRef *>(&that);
+  
+  return this->as_ == l_that->as_;
+  */
+}
+
+
+omega::CG_outputRepr *IR_chillArrayRef::convert() {
+  //fprintf(stderr, "IR_chillArrayRef::convert()\n"); 
+  CG_chillRepr *result = new  CG_chillRepr( chillASE->clone() ); 
+//  omega::CG_chillRepr *temp = new omega::CG_chillRepr(static_cast<Expr*>(this->as_));
+//  omega::CG_outputRepr *result = temp->clone();
+  delete this;
+  return result;
+}
+
+
+IR_Ref *IR_chillArrayRef::clone() const {
+  return new IR_chillArrayRef(ir_, chillASE, iswrite);
+}
+
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillLoop
+// ----------------------------------------------------------------------------
+IR_chillLoop::IR_chillLoop(const IR_Code *ir, clang::ForStmt *tf) { fprintf(stderr, "IR_chillLoop::IR_chillLoop() you lose\n"); exit(-1); }; 
+
+IR_chillLoop::IR_chillLoop(const IR_Code *ir, chillAST_ForStmt *achillforstmt) { 
+  fprintf(stderr, "IR_xxxxLoop::IR_xxxxLoop()\n"); 
+  fprintf(stderr, "loop is:\n"); 
+  achillforstmt->print(); 
+
+  ir_ = ir; 
+  chillforstmt = achillforstmt;
+
+  chillAST_BinaryOperator *init = (chillAST_BinaryOperator *)chillforstmt->getInit();
+  chillAST_BinaryOperator *cond = (chillAST_BinaryOperator *)chillforstmt->getCond();
+  // check to be sure  (assert) 
+  if (!init->isAssignmentOp() || !cond->isComparisonOp() ) {
+    fprintf(stderr, "ir_clang.cc, malformed loop init or cond:\n");
+    achillforstmt->print(); 
+    exit(-1); 
+  }
+
+  chilllowerbound = init->getRHS();
+  chillupperbound = cond->getRHS();
+  conditionoperator = achillforstmt->conditionoperator; 
+  
+  chillAST_node *inc  = chillforstmt->getInc();
+  // check the increment
+  //fprintf(stderr, "increment is of type %s\n", inc->getTypeString()); 
+  //inc->print(); printf("\n"); fflush(stdout);
+
+  if (inc->asttype == CHILLAST_NODETYPE_UNARYOPERATOR) { 
+    if (!strcmp(((chillAST_UnaryOperator *) inc)->op, "++")) step_size_ = 1;
+    else  step_size_ = -1;
+  }
+  else if (inc->asttype == CHILLAST_NODETYPE_BINARYOPERATOR) { 
+    int beets = false;  // slang
+    chillAST_BinaryOperator *bop = (chillAST_BinaryOperator *) inc;
+    if (bop->isAssignmentOp()) {        // I=I+1   or similar
+      chillAST_node *rhs = bop->getRHS();  // (I+1)
+      // TODO looks like this will fail for I=1+I or I=J+1 etc. do more checking
+      
+      char *assop =  bop->getOp(); 
+      //fprintf(stderr, "'%s' is an assignment op\n", bop->getOp()); 
+      if (streq(assop, "+=") || streq(assop, "-=")) {
+        chillAST_node *stride = rhs;
+        //fprintf(stderr, "stride is of type %s\n", stride->getTypeString());
+        if  (stride->isIntegerLiteral()) {
+          int val = ((chillAST_IntegerLiteral *)stride)->value;
+          if      (streq( assop, "+=")) step_size_ =  val;
+          else if (streq( assop, "-=")) step_size_ = -val;
+          else beets = true; 
+        }
+        else beets = true;  // += or -= but not constant stride
+      }
+      else if (rhs->isBinaryOperator()) { 
+        chillAST_BinaryOperator *binoprhs = (chillAST_BinaryOperator *)rhs;
+        chillAST_node *intlit =  binoprhs->getRHS();
+        if (intlit->isIntegerLiteral()) {
+          int val = ((chillAST_IntegerLiteral *)intlit)->value;
+          if      (!strcmp( binoprhs->getOp(), "+")) step_size_ =  val;
+          else if (!strcmp( binoprhs->getOp(), "-")) step_size_ = -val;
+          else beets = true; 
+        }
+        else beets = true;
+      }
+      else beets = true;
+    }
+    else beets = true;
+
+    if (beets) {
+      fprintf(stderr, "malformed loop increment (or more likely unhandled case)\n");
+      inc->print(); 
+      exit(-1); 
+    }
+  } // binary operator 
+  else { 
+    fprintf(stderr, "IR_chillLoop constructor, unhandled loop increment\n");
+      inc->print(); 
+      exit(-1); 
+  }
+  //inc->print(0, stderr);fprintf(stderr, "\n"); 
+
+  chillAST_DeclRefExpr *dre = (chillAST_DeclRefExpr *)init->getLHS();
+  if (!dre->isDeclRefExpr()) { 
+    fprintf(stderr, "malformed loop init.\n"); 
+    init->print(); 
+  }
+
+  chillindex = dre; // the loop index variable
+
+  //fprintf(stderr, "\n\nindex is ");  dre->print(0, stderr);  fprintf(stderr, "\n"); 
+  //fprintf(stderr, "init is   "); 
+  //chilllowerbound->print(0, stderr);  fprintf(stderr, "\n");
+  //fprintf(stderr, "condition is  %s ", "<"); 
+  //chillupperbound->print(0, stderr);  fprintf(stderr, "\n");
+  //fprintf(stderr, "step size is %d\n\n", step_size_) ; 
+
+  chillbody = achillforstmt->getBody(); 
+
+  fprintf(stderr, "IR_xxxxLoop::IR_xxxxLoop() DONE\n"); 
+}
+
+
+omega::CG_outputRepr *IR_chillLoop::lower_bound() const {
+  fprintf(stderr, "IR_xxxxLoop::lower_bound()\n"); 
+  return new omega::CG_chillRepr(chilllowerbound);
+}
+
+omega::CG_outputRepr *IR_chillLoop::upper_bound() const {
+  fprintf(stderr, "IR_xxxxLoop::upper_bound()\n"); 
+  return new omega::CG_chillRepr(chillupperbound);
+}
+
+IR_Block *IR_chillLoop::body() const {
+  fprintf(stderr, "IR_xxxxLoop::body()\n");
+  //assert(isa<CompoundStmt>(tf_->getBody()));
+  //fprintf(stderr, "returning a clangBLOCK corresponding to the body of the loop\n"); 
+  //fprintf(stderr, "body type %s\n", chillbody->getTypeString()); 
+  return new IR_chillBlock(ir_, chillbody ) ; // static_cast<CompoundStmt *>(tf_->getBody()));
+}
+
+IR_Control *IR_chillLoop::clone() const {
+  fprintf(stderr, "IR_xxxxLoop::clone()\n"); 
+  //chillforstmt->print(); fflush(stdout); 
+  return new IR_chillLoop(ir_, chillforstmt);
+}
+
+IR_CONDITION_TYPE IR_chillLoop::stop_cond() const {
+  chillAST_BinaryOperator *loopcondition = (chillAST_BinaryOperator*) chillupperbound;
+  fprintf(stderr, "IR_xxxxLoop::stop_cond()\n"); 
+  return conditionoperator; 
+}
+
+IR_Block *IR_chillLoop::convert() { // convert the loop to a block 
+  fprintf(stderr, "IR_xxxxLoop::convert()   maybe \n"); 
+  return new IR_chillBlock( ir_, chillbody ); // ?? 
+  return NULL;
+}
+
+void IR_chillLoop::dump() const { 
+  fprintf(stderr, "TODO:  IR_chillLoop::dump()\n"); exit(-1); 
+}
+
+
+// ----------------------------------------------------------------------------
+// Class: IR_chillBlock
+// ----------------------------------------------------------------------------
+omega::CG_outputRepr *IR_chillBlock::original() const {
+  fprintf(stderr, "IR_xxxxBlock::original()  TODO \n"); 
+  exit(-1); 
+  return NULL;
+}
+
+
+
+omega::CG_outputRepr *IR_chillBlock::extract() const {
+  fflush(stdout); 
+  fprintf(stderr, "IR_xxxxBlock::extract()\n"); 
+  //omega::CG_chillRepr *tnl =  new omega::CG_chillRepr(getStmtList());
+
+  // if the block refers to a compound statement, return the next level
+  // of statements ;  otherwise just return a repr of the statements
+
+  chillAST_node *code = chillAST;
+  //if (chillAST != NULL) fprintf(stderr, "block has chillAST of type %s\n",code->getTypeString()); 
+  //fprintf(stderr, "block has %d exploded statements\n", statements.size()); 
+
+  omega::CG_chillRepr *OR; 
+  if (0 == statements.size()) { 
+    OR = new omega::CG_chillRepr(code); // presumably a compound statement ??
+  }
+  else { 
+    fprintf(stderr, "adding a statement from IR_chillBlock::extract()\n"); 
+    OR = new omega::CG_chillRepr(); // empty of statements
+    for (int i=0; i<statements.size(); i++) OR->addStatement( statements[i] ); 
+  }
+
+  fflush(stdout); 
+  fprintf(stderr, "IR_xxxxBlock::extract() LEAVING\n"); 
+  return OR;
+}
+
+IR_Control *IR_chillBlock::clone() const {
+  fprintf(stderr, "IR_xxxxBlock::clone()\n"); 
+  //fprintf(stderr, "IR_xxxxBlock::clone()  %d statements\n", statements.size());
+  return new IR_chillBlock( this );  // shallow copy ? 
+}
+
+void IR_chillBlock::dump() const { 
+  fprintf(stderr, "IR_chillBlock::dump()  TODO\n");  return;
+}
+
+//StmtList 
+vector<chillAST_node*> IR_chillBlock::getStmtList() const {
+  fprintf(stderr, "IR_xxxxBlock::getStmtList()\n");
+  return statements; // ?? 
+}
+
+
+void IR_chillBlock::addStatement( chillAST_node* s ) {
+  statements.push_back( s );
+}
+
+
+
+void PrintTranslationUnit(  TranslationUnitDecl *TUD) { // ,  ASTContext &CTX ) {
+  fprintf(stderr, "MY PrintTranslationUnit()\n"); 
+  // TUD derived from Decl and DeclContext
+  static DeclContext *DC = TUD->castToDeclContext( TUD );
+  //SourceManager  SM =  CTX.getSourceManager();
+
+  for (DeclContext::decl_iterator DI = DC->decls_begin(), DE = DC->decls_end(); DI != DE; ++DI) {
+    Decl *D = *DI;
+    fprintf(stderr, "D\n"); 
+    if (isa<FunctionDecl>(D))  { fprintf(stderr, "FunctionDecl\n");
+      //PrintFunctionDecl( dyn_cast<FunctionDecl>(D), CTX.getSourceManager(), 0);
+    }
+    else if (isa<VarDecl>(D)) { fprintf(stderr, "VarDecl\n"); 
+      //PrintVarDecl( dyn_cast<VarDecl>(D), CTX.getSourceManager(), 0 );
+    }
+    else if (isa<TypedefDecl>(D)) { fprintf(stderr, "TypedefDecl\n"); 
+      //PrintTypeDefDecl( dyn_cast<TypedefDecl>(D), CTX.getSourceManager(), 0 );
+    }
+    else if (isa<TypeAliasDecl>(D)) { fprintf(stderr, "TypeAliasDecl\n");
+    }
+    else fprintf(stderr, "\na declaration of type %s (%d)\n",   D->getDeclKindName(), D->getKind());
+    //else if (isa<TypedefNameDecl>(D)) { fprintf(stderr, "TypedefNameDecl\n");}
+  }
+}
+
+class NULLASTConsumer : public ASTConsumer
+{
+};
+
+
+
+void findmanually( chillAST_node *node, char *procname, std::vector<chillAST_node*>& procs ) {
+  //fprintf(stderr, "findmanually()                CHILL AST node of type %s\n", node->getTypeString()); 
+  
+  if (node->asttype == CHILLAST_NODETYPE_FUNCTIONDECL ) { 
+    char *name = ((chillAST_FunctionDecl *) node)->functionName;
+    //fprintf(stderr, "node name 0x%x  ", name);
+    //fprintf(stderr, "%s     procname ", name); 
+    //fprintf(stderr, "0x%x  ", procname);
+    //fprintf(stderr, "%s\n", procname); 
+    if (!strcmp( name, procname)) {
+      //fprintf(stderr, "found procedure %s\n", procname ); 
+      procs.push_back( node ); 
+      // quit recursing. probably not correct in some horrible case
+      return; 
+    }
+    //else fprintf(stderr, "this is not the function we're looking for\n"); 
+  }
+
+
+  // this is where the children can be used effectively. 
+  // we don't really care what kind of node we're at. We just check the node itself
+  // and then its children is needed. 
+
+  int numc = node->children.size();  
+  //fprintf(stderr, "%d children\n", numc);
+
+  for (int i=0; i<numc; i++) {
+    //fprintf(stderr, "node of type %s is recursing to child %d\n",  node->getTypeString(), i); 
+    findmanually( node->children[i], procname, procs );
+  }
+  return; 
+}
+
+// ----------------------------------------------------------------------------
+// Class: IR_clangCode_Global_Init
+// ----------------------------------------------------------------------------
+
+IR_clangCode_Global_Init *IR_clangCode_Global_Init::pinstance = 0;
+
+
+IR_clangCode_Global_Init *IR_clangCode_Global_Init::Instance(char **argv) {
+  fprintf(stderr, "in IR_clangCode_Global_Init::Instance(), "); 
+  if (pinstance == 0) {  
+    //fprintf(stderr, "\n\n***  making the one and only instance ***\n\n\n"); 
+    // this is the only way to create an IR_clangCode_Global_Init
+    pinstance = new IR_clangCode_Global_Init; 
+    pinstance->ClangCompiler = new aClangCompiler( argv[1] );
+
+  }
+  //fprintf(stderr, "leaving  IR_clangCode_Global_Init::Instance()\n"); 
+  return pinstance;
+}
+
+
+aClangCompiler::aClangCompiler( char *filename ) {
+  
+  //fprintf(stderr, "making a clang compiler for file %s\n", filename);
+  SourceFileName = strdup( filename );
+
+  // Arguments to pass to the clang frontend
+  std::vector<const char *> args;
+  args.push_back(strdup(filename)); 
+  
+  // The compiler invocation needs a DiagnosticsEngine so it can report problems
+  //IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); // temp
+  diagnosticOptions =  new DiagnosticOptions(); // private member of aClangCompiler
+  
+  pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter(llvm::errs(), diagnosticOptions); // private member of aClangCompiler
+  
+  //llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagID(new clang::DiagnosticIDs());
+  diagID =  new clang::DiagnosticIDs(); // private member of IR_clangCode_Global_Init
+  
+  //clang::DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
+  diagnosticsEngine = new clang::DiagnosticsEngine(diagID, diagnosticOptions, pTextDiagnosticPrinter);
+  
+  // Create the compiler invocation
+  // This class is designed to represent an abstract "invocation" of the compiler, 
+  // including data such as the include paths, the code generation options, 
+  // the warning flags, and so on.   
+  std::unique_ptr<clang::CompilerInvocation> CI(new clang::CompilerInvocation());
+  //CI = new clang::CompilerInvocation;
+  clang::CompilerInvocation::CreateFromArgs(*CI, &args[0], &args[0] + args.size(), *diagnosticsEngine);
+
+  
+  // Create the compiler instance
+  Clang = new clang::CompilerInstance();  // TODO should have a better name ClangCompilerInstance
+
+
+  // Get ready to report problems
+  Clang->createDiagnostics(nullptr, true);
+  //Clang.createDiagnostics(0, 0);
+  
+  
+//#ifdef KIDDINGME
+    //fprintf(stderr, "target\n"); 
+  // Initialize target info with the default triple for our platform.
+  //TargetOptions TO;
+  //TO.Triple = llvm::sys::getDefaultTargetTriple();
+  //TargetInfo *TI = TargetInfo::CreateTargetInfo( Clang->getDiagnostics(), TO);
+
+  // the above causes core dumps, because clang is stupid and frees the target multiple times, corrupting memory
+  const std::shared_ptr<clang::TargetOptions> to = std::make_shared<clang::TargetOptions>();
+  targetOptions->Triple = llvm::sys::getDefaultTargetTriple();
+
+  TargetInfo *pti = TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),to);
+
+  Clang->setTarget(pti);
+  
+//#endif
+
+  
+  // ?? 
+  //fprintf(stderr, "filemgr\n");
+  Clang->createFileManager();
+  FileManager &FileMgr = Clang->getFileManager();
+  fileManager = &FileMgr;
+  
+  //fprintf(stderr, "sourcemgr\n");
+  Clang->createSourceManager(FileMgr);
+  SourceManager &SourceMgr = Clang->getSourceManager();
+  sourceManager = &SourceMgr; // ?? aclangcompiler copy
+  globalSRCMAN =  &SourceMgr; //  TODO   global bad 
+
+  Clang->setInvocation(CI.get()); // Replace the current invocation
+
+
+
+  //fprintf(stderr, "PP\n");
+  Clang->createPreprocessor(TU_Complete);
+
+
+
+  //clang::Preprocessor Pre = Clang->getPreprocessor();
+  //preprocessor = &Pre;
+
+  //fprintf(stderr, "CONTEXT\n");
+  Clang->createASTContext();                              // needs preprocessor 
+  astContext_ = &Clang->getASTContext(); 
+  
+
+  //fprintf(stderr, "filein\n"); 
+  const FileEntry *FileIn = FileMgr.getFile(filename); // needs preprocessor
+  SourceMgr.setMainFileID(SourceMgr.createFileID(FileIn,clang::SourceLocation(),clang::SrcMgr::C_User));
+  //DiagnosticConsumer DiagConsumer = Clang->getDiagnosticClient();
+  Clang->getDiagnosticClient().BeginSourceFile( Clang->getLangOpts(), &Clang->getPreprocessor());
+
+
+  NULLASTConsumer TheConsumer; // must pass a consumer in to ParseAST(). This one does nothing
+
+  //fprintf(stderr, "ready? Parse.\n");
+  fprintf(stderr, "actually parsing file %s using clang\n", filename); 
+
+  ParseAST( Clang->getPreprocessor(), &TheConsumer, Clang->getASTContext());
+
+  // Translation Unit is contents of a file 
+  TranslationUnitDecl* TUD = astContext_->getTranslationUnitDecl();
+  // TUD->dump();  // print it out 
+
+  // create another AST, very similar to the clang AST but not written by idiots
+  fprintf(stderr, "converting entire clang AST into chill AST (ir_clang.cc)\n"); 
+  chillAST_node * wholefile = ConvertTranslationUnit( TUD, filename); 
+
+  fflush(stdout);
+  //fprintf(stderr, "printing whole file\n"); 
+  //fprintf(stdout, "\n\n" );   fflush(stdout);
+  //wholefile->print();
+  //wholefile->dump(); 
+  //fflush(stdout);
+
+  entire_file_AST = (chillAST_SourceFile *)wholefile; 
+
+
+  astContext_ = &Clang->getASTContext(); 
+
+  //#define DOUBLE
+#ifdef DOUBLE
+  fprintf(stderr, "DOUBLE\n"); 
+
+  fprintf(stderr, "\n\nCLANG dump of the file I parsed:\n"); 
+  llvm::OwningPtr<clang::FrontendAction> Act2(new clang::ASTDumpAction());
+  // here it actually does the FrontEndAction ?? 
+  if (!Clang->ExecuteAction(*Act2)) { // ast dump using builtin function
+    exit(3);
+  }
+#endif
+  fflush(stdout); fflush(stderr); 
+  fflush(stdout); fflush(stderr); 
+  fflush(stdout); fflush(stderr); 
+  fflush(stdout); fflush(stderr); 
+
+
+
+
+
+
+
+
+
+#ifdef DONTDOTHIS   
+  
+  // calling this Action seems to overwrite the astcontext and the AST. (!)
+  // don't ever do this, or you lose contact with the original AST (?)
+
+  // Create an action and make the compiler instance carry it out
+  //llvm::OwningPtr<clang::CodeGenAction> Act(new clang::EmitLLVMOnlyAction());
+  llvm::OwningPtr<clang::FrontendAction> Act(new clang::ASTDumpAction());
+  
+  fprintf(stderr, "\n\ndump of the file I parsed:\n"); 
+  // here it actually does the FrontEndAction ?? 
+  if (!Clang->ExecuteAction(*Act)) { // ast dump using builtin function
+    exit(3);
+  }
+  fflush(stdout);
+#endif
+
+  
+  //fprintf(stderr, "leaving aClangCompiler::aClangCompiler( filename )\n"); 
+}
+
+
+
+
+chillAST_FunctionDecl*  aClangCompiler::findprocedurebyname( char *procname ) {
+
+  //fprintf(stderr, "searching through files in the clang AST\n\n");
+  //fprintf(stderr, "astContext_  0x%x\n", astContext_);
+
+  std::vector<chillAST_node*> procs;
+  findmanually( entire_file_AST, procname, procs );
+
+  //fprintf(stderr, "procs has %d members\n", procs.size());
+
+  if ( procs.size() == 0 ) { 
+    fprintf(stderr, "could not find function named '%s' in AST from file %s\n", procname, SourceFileName);
+    exit(-1);
+  }
+  
+  if ( procs.size() > 1 ) { 
+    fprintf(stderr, "oddly, found %d functions named '%s' in AST from file %s\n", procs.size(), procname, SourceFileName);
+    fprintf(stderr, "I am unsure what to do\n"); 
+    exit(-1);
+  }
+
+  fprintf(stderr, "found the procedure named %s\n", procname); 
+  return (chillAST_FunctionDecl *)procs[0];
+
+}
+
+
+
+#ifdef NOPE 
+IR_clangCode_Global_Init::IR_clangCode_Global_Init(char *filename  , clang::FileSystemOptions fso ) :   
+  fileManager(fso) // ,  headerSearch( headerSearchOptions, fileManager, diagengine,  languageOptions, pTargetInfo )
+{ 
+  /* CLANG Initialization */
+  diagnosticsEngine = new clang::DiagnosticsEngine( const IntrusiveRefCntPtr<DiagnosticIDs> &Diags,
+                                                    diagnosticOptionsnsa utah
+                                                    ) ; // DiagnosticConsumer *client = 0,  bool ShouldOwnClient = true)
+  pTextDiagnosticPrinter = new clang::TextDiagnosticPrinter(llvm::outs(), diagnosticOptions);
+  diagnostic = new clang::Diagnostic(pTextDiagnosticPrinter);
+  sourceManager = new clang::SourceManager(*diagnostic);
+  
+  // FIXME
+  
+  // <Warning!!> -- Platform Specific Code lives here
+  // This depends on A) that you're running linux and
+  // B) that you have the same GCC LIBs installed that
+  // I do. 
+  // Search through Clang itself for something like this,
+  // go on, you won't find it. The reason why is Clang
+  // has its own versions of std* which are installed under 
+  // /usr/local/lib/clang/<version>/include/
+  // See somewhere around Driver.cpp:77 to see Clang adding
+  // its version of the headers to its include path.
+  /*headerSearchOptions.AddPath("/usr/include/linux", clang::frontend::Angled, false, false, false);
+    headerSearchOptions.AddPath("/usr/include/c++/4.3/tr1", clang::frontend::Angled, false, false, false);
+    headerSearchOptions.AddPath("/usr/include/c++/4.3", clang::frontend::Angled, false, false, false);*/
+  // </Warning!!> -- End of Platform Specific Code
+  
+  targetOptions.Triple = llvm::sys::getHostTriple();
+  pTargetInfo = clang::TargetInfo::CreateTargetInfo(*diagnostic, targetOptions);
+  clang::ApplyHeaderSearchOptions( headerSearch, headerSearchOptions, languageOptions, pTargetInfo->getTriple());
+  preprocessor = new clang::Preprocessor(*diagnostic, languageOptions, *pTargetInfo, *sourceManager, headerSearch);
+  clang::InitializePreprocessor(*preprocessor, preprocessorOptions, headerSearchOptions, frontendOptions); 
+  const clang::FileEntry *pFile = fileManager.getFile(filename);
+  sourceManager->createMainFileID(pFile);
+  //preprocessor.EnterMainSourceFile();
+  
+  clang::TargetInfo &targetInfo = *pTargetInfo;
+  
+  idTable = new clang::IdentifierTable(languageOptions);
+  
+  builtinContext = new clang::Builtin::Context(targetInfo);
+  astContext_ = new clang::ASTContext(languageOptions, *sourceManager, targetInfo, *idTable, selTable, *builtinContext, 0); 
+  astConsumer_ = new Chill_ASTConsumer();
+  clang::Sema sema(*preprocessor, *astContext_, *astConsumer_);
+  sema.Initialize();
+  clang::ParseAST(*preprocessor, astConsumer_, *astContext_);
+}
+#endif 
+
+
+IR_clangCode_Global_Init::~IR_clangCode_Global_Init()
+{
+  /*
+  delete pTextDiagnosticPrinter;
+  delete diagnostic;
+  delete sourceManager;
+  delete preprocessor;
+  delete idTable;
+  delete builtinContext;
+  delete astContext_;
+  delete astConsumer_;
+  */
+}
+
+
+
+// ----------------------------------------------------------------------------
+// Class: IR_clangCode
+// ----------------------------------------------------------------------------
+
+IR_clangCode::IR_clangCode(const char *fname, char *proc_name): IR_Code() {
+  fprintf(stderr, "\nIR_xxxxCode::IR_xxxxCode()\n\n"); 
+  //fprintf(stderr, "IR_clangCode::IR_clangCode( filename %s, procedure %s )\n", filename, proc_name);
+  
+  filename = strdup(fname); // filename is internal to IR_clangCode
+  procedurename = strdup(proc_name);
+
+  int argc = 2;
+  char *argv[2];
+  argv[0] = "chill";
+  argv[1] = strdup(filename);
+  
+  // use clang to parse the input file  ?   (or is that already done?) 
+  //fprintf(stderr, "IR_clangCode::IR_clangCode(), parsing input file %s\n", argv[1]);
+  
+  // this causes opening and parsing of the file.  
+  // this is the only call to Instance that has an argument list or file name 
+  IR_clangCode_Global_Init *pInstance = IR_clangCode_Global_Init::Instance(argv);
+  
+  if(pInstance) {
+    
+    aClangCompiler *Clang = pInstance->ClangCompiler;
+    //fprintf(stderr, "Clang is 0x%x\n", Clang);
+
+    //fprintf(stderr, "want to get pointer to clang ast for procedure %s\n", proc_name); 
+    pInstance->setCurrentFunction( NULL );  // we have no function AST yet
+
+    entire_file_AST = Clang->entire_file_AST;  // ugly that same name, different classes
+    chillAST_FunctionDecl *localFD = Clang->findprocedurebyname( proc_name );   // stored locally
+    //fprintf(stderr, "back from findprocedurebyname( %s )\n", proc_name ); 
+    //localFD->print();
+
+    pInstance->setCurrentFunction( localFD ); 
+
+    chillAST_node *b = localFD->getBody();  // we do this just because it will get done next 
+    fprintf(stderr, "in IR_xxxxCode::IR_xxxxCode(), new CG_xxxxBuilder\n"); 
+
+    fprintf(stderr, "ir_clang.cc calling new CG_chillBuilder() umwut?\n"); 
+    ocg_ = new omega::CG_chillBuilder();  // ocg == omega code gen
+    chillfunc =  localFD; 
+
+  }
+
+  fprintf(stderr, "IR_xxxxCode::IR_xxxxCode() returning after reading source file and finding function\n\n"); 
+
+  //chillfunc->dump( 0, stderr); 
+
+}
+
+
+IR_clangCode::~IR_clangCode() {
+  //func_->print(llvm::outs(), 4); // printing as part of the destructor !! 
+  fprintf(stderr, "IR_xxxxCode::~IR_xxxxCode()\noutput happening as part of the destructor !!\n");
+  //chillfunc->dump(); 
+  //chillfunc->print(); 
+
+  //fprintf(stderr, "Constant Folding before\n"); 
+  //chillfunc->print(); 
+  chillfunc->constantFold(); 
+  //fprintf(stderr, "\nConstant Folding after\n"); 
+  //chillfunc->print(); 
+
+  chillfunc->cleanUpVarDecls(); 
+
+  //chillfunc->dump(); 
+
+  // TODO should output the entire file, not just the function we're working on
+  chillAST_SourceFile *src = chillfunc->getSourceFile(); 
+  //chillAST_node *p = chillfunc->parent; // should be translationDeclUnit
+  if (src) { 
+    //src->print(); // tmp
+    if (src->isSourceFile()) src->printToFile(  ); 
+  }
+}
+
+
+
+
+
+//TODO
+IR_ScalarSymbol *IR_clangCode::CreateScalarSymbol(const IR_Symbol *sym, int i) {
+  //fprintf(stderr, "IR_clangCode::CreateScalarSymbol()\n");  
+  if (typeid(*sym) == typeid( IR_chillScalarSymbol ) ) {  // should be the case ??? 
+    fprintf(stderr, "IR_xxxxCode::CreateScalarSymbol() from a scalar symbol\n"); 
+    //fprintf(stderr, "(typeid(*sym) == typeid( IR_chillScalarSymbol )\n"); 
+    const IR_chillScalarSymbol *CSS = (IR_chillScalarSymbol*) sym;
+    chillAST_VarDecl *vd = CSS->chillvd;
+    
+    // do we have to check to see if it's already there? 
+     VariableDeclarations.push_back(vd);
+     chillAST_node *bod = chillfunc->getBody(); // always a compoundStmt ?? 
+     bod->insertChild(0, vd);
+     fprintf(stderr, "returning ... really\n"); 
+    return new IR_chillScalarSymbol( this, CSS->chillvd); // CSS->clone(); 
+  }
+
+  // ?? 
+  if (typeid(*sym) == typeid( IR_chillArraySymbol ) ) {  
+    fprintf(stderr, "IR_xxxxCode::CreateScalarSymbol() from an array symbol?\n"); 
+    const IR_chillArraySymbol *CAS = (IR_chillArraySymbol*) sym;
+    //fprintf(stderr, "CAS 0x%x   chillvd = 0x%x\n", CAS, CAS->chillvd);
+    //fprintf(stderr, "\nthis is the SYMBOL?: \n"); 
+    //CAS->print();
+    //CAS->dump();
+
+    chillAST_VarDecl *vd = CAS->chillvd; 
+    //fprintf(stderr, "\nthis is the var decl?: "); 
+    //vd->print(); printf("\n"); 
+    //vd->dump(); printf("\n\n");
+    fflush(stdout);  
+    
+    // figure out the base type (probably float) of the array
+    char *basetype = vd->underlyingtype;
+    fprintf(stderr, "scalar will be of type SgType%s\n", basetype);   
+
+    char tmpname[128];
+    sprintf(tmpname, "newVariable%i\0", vd->chill_scalar_counter++); 
+    chillAST_VarDecl * scalarvd = new chillAST_VarDecl( basetype, tmpname,  "",  NULL);  // TODO parent
+    scalarvd->print(); printf("\n"); fflush(stdout); 
+
+    fprintf(stderr, "VarDecl has parent that is a NULL\n"); 
+
+    return (IR_ScalarSymbol *) (new IR_chillScalarSymbol( this, scalarvd)); // CSS->clone(); 
+  }
+  
+  fprintf(stderr, "IR_clangCode::CreateScalarSymbol(), passed a sym that is not a clang scalar symbol OR an array symbol???\n"); 
+  int *n = NULL;
+  n[0] = 1;
+  exit(-1); 
+  return NULL;
+}
+
+
+IR_ArraySymbol *IR_clangCode::CreateArraySymbol(const IR_Symbol *sym, std::vector<omega::CG_outputRepr *> &size, int i) {
+  fprintf(stderr, "IR_xxxxCode::CreateArraySymbol()\n");  
+
+  // build a new array name 
+  char namestring[128];
+
+  sprintf(namestring, "_P%d\0", entire_file_AST->chill_array_counter++);
+  fprintf(stderr, "creating Array %s\n", namestring); 
+    
+  char arraypart[100];
+  char *s = &arraypart[0];
+
+  for (int i=0; i<size.size(); i++) { 
+    omega::CG_outputRepr *OR = size[i];
+    CG_chillRepr * CR = (CG_chillRepr * ) OR;
+    //fprintf(stderr, "%d chillnodes\n", CR->chillnodes.size()); 
+    
+    // this SHOULD be 1 chillnode of type IntegerLiteral (per dimension)
+    int numnodes = CR->chillnodes.size();
+    if (1 != numnodes) { 
+      fprintf(stderr, 
+              "IR_clangCode::CreateArraySymbol() array dimension %d has %d chillnodes\n", 
+              i, numnodes );
+      exit(-1);
+    }
+
+    chillAST_node *nodezero = CR->chillnodes[0];
+    if (!nodezero->isIntegerLiteral())  {
+      fprintf(stderr, "IR_clangCode::CreateArraySymbol() array dimension %d not an IntegerLiteral\n", i);
+      exit(-1);
+    }
+
+    chillAST_IntegerLiteral *IL = (chillAST_IntegerLiteral *)nodezero;
+    int val = IL->value;
+    sprintf(s, "[%d]\0", val); 
+    s = &arraypart[ strlen(arraypart) ];
+  }
+  //fprintf(stderr, "arraypart '%s'\n", arraypart); 
+
+  chillAST_VarDecl *vd = new chillAST_VarDecl( "float",  namestring, arraypart, NULL); // todo type from sym
+
+  // put decl in some symbol table
+  VariableDeclarations.push_back(vd);
+  // insert decl in the IR_code body
+  chillAST_node *bod = chillfunc->getBody(); // always a compoundStmt ?? 
+  bod->insertChild(0, vd);
+
+  return new IR_chillArraySymbol( this, vd); 
+}
+
+// TODO 
+std::vector<IR_ScalarRef *> IR_clangCode::FindScalarRef(const omega::CG_outputRepr *repr) const {
+  std::vector<IR_ScalarRef *> scalars;
+  fprintf(stderr, "IR_clangCode::FindScalarRef() DIE\n");  exit(-1); 
+  return scalars;
+}
+
+
+
+IR_ScalarRef *IR_clangCode::CreateScalarRef(const IR_ScalarSymbol *sym) {
+  //fprintf(stderr, "\n***** ir_clang.cc IR_clangCode::CreateScalarRef( sym %s )\n", sym->name().c_str()); 
+  //DeclRefExpr *de = new (vd->getASTContext())DeclRefExpr(static_cast<ValueDecl*>(vd), vd->getType(), SourceLocation());
+  //fprintf(stderr, "sym 0x%x\n", sym); 
+
+  IR_chillScalarRef *sr = new IR_chillScalarRef(this, buildDeclRefExpr(((IR_chillScalarSymbol*)sym)->chillvd)); // uses VarDecl to mak a declrefexpr
+  //fprintf(stderr, "returning ScalarRef with dre 0x%x\n", sr->dre); 
+  return sr; 
+  //return (IR_ScalarRef *)NULL;
+}
+
+
+
+IR_ArrayRef *IR_clangCode::CreateArrayRef(const IR_ArraySymbol *sym, std::vector<omega::CG_outputRepr *> &index) {
+  fprintf(stderr, "IR_clangCode::CreateArrayRef()   ir_clang.cc\n"); 
+  fprintf(stderr, "sym->n_dim() %d   index.size() %d\n", sym->n_dim(), index.size()); 
+
+  int t;
+  if(sym->n_dim() != index.size()) {
+    throw std::invalid_argument("incorrect array symbol dimensionality   dim != size    ir_clang.cc L2359");
+  }
+
+  const IR_chillArraySymbol *c_sym = static_cast<const IR_chillArraySymbol *>(sym);
+  chillAST_VarDecl *vd = c_sym->chillvd;
+  std::vector<chillAST_node *> inds;
+
+  //fprintf(stderr, "%d array indeces\n", sym->n_dim()); 
+  for (int i=0; i< index.size(); i++) { 
+    CG_chillRepr *CR = (CG_chillRepr *)index[i];
+   
+    int numnodes = CR->chillnodes.size();
+    if (1 != numnodes) { 
+      fprintf(stderr, 
+              "IR_clangCode::CreateArrayRef() array dimension %d has %d chillnodes\n", 
+              i, numnodes );
+      exit(-1);
+    }
+
+    inds.push_back( CR->chillnodes[0] );
+
+    /* 
+       chillAST_node *nodezero = CR->chillnodes[0];
+    if (!nodezero->isIntegerLiteral())  {
+      fprintf(stderr,"IR_clangCode::CreateArrayRef() array dimension %d not an IntegerLiteral\n",i);
+      fprintf(stderr, "it is a %s\n", nodezero->getTypeString()); 
+      nodezero->print(); printf("\n"); fflush(stdout); 
+      exit(-1);
+    }
+
+    chillAST_IntegerLiteral *IL = (chillAST_IntegerLiteral *)nodezero;
+    int val = IL->value;
+    inds.push_back( val );
+    */
+  }
+
+  // now we've got the vardecl AND the indeces to make a chillAST that represents the array reference
+  // TODO Passing NULL for chillAST node?
+  chillAST_ArraySubscriptExpr *ASE = new chillAST_ArraySubscriptExpr( vd, inds, NULL);
+
+  auto ref = new IR_chillArrayRef( this, ASE, 0 );
+
+  return ref;
+}
+
+// find all array references ANYWHERE in this block of code  ?? 
+std::vector<IR_ArrayRef *> IR_clangCode::FindArrayRef(const omega::CG_outputRepr *repr) const {
+  //fprintf(stderr, "FindArrayRef()\n"); 
+  std::vector<IR_ArrayRef *> arrays;
+  const omega::CG_chillRepr *crepr = static_cast<const omega::CG_chillRepr *>(repr); 
+  std::vector<chillAST_node*> chillstmts = crepr->getChillCode();
+
+  //fprintf(stderr, "there are %d chill statements in this repr\n", chillstmts.size()); 
+
+  std::vector<chillAST_ArraySubscriptExpr*> refs; 
+  for (int i=0; i<chillstmts.size(); i++) { 
+    //fprintf(stderr, "\nchillstatement %d = ", i); chillstmts[i]->print(0, stderr); fprintf(stderr, "\n"); 
+    chillstmts[i]->gatherArrayRefs( refs, false );
+  }
+  //fprintf(stderr, "%d total refs\n", refs.size());
+  for (int i=0; i<refs.size(); i++) { 
+    if (refs[i]->imreadfrom) { 
+      //fprintf(stderr, "ref[%d] going to be put in TWICE, as both read and write\n", i); 
+      arrays.push_back( new IR_chillArrayRef( this, refs[i], 0 ) );  // UGLY TODO dual usage of a ref in "+="
+    }
+    arrays.push_back( new IR_chillArrayRef( this, refs[i], refs[i]->imwrittento ) ); // this is wrong
+    // we need to know whether this reference will be written, etc. 
+  }
+
+  /* 
+  if(chillstmts.size() > 1) {
+    for(int i=0; i<tnl->size(); ++i) {
+      omega::CG_chillRepr *r = new omega::CG_chillRepr((*tnl)[i]);
+      std::vector<IR_ArrayRef *> a = FindArrayRef(r);
+      delete r;
+      std::copy(a.begin(), a.end(), back_inserter(arrays));
+    }
+  } else if(chillstmts.size() == 1) {
+    Stmt *s = (*tnl)[0];
+    
+    if(CompoundStmt *cs = dyn_cast<CompoundStmt>(s)) {
+      for(CompoundStmt::body_iterator bi = cs->body_begin(); bi != cs->body_end(); ++bi) {
+        omega::CG_chillRepr *r = new omega::CG_chillRepr(*bi);
+        std::vector<IR_ArrayRef *> a = FindArrayRef(r);
+        delete r;
+        std::copy(a.begin(), a.end(), back_inserter(arrays));
+      }
+    } else if(ForStmt *fs = dyn_cast<ForStmt>(s)) {
+      omega::CG_chillRepr *r = new omega::CG_chillRepr(fs->getBody());
+      std::vector<IR_ArrayRef *> a = FindArrayRef(r);
+      delete r;
+      std::copy(a.begin(), a.end(), back_inserter(arrays));
+    } else if(IfStmt *ifs = dyn_cast<IfStmt>(s)) {
+      omega::CG_chillRepr *r = new omega::CG_chillRepr(ifs->getCond());
+      std::vector<IR_ArrayRef *> a = FindArrayRef(r);
+      delete r;
+      std::copy(a.begin(), a.end(), back_inserter(arrays));
+      r = new omega::CG_chillRepr(ifs->getThen());
+      a = FindArrayRef(r);
+      delete r;
+      std::copy(a.begin(), a.end(), back_inserter(arrays));
+      if(Stmt *s_else = ifs->getElse()) {
+        r = new omega::CG_chillRepr(s_else);
+        a = FindArrayRef(r);
+        delete r;
+        std::copy(a.begin(), a.end(), back_inserter(arrays));
+      }
+    } else if(Expr *e = dyn_cast<Expr>(s)) {
+      omega::CG_chillRepr *r = new omega::CG_chillRepr(static_cast<Expr*>(s));
+      std::vector<IR_ArrayRef *> a = FindArrayRef(r);
+      delete r;
+      std::copy(a.begin(), a.end(), back_inserter(arrays));
+    } else throw ir_error("control structure not supported");
+  }
+  */
+/* 
+  else { // We have an expression
+    Expr *op = static_cast<const omega::CG_chillRepr *>(repr)->GetExpression();
+    if(0) { // TODO: Handle pointer reference exp. here
+    } else if(BinaryOperator *bop = dyn_cast<BinaryOperator>(op)) {
+      omega::CG_chillRepr *r1 = new omega::CG_chillRepr(bop->getLHS());
+      std::vector<IR_ArrayRef *> a1 = FindArrayRef(r1);
+      delete r1;      
+      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
+      omega::CG_chillRepr *r2 = new omega::CG_chillRepr(bop->getRHS());
+      std::vector<IR_ArrayRef *> a2 = FindArrayRef(r2);
+      delete r2;
+      std::copy(a2.begin(), a2.end(), back_inserter(arrays));
+    } else if(UnaryOperator *uop = dyn_cast<UnaryOperator>(op)) {
+      omega::CG_chillRepr *r1 = new omega::CG_chillRepr(uop->getSubExpr());
+      std::vector<IR_ArrayRef *> a1 = FindArrayRef(r1);
+      delete r1;      
+      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
+    } //else throw ir_error("Invalid expr. type passed to FindArrayRef");
+  }
+  */
+  return arrays;
+}
+
+
+std::vector<IR_Control *> IR_clangCode::FindOneLevelControlStructure(const IR_Block *block) const {
+  fprintf(stderr, "IR_xxxxCode::FindOneLevelControlStructure()\n"); 
+  const IR_chillBlock *CB = (const IR_chillBlock *) block; 
+  //fprintf(stderr, "block 0x%x\n", block); 
+
+  std::vector<IR_Control *> controls;
+
+  chillAST_node *blockast = CB->chillAST;
+  //fprintf(stderr, "blockast 0x%x\n", blockast); 
+  if (blockast == NULL) { 
+    int numstmts = CB->statements.size(); 
+    fprintf(stderr, "%d statements\n", numstmts); 
+
+    if (numstmts == 0) return controls; 
+
+    else if (numstmts == 1) blockast = CB->statements[0]; // a single statement
+
+    else { 
+      fprintf(stderr, "IR_xxxBlock is dumb, with multiple ways to hold statements\n");
+      exit(-1); // TODO FIX 
+    }
+  }
+
+  //fprintf(stderr, "block's AST is of type %s\n", blockast->getTypeString()); 
+  //blockast->print(); printf("\n\n"); fflush(stdout);
+
+  
+  //vector<chillAST_node *> funcchildren = chillfunc->getChildren(); 
+  //fprintf(stderr, "%d children of clangcode\n", funcchildren.size());  // includes parameters
+
+  // build up a vector of "controls".
+  // a run of straight-line code (statements that can't cause branching) will be 
+  // bundled up into an IR_Block
+  // ifs and loops will get their own entry
+
+  std::vector<chillAST_node *> children;
+
+  
+  if (blockast->asttype == CHILLAST_NODETYPE_FORSTMT) { fflush(stdout); 
+    fprintf(stderr, "found a top level For statement (Loop)\n"); 
+    fprintf(stderr, "For Stmt (loop) is:\n");
+    blockast->print(); 
+    fprintf(stderr, "pushing the loop at TOP\n"); 
+
+    controls.push_back( new IR_chillLoop( this, (chillAST_ForStmt *)blockast)); 
+  }
+  //else if (blockast->asttype == CHILLAST_NODETYPE_IFSTMT) { 
+  //  controls.push_back( new IR_clangIf( this, (chillAST_IfStmt *)blockast)); 
+  //} 
+  else if (blockast->asttype == CHILLAST_NODETYPE_COMPOUNDSTMT || 
+           blockast->asttype == CHILLAST_NODETYPE_FUNCTIONDECL) { 
+
+    if (blockast->asttype == CHILLAST_NODETYPE_FUNCTIONDECL) { 
+      //fprintf(stderr, "ir_clanc.cc blockast->asttype == CHILLAST_NODETYPE_FUNCTIONDECL\n"); 
+
+      chillAST_FunctionDecl *FD =  (chillAST_FunctionDecl *)blockast;
+      chillAST_node *bod = FD->getBody(); 
+      //fprintf(stderr, "bod 0x%x\n", bod); 
+
+      children = bod->getChildren(); 
+
+      //fprintf(stderr, "FunctionDecl body is of type %s\n", bod->getTypeString()); 
+      //fprintf(stderr, "found a top level FunctionDecl (Basic Block)\n"); 
+      //fprintf(stderr, "basic block has %d statements\n", children.size() );
+      //fprintf(stderr, "basic block is:\n");
+      //bod->print(); 
+    }
+    else /* CompoundStmt */ {
+      //fprintf(stderr, "found a top level Basic Block\n"); 
+      children = blockast->getChildren();
+    }
+    
+    int numchildren = children.size(); 
+    //fprintf(stderr, "basic block has %d statements\n", numchildren);
+    //fprintf(stderr, "basic block is:\n");
+    //fprintf(stderr, "{\n");
+    //blockast->print(); 
+    //fprintf(stderr, "}\n");
+    
+    int ns; 
+    IR_chillBlock *basicblock = new IR_chillBlock(this); // no statements
+    for (int i=0; i<numchildren; i++) { 
+      //fprintf(stderr, "child %d is of type %s\n", i, children[i]->getTypeString());
+      CHILL_ASTNODE_TYPE typ = children[i]->asttype;
+      if (typ == CHILLAST_NODETYPE_LOOP) {
+        if (numchildren == 1) { 
+          fprintf(stderr, "found a For statement (Loop)\n"); 
+        }
+        else { 
+          fprintf(stderr, "found a For statement (Loop) at %d within a Basic Block\n", i); 
+        }
+        //children[i]->print(); printf("\n"); fflush(stdout);
+        
+        ns = basicblock->numstatements();
+        if (ns) {
+          fprintf(stderr, "pushing a run of statements %d to %d as a block\n", i-ns, i-1); 
+          controls.push_back( basicblock );
+          basicblock = new IR_chillBlock(this); // start a new one
+        }
+        
+        //fprintf(stderr, "pushing the loop at %d\n", i); 
+        controls.push_back( new IR_chillLoop(this, (chillAST_ForStmt *)children[i] )); 
+        
+      }
+      //else if (typ == CHILLAST_NODETYPE_IFSTMT ) // TODO 
+      else { // straight line code
+        //fprintf(stderr, "straight line code\n"); 
+        basicblock->addStatement( children[i] );
+        //fprintf(stderr, "child %d = \n", i); children[i]->print(); printf("\n"); fflush(stdout); 
+        //fprintf(stderr, "child %d is part of a basic block\n", i);
+      }
+    } // for each child
+    ns = basicblock->numstatements();
+    //fprintf(stderr, "ns %d\n", ns); 
+    if (ns != 0 ) { 
+      if (ns != numchildren) {
+        //fprintf(stderr, "end of body ends the run of %d statements in the Basic Block\n", ns); 
+        controls.push_back( basicblock );
+      }
+      else { 
+        //fprintf(stderr, "NOT sending straightline run of statements, because it would be the entire block. There are no control statements in the block\n"); 
+      }
+    }
+    //else fprintf(stderr, "NOT sending the last run of %d statements\n", ns); 
+    
+  }
+  else { 
+    fprintf(stderr, "IR_clangCode::FindOneLevelControlStructure(), block is a %s???\n", blockast->getTypeString());
+    exit(-1);
+  }
+  
+  fprintf(stderr, "returning vector of %d controls\n", controls.size() ); 
+  return controls;
+}
+
+
+IR_Block *IR_clangCode::MergeNeighboringControlStructures(const std::vector<IR_Control *> &controls) const {
+  fprintf(stderr, "IR_xxxxCode::MergeNeighboringControlStructures  %d controls\n", controls.size());
+
+  if (controls.size() == 0)
+    return NULL;
+  
+  IR_chillBlock *CBlock =  new IR_chillBlock(controls[0]->ir_); // the thing we're building
+
+  std::vector<chillAST_node*> statements;
+  chillAST_node *parent = NULL; 
+   for (int i = 0; i < controls.size(); i++) {
+    switch (controls[i]->type()) {
+    case IR_CONTROL_LOOP: {
+      fprintf(stderr, "control %d is IR_CONTROL_LOOP\n", i); 
+      chillAST_ForStmt *loop =  static_cast<IR_chillLoop *>(controls[i])->chillforstmt;
+      if (parent == NULL) {
+        parent = loop->parent;
+      } else {
+        if (parent != loop->parent) { 
+          throw ir_error("controls to merge not at the same level");
+        }
+      }
+      CBlock->addStatement( loop );
+      break;
+     }
+    case IR_CONTROL_BLOCK: {
+      fprintf(stderr, "control %d is IR_CONTROL_BLOCK\n", i); 
+      IR_chillBlock *CB =  static_cast<IR_chillBlock*>(controls[i]);
+      std::vector<chillAST_node*> blockstmts = CB->statements;
+      if (statements.size() != 0) { 
+        for (int j=0; j< blockstmts.size(); j++) {
+          if (parent == NULL) {
+            parent = blockstmts[j]->parent;
+          }
+          else { 
+            if (parent !=  blockstmts[j]->parent) { 
+              throw ir_error("ir_clang.cc  IR_clangCode::MergeNeighboringControlStructures  controls to merge not at the same level");
+            }
+          }
+          CBlock->addStatement( blockstmts[j] );
+        }
+      }
+      else {
+        if (CB->chillAST)  CBlock->addStatement(CBlock->chillAST); // if this is a block, add theblock's statements? 
+        else { // should never happen
+          fprintf(stderr, "WARNING: ir_clang.cc  IR_clangCode::MergeNeighboringControlStructures");
+          fprintf(stderr, "    empty IR_CONTROL_BLOCK \n");
+        }
+      }
+      break;
+    }
+    default:
+      throw ir_error("unrecognized control to merge");
+    }
+   } // for each control
+
+   return CBlock; 
+}
+
+
+IR_Block *IR_clangCode::GetCode() const {    // return IR_Block corresponding to current function?
+  //fprintf(stderr, "IR_clangCode::GetCode()\n"); 
+  //Stmt *s = func_->getBody();  // clang statement, and clang getBody
+  //fprintf(stderr, "chillfunc 0x%x\n", chillfunc);
+
+  //chillAST_node *bod = chillfunc->getBody();  // chillAST 
+  //fprintf(stderr, "printing the function getBody()\n"); 
+  //fprintf(stderr, "sourceManager 0x%x\n", sourceManager); 
+  //bod->print(); 
+
+  return new IR_chillBlock(this, chillfunc ) ; 
+}
+
+
+void IR_clangCode::ReplaceCode(IR_Control *old, omega::CG_outputRepr *repr) {
+  fflush(stdout); 
+  fprintf(stderr, "IR_xxxxCode::ReplaceCode( old, *repr)\n"); 
+
+  CG_chillRepr *chillrepr = (CG_chillRepr *) repr;
+  std::vector<chillAST_node*>  newcode = chillrepr->getChillCode();
+  int numnew = newcode.size();
+
+  //fprintf(stderr, "new code (%d) is\n", numnew); 
+  //for (int i=0; i<numnew; i++) { 
+  //  newcode[i]->print(0, stderr);
+  //  fprintf(stderr, "\n"); 
+  //} 
+
+  struct IR_chillLoop* cloop;
+
+  std::vector<chillAST_VarDecl*> olddecls;
+  chillfunc->gatherVarDecls( olddecls );
+  //fprintf(stderr, "\n%d old decls   they are:\n", olddecls.size()); 
+  //for (int i=0; i<olddecls.size(); i++) {
+  //  fprintf(stderr, "olddecl[%d]  ox%x  ",i, olddecls[i]); 
+  //  olddecls[i]->print(); printf("\n"); fflush(stdout); 
+  //} 
+
+
+  //fprintf(stderr, "num new stmts %d\n", numnew); 
+  //fprintf(stderr, "new code we're look for decls in:\n"); 
+  std::vector<chillAST_VarDecl*> decls;
+  for (int i=0; i<numnew; i++)  {
+    //newcode[i]->print(0,stderr);
+    //fprintf(stderr, "\n"); 
+    newcode[i]->gatherVarUsage( decls );
+  }
+
+  //fprintf(stderr, "\n%d new vars used  they are:\n", decls.size()); 
+  //for (int i=0; i<decls.size(); i++) {
+  //  fprintf(stderr, "decl[%d]  ox%x  ",i, decls[i]); 
+  //  decls[i]->print(); printf("\n"); fflush(stdout); 
+  //} 
+
+
+  for (int i=0; i<decls.size(); i++) {
+    //fprintf(stderr, "\nchecking "); decls[i]->print(); printf("\n"); fflush(stdout); 
+    int inthere = 0; 
+    for (int j=0; j<VariableDeclarations.size(); j++) { 
+      if (VariableDeclarations[j] == decls[i]) { 
+        //fprintf(stderr, "it's in the Variable Declarations()\n");
+      }
+    }
+    for (int j=0; j<olddecls.size(); j++) { 
+      if (decls[i] == olddecls[j]) { 
+        //fprintf(stderr, "it's in the olddecls (exactly)\n");
+        inthere = 1;
+      }
+      if (streq(decls[i]->varname, olddecls[j]->varname)) { 
+        if (streq(decls[i]->arraypart, olddecls[j]->arraypart)) { 
+          //fprintf(stderr, "it's in the olddecls (INEXACTLY)\n");
+          inthere = 1;
+        }
+      }
+    }
+    if (!inthere) {
+      //fprintf(stderr, "inserting decl[%d] for ",i); decls[i]->print(); printf("\n");fflush(stdout); 
+      chillfunc->getBody()->insertChild(0, decls[i]); 
+      olddecls.push_back( decls[i] ); 
+    }
+  }
+  
+  chillAST_node *par;
+  switch (old->type()) {
+  case IR_CONTROL_LOOP: 
+    {
+      //fprintf(stderr, "old is IR_CONTROL_LOOP\n"); 
+      cloop = (struct IR_chillLoop* )old;
+      chillAST_ForStmt *forstmt = cloop->chillforstmt;
+
+      fprintf(stderr, "old was\n");
+      forstmt->print(); printf("\n"); fflush(stdout);
+
+      //fprintf(stderr, "\nnew code is\n");
+      //for (int i=0; i<numnew; i++) { newcode[i]->print(); printf("\n"); } 
+      //fflush(stdout);
+      
+
+      par = forstmt->parent;
+      if (!par) {
+        fprintf(stderr, "old parent was NULL\n"); 
+        fprintf(stderr, "ir_clang.cc that will not work very well.\n");
+        exit(-1); 
+      }
+
+      
+
+      fprintf(stderr, "\nold parent was\n\n{\n"); 
+      par->print(); printf("\n"); fflush(stdout);
+      fprintf(stderr, "\n}\n"); 
+
+      std::vector<chillAST_node*>  oldparentcode = par->getChildren(); // probably only works for compoundstmts
+      //fprintf(stderr, "ir_clang.cc oldparentcode\n"); 
+
+      // find loop in the parent
+      int index = -1;
+      int numstatements = oldparentcode.size();
+      for (int i=0; i<numstatements; i++) if (oldparentcode[i] == forstmt) { index = i; }
+      if (index == -1) { 
+        fprintf(stderr, "ir_clang.cc can't find the loop in its parent\n"); 
+        exit(-1); 
+      }
+      //fprintf(stderr, "loop is index %d\n", index); 
+
+      // insert the new code
+      par->setChild(index, newcode[0]);    // overwrite old stmt
+      //fprintf(stderr, "inserting %s 0x%x as index %d of 0x%x\n", newcode[0]->getTypeString(), newcode[0], index, par); 
+      // do we need to update the IR_cloop? 
+      cloop->chillforstmt = (chillAST_ForStmt*) newcode[0]; // ?? DFL 
+
+
+
+      //printf("inserting "); newcode[0]->print(); printf("\n"); 
+      if (numnew > 1){ 
+        //oldparentcode.insert( oldparentcode.begin()+index+1, numnew-1, NULL); // allocate in bulk
+        
+        // add the rest of the new statements
+        for (int i=1; i<numnew; i++) {
+          printf("inserting "); newcode[i]->print(); printf("\n"); 
+          par->insertChild( index+i, newcode[i] );  // sets parent
+        }
+      }
+
+      // TODO add in (insert) variable declarations that go with the new loops
+      
+
+      fflush(stdout); 
+    }
+    break; 
+  case IR_CONTROL_BLOCK:
+    fprintf(stderr, "old is IR_CONTROL_BLOCK\n"); 
+    fprintf(stderr, "IR_clangCode::ReplaceCode() stubbed out\n"); 
+    exit(-1); 
+    //tf_old = static_cast<IR_chillBlock *>(old)->getStmtList()[0];
+    break; 
+  default:
+    throw ir_error("control structure to be replaced not supported");
+    break;    
+  }
+  
+  fflush(stdout); 
+  //fprintf(stderr, "\nafter inserting %d statements into the Clang IR,", numnew);
+  fprintf(stderr, "\nnew parent2 is\n\n{\n");
+  std::vector<chillAST_node*>  newparentcode = par->getChildren();
+  for (int i=0; i<newparentcode.size(); i++) { 
+    fflush(stdout); 
+    //fprintf(stderr, "%d ", i); 
+    newparentcode[i]->print(); printf(";\n"); fflush(stdout); 
+  }
+
+
+
+  fprintf(stderr, "}\n"); 
+
+}
+
+
+
+
+void IR_clangCode::ReplaceExpression(IR_Ref *old, omega::CG_outputRepr *repr) {
+  fprintf(stderr, "IR_xxxxCode::ReplaceExpression()\n");
+
+  if (typeid(*old) == typeid(IR_chillArrayRef)) {
+    //fprintf(stderr, "expressions is IR_chillArrayRef\n"); 
+    IR_chillArrayRef *CAR = (IR_chillArrayRef *)old;
+    chillAST_ArraySubscriptExpr* CASE = CAR->chillASE;
+    printf("\nreplacing old "); CASE->print(); printf("\n"); fflush(stdout);
+
+    omega::CG_chillRepr *crepr = (omega::CG_chillRepr *)repr;
+    if (crepr->chillnodes.size() != 1) { 
+      fprintf(stderr, "IR_clangCode::ReplaceExpression(), replacing with %d chillnodes???\n"); 
+      //exit(-1);
+    }
+    
+    chillAST_node *newthing = crepr->chillnodes[0]; 
+    fprintf(stderr, "with new "); newthing->print(); printf("\n\n"); fflush(stdout);
+
+    if (!CASE->parent) { 
+      fprintf(stderr, "IR_clangCode::ReplaceExpression()  old has no parent ??\n"); 
+      exit(-1); 
+    }
+
+    fprintf(stderr, "OLD parent = "); // of type %s\n", CASE->parent->getTypeString()); 
+    if (CASE->parent->isImplicitCastExpr()) CASE->parent->parent->print(); 
+    else CASE->parent->print(); 
+    printf("\n"); fflush(stdout); 
+
+    //CASE->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->parent->print(); printf("\n"); fflush(stdout); 
+
+    CASE->parent->replaceChild( CASE, newthing ); 
+
+    fprintf(stderr, "after replace parent is "); // of type %s\n", CASE->parent->getTypeString()); 
+    if (CASE->parent->isImplicitCastExpr()) CASE->parent->parent->print(); 
+    else CASE->parent->print(); 
+    printf("\n\n"); fflush(stdout); 
+
+
+
+    //CASE->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->print(); printf("\n"); fflush(stdout); 
+    //CASE->parent->parent->parent->print(); printf("\n"); fflush(stdout); 
+
+
+  }
+  else  if (typeid(*old) == typeid(IR_chillScalarRef)) {
+    fprintf(stderr, "IR_clangCode::ReplaceExpression()  IR_chillScalarRef unhandled\n"); 
+  }
+  else { 
+    fprintf(stderr, "UNKNOWN KIND OF REF\n"); exit(-1); 
+  }
+
+  delete old;
+}
+
+
+// TODO 
+IR_CONDITION_TYPE IR_clangCode::QueryBooleanExpOperation(const omega::CG_outputRepr *repr) const {
+  return IR_COND_UNKNOWN;
+}
+
+
+
+IR_OPERATION_TYPE IR_clangCode::QueryExpOperation(const omega::CG_outputRepr *repr) const {
+  //fprintf(stderr, "IR_clangCode::QueryExpOperation()\n");
+
+  CG_chillRepr *crepr = (CG_chillRepr *) repr; 
+  chillAST_node *node = crepr->chillnodes[0];
+  //fprintf(stderr, "chillAST node type %s\n", node->getTypeString());
+
+  // really need to be more rigorous than this hack  // TODO 
+  if (node->isImplicitCastExpr()) node = ((chillAST_ImplicitCastExpr*)node)->subexpr;
+  if (node->isCStyleCastExpr())   node = ((chillAST_CStyleCastExpr*)  node)->subexpr;
+  if (node->isParenExpr())        node = ((chillAST_ParenExpr*)       node)->subexpr;
+
+  if (node->isIntegerLiteral() || node->isFloatingLiteral())  return IR_OP_CONSTANT;
+  else if (node->isBinaryOperator() || node->isUnaryOperator()) {
+    char *opstring;
+    if (node->isBinaryOperator()) 
+      opstring= ((chillAST_BinaryOperator*)node)->op; // TODO enum
+    else
+      opstring= ((chillAST_UnaryOperator*)node)->op; // TODO enum
+      
+    if (!strcmp(opstring, "+")) return IR_OP_PLUS;
+    if (!strcmp(opstring, "-")) return IR_OP_MINUS;
+    if (!strcmp(opstring, "*")) return IR_OP_MULTIPLY;
+    if (!strcmp(opstring, "/")) return IR_OP_DIVIDE;
+    if (!strcmp(opstring, "=")) return IR_OP_ASSIGNMENT;
+
+    fprintf(stderr, "ir_clang.cc  IR_clangCode::QueryExpOperation() UNHANDLED Binary(or Unary)Operator op type (%s)\n", opstring); 
+    exit(-1);
+  }
+  else if (node->isDeclRefExpr() ) return  IR_OP_VARIABLE; // ?? 
+  //else if (node->is ) return  something;
+  else { 
+    fprintf(stderr, "IR_clangCode::QueryExpOperation()  UNHANDLED NODE TYPE %s\n", node->getTypeString());
+    exit(-1); 
+  }
+
+  /* CLANG 
+  Expr *e = static_cast<const omega::CG_chillRepr *>(repr)->GetExpression();
+  if(isa<IntegerLiteral>(e) || isa<FloatingLiteral>(e)) return IR_OP_CONSTANT;
+  else if(isa<DeclRefExpr>(e)) return IR_OP_VARIABLE;
+  else if(BinaryOperator *bop = dyn_cast<BinaryOperator>(e)) {
+    switch(bop->getOpcode()) {
+    case BO_Assign: return IR_OP_ASSIGNMENT;
+    case BO_Add: return IR_OP_PLUS;
+    case BO_Sub: return IR_OP_MINUS;
+    case BO_Mul: return IR_OP_MULTIPLY;
+    case BO_Div: return IR_OP_DIVIDE;
+    default: return IR_OP_UNKNOWN;
+    }
+  } else if(UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
+    switch(uop->getOpcode()) {
+    case UO_Minus: return IR_OP_NEGATIVE;
+    case UO_Plus: return IR_OP_POSITIVE;
+    default: return IR_OP_UNKNOWN;
+    }
+  } else if(ConditionalOperator *cop = dyn_cast<ConditionalOperator>(e)) {
+    BinaryOperator *bop;
+    if(bop = dyn_cast<BinaryOperator>(cop->getCond())) {
+      if(bop->getOpcode() == BO_GT) return IR_OP_MAX;
+      else if(bop->getOpcode() == BO_LT) return IR_OP_MIN;
+    } else return IR_OP_UNKNOWN;
+    
+  } 
+  
+  else if(e == NULL) return IR_OP_NULL;
+  else return IR_OP_UNKNOWN;
+  }
+   END CLANG */
+}
+
+
+std::vector<omega::CG_outputRepr *> IR_clangCode::QueryExpOperand(const omega::CG_outputRepr *repr) const { 
+  //fprintf(stderr, "IR_clangCode::QueryExpOperand()\n"); 
+  std::vector<omega::CG_outputRepr *> v;
+  
+  CG_chillRepr *crepr = (CG_chillRepr *) repr; 
+  //Expr *e = static_cast<const omega::CG_chillRepr *>(repr)->GetExpression(); wrong.. CLANG
+  chillAST_node *e = crepr->chillnodes[0]; // ?? 
+  //e->print(); printf("\n"); fflush(stdout); 
+
+  // really need to be more rigorous than this hack  // TODO 
+  if (e->isImplicitCastExpr()) e = ((chillAST_ImplicitCastExpr*)e)->subexpr;
+  if (e->isCStyleCastExpr())   e = ((chillAST_CStyleCastExpr*)  e)->subexpr;
+  if (e->isParenExpr())        e = ((chillAST_ParenExpr*)       e)->subexpr;
+
+
+  //if(isa<IntegerLiteral>(e) || isa<FloatingLiteral>(e) || isa<DeclRefExpr>(e)) {
+  if (e->isIntegerLiteral() || e->isFloatingLiteral() || e->isDeclRefExpr() ) { 
+    //fprintf(stderr, "it's a constant\n"); 
+    omega::CG_chillRepr *repr = new omega::CG_chillRepr(e);
+    v.push_back(repr);
+    //} else if(BinaryOperator *bop = dyn_cast<BinaryOperator>(e)) {
+  } else if (e->isBinaryOperator()) { 
+    //fprintf(stderr, "ir_clang.cc BOP TODO\n"); exit(-1); // 
+    chillAST_BinaryOperator *bop = (chillAST_BinaryOperator*)e;
+    char *op = bop->op;  // TODO enum for operator types
+    if (streq(op, "=")) { 
+      v.push_back(new omega::CG_chillRepr( bop->rhs ));  // for assign, return RHS
+    }
+    else if (streq(op, "+") || streq(op, "-") || streq(op, "*") || streq(op, "/") ) {
+      v.push_back(new omega::CG_chillRepr( bop->lhs ));  // for +*-/ return both lhs and rhs
+      v.push_back(new omega::CG_chillRepr( bop->rhs )); 
+    }
+    else { 
+      fprintf(stderr, "ir_clang.cc  IR_clangCode::QueryExpOperand() Binary Operator  UNHANDLED op (%s)\n", op); 
+      exit(-1);
+    }
+  } // BinaryOperator
+  else if  (e->isUnaryOperator()) { 
+    omega::CG_chillRepr *repr;
+    chillAST_UnaryOperator *uop = (chillAST_UnaryOperator*)e;
+    char *op = uop->op; // TODO enum
+    if (streq(op, "+") || streq(op, "-")) {
+      v.push_back( new omega::CG_chillRepr( uop->subexpr ));
+    }
+    else { 
+      fprintf(stderr, "ir_clang.cc  IR_clangCode::QueryExpOperand() Unary Operator  UNHANDLED op (%s)\n", op); 
+      exit(-1);
+    }
+  } // unaryoperator
+  else { 
+    fprintf(stderr, "ir_clang.cc  IR_clangCode::QueryExpOperand() UNHANDLED node type %s\n", e->getTypeString()); 
+    exit(-1); 
+  }
+    
+
+    /*   
+  Expr *op1, *op2;
+    switch(bop->getOpcode()) {
+    case BO_Assign:
+      op2 = bop->getRHS();
+      repr = new omega::CG_chillRepr(op2);
+      v.push_back(repr);
+      break;
+    case BO_Add:
+    case BO_Sub:
+    case BO_Mul:
+    case BO_Div:
+      op1 = bop->getLHS();
+      repr = new omega::CG_chillRepr(op1);
+      v.push_back(repr);
+      op2 = bop->getRHS();
+      repr = new omega::CG_chillRepr(op2);
+      v.push_back(repr);
+      break;
+    default:
+      throw ir_error("operation not supported");
+    }
+    */
+    //} else if(UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
+    //} else if(e->isUnaryOperator()) { 
+    /* 
+    omega::CG_chillRepr *repr;
+    
+    switch(uop->getOpcode()) {
+    case UO_Minus:
+    case UO_Plus:
+      op1 = uop->getSubExpr();
+      repr = new omega::CG_chillRepr(op1);
+      v.push_back(repr);
+      break;
+    default:
+      throw ir_error("operation not supported");
+    }
+    */
+    //} else if(ConditionalOperator *cop = dyn_cast<ConditionalOperator>(e)) {
+    //omega::CG_chillRepr *repr;
+    
+    // TODO: Handle conditional operator here
+    //} else  throw ir_error("operand type UNsupported");
+  
+  return v;
+}
+
+IR_Ref *IR_clangCode::Repr2Ref(const omega::CG_outputRepr *repr) const {
+  CG_chillRepr *crepr = (CG_chillRepr *) repr; 
+  chillAST_node *node = crepr->chillnodes[0]; 
+  
+  //Expr *e = static_cast<const omega::CG_chillRep *>(repr)->GetExpression();
+
+  if(node->isIntegerLiteral()) { 
+    // FIXME: Not sure if it'll work in all cases (long?)
+    int val = ((chillAST_IntegerLiteral*)node)->value; 
+    return new IR_chillConstantRef(this, static_cast<omega::coef_t>(val) ); 
+  } else if(node->isFloatingLiteral()) { 
+    float val = ((chillAST_FloatingLiteral*)node)->value; 
+    return new IR_chillConstantRef(this, val );
+  } else if(node->isDeclRefExpr()) { 
+    //fprintf(stderr, "ir_clang.cc  IR_clangCode::Repr2Ref()  declrefexpr TODO\n"); exit(-1); 
+    return new IR_chillScalarRef(this, (chillAST_DeclRefExpr*)node);  // uses DRE
+  } else  { 
+    fprintf(stderr, "ir_clang.cc IR_clangCode::Repr2Ref() UNHANDLED node type %s\n", node->getTypeString()); 
+    exit(-1); 
+    //assert(0);
+  }
+}
+
+chillAST_node * ConvertMemberExpr( clang::MemberExpr *clangME , chillAST_node *) { 
+  fprintf(stderr, "ConvertMemberExpr()\n"); 
+  
+  clang::Expr *E = clangME->getBase(); 
+  E->dump();
+
+  chillAST_node *base = ConvertGenericClangAST( clangME->getBase(), NULL );
+
+  DeclarationNameInfo memnameinfo = clangME->getMemberNameInfo(); 
+  DeclarationName DN = memnameinfo.getName();
+  const char *member = DN.getAsString().c_str();
+  //fprintf(stderr, "%s\n", DN.getAsString().c_str());  
+
+  chillAST_MemberExpr *ME = new chillAST_MemberExpr( base, member, NULL, clangME ); 
+
+  fprintf(stderr, "this is the Member Expresion\n"); 
+  ME->print(); 
+  fprintf(stderr, "\n"); 
+
+  return ME; 
+  
+} 
diff --git a/src/ir_rose.cc b/src/ir_rose.cc
deleted file mode 100644
index f4039ab..0000000
--- a/src/ir_rose.cc
+++ /dev/null
@@ -1,1699 +0,0 @@
-/*****************************************************************************
- Copyright (C) 2009-2010 University of Utah
- All Rights Reserved.
-
- Purpose:
- CHiLL's rose interface.
-
- Notes:
- Array supports mixed pointer and array type in a single declaration.
-
- History:
- 02/23/2009 Created by Chun Chen.
-*****************************************************************************/
-#include <string>
-#include "ir_rose.hh"
-#include "ir_rose_utils.hh"
-#include "code_gen/rose_attributes.h"
-#include "code_gen/CG_roseRepr.h"
-#include "code_gen/CG_roseBuilder.h"
-
-using namespace SageBuilder;
-using namespace SageInterface;
-using namespace omega;
-// ----------------------------------------------------------------------------
-// Class: IR_roseScalarSymbol
-// ----------------------------------------------------------------------------
-
-std::string IR_roseScalarSymbol::name() const {
-  return vs_->get_name().getString();
-}
-
-int IR_roseScalarSymbol::size() const {
-  return (vs_->get_type()->memoryUsage()) / (vs_->get_type()->numberOfNodes());
-}
-
-bool IR_roseScalarSymbol::operator==(const IR_Symbol &that) const {
-  if (typeid(*this) != typeid(that))
-    return false;
-  
-  const IR_roseScalarSymbol *l_that =
-    static_cast<const IR_roseScalarSymbol *>(&that);
-  return this->vs_ == l_that->vs_;
-}
-
-IR_Symbol *IR_roseScalarSymbol::clone() const {
-  return NULL;
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseArraySymbol
-// ----------------------------------------------------------------------------
-
-std::string IR_roseArraySymbol::name() const {
-  return (vs_->get_declaration()->get_name().getString());
-}
-
-int IR_roseArraySymbol::elem_size() const {
-  
-  SgType *tn = vs_->get_type();
-  SgType* arrType;
-  
-  int elemsize;
-  
-  if (arrType = isSgArrayType(tn)) {
-    while (isSgArrayType(arrType)) {
-      arrType = arrType->findBaseType();
-    }
-  } else if (arrType = isSgPointerType(tn)) {
-    while (isSgPointerType(arrType)) {
-      arrType = arrType->findBaseType();
-    }
-  }
-  
-  elemsize = (int) arrType->memoryUsage() / arrType->numberOfNodes();
-  return elemsize;
-}
-
-int IR_roseArraySymbol::n_dim() const {
-  int dim = 0;
-  SgType* arrType = isSgArrayType(vs_->get_type());
-  SgType* ptrType = isSgPointerType(vs_->get_type());
-  if (arrType != NULL) {
-    while (isSgArrayType(arrType)) {
-      arrType = isSgArrayType(arrType)->get_base_type();
-      dim++;
-    }
-  } else if (ptrType != NULL) {
-    while (isSgPointerType(ptrType)) {
-      ptrType = isSgPointerType(ptrType)->get_base_type();
-      dim++;
-    }
-  }
-
-  // Manu:: fortran support
-  if (static_cast<const IR_roseCode *>(ir_)->is_fortran_) {
-
-	  if (arrType != NULL) {
-		  dim = 0;
-		  SgExprListExp * dimList = isSgArrayType(vs_->get_type())->get_dim_info();
-		  SgExpressionPtrList::iterator it = dimList->get_expressions().begin();
-		  for(;it != dimList->get_expressions().end(); it++) {
-		    dim++;
-		  }
-	  } else if (ptrType != NULL) {
-		  ; // not sure if this case will happen
-	  }
-  }
-
-  return dim;
-}
-
-omega::CG_outputRepr *IR_roseArraySymbol::size(int dim) const {
-  
-  SgArrayType* arrType = isSgArrayType(vs_->get_type());
-  int count = 0;
-  SgExpression* expr;
-  SgType* pntrType = isSgPointerType(vs_->get_type());
-  
-  if (arrType != NULL) {
-    SgExprListExp* dimList = arrType->get_dim_info();
-    if (!static_cast<const IR_roseCode *>(ir_)->is_fortran_) {
-      SgExpressionPtrList::iterator it =
-        dimList->get_expressions().begin();
-      
-      while ((it != dimList->get_expressions().end()) && (count < dim)) {
-        it++;
-        count++;
-      }
-      
-      expr = *it;
-    } else {
-      SgExpressionPtrList::reverse_iterator i =
-        dimList->get_expressions().rbegin();
-      for (; (i != dimList->get_expressions().rend()) && (count < dim);
-           i++) {
-        
-        count++;
-      }
-      
-      expr = *i;
-    }
-  } else if (pntrType != NULL) {
-    
-    while (count < dim) {
-      pntrType = (isSgPointerType(pntrType))->get_base_type();
-      count++;
-    }
-    if (isSgPointerType(pntrType))
-      expr = new SgExpression;
-  }
-  
-  if (!expr)
-    throw ir_error("Index variable is NULL!!");
-  
-  // Manu :: debug
-  std::cout << "---------- size :: " << isSgNode(expr)->unparseToString().c_str() << "\n";
-
-  return new omega::CG_roseRepr(expr);
-  
-}
-
-IR_ARRAY_LAYOUT_TYPE IR_roseArraySymbol::layout_type() const {
-  if (static_cast<const IR_roseCode *>(ir_)->is_fortran_)
-    return IR_ARRAY_LAYOUT_COLUMN_MAJOR;
-  else
-    return IR_ARRAY_LAYOUT_ROW_MAJOR;
-  
-}
-
-bool IR_roseArraySymbol::operator==(const IR_Symbol &that) const {
-  
-  if (typeid(*this) != typeid(that))
-    return false;
-  
-  const IR_roseArraySymbol *l_that =
-    static_cast<const IR_roseArraySymbol *>(&that);
-  return this->vs_ == l_that->vs_;
-  
-}
-
-IR_Symbol *IR_roseArraySymbol::clone() const {
-  return new IR_roseArraySymbol(ir_, vs_);
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseConstantRef
-// ----------------------------------------------------------------------------
-
-bool IR_roseConstantRef::operator==(const IR_Ref &that) const {
-  
-  if (typeid(*this) != typeid(that))
-    return false;
-  
-  const IR_roseConstantRef *l_that =
-    static_cast<const IR_roseConstantRef *>(&that);
-  
-  if (this->type_ != l_that->type_)
-    return false;
-  
-  if (this->type_ == IR_CONSTANT_INT)
-    return this->i_ == l_that->i_;
-  else
-    return this->f_ == l_that->f_;
-  
-}
-
-omega::CG_outputRepr *IR_roseConstantRef::convert() {
-  if (type_ == IR_CONSTANT_INT) {
-    omega::CG_roseRepr *result = new omega::CG_roseRepr(
-      isSgExpression(buildIntVal(static_cast<int>(i_))));
-    delete this;
-    return result;
-  } else
-    throw ir_error("constant type not supported");
-  
-}
-
-IR_Ref *IR_roseConstantRef::clone() const {
-  if (type_ == IR_CONSTANT_INT)
-    return new IR_roseConstantRef(ir_, i_);
-  else if (type_ == IR_CONSTANT_FLOAT)
-    return new IR_roseConstantRef(ir_, f_);
-  else
-    throw ir_error("constant type not supported");
-  
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseScalarRef
-// ----------------------------------------------------------------------------
-
-bool IR_roseScalarRef::is_write() const {
-  if (is_write_ == 1)
-    return true;
-  
-  return false;
-}
-
-IR_ScalarSymbol *IR_roseScalarRef::symbol() const {
-  return new IR_roseScalarSymbol(ir_, vs_->get_symbol());
-}
-
-bool IR_roseScalarRef::operator==(const IR_Ref &that) const {
-  if (typeid(*this) != typeid(that))
-    return false;
-  
-  const IR_roseScalarRef *l_that =
-    static_cast<const IR_roseScalarRef *>(&that);
-  
-  if (this->ins_pos_ == NULL)
-    return this->vs_ == l_that->vs_;
-  else
-    return this->ins_pos_ == l_that->ins_pos_
-      && this->op_pos_ == l_that->op_pos_;
-}
-
-omega::CG_outputRepr *IR_roseScalarRef::convert() {
-  omega::CG_roseRepr *result = new omega::CG_roseRepr(isSgExpression(vs_));
-  delete this;
-  return result;
-  
-}
-
-IR_Ref * IR_roseScalarRef::clone() const {
-  return new IR_roseScalarRef(ir_, vs_, this->is_write_);
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseArrayRef
-// ----------------------------------------------------------------------------
-
-bool IR_roseArrayRef::is_write() const {
-  SgAssignOp* assignment;
-  
-  if (is_write_ == 1 || is_write_ == 0)
-    return is_write_;
-  if (assignment = isSgAssignOp(ia_->get_parent())) {
-    if (assignment->get_lhs_operand() == ia_)
-      return true;
-  } else if (SgExprStatement* expr_stmt = isSgExprStatement(
-               ia_->get_parent())) {
-    SgExpression* exp = expr_stmt->get_expression();
-    
-    if (exp) {
-      if (assignment = isSgAssignOp(exp)) {
-        if (assignment->get_lhs_operand() == ia_)
-          return true;
-        
-      }
-    }
-    
-  }
-  return false;
-}
-
-omega::CG_outputRepr *IR_roseArrayRef::index(int dim) const {
-  
-  SgExpression *current = isSgExpression(ia_);
-  SgExpression* expr;
-  int count = 0;
-  
-  while (isSgPntrArrRefExp(current)) {
-    current = isSgPntrArrRefExp(current)->get_lhs_operand();
-    count++;
-  }
-  
-  current = ia_;
-  
-  while (count > dim) {
-    expr = isSgPntrArrRefExp(current)->get_rhs_operand();
-    current = isSgPntrArrRefExp(current)->get_lhs_operand();
-    count--;
-  }
-
-  // Manu:: fortran support
-  if (static_cast<const IR_roseCode *>(ir_)->is_fortran_) {
-	  expr = isSgPntrArrRefExp(ia_)->get_rhs_operand();
-	  count = 0;
-	  if (isSgExprListExp(expr)) {
-		  SgExpressionPtrList::iterator indexList = isSgExprListExp(expr)->get_expressions().begin();
-		  while (count < dim) {
-			  indexList++;
-			  count++;
-		  }
-		  expr = isSgExpression(*indexList);
-	  }
-  }
-
-  if (!expr)
-    throw ir_error("Index variable is NULL!!");
-
-
-  omega::CG_roseRepr* ind = new omega::CG_roseRepr(expr);
-  
-  return ind->clone();
-  
-}
-
-IR_ArraySymbol *IR_roseArrayRef::symbol() const {
-  
-  SgExpression *current = isSgExpression(ia_);
-  
-  SgVarRefExp* base;
-  SgVariableSymbol *arrSymbol;
-  while (isSgPntrArrRefExp(current) || isSgUnaryOp(current)) {
-    if (isSgPntrArrRefExp(current))
-      current = isSgPntrArrRefExp(current)->get_lhs_operand();
-    else if (isSgUnaryOp(current))
-      /* To handle support for addressof operator and pointer dereference
-       * both of which are unary ops
-       */
-      current = isSgUnaryOp(current)->get_operand();
-  }
-  if (base = isSgVarRefExp(current)) {
-    arrSymbol = (SgVariableSymbol*) (base->get_symbol());
-    std::string x = arrSymbol->get_name().getString();
-  } else
-    throw ir_error("Array Symbol is not a variable?!");
-  
-  return new IR_roseArraySymbol(ir_, arrSymbol);
-  
-}
-
-bool IR_roseArrayRef::operator==(const IR_Ref &that) const {
-  if (typeid(*this) != typeid(that))
-    return false;
-  
-  const IR_roseArrayRef *l_that = static_cast<const IR_roseArrayRef *>(&that);
-  
-  return this->ia_ == l_that->ia_;
-}
-
-omega::CG_outputRepr *IR_roseArrayRef::convert() {
-  omega::CG_roseRepr *temp = new omega::CG_roseRepr(
-    isSgExpression(this->ia_));
-  omega::CG_outputRepr *result = temp->clone();
-//  delete this;   // Commented by Manu
-  return result;
-}
-
-IR_Ref *IR_roseArrayRef::clone() const {
-  return new IR_roseArrayRef(ir_, ia_, is_write_);
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseLoop
-// ----------------------------------------------------------------------------
-
-IR_ScalarSymbol *IR_roseLoop::index() const {
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  SgVariableSymbol* vs = NULL;
-  if (tf) {
-    SgForInitStatement* list = tf->get_for_init_stmt();
-    SgStatementPtrList& initStatements = list->get_init_stmt();
-    SgStatementPtrList::const_iterator j = initStatements.begin();
-    
-    if (SgExprStatement *expr = isSgExprStatement(*j))
-      if (SgAssignOp* op = isSgAssignOp(expr->get_expression()))
-        if (SgVarRefExp* var_ref = isSgVarRefExp(op->get_lhs_operand()))
-          vs = var_ref->get_symbol();
-  } else if (tfortran) {
-    SgExpression* init = tfortran->get_initialization();
-    
-    if (SgAssignOp* op = isSgAssignOp(init))
-      if (SgVarRefExp* var_ref = isSgVarRefExp(op->get_lhs_operand()))
-        vs = var_ref->get_symbol();
-    
-  }
-  
-  if (vs == NULL)
-    throw ir_error("Index variable is NULL!!");
-  
-  return new IR_roseScalarSymbol(ir_, vs);
-}
-
-omega::CG_outputRepr *IR_roseLoop::lower_bound() const {
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  
-  SgExpression* lowerBound = NULL;
-  
-  if (tf) {
-    SgForInitStatement* list = tf->get_for_init_stmt();
-    SgStatementPtrList& initStatements = list->get_init_stmt();
-    SgStatementPtrList::const_iterator j = initStatements.begin();
-    
-    if (SgExprStatement *expr = isSgExprStatement(*j))
-      if (SgAssignOp* op = isSgAssignOp(expr->get_expression())) {
-        lowerBound = op->get_rhs_operand();
-        //Rose sometimes introduces an unnecessary cast which is a unary op
-        if (isSgUnaryOp(lowerBound))
-          lowerBound = isSgUnaryOp(lowerBound)->get_operand();
-        
-      }
-  } else if (tfortran) {
-    SgExpression* init = tfortran->get_initialization();
-    
-    if (SgAssignOp* op = isSgAssignOp(init))
-      lowerBound = op->get_rhs_operand();
-  }
-  
-  if (lowerBound == NULL)
-    throw ir_error("Lower Bound is NULL!!");
-  
-  return new omega::CG_roseRepr(lowerBound);
-}
-
-omega::CG_outputRepr *IR_roseLoop::upper_bound() const {
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  SgExpression* upperBound = NULL;
-  if (tf) {
-    SgBinaryOp* test_expr = isSgBinaryOp(tf->get_test_expr());
-    if (test_expr == NULL)
-      throw ir_error("Test Expression is NULL!!");
-    
-    upperBound = test_expr->get_rhs_operand();
-    //Rose sometimes introduces an unnecessary cast which is a unary op
-    if (isSgUnaryOp(upperBound))
-      upperBound = isSgUnaryOp(upperBound)->get_operand();
-    if (upperBound == NULL)
-      throw ir_error("Upper Bound is NULL!!");
-  } else if (tfortran) {
-    
-    upperBound = tfortran->get_bound();
-    
-  }
-  
-  return new omega::CG_roseRepr(upperBound);
-  
-}
-
-IR_CONDITION_TYPE IR_roseLoop::stop_cond() const {
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  
-  if (tf) {
-    SgExpression* stopCond = NULL;
-    SgExpression* test_expr = tf->get_test_expr();
-    
-    if (isSgLessThanOp(test_expr))
-      return IR_COND_LT;
-    else if (isSgLessOrEqualOp(test_expr))
-      return IR_COND_LE;
-    else if (isSgGreaterThanOp(test_expr))
-      return IR_COND_GT;
-    else if (isSgGreaterOrEqualOp(test_expr))
-      return IR_COND_GE;
-    
-    else
-      throw ir_error("loop stop condition unsupported");
-  } else if (tfortran) {
-    SgExpression* increment = tfortran->get_increment();
-    if (!isSgNullExpression(increment)) {
-      if (isSgMinusOp(increment)
-          && !isSgBinaryOp(isSgMinusOp(increment)->get_operand()))
-        return IR_COND_GE;
-      else
-        return IR_COND_LE;
-    } else {
-    	return IR_COND_LE; // Manu:: if increment is not present, assume it to be 1. Just a workaround, not sure if it will be correct for all cases.
-      SgExpression* lowerBound = NULL;
-      SgExpression* upperBound = NULL;
-      SgExpression* init = tfortran->get_initialization();
-      SgIntVal* ub;
-      SgIntVal* lb;
-      if (SgAssignOp* op = isSgAssignOp(init))
-        lowerBound = op->get_rhs_operand();
-      
-      upperBound = tfortran->get_bound();
-      
-      if ((upperBound != NULL) && (lowerBound != NULL)) {
-        
-        if ((ub = isSgIntVal(isSgValueExp(upperBound))) && (lb =
-                                                            isSgIntVal(isSgValueExp(lowerBound)))) {
-          if (ub->get_value() > lb->get_value())
-            return IR_COND_LE;
-          else
-            return IR_COND_GE;
-        } else
-          throw ir_error("loop stop condition unsupported");
-        
-      } else
-        throw ir_error("malformed fortran loop bounds!!");
-      
-    }
-  }
-  
-}
-
-IR_Block *IR_roseLoop::body() const {
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  SgNode* loop_body = NULL;
-  SgStatement* body_statements = NULL;
-  
-  if (tf) {
-    body_statements = tf->get_loop_body();
-  } else if (tfortran) {
-    body_statements = isSgStatement(tfortran->get_body());
-    
-  }
-  
-  loop_body = isSgNode(body_statements);
-  
-  SgStatementPtrList list;
-  if (isSgBasicBlock(loop_body)) {
-    list = isSgBasicBlock(loop_body)->get_statements();
-    
-    if (list.size() == 1)
-      loop_body = isSgNode(*(list.begin()));
-  }
-  
-  if (loop_body == NULL)
-    throw ir_error("for loop body is NULL!!");
-  
-  return new IR_roseBlock(ir_, loop_body);
-}
-
-int IR_roseLoop::step_size() const {
-  
-  SgForStatement *tf = isSgForStatement(tf_);
-  SgFortranDo *tfortran = isSgFortranDo(tf_);
-  
-  if (tf) {
-    SgExpression *increment = tf->get_increment();
-    
-    if (isSgPlusPlusOp(increment))
-      return 1;
-    if (isSgMinusMinusOp(increment))
-      return -1;
-    else if (SgAssignOp* assignment = isSgAssignOp(increment)) {
-      SgBinaryOp* stepsize = isSgBinaryOp(assignment->get_lhs_operand());
-      if (stepsize == NULL)
-        throw ir_error("Step size expression is NULL!!");
-      SgIntVal* step = isSgIntVal(stepsize->get_lhs_operand());
-      return step->get_value();
-    } else if (SgBinaryOp* inc = isSgPlusAssignOp(increment)) {
-      SgIntVal* step = isSgIntVal(inc->get_rhs_operand());
-      return (step->get_value());
-    } else if (SgBinaryOp * inc = isSgMinusAssignOp(increment)) {
-      SgIntVal* step = isSgIntVal(inc->get_rhs_operand());
-      return -(step->get_value());
-    } else if (SgBinaryOp * inc = isSgCompoundAssignOp(increment)) {
-      SgIntVal* step = isSgIntVal(inc->get_rhs_operand());
-      return (step->get_value());
-    }
-    
-  } else if (tfortran) {
-    
-    SgExpression* increment = tfortran->get_increment();
-    
-    if (!isSgNullExpression(increment)) {
-      if (isSgMinusOp(increment)) {
-        if (SgValueExp *inc = isSgValueExp(
-              isSgMinusOp(increment)->get_operand()))
-          if (isSgIntVal(inc))
-            return -(isSgIntVal(inc)->get_value());
-      } else {
-        if (SgValueExp* inc = isSgValueExp(increment))
-          if (isSgIntVal(inc))
-            return isSgIntVal(inc)->get_value();
-      }
-    } else {
-    	return 1; // Manu:: if increment is not present, assume it to be 1. Just a workaround, not sure if it will be correct for all cases.
-      SgExpression* lowerBound = NULL;
-      SgExpression* upperBound = NULL;
-      SgExpression* init = tfortran->get_initialization();
-      SgIntVal* ub;
-      SgIntVal* lb;
-      if (SgAssignOp* op = isSgAssignOp(init))
-        lowerBound = op->get_rhs_operand();
-      
-      upperBound = tfortran->get_bound();
-      
-      if ((upperBound != NULL) && (lowerBound != NULL)) {
-        
-        if ((ub = isSgIntVal(isSgValueExp(upperBound))) && (lb =
-                                                            isSgIntVal(isSgValueExp(lowerBound)))) {
-          if (ub->get_value() > lb->get_value())
-            return 1;
-          else
-            return -1;
-        } else
-          throw ir_error("loop stop condition unsupported");
-        
-      } else
-        throw ir_error("loop stop condition unsupported");
-      
-    }
-    
-  }
-  
-}
-
-IR_Block *IR_roseLoop::convert() {
-  const IR_Code *ir = ir_;
-  SgNode *tnl = isSgNode(tf_);
-  delete this;
-  return new IR_roseBlock(ir, tnl);
-}
-
-IR_Control *IR_roseLoop::clone() const {
-  
-  return new IR_roseLoop(ir_, tf_);
-  
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseBlock
-// ----------------------------------------------------------------------------
-
-omega::CG_outputRepr *IR_roseBlock::original() const {
-  
-  omega::CG_outputRepr * tnl;
-  
-  if (isSgBasicBlock(tnl_)) {
-    
-    SgStatementPtrList *bb = new SgStatementPtrList();
-    SgStatementPtrList::iterator it;
-    for (it = (isSgBasicBlock(tnl_)->get_statements()).begin();
-         it != (isSgBasicBlock(tnl_)->get_statements()).end()
-           && (*it != start_); it++)
-      ;
-    
-    if (it != (isSgBasicBlock(tnl_)->get_statements()).end()) {
-      for (; it != (isSgBasicBlock(tnl_)->get_statements()).end(); it++) {
-        bb->push_back(*it);
-        if ((*it) == end_)
-          break;
-      }
-    }
-    tnl = new omega::CG_roseRepr(bb);
-
-  } else {
-
-    tnl = new omega::CG_roseRepr(tnl_);
-
-  }
-  
-  return tnl;
-  
-}
-omega::CG_outputRepr *IR_roseBlock::extract() const {
-  
-  std::string x = tnl_->unparseToString();
-  
-  omega::CG_roseRepr * tnl;
-  
-  omega::CG_outputRepr* block;
-  
-  if (isSgBasicBlock(tnl_)) {
-    
-    SgStatementPtrList *bb = new SgStatementPtrList();
-    SgStatementPtrList::iterator it;
-    for (it = (isSgBasicBlock(tnl_)->get_statements()).begin();
-         it != (isSgBasicBlock(tnl_)->get_statements()).end()
-           && (*it != start_); it++)
-      ;
-    
-    if (it != (isSgBasicBlock(tnl_)->get_statements()).end()) {
-      for (; it != (isSgBasicBlock(tnl_)->get_statements()).end(); it++) {
-        bb->push_back(*it);
-        if ((*it) == end_)
-          break;
-      }
-    }
-    tnl = new omega::CG_roseRepr(bb);
-    block = tnl->clone();
-    
-  } else {
-    tnl = new omega::CG_roseRepr(tnl_);
-    
-    block = tnl->clone();
-  }
-  
-  delete tnl;
-  return block;
-}
-
-IR_Control *IR_roseBlock::clone() const {
-  return new IR_roseBlock(ir_, tnl_, start_, end_);
-  
-}
-// ----------------------------------------------------------------------------
-// Class: IR_roseIf
-// ----------------------------------------------------------------------------
-omega::CG_outputRepr *IR_roseIf::condition() const {
-  SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_conditional());
-  SgExpression* exp = NULL;
-  if (SgExprStatement* stmt = isSgExprStatement(tnl))
-    exp = stmt->get_expression();
-  if (exp == NULL)
-    return new omega::CG_roseRepr(tnl);
-  else
-    return new omega::CG_roseRepr(exp);
-}
-
-IR_Block *IR_roseIf::then_body() const {
-  SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_true_body());
-  
-  if (tnl == NULL)
-    return NULL;
-  
-  return new IR_roseBlock(ir_, tnl);
-}
-
-IR_Block *IR_roseIf::else_body() const {
-  SgNode *tnl = isSgNode(isSgIfStmt(ti_)->get_false_body());
-  
-  if (tnl == NULL)
-    return NULL;
-  
-  return new IR_roseBlock(ir_, tnl);
-}
-
-IR_Block *IR_roseIf::convert() {
-  const IR_Code *ir = ir_;
-  delete this;
-  return new IR_roseBlock(ir, ti_);
-}
-
-IR_Control *IR_roseIf::clone() const {
-  return new IR_roseIf(ir_, ti_);
-}
-
-// -----------------------------------------------------------y-----------------
-// Class: IR_roseCode_Global_Init
-// ----------------------------------------------------------------------------
-
-IR_roseCode_Global_Init *IR_roseCode_Global_Init::pinstance = 0;
-
-IR_roseCode_Global_Init * IR_roseCode_Global_Init::Instance(char** argv) {
-  if (pinstance == 0) {
-    pinstance = new IR_roseCode_Global_Init;
-    pinstance->project = frontend(2, argv);
-    
-  }
-  return pinstance;
-}
-
-// ----------------------------------------------------------------------------
-// Class: IR_roseCode
-// ----------------------------------------------------------------------------
-
-IR_roseCode::IR_roseCode(const char *filename, const char* proc_name) :
-  IR_Code() {
-  
-  SgProject* project;
-  
-  char* argv[2];
-  int counter = 0;
-  argv[0] = (char*) malloc(5 * sizeof(char));
-  argv[1] = (char*) malloc((strlen(filename) + 1) * sizeof(char));
-  strcpy(argv[0], "rose");
-  strcpy(argv[1], filename);
-  
-  project = (IR_roseCode_Global_Init::Instance(argv))->project;
-  firstScope = getFirstGlobalScope(project);
-  SgFilePtrList& file_list = project->get_fileList();
-  
-  for (SgFilePtrList::iterator it = file_list.begin(); it != file_list.end();
-       it++) {
-    file = isSgSourceFile(*it);
-    if (file->get_outputLanguage() == SgFile::e_Fortran_output_language)
-      is_fortran_ = true;
-    else
-      is_fortran_ = false;
-
-    root = file->get_globalScope();
-
-    if (!is_fortran_) { // Manu:: this macro should not be created if the input code is in fortran
-    	buildCpreprocessorDefineDeclaration(root,
-                                        "#define __rose_lt(x,y) ((x)<(y)?(x):(y))",
-                                        PreprocessingInfo::before);
-    	buildCpreprocessorDefineDeclaration(root,
-                                        "#define __rose_gt(x,y) ((x)>(y)?(x):(y))",
-                                        PreprocessingInfo::before);
-    }
-    
-    symtab_ = isSgScopeStatement(root)->get_symbol_table();
-    SgDeclarationStatementPtrList& declList = root->get_declarations();
-    
-    p = declList.begin();
-
-    while (p != declList.end()) {
-      func = isSgFunctionDeclaration(*p);
-      if (func) {
-        if (!strcmp((func->get_name().getString()).c_str(), proc_name))
-          break;
-        
-      }
-      p++;
-      counter++;
-    }
-    if (p != declList.end())
-      break;
-    
-  }
-  
-  symtab2_ = func->get_definition()->get_symbol_table();
-  symtab3_ = func->get_definition()->get_body()->get_symbol_table();
-  // Manu:: added is_fortran_ parameter
-  // TODO Substitute it with a better builder
-  ocg_ = new omega::CG_roseBuilder(is_fortran_, root, firstScope,
-                                   func->get_definition()->get_symbol_table(),
-                                   func->get_definition()->get_body()->get_symbol_table(),
-                                   isSgNode(func->get_definition()->get_body()));
-  
-  i_ = 0; /*i_ handling may need revision */
-  
-  free(argv[1]);
-  free(argv[0]);
-  
-}
-
-IR_roseCode::~IR_roseCode() {
-}
-
-void IR_roseCode::finalizeRose() {
-  SgProject* project = (IR_roseCode_Global_Init::Instance(NULL))->project;
-  project->unparse();
-}
-
-IR_ScalarSymbol *IR_roseCode::CreateScalarSymbol(const IR_Symbol *sym, int) {
-  char str1[14];
-  if (typeid(*sym) == typeid(IR_roseScalarSymbol)) {
-    SgType *tn =
-      static_cast<const IR_roseScalarSymbol *>(sym)->vs_->get_type();
-    sprintf(str1, "newVariable%i", i_);
-    SgVariableDeclaration* defn = buildVariableDeclaration(str1, tn);
-    i_++;
-    
-    SgInitializedNamePtrList& variables = defn->get_variables();
-    SgInitializedNamePtrList::const_iterator i = variables.begin();
-    SgInitializedName* initializedName = *i;
-    SgVariableSymbol* vs = new SgVariableSymbol(initializedName);
-    
-    prependStatement(defn,
-                     isSgScopeStatement(func->get_definition()->get_body()));
-    vs->set_parent(symtab_);
-    symtab_->insert(str1, vs);
-    
-    if (vs == NULL)
-      throw ir_error("in CreateScalarSymbol: vs is NULL!!");
-    
-    return new IR_roseScalarSymbol(this, vs);
-  } else if (typeid(*sym) == typeid(IR_roseArraySymbol)) {
-    SgType *tn1 =
-      static_cast<const IR_roseArraySymbol *>(sym)->vs_->get_type();
-    while (isSgArrayType(tn1) || isSgPointerType(tn1)) {
-      if (isSgArrayType(tn1))
-        tn1 = isSgArrayType(tn1)->get_base_type();
-      else if (isSgPointerType(tn1))
-        tn1 = isSgPointerType(tn1)->get_base_type();
-      else
-        throw ir_error(
-          "in CreateScalarSymbol: symbol not an array nor a pointer!");
-    }
-    
-    sprintf(str1, "newVariable%i", i_);
-    i_++;
-    
-    SgVariableDeclaration* defn1 = buildVariableDeclaration(str1, tn1);
-    SgInitializedNamePtrList& variables1 = defn1->get_variables();
-    
-    SgInitializedNamePtrList::const_iterator i1 = variables1.begin();
-    SgInitializedName* initializedName1 = *i1;
-    
-    SgVariableSymbol *vs1 = new SgVariableSymbol(initializedName1);
-    prependStatement(defn1,
-                     isSgScopeStatement(func->get_definition()->get_body()));
-    
-    vs1->set_parent(symtab_);
-    symtab_->insert(str1, vs1);
-    
-    if (vs1 == NULL)
-      throw ir_error("in CreateScalarSymbol: vs1 is NULL!!");
-    
-    return new IR_roseScalarSymbol(this, vs1);
-  } else
-    throw std::bad_typeid();
-  
-}
-
-IR_ArraySymbol *IR_roseCode::CreateArraySymbol(const IR_Symbol *sym,
-                                               std::vector<omega::CG_outputRepr *> &size, int) {
-  SgType *tn;
-  char str1[14];
-  
-  if (typeid(*sym) == typeid(IR_roseScalarSymbol)) {
-    tn = static_cast<const IR_roseScalarSymbol *>(sym)->vs_->get_type();
-  } else if (typeid(*sym) == typeid(IR_roseArraySymbol)) {
-    tn = static_cast<const IR_roseArraySymbol *>(sym)->vs_->get_type();
-    while (isSgArrayType(tn) || isSgPointerType(tn)) {
-      if (isSgArrayType(tn))
-        tn = isSgArrayType(tn)->get_base_type();
-      else if (isSgPointerType(tn))
-        tn = isSgPointerType(tn)->get_base_type();
-      else
-        throw ir_error(
-          "in CreateScalarSymbol: symbol not an array nor a pointer!");
-    }
-  } else
-    throw std::bad_typeid();
-
-  
-  // Manu:: Fortran support
-  std::vector<SgExpression *>exprs;
-  SgExprListExp *exprLstExp;
-  SgExpression* sizeExpression = new SgNullExpression();
-  SgArrayType* arrayType = new SgArrayType(tn,sizeExpression);
-  sizeExpression->set_parent(arrayType);
-
-  if (!is_fortran_) {
-	  for (int i = size.size() - 1; i >= 0; i--) {
-		tn = buildArrayType(tn,static_cast<omega::CG_roseRepr *>(size[i])->GetExpression());
-	  }
-  } else { // Manu:: required for fortran support
-	  for (int i = size.size() - 1; i >= 0; i--) {
-		exprs.push_back(static_cast<omega::CG_roseRepr *>(size[i])->GetExpression());
-	  }
-  }
-
-  if (is_fortran_) {
-	  exprLstExp = buildExprListExp(exprs);
-	  arrayType->set_dim_info(exprLstExp);
- 	  exprLstExp->set_parent(arrayType);
- 	  arrayType->set_rank(exprLstExp->get_expressions().size());
-  }
-
-  static int rose_array_counter = 1;
-  SgVariableDeclaration* defn2;
-  std::string s;
-  if (!is_fortran_) {
-	  s = std::string("_P") + omega::to_string(rose_array_counter++);
-	  defn2 = buildVariableDeclaration(const_cast<char *>(s.c_str()), tn);
-  } else {// Manu:: fortran support
-	  s = std::string("f_P") + omega::to_string(rose_array_counter++);
-	  defn2 = buildVariableDeclaration(const_cast<char *>(s.c_str()), arrayType);
-  }
-
-
-  SgInitializedNamePtrList& variables2 = defn2->get_variables();
-  
-  SgInitializedNamePtrList::const_iterator i2 = variables2.begin();
-  SgInitializedName* initializedName2 = *i2;
-  SgVariableSymbol *vs = new SgVariableSymbol(initializedName2);
-  
-  prependStatement(defn2,
-                   isSgScopeStatement(func->get_definition()->get_body()));
-  
-  vs->set_parent(symtab_);
-  symtab_->insert(SgName(s.c_str()), vs);
-  
-  return new IR_roseArraySymbol(this, vs);
-}
-
-IR_ScalarRef *IR_roseCode::CreateScalarRef(const IR_ScalarSymbol *sym) {
-  return new IR_roseScalarRef(this,
-                              buildVarRefExp(static_cast<const IR_roseScalarSymbol *>(sym)->vs_));
-  
-}
-
-IR_ArrayRef *IR_roseCode::CreateArrayRef(const IR_ArraySymbol *sym,
-                                         std::vector<omega::CG_outputRepr *> &index) {
-  
-  int t;
-  
-  if (sym->n_dim() != index.size())
-    throw std::invalid_argument("incorrect array symbol dimensionality");
-  
-  const IR_roseArraySymbol *l_sym =
-    static_cast<const IR_roseArraySymbol *>(sym);
-  
-  SgVariableSymbol *vs = l_sym->vs_;
-  SgExpression* ia1 = buildVarRefExp(vs);
-  
-
-
-  if (is_fortran_) { // Manu:: fortran support
-	  std::vector<SgExpression *>exprs;
-	  for (int i = 0 ; i < index.size(); i++) {
-		exprs.push_back(static_cast<omega::CG_roseRepr *>(index[i])->GetExpression());
-	  }
-	  SgExprListExp *exprLstExp;
-	  exprLstExp = buildExprListExp(exprs);
-	  ia1 = buildPntrArrRefExp(ia1,exprLstExp);
-  } else {
-     for (int i = 0; i < index.size(); i++) {
-
-        ia1 = buildPntrArrRefExp(ia1,
-                             static_cast<omega::CG_roseRepr *>(index[i])->GetExpression());
-    
-     }
-  }
-  
-  SgPntrArrRefExp *ia = isSgPntrArrRefExp(ia1);
-  
-  return new IR_roseArrayRef(this, ia, -1);
-  
-}
-
-std::vector<IR_ScalarRef *> IR_roseCode::FindScalarRef(
-  const omega::CG_outputRepr *repr) const {
-  std::vector<IR_ScalarRef *> scalars;
-  SgNode *tnl = static_cast<const omega::CG_roseRepr *>(repr)->GetCode();
-  SgStatementPtrList *list =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetList();
-  SgStatement* stmt;
-  SgExpression * exp;
-  
-  if (list != NULL) {
-    for (SgStatementPtrList::iterator it = (*list).begin();
-         it != (*list).end(); it++) {
-      omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgNode(*it));
-      std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-      delete r;
-      std::copy(a.begin(), a.end(), back_inserter(scalars));
-    }
-  }
-  
-  else if (tnl != NULL) {
-    if (stmt = isSgStatement(tnl)) {
-      if (isSgBasicBlock(stmt)) {
-        SgStatementPtrList& stmts =
-          isSgBasicBlock(stmt)->get_statements();
-        for (int i = 0; i < stmts.size(); i++) {
-          omega::CG_roseRepr *r = new omega::CG_roseRepr(
-            isSgNode(stmts[i]));
-          std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-          delete r;
-          std::copy(a.begin(), a.end(), back_inserter(scalars));
-        }
-        
-      } else if (isSgForStatement(stmt)) {
-        
-        SgForStatement *tnf = isSgForStatement(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgStatement(tnf->get_loop_body()));
-        std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-      } else if (isSgFortranDo(stmt)) {
-        SgFortranDo *tfortran = isSgFortranDo(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgStatement(tfortran->get_body()));
-        std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-      } else if (isSgIfStmt(stmt)) {
-        SgIfStmt* tni = isSgIfStmt(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgNode(tni->get_conditional()));
-        std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-        r = new omega::CG_roseRepr(isSgNode(tni->get_true_body()));
-        a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-        r = new omega::CG_roseRepr(isSgNode(tni->get_false_body()));
-        a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-      } else if (isSgExprStatement(stmt)) {
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgExpression(
-            isSgExprStatement(stmt)->get_expression()));
-        std::vector<IR_ScalarRef *> a = FindScalarRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(scalars));
-        
-      }
-    }
-  } else {
-    SgExpression* op =
-      static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-    if (isSgVarRefExp(op)
-        && (!isSgArrayType(isSgVarRefExp(op)->get_type()))) {
-      if (SgBinaryOp* op_ = isSgBinaryOp(
-            isSgVarRefExp(op)->get_parent())) {
-        if (SgCompoundAssignOp *op__ = isSgCompoundAssignOp(op_)) {
-          if (isSgCompoundAssignOp(op_)->get_lhs_operand()
-              == isSgVarRefExp(op)) {
-            scalars.push_back(
-              new IR_roseScalarRef(this, isSgVarRefExp(op),
-                                   1));
-            scalars.push_back(
-              new IR_roseScalarRef(this, isSgVarRefExp(op),
-                                   0));
-          }
-        }
-      } else if (SgAssignOp* assmt = isSgAssignOp(
-                   isSgVarRefExp(op)->get_parent())) {
-        
-        if (assmt->get_lhs_operand() == isSgVarRefExp(op))
-          scalars.push_back(
-            new IR_roseScalarRef(this, isSgVarRefExp(op), 1));
-      } else if (SgAssignOp * assmt = isSgAssignOp(
-                   isSgVarRefExp(op)->get_parent())) {
-        
-        if (assmt->get_rhs_operand() == isSgVarRefExp(op))
-          scalars.push_back(
-            new IR_roseScalarRef(this, isSgVarRefExp(op), 0));
-      } else
-        scalars.push_back(
-          new IR_roseScalarRef(this, isSgVarRefExp(op), 0));
-    } else if (isSgAssignOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgAssignOp(op)->get_lhs_operand());
-      std::vector<IR_ScalarRef *> a1 = FindScalarRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(scalars));
-      omega::CG_roseRepr *r2 = new omega::CG_roseRepr(
-        isSgAssignOp(op)->get_rhs_operand());
-      std::vector<IR_ScalarRef *> a2 = FindScalarRef(r2);
-      delete r2;
-      std::copy(a2.begin(), a2.end(), back_inserter(scalars));
-      
-    } else if (isSgBinaryOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgBinaryOp(op)->get_lhs_operand());
-      std::vector<IR_ScalarRef *> a1 = FindScalarRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(scalars));
-      omega::CG_roseRepr *r2 = new omega::CG_roseRepr(
-        isSgBinaryOp(op)->get_rhs_operand());
-      std::vector<IR_ScalarRef *> a2 = FindScalarRef(r2);
-      delete r2;
-      std::copy(a2.begin(), a2.end(), back_inserter(scalars));
-    } else if (isSgUnaryOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgUnaryOp(op)->get_operand());
-      std::vector<IR_ScalarRef *> a1 = FindScalarRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(scalars));
-    }
-    
-  }
-  return scalars;
-  
-}
-
-std::vector<IR_ArrayRef *> IR_roseCode::FindArrayRef(
-  const omega::CG_outputRepr *repr) const {
-  std::vector<IR_ArrayRef *> arrays;
-  SgNode *tnl = static_cast<const omega::CG_roseRepr *>(repr)->GetCode();
-  SgStatementPtrList* list =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetList();
-  SgStatement* stmt;
-  SgExpression * exp;
-  
-  if (list != NULL) {
-    for (SgStatementPtrList::iterator it = (*list).begin();
-         it != (*list).end(); it++) {
-      omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgNode(*it));
-      std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-      delete r;
-      std::copy(a.begin(), a.end(), back_inserter(arrays));
-    }
-  } else if (tnl != NULL) {
-    if (stmt = isSgStatement(tnl)) {
-      if (isSgBasicBlock(stmt)) {
-        SgStatementPtrList& stmts =
-          isSgBasicBlock(stmt)->get_statements();
-        for (int i = 0; i < stmts.size(); i++) {
-          omega::CG_roseRepr *r = new omega::CG_roseRepr(
-            isSgNode(stmts[i]));
-          std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-          delete r;
-          std::copy(a.begin(), a.end(), back_inserter(arrays));
-        }
-        
-      } else if (isSgForStatement(stmt)) {
-        
-        SgForStatement *tnf = isSgForStatement(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgStatement(tnf->get_loop_body()));
-        std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-      } else if (isSgFortranDo(stmt)) {
-        SgFortranDo *tfortran = isSgFortranDo(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgStatement(tfortran->get_body()));
-        std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-      } else if (isSgIfStmt(stmt)) {
-        SgIfStmt* tni = isSgIfStmt(stmt);
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgNode(tni->get_conditional()));
-        std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-        r = new omega::CG_roseRepr(isSgNode(tni->get_true_body()));
-        a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-        r = new omega::CG_roseRepr(isSgNode(tni->get_false_body()));
-        a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-      } else if (isSgExprStatement(stmt)) {
-        omega::CG_roseRepr *r = new omega::CG_roseRepr(
-          isSgExpression(
-            isSgExprStatement(stmt)->get_expression()));
-        std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-        delete r;
-        std::copy(a.begin(), a.end(), back_inserter(arrays));
-        
-      }
-    }
-  } else {
-    SgExpression* op =
-      static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-    if (isSgPntrArrRefExp(op)) {
-      
-      SgVarRefExp* base;
-      SgExpression* op2;
-      if (isSgCompoundAssignOp(isSgPntrArrRefExp(op)->get_parent())) {
-        IR_roseArrayRef *ref1 = new IR_roseArrayRef(this,
-                                                    isSgPntrArrRefExp(op), 0);
-        arrays.push_back(ref1);
-        IR_roseArrayRef *ref2 = new IR_roseArrayRef(this,
-                                                    isSgPntrArrRefExp(op), 1);
-        arrays.push_back(ref2);
-      } else {
-        IR_roseArrayRef *ref3 = new IR_roseArrayRef(this,
-                                                    isSgPntrArrRefExp(op), -1);
-        arrays.push_back(ref3);
-        
-        while (isSgPntrArrRefExp(op)) {
-          op2 = isSgPntrArrRefExp(op)->get_rhs_operand();
-          op = isSgPntrArrRefExp(op)->get_lhs_operand();
-          omega::CG_roseRepr *r = new omega::CG_roseRepr(op2);
-          std::vector<IR_ArrayRef *> a = FindArrayRef(r);
-          delete r;
-          std::copy(a.begin(), a.end(), back_inserter(arrays));
-          
-        }
-      }
-    } else if (isSgAssignOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgAssignOp(op)->get_lhs_operand());
-      std::vector<IR_ArrayRef *> a1 = FindArrayRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-      omega::CG_roseRepr *r2 = new omega::CG_roseRepr(
-        isSgAssignOp(op)->get_rhs_operand());
-      std::vector<IR_ArrayRef *> a2 = FindArrayRef(r2);
-      delete r2;
-      std::copy(a2.begin(), a2.end(), back_inserter(arrays));
-      
-    } else if (isSgBinaryOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgBinaryOp(op)->get_lhs_operand());
-      std::vector<IR_ArrayRef *> a1 = FindArrayRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-      omega::CG_roseRepr *r2 = new omega::CG_roseRepr(
-        isSgBinaryOp(op)->get_rhs_operand());
-      std::vector<IR_ArrayRef *> a2 = FindArrayRef(r2);
-      delete r2;
-      std::copy(a2.begin(), a2.end(), back_inserter(arrays));
-    } else if (isSgUnaryOp(op)) {
-      omega::CG_roseRepr *r1 = new omega::CG_roseRepr(
-        isSgUnaryOp(op)->get_operand());
-      std::vector<IR_ArrayRef *> a1 = FindArrayRef(r1);
-      delete r1;
-      std::copy(a1.begin(), a1.end(), back_inserter(arrays));
-    }
-    
-  }
-  return arrays;
-}
-
-std::vector<IR_Control *> IR_roseCode::FindOneLevelControlStructure(
-  const IR_Block *block) const {
-
-  std::vector<IR_Control *> controls;
-  int i;
-  int j;
-  int begin;
-  int end;
-  SgNode* tnl_ =
-    ((static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->tnl_);
-  
-  if (isSgForStatement(tnl_))
-    controls.push_back(new IR_roseLoop(this, tnl_));
-  else if (isSgFortranDo(tnl_))
-	  controls.push_back(new IR_roseLoop(this, tnl_));
-  else if (isSgIfStmt(tnl_))
-    controls.push_back(new IR_roseIf(this, tnl_));
-  
-  else if (isSgBasicBlock(tnl_)) {
-    
-    SgStatementPtrList& stmts = isSgBasicBlock(tnl_)->get_statements();
-    
-    for (i = 0; i < stmts.size(); i++) {
-      if (isSgNode(stmts[i])
-          == ((static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->start_))
-        begin = i;
-      if (isSgNode(stmts[i])
-          == ((static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->end_))
-        end = i;
-    }
-    
-    SgNode* start = NULL;
-    SgNode* prev = NULL;
-    for (i = begin; i <= end; i++) {
-      if (isSgForStatement(stmts[i]) || isSgFortranDo(stmts[i])) {
-        if (start != NULL) {
-          controls.push_back(
-            new IR_roseBlock(this,
-                             (static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->tnl_,
-                             start, prev));
-          start = NULL;
-        }
-        controls.push_back(new IR_roseLoop(this, isSgNode(stmts[i])));
-      } else if (isSgIfStmt(stmts[i])) {
-        if (start != NULL) {
-          controls.push_back(
-            new IR_roseBlock(this,
-                             (static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->tnl_,
-                             start, prev));
-          start = NULL;
-        }
-        controls.push_back(new IR_roseIf(this, isSgNode(stmts[i])));
-        
-      } else if (start == NULL)
-        start = isSgNode(stmts[i]);
-      
-      prev = isSgNode(stmts[i]);
-    }
-    
-    if ((start != NULL) && (start != isSgNode(stmts[begin])))
-      controls.push_back(
-        new IR_roseBlock(this,
-                         (static_cast<IR_roseBlock *>(const_cast<IR_Block *>(block)))->tnl_,
-                         start, prev));
-  }
-  
-  return controls;
-  
-}
-
-IR_Block *IR_roseCode::MergeNeighboringControlStructures(
-  const std::vector<IR_Control *> &controls) const {
-  if (controls.size() == 0)
-    return NULL;
-  
-  SgNode *tnl = NULL;
-  SgNode *start, *end;
-  for (int i = 0; i < controls.size(); i++) {
-    switch (controls[i]->type()) {
-    case IR_CONTROL_LOOP: {
-      SgNode *tf = static_cast<IR_roseLoop *>(controls[i])->tf_;
-      if (tnl == NULL) {
-        tnl = tf->get_parent();
-        start = end = tf;
-      } else {
-        if (tnl != tf->get_parent())
-          throw ir_error("controls to merge not at the same level");
-        end = tf;
-      }
-      break;
-    }
-    case IR_CONTROL_BLOCK: {
-      if (tnl == NULL) {
-        tnl = static_cast<IR_roseBlock *>(controls[0])->tnl_;
-        start = static_cast<IR_roseBlock *>(controls[0])->start_;
-        end = static_cast<IR_roseBlock *>(controls[0])->end_;
-      } else {
-        if (tnl != static_cast<IR_roseBlock *>(controls[0])->tnl_)
-          throw ir_error("controls to merge not at the same level");
-        end = static_cast<IR_roseBlock *>(controls[0])->end_;
-      }
-      break;
-    }
-    default:
-      throw ir_error("unrecognized control to merge");
-    }
-  }
-  
-  return new IR_roseBlock(controls[0]->ir_, tnl, start, end);
-}
-
-IR_Block *IR_roseCode::GetCode() const {
-  SgFunctionDefinition* def = NULL;
-  SgBasicBlock* block = NULL;
-  if (func != 0) {
-    if (def = func->get_definition()) {
-      if (block = def->get_body())
-        return new IR_roseBlock(this,
-                                func->get_definition()->get_body());
-    }
-  }
-  
-  return NULL;
-  
-}
-
-void IR_roseCode::ReplaceCode(IR_Control *old, omega::CG_outputRepr *repr) {
-  SgStatementPtrList *tnl =
-    static_cast<omega::CG_roseRepr *>(repr)->GetList();
-  SgNode* node_ = static_cast<omega::CG_roseRepr *>(repr)->GetCode();
-  SgNode * tf_old;
-  
-  /* May need future revision if tnl has more than one statement */
-  
-  switch (old->type()) {
-    
-  case IR_CONTROL_LOOP:
-    tf_old = static_cast<IR_roseLoop *>(old)->tf_;
-    break;
-  case IR_CONTROL_BLOCK:
-    tf_old = static_cast<IR_roseBlock *>(old)->start_;
-    break;
-    
-  default:
-    throw ir_error("control structure to be replaced not supported");
-    break;
-  }
-  
-  std::string y = tf_old->unparseToString();
-  SgStatement *s = isSgStatement(tf_old);
-  if (s != 0) {
-    SgStatement *p = isSgStatement(tf_old->get_parent());
-    
-    if (p != 0) {
-      SgStatement* temp = s;
-      if (tnl != NULL) {
-        SgStatementPtrList::iterator it = (*tnl).begin();
-        p->insert_statement(temp, *it, true);
-        temp = *it;
-        p->remove_statement(s);
-        it++;
-        for (; it != (*tnl).end(); it++) {
-          p->insert_statement(temp, *it, false);
-          temp = *it;
-        }
-      } else if (node_ != NULL) {
-        if (!isSgStatement(node_))
-          throw ir_error("Replacing Code not a statement!");
-        else {
-          SgStatement* replace_ = isSgStatement(node_);
-          p->insert_statement(s, replace_, true);
-          p->remove_statement(s);
-          
-        }
-      } else {
-        throw ir_error("Replacing Code not a statement!");
-      }
-    } else
-      throw ir_error("Replacing Code not a statement!");
-  } else
-    throw ir_error("Replacing Code not a statement!");
-  
-  delete old;
-  delete repr;
-}
-
-void IR_roseCode::ReplaceExpression(IR_Ref *old, omega::CG_outputRepr *repr) {
-  
-  SgExpression* op = static_cast<omega::CG_roseRepr *>(repr)->GetExpression();
-  
-  if (typeid(*old) == typeid(IR_roseArrayRef)) {
-    SgPntrArrRefExp* ia_orig = static_cast<IR_roseArrayRef *>(old)->ia_;
-    SgExpression* parent = isSgExpression(isSgNode(ia_orig)->get_parent());
-    std::string x = isSgNode(op)->unparseToString();
-    std::string y = isSgNode(ia_orig)->unparseToString();
-    if (parent != NULL) {
-      std::string z = isSgNode(parent)->unparseToString();
-      parent->replace_expression(ia_orig, op);
-      isSgNode(op)->set_parent(isSgNode(parent));
-    } else {
-      SgStatement* parent_stmt = isSgStatement(
-        isSgNode(ia_orig)->get_parent());
-      if (parent_stmt != NULL)
-        parent_stmt->replace_expression(ia_orig, op);
-      else
-        throw ir_error(
-          "ReplaceExpression: parent neither expression nor statement");
-    }
-  } else
-    throw ir_error("replacing a scalar variable not implemented");
-  
-  delete old;
-}
-
-IR_OPERATION_TYPE IR_roseCode::QueryExpOperation(
-  const omega::CG_outputRepr *repr) const {
-  SgExpression* op =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-  
-  if (isSgValueExp(op))
-    return IR_OP_CONSTANT;
-  else if (isSgVarRefExp(op) || isSgPntrArrRefExp(op))
-    return IR_OP_VARIABLE;
-  else if (isSgAssignOp(op) || isSgCompoundAssignOp(op))
-    return IR_OP_ASSIGNMENT;
-  else if (isSgAddOp(op))
-    return IR_OP_PLUS;
-  else if (isSgSubtractOp(op))
-    return IR_OP_MINUS;
-  else if (isSgMultiplyOp(op))
-    return IR_OP_MULTIPLY;
-  else if (isSgDivideOp(op))
-    return IR_OP_DIVIDE;
-  else if (isSgMinusOp(op))
-    return IR_OP_NEGATIVE;
-  else if (isSgConditionalExp(op)) {
-    SgExpression* cond = isSgConditionalExp(op)->get_conditional_exp();
-    if (isSgGreaterThanOp(cond))
-      return IR_OP_MAX;
-    else if (isSgLessThanOp(cond))
-      return IR_OP_MIN;
-  } else if (isSgUnaryAddOp(op))
-    return IR_OP_POSITIVE;
-  else if (isSgNullExpression(op))
-    return IR_OP_NULL;
-  else
-    return IR_OP_UNKNOWN;
-}
-
-IR_CONDITION_TYPE IR_roseCode::QueryBooleanExpOperation(
-  const omega::CG_outputRepr *repr) const {
-  SgExpression* op2 =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-  SgNode* op;
-  
-  if (op2 == NULL) {
-    op = static_cast<const omega::CG_roseRepr *>(repr)->GetCode();
-    
-    if (op != NULL) {
-      if (isSgExprStatement(op))
-        op2 = isSgExprStatement(op)->get_expression();
-      else
-        return IR_COND_UNKNOWN;
-    } else
-      return IR_COND_UNKNOWN;
-  }
-  
-  if (isSgEqualityOp(op2))
-    return IR_COND_EQ;
-  else if (isSgNotEqualOp(op2))
-    return IR_COND_NE;
-  else if (isSgLessThanOp(op2))
-    return IR_COND_LT;
-  else if (isSgLessOrEqualOp(op2))
-    return IR_COND_LE;
-  else if (isSgGreaterThanOp(op2))
-    return IR_COND_GT;
-  else if (isSgGreaterOrEqualOp(op2))
-    return IR_COND_GE;
-  
-  return IR_COND_UNKNOWN;
-  
-}
-
-std::vector<omega::CG_outputRepr *> IR_roseCode::QueryExpOperand(
-  const omega::CG_outputRepr *repr) const {
-  std::vector<omega::CG_outputRepr *> v;
-  SgExpression* op1;
-  SgExpression* op2;
-  SgExpression* op =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-  omega::CG_roseRepr *repr1;
-  
-  if (isSgValueExp(op) || isSgVarRefExp(op)) {
-    omega::CG_roseRepr *repr = new omega::CG_roseRepr(op);
-    v.push_back(repr);
-  } else if (isSgAssignOp(op)) {
-    op1 = isSgAssignOp(op)->get_rhs_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-    /*may be a problem as assignOp is a binaryop destop might be needed */
-  } else if (isSgMinusOp(op)) {
-    op1 = isSgMinusOp(op)->get_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-  } else if (isSgUnaryAddOp(op)) {
-    op1 = isSgUnaryAddOp(op)->get_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-  } else if ((isSgAddOp(op) || isSgSubtractOp(op))
-             || (isSgMultiplyOp(op) || isSgDivideOp(op))) {
-    op1 = isSgBinaryOp(op)->get_lhs_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-    
-    op2 = isSgBinaryOp(op)->get_rhs_operand();
-    repr1 = new omega::CG_roseRepr(op2);
-    v.push_back(repr1);
-  } else if (isSgConditionalExp(op)) {
-    SgExpression* cond = isSgConditionalExp(op)->get_conditional_exp();
-    op1 = isSgBinaryOp(cond)->get_lhs_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-    
-    op2 = isSgBinaryOp(cond)->get_rhs_operand();
-    repr1 = new omega::CG_roseRepr(op2);
-    v.push_back(repr1);
-  } else if (isSgCompoundAssignOp(op)) {
-    SgExpression* cond = isSgCompoundAssignOp(op);
-    op1 = isSgBinaryOp(cond)->get_lhs_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-    
-    op2 = isSgBinaryOp(cond)->get_rhs_operand();
-    repr1 = new omega::CG_roseRepr(op2);
-    v.push_back(repr1);
-    
-  } else if (isSgBinaryOp(op)) {
-    
-    op1 = isSgBinaryOp(op)->get_lhs_operand();
-    repr1 = new omega::CG_roseRepr(op1);
-    v.push_back(repr1);
-    
-    op2 = isSgBinaryOp(op)->get_rhs_operand();
-    repr1 = new omega::CG_roseRepr(op2);
-    v.push_back(repr1);
-  }
-  
-  else
-    throw ir_error("operation not supported");
-  
-  return v;
-}
-
-IR_Ref *IR_roseCode::Repr2Ref(const omega::CG_outputRepr *repr) const {
-  SgExpression* op =
-    static_cast<const omega::CG_roseRepr *>(repr)->GetExpression();
-  
-  if (SgValueExp* im = isSgValueExp(op)) {
-    if (isSgIntVal(im))
-      return new IR_roseConstantRef(this,
-                                    static_cast<omega::coef_t>(isSgIntVal(im)->get_value()));
-    else if (isSgUnsignedIntVal(im))
-      return new IR_roseConstantRef(this,
-                                    static_cast<omega::coef_t>(isSgUnsignedIntVal(im)->get_value()));
-    else if (isSgLongIntVal(im))
-      return new IR_roseConstantRef(this,
-                                    static_cast<omega::coef_t>(isSgLongIntVal(im)->get_value()));
-    else if (isSgFloatVal(im))
-      return new IR_roseConstantRef(this, isSgFloatVal(im)->get_value());
-    else
-      assert(0);
-    
-  } else if (isSgVarRefExp(op))
-    return new IR_roseScalarRef(this, isSgVarRefExp(op));
-  else
-    assert(0);
-  
-}
-
diff --git a/src/ir_rose_utils.cc b/src/ir_rose_utils.cc
deleted file mode 100644
index 1329031..0000000
--- a/src/ir_rose_utils.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-/*****************************************************************************
- Copyright (C) 2008 University of Southern California
- Copyright (C) 2009 University of Utah
- All Rights Reserved.
-
- Purpose:
-   ROSE interface utilities.
-
- Notes:
-
- Update history:
-   01/2006 created by Chun Chen
-*****************************************************************************/
-
-#include "ir_rose_utils.hh"
-
-
-
-std::vector<SgForStatement *> find_loops(SgNode *tnl) {
-  std::vector<SgForStatement *> result;
- 
-  SgStatementPtrList& blockStatements = isSgBasicBlock(tnl)->get_statements();
-  for(SgStatementPtrList::const_iterator j = blockStatements.begin(); j != blockStatements.end(); j++)
-    if(isSgForStatement(*j))
-      result.push_back(isSgForStatement(*j));
-  
-  return result;
-}
-
-std::vector<SgForStatement *> find_deepest_loops(SgStatementPtrList& tnl) {
-  
-  std::vector<SgForStatement *> loops;
-  
-  for(SgStatementPtrList::const_iterator j = tnl.begin(); j != tnl.end(); j++)
-  {
-    std::vector<SgForStatement *> t = find_deepest_loops(isSgNode(*j));
-    if (t.size() > loops.size())
-      loops = t;
-  }       
-  
-  return loops;
-}
-
-std::vector<SgForStatement *> find_deepest_loops(SgNode *tn) {
-  if (isSgForStatement(tn)) {
-    std::vector<SgForStatement *> loops;
-    
-    SgForStatement *tnf = static_cast<SgForStatement*>(tn);
-    loops.insert(loops.end(), tnf);
-    std::vector<SgForStatement*> t = find_deepest_loops(isSgNode(tnf->get_loop_body()));
-    std::copy(t.begin(), t.end(), std::back_inserter(loops));
-    
-    return loops;
-  }
-  else if (isSgBasicBlock(tn)) {
-    SgBasicBlock *tnb = static_cast<SgBasicBlock*>(tn);
-    return find_deepest_loops(tnb->get_statements());
-  }
-  else 
-    return std::vector<SgForStatement *>();               
-}
-
diff --git a/src/irtools.cc b/src/irtools.cc
index e7e5029..16c4f7c 100644
--- a/src/irtools.cc
+++ b/src/irtools.cc
@@ -19,61 +19,80 @@
 
 using namespace omega;
 
-std::vector<ir_tree_node *> build_ir_tree(IR_Control *control, ir_tree_node *parent) {
+// Build Chill IR tree from the source code (from the front end compiler's AST). 
+// Block type node can only be a leaf, i.e., there are no further structures 
+// inside a block allowed.
+std::vector<ir_tree_node *> build_ir_tree(IR_Control *control, 
+                                          ir_tree_node *parent) {
   std::vector<ir_tree_node *> result;
   
+  fprintf(stderr, "irtools.cc, build_ir_tree( control, parent)   building a CHILL IR tree \n");
+
   switch (control->type()) {
   case IR_CONTROL_BLOCK: {
-    std::vector<IR_Control *> controls = control->ir_->FindOneLevelControlStructure(static_cast<IR_Block *>(control));
+    fprintf(stderr, "irtools.cc L31   case IR_CONTROL_BLOCK\n"); 
+    IR_Block *IRCB = static_cast<IR_Block *>(control); 
+    std::vector<IR_Control *> controls = control->ir_->FindOneLevelControlStructure(IRCB);
+
+    fprintf(stderr, "irtools.cc BACK FROM FindOneLevelControlStructure()  %d controls\n", controls.size()); 
+
     if (controls.size() == 0) {
+      fprintf(stderr, "controls.size() == 0\n"); 
+
       ir_tree_node *node = new ir_tree_node;
-      node->content = control;
-      node->parent = parent;
+      node->content = control; 
+      node->parent  = parent;
       node->payload = -1;
       result.push_back(node);
     }
     else {
+      fprintf(stderr, "controls.size() == %d  (NONZERO)\n", controls.size()); 
       delete control;
+
       for (int i = 0; i < controls.size(); i++)
         switch (controls[i]->type()) {
         case IR_CONTROL_BLOCK: {
+          fprintf(stderr, "controls[%d] is IR_CONTROL_BLOCK\n", i); 
           std::vector<ir_tree_node *> t = build_ir_tree(controls[i], parent);
           result.insert(result.end(), t.begin(), t.end());
           break;
         }
         case IR_CONTROL_LOOP: {
+          fprintf(stderr, "controls[%d] is IR_CONTROL_LOOP\n", i); 
           ir_tree_node *node = new ir_tree_node;
           node->content = controls[i];
           node->parent = parent;
-          node->children = build_ir_tree(static_cast<IR_Loop *>(controls[i])->body(), node);
+          node->children = build_ir_tree(static_cast<IR_Loop *>(controls[i])->body(), node); // recurse
           node->payload = -1;
           result.push_back(node);
           break;
         }
         case IR_CONTROL_IF: {
+          fprintf(stderr, "controls[%d] is IR_CONTROL_IF\n", i); 
           static int unique_if_identifier = 0;
           
-          IR_Block *block = static_cast<IR_If *>(controls[i])->then_body();
+          IR_If* theif = static_cast<IR_If *>(controls[i]); 
+          IR_Block *block = theif->then_body();
           if (block != NULL) {
             ir_tree_node *node = new ir_tree_node;
             node->content = controls[i];
             node->parent = parent;
-            node->children = build_ir_tree(block, node);
+            node->children = build_ir_tree(block, node); // recurse 
             node->payload = unique_if_identifier+1;
             result.push_back(node);
           }
           
           
-          block = static_cast<IR_If *>(controls[i])->else_body();
-          if ( block != NULL) {
+          block = theif->else_body();
+          if (block != NULL) { 
+            fprintf(stderr, "IF_CONTROL has an else\n"); 
             ir_tree_node *node = new ir_tree_node;
             node->content = controls[i]->clone();
             node->parent = parent;
-            node->children = build_ir_tree(block, node);
+            node->children = build_ir_tree(block, node); // recurse
             node->payload = unique_if_identifier;
             result.push_back(node);
           }
-          
           unique_if_identifier += 2;
           break;
         }
@@ -89,42 +108,58 @@ std::vector<ir_tree_node *> build_ir_tree(IR_Control *control, ir_tree_node *par
     break;
   }
   case IR_CONTROL_LOOP: {
+    fprintf(stderr, "case IR_CONTROL_LOOP\n"); 
     ir_tree_node *node = new ir_tree_node;
     node->content = control;
-    node->parent = parent;
-    node->children = build_ir_tree(static_cast<const IR_Loop *>(control)->body(), node);
+    node->parent  = parent;
+    fprintf(stderr, "recursing. build_ir_tree() of CONTROL_LOOP creating children  L122\n");
+    node->children = build_ir_tree(
+      static_cast<const IR_Loop *>(control)->body(), node);
     node->payload = -1;
     result.push_back(node);
+    fprintf(stderr, "recursing. build_ir_tree() of CONTROL_LOOP creating children DONE\n");
     break;
   }
   default:
     ir_tree_node *node = new ir_tree_node;
     node->content = control;
-    node->parent = parent;
+    node->parent  = parent;
     node->payload = -1;
     result.push_back(node);
     break;
   }
   
+  fprintf(stderr, "build_ir_tree()  vector result has %ld parts\n", result.size());  
   return result;
 }
 
+
+// Extract statements from IR tree. Statements returned are ordered in
+// lexical order in the source code.
 std::vector<ir_tree_node *> extract_ir_stmts(const std::vector<ir_tree_node *> &ir_tree) {
+
+  fprintf(stderr, "extract_ir_stmts()   ir_tree.size() %d\n", ir_tree.size()); 
   std::vector<ir_tree_node *> result;
   for (int i = 0; i < ir_tree.size(); i++)
     switch (ir_tree[i]->content->type()) {
+
     case IR_CONTROL_BLOCK:
+      fprintf(stderr, "IR_CONTROL_BLOCK\n"); 
       result.push_back(ir_tree[i]);
       break;
+
     case IR_CONTROL_LOOP: {
+      fprintf(stderr, "IR_CONTROL_LOOP( recursing )\n"); 
       // clear loop payload from previous unsuccessful initialization process
       ir_tree[i]->payload = -1;
       
       std::vector<ir_tree_node *> t = extract_ir_stmts(ir_tree[i]->children);
+      
       result.insert(result.end(), t.begin(), t.end());
       break;
     }      
     case IR_CONTROL_IF: {
+      fprintf(stderr, "IR_CONTROL_IF( recursing )\n"); 
       std::vector<ir_tree_node *> t = extract_ir_stmts(ir_tree[i]->children);
       result.insert(result.end(), t.begin(), t.end());
       break;
@@ -136,6 +171,20 @@ std::vector<ir_tree_node *> extract_ir_stmts(const std::vector<ir_tree_node *> &
   return result;
 }
 
+std::string chill_ir_control_type_string( IR_CONTROL_TYPE type ) {
+  switch(type) {
+  case IR_CONTROL_BLOCK:  return std::string( "IR_CONTROL_BLOCK");
+  case IR_CONTROL_LOOP:   return std::string( "IR_CONTROL_LOOP" );
+  case IR_CONTROL_IF:     return std::string( "IR_CONTROL_IF" );
+  case IR_CONTROL_WHILE:  return std::string( "IR_CONTROL_WHLIE"); break;
+  default: return std::string( "UNKNOWN_IR_NODE_TYPE" ); 
+  }
+}
+
+std::string chill_ir_node_type_string( ir_tree_node *node ) {
+  return chill_ir_control_type_string( node->content->type() );
+}
+
 
 bool is_dependence_valid(ir_tree_node *src_node, ir_tree_node *dst_node,
                          const DependenceVector &dv, bool before) {
@@ -179,46 +228,240 @@ bool is_dependence_valid(ir_tree_node *src_node, ir_tree_node *dst_node,
   
 }
 
-std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > test_data_dependences(
-  IR_Code *ir, const CG_outputRepr *repr1, const Relation &IS1,
-  const CG_outputRepr *repr2, const Relation &IS2,
-  std::vector<Free_Var_Decl*> &freevar, std::vector<std::string> index,
-  int i, int j) {
+
+//Anand: Adding function to collect the loop inductive and possibly if conditions
+//enclosing a statement
+
+std::vector<omega::CG_outputRepr *> collect_loop_inductive_and_conditionals(
+  ir_tree_node * stmt_node) {
+  
+  std::vector<omega::CG_outputRepr *> to_return;
+  ir_tree_node *itn = stmt_node;
+  
+  while (itn->parent != NULL) {
+    itn = itn->parent;
+    
+    switch (itn->content->type()) {
+    case IR_CONTROL_LOOP: {
+      IR_Loop *lp = static_cast<IR_Loop *>(itn->content);
+      to_return.push_back(lp->lower_bound());
+      to_return.push_back(lp->upper_bound());
+      
+      break;
+    }
+    case IR_CONTROL_IF: {
+      CG_outputRepr *cond =
+        static_cast<IR_If *>(itn->content)->condition();
+      
+      to_return.push_back(cond);
+      break;
+    }
+    default:
+      throw std::invalid_argument("invalid ir tree");
+    }
+  }
+  return to_return;
+}
+
+
+// Test data dependences between two statements. The first statement
+// in parameter must be lexically before the second statement in
+// parameter.  Returned dependences are all lexicographically
+// positive. The first vector in returned pair is dependences from the
+// first statement to the second statement and the second vector in
+// returned pair is in reverse order.
+std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > 
+test_data_dependences(IR_Code *ir, 
+                      const CG_outputRepr *repr1, 
+                      const Relation &IS1,
+                      const CG_outputRepr *repr2, 
+                      const Relation &IS2,
+                      std::vector<Free_Var_Decl*> &freevar, 
+                      std::vector<std::string> index,
+                      int nestLeveli, 
+                      int nestLevelj, 
+                      std::map<std::string, std::vector<omega::CG_outputRepr * > > &uninterpreted_symbols,
+                      std::map<std::string, std::vector<omega::CG_outputRepr * > > &uninterpreted_symbols_stringrepr) {
+
+  fprintf(stderr, "\nirtools.cc test_data_dependences()  %d freevars\n", freevar.size()); 
+  fprintf(stderr, "\nrepr1  %p    ", repr1); repr1->dump(); fflush(stdout); 
+  fprintf(stderr, "\nrepr2  %p    ", repr2); repr2->dump(); fflush(stdout); 
+
+  for (int i=0; i<index.size(); i++) fprintf(stderr, "index %d %s\n", i, index[i].c_str()); 
+  Relation *helper = new Relation(IS1); fprintf(stderr, "IS1  "); helper->print(); fflush(stdout); 
+  helper = new Relation(IS2); fprintf(stderr, "IS2  "); helper->print(); fflush(stdout); 
+
+
+  //for (int i=0; i<freevar.size(); i++) {
+  //  std::string shit = (const std::string)(freevar[i]->base_name()); 
+  
+  //  fprintf(stderr, "freevar %d %s\n", i, shit.c_str()); 
+  //} 
+  
   std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > result;
   
   if (repr1 == repr2) {
+    fprintf(stderr, "repr1 == repr2\nrepr1->dump()\n"); 
+    repr1->dump(); 
+    fflush(stdout);
+
     std::vector<IR_ArrayRef *> access = ir->FindArrayRef(repr1);
+    fprintf(stderr, "access of size %d\n", access.size()); 
+    for (int i = 0; i < access.size(); i++) {
+      IR_ArrayRef *a = access[i];
+      
+      if (a->is_write()) { 
+        fprintf(stderr, "WRITE  array access %d = %s\n", i, a->name().c_str()); 
+      } 
+      else { 
+        fprintf(stderr, "       array access %d = %s\n", i, a->name().c_str()); 
+      } 
+    } 
+    fprintf(stderr, "that was the list\n\n"); 
+
+    // Manu:: variables/structures added to identify dependence vectors related to reduction operation
+    tempResultMap trMap;
+    tempResultMap::iterator ittrMap;
+    int ref2Stmt[access.size()]; // mapping of reference to statement
+    std::set<int> nrStmts; // stores statements that can't be reduced
+    std::set<int> tnrStmts;
+    int stmtId = 1;
+    int tempStmtId = 1;
+    std::map<int,std::set<int> > rMap; // This maps statement number to a set of dependences
+    std::map<int, std::set<int> >::iterator itMap;
+    for (int i = 0; i < access.size(); i++) {
+      ref2Stmt[i] = -1;
+    }
+    
+    // Manu -- changes for identifying possible reduction operation
+    // The below loop nest is used to classify array references into different statements
+    fprintf(stderr, "\nbefore mapRefstoStatements()\n"); 
+    mapRefstoStatements(ir,access,ref2Stmt,rMap,tnrStmts,nrStmts);
+    fprintf(stderr, "after mapRefstoStatements()\n\n"); 
+
+    //-------------------------------------------------------------
+    omega::coef_t lbound[3], ubound[3];   // for each  kind of dependence. We can potentially have reduction only if all
+    // lbounds match and all ubounds match. At present, we only check the last loop level.
+    lbound[0] = lbound[1] = lbound[2] = LLONG_MAX;
+    ubound[0] = ubound[1] = ubound[2] = LLONG_MIN;
+    //-------------------------------------------------------------
     
     for (int i = 0; i < access.size(); i++) {
+      fprintf(stderr, "i %d\n", i); 
       IR_ArrayRef *a = access[i];
       IR_ArraySymbol *sym_a = a->symbol();
+      fprintf(stderr, "sym_a = %s\n", a->name().c_str()); 
       for (int j = i; j < access.size(); j++) {
+        fprintf(stderr, "irtools.cc j %d\n", j); 
         IR_ArrayRef *b = access[j];
         IR_ArraySymbol *sym_b = b->symbol();
+        fprintf(stderr, "sym_b = %s\n", b->name().c_str()); 
+        
+        fprintf(stderr, "irtools.cc ij %d %d\n", i, j); 
         
+        if  (*sym_a == *sym_b) fprintf(stderr, "*sym_a == *sym_b\n");
+        else fprintf(stderr, "*sym_a NOT == *sym_b\n");
+
+        if ( a->is_write()) fprintf(stderr, "%d a->is_write()\n", i); 
+        else fprintf(stderr, "%d a->is_NOT_write()\n", i); 
+        if ( b->is_write()) fprintf(stderr, "%d b->is_write()\n", j); 
+        else fprintf(stderr, "%d b->is_NOT_write()\n", j); 
+
         if (*sym_a == *sym_b && (a->is_write() || b->is_write())) {
-          Relation r = arrays2relation(ir, freevar, a, IS1, b, IS2);
+          fprintf(stderr, "\nirtools.cc ij %d %d   SYMBOL A == SYMBOL B and one is a write\n", i, j); 
+          Relation r = arrays2relation(ir, freevar, a, IS1, b, IS2,uninterpreted_symbols,uninterpreted_symbols_stringrepr);
+          helper = new Relation(r); fprintf(stderr, "r    "); helper->print(); fflush(stdout); 
+
+
+          fprintf(stderr, "1\n"); 
           std::pair<std::vector<DependenceVector>,
             std::vector<DependenceVector> > dv =
             relation2dependences(a, b, r);
-          result.first.insert(result.first.end(), dv.first.begin(),
+          fprintf(stderr, "\nirtools.cc ij %d %d dv.first %d   dv.second %d\n", i, j, dv.first.size(), dv.second.size()); 
+          fprintf(stderr, "2"); 
+          result.first.insert(result.first.end(), dv.first.begin(), 
                               dv.first.end());
+          fprintf(stderr, "3"); 
           result.second.insert(result.second.end(), dv.second.begin(),
                                dv.second.end());
+          fprintf(stderr, "4"); 
+
+          // Manu:: check if the array references belong to the same statement
+          // If yes, set the flag in the dependence vector
+          //----------------------------------------------
+          if(DEP_DEBUG){
+            std::cout << "Size of the dependence vector '" << a->name().c_str() << "'  -- " << dv.first.size() << "\n";
+            std::cout << "------------ Printing dependence vector START ---------------\n";
+            
+            for (std::vector<DependenceVector>::iterator itd = dv.first.begin(); itd != dv.first.end(); itd++){
+              if (itd->type == DEP_R2W)
+                std::cout<<"WAR\n";
+              else if (itd->type == DEP_W2R)
+                std::cout<<"RAW\n";
+              else if (itd->type == DEP_W2W)
+                std::cout<<"WAW\n";
+              
+              std::vector<omega::coef_t>::iterator itu = itd->ubounds.begin();
+              for (std::vector<omega::coef_t>::iterator itl = itd->lbounds.begin(); itl != itd->lbounds.end(); itl++){
+                std::cout << "(" << *itl << ", " << *itu << ")\n";
+                itu++;
+              }
+            }
+            std::cout << "--------\n";
+            for (std::vector<DependenceVector>::iterator itd = dv.second.begin(); itd != dv.second.end(); itd++){
+              if (itd->type == DEP_R2W)
+                std::cout<<"WAR\n";
+              else if (itd->type == DEP_W2R)
+                std::cout<<"RAW\n";
+              else if (itd->type == DEP_W2W)
+                std::cout<<"WAW\n";
+              
+              std::vector<omega::coef_t>::iterator itu = itd->ubounds.begin();
+              for (std::vector<omega::coef_t>::iterator itl = itd->lbounds.begin(); itl != itd->lbounds.end(); itl++){
+                std::cout << "(" << *itl << ", " << *itu << ")\n";
+                itu++;
+              }
+            }
+            std::cout << "------------ Printing dependence vector END---------------\n";
+          }
+          checkReductionDependence(i,j,nestLeveli,lbound,ubound,ref2Stmt,rMap,dv,trMap,nrStmts);
+          //----------------------------------------------
+          
+//           // Manu:: original code without the condition
+          if (((rMap.find(ref2Stmt[i])->second).size() != 3) || (lbound[0] != lbound[1]) || (lbound[1] != lbound[2]) ||
+              (lbound[0] != lbound[2]) || (ubound[0] != ubound[1]) || (ubound[1] != ubound[2]) || (ubound[0] != ubound[2])) { // Manu:: original code without the condition
+            result.first.insert(result.first.end(),
+                                dv.first.begin(), dv.first.end());
+            result.second.insert(result.second.end(),
+                                 dv.second.begin(), dv.second.end());
+          }
+
+
         }
         delete sym_b;
       }
       delete sym_a;
-      
+    }
+    
+    // Manu
+    for (ittrMap = trMap.begin(); ittrMap != trMap.end(); ittrMap++) {
+      DVPair tdv = ittrMap->second;
+      result.first.insert(result.first.end(), tdv.first.begin(),
+                          tdv.first.end());
+      result.second.insert(result.second.end(), tdv.second.begin(),
+                           tdv.second.end());
     }
     
     for (int i = 0; i < access.size(); i++)
       delete access[i];
   } else {
+    fprintf(stderr, "\nrepr1 != repr2\n"); 
+
     std::vector<IR_ArrayRef *> access1 = ir->FindArrayRef(repr1);
     std::vector<IR_ArrayRef *> access2 = ir->FindArrayRef(repr2);
     
     for (int i = 0; i < access1.size(); i++) {
+      fprintf(stderr, "i %d\n", i); 
       IR_ArrayRef *a = access1[i];
       IR_ArraySymbol *sym_a = a->symbol();
       
@@ -226,7 +469,7 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > test_da
         IR_ArrayRef *b = access2[j];
         IR_ArraySymbol *sym_b = b->symbol();
         if (*sym_a == *sym_b && (a->is_write() || b->is_write())) {
-          Relation r = arrays2relation(ir, freevar, a, IS1, b, IS2);
+          Relation r = arrays2relation(ir, freevar, a, IS1, b, IS2, uninterpreted_symbols,uninterpreted_symbols_stringrepr);
           std::pair<std::vector<DependenceVector>,
             std::vector<DependenceVector> > dv =
             relation2dependences(a, b, r);
@@ -246,6 +489,242 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > test_da
     for (int i = 0; i < access2.size(); i++)
       delete access2[i];
   }
+  /*std::pair<std::vector<DependenceVector>,
+    std::vector<DependenceVector> > dv =
+    ir->FindScalarDeps(repr1, repr2, index, i, j);
+    
+    
+    result.first.insert(result.first.end(), dv.first.begin(),
+    dv.first.end());
+    result.second.insert(result.second.end(), dv.second.begin(),
+    dv.second.end());*/
+  /*result.first.insert(result.first.end(), dv.first.begin(),
+    dv.first.end());
+    result.second.insert(result.second.end(), dv.second.begin(),
+    dv.second.end());
+  */
+  
+  fprintf(stderr, "LEAVING test_data_dependences()  first size %d    second size %d\n\n",  result.first.size(), result.second.size()); 
   return result;
 }
 
+
+//Manu:: This function tests if two references are from the same statement
+//CG_outputRepr * from_same_statement(IR_Code *ir, IR_ArrayRef *a, IR_ArrayRef *b) {
+bool from_same_statement(IR_Code *ir, IR_ArrayRef *a, IR_ArrayRef *b) {
+  return ir->FromSameStmt(a,b);
+}
+
+// Manu
+int stmtType(IR_Code *ir, const CG_outputRepr *repr) {
+  fprintf(stderr, "stmtType() DIE \n"); 
+  exit(-1); 
+  return (ir->getStmtType(repr)); /// AIEEE returns a meaningless number encoding rose internals. 
+}
+
+// Manu:: set the reduction operation
+IR_OPERATION_TYPE getReductionOperator(IR_Code *ir, const CG_outputRepr *repr) {
+  return (ir->getReductionOp(repr));
+}
+
+// Manu:: map references to its corresponding statements
+void mapRefstoStatements(IR_Code *ir, std::vector<IR_ArrayRef *> access, int ref2Stmt[], std::map<int,std::set<int> >& rMap, std::set<int>& tnrStmts, std::set<int>& nrStmts) {
+  
+  int stmtId = 1;
+  for (int i = 0; i < access.size(); i++) {
+    IR_ArrayRef *a = access[i];
+    IR_ArraySymbol *sym_a = a->symbol();
+    for (int j = i; j < access.size(); j++) {
+      IR_ArrayRef *b = access[j];
+      IR_ArraySymbol *sym_b = b->symbol();
+      bool inSameStmt;
+      if (from_same_statement(ir,access[i],access[j])) {
+        inSameStmt = true;
+//            std::cout << "Manu:: inSameStmt " << a->name().c_str() << ", " << b->name().c_str() << "\n";
+      } else {
+        inSameStmt = false;
+//            std::cout << "Manu:: NOT inSameStmt " << a->name().c_str() << ", " << b->name().c_str() << "\n";
+      }
+      if (inSameStmt) {
+        if (ref2Stmt[i] == -1)
+          ref2Stmt[i] = stmtId++;
+        ref2Stmt[j] = ref2Stmt[i];
+        rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],std::set<int>()));
+      } else {
+        if (ref2Stmt[i] == -1)
+          ref2Stmt[i] = stmtId++;
+        if (ref2Stmt[j] == -1)
+          ref2Stmt[j] = stmtId++;
+        if (*sym_a == *sym_b && (a->is_write() || b->is_write())) {
+          tnrStmts.insert(i);
+          tnrStmts.insert(j);
+        }
+      }
+      
+    }
+  }
+  std::set<int>::iterator itS;
+  for (itS = tnrStmts.begin(); itS != tnrStmts.end(); itS++) {
+    nrStmts.insert(ref2Stmt[*itS]);
+  }
+  
+}
+
+// Manu:: This function tests reduction dependence and updates corresponding data structures
+void checkReductionDependence(int i, int j, int nestLeveli, omega::coef_t lbound[], omega::coef_t ubound[], int ref2Stmt[], std::map<int,std::set<int> >& rMap, DVPair& dv, tempResultMap& trMap, std::set<int> nrStmts ) {
+  
+  std::map<int, std::set<int> >::iterator itMap;
+  tempResultMap::iterator ittrMap;
+  bool raw,war,waw, flg;
+  raw = war = waw = flg = false;
+  if ((ref2Stmt[i] == ref2Stmt[j]) && (nrStmts.find(ref2Stmt[i])== nrStmts.end())) {
+    for (int k = 0; k < dv.first.size(); k++) {
+      if ((dv.first[k].lbounds[nestLeveli-1] == 0) && (dv.first[k].ubounds[nestLeveli-1] == 0))
+        continue;
+      itMap = rMap.find(ref2Stmt[i]);
+      if (dv.first[k].type == DEP_R2W) {
+        war = true;
+        std::set<int> s = itMap->second;
+        s.insert(1); // war == 1
+        rMap.erase(itMap);
+        rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+        if (lbound[0] > dv.first[k].lbounds[nestLeveli-1])
+          lbound[0] = dv.first[k].lbounds[nestLeveli-1];
+        if(ubound[0] < dv.first[k].ubounds[nestLeveli-1])
+          ubound[0] = dv.first[k].ubounds[nestLeveli-1];
+      } else if (dv.first[k].type == DEP_W2R) {
+        //    for (int k1 = 0; k1 < dv.first[k].lbounds.size(); k1++) {
+        //      omega::coef_t lbound = dv.first[k].lbounds[k1];
+        omega::coef_t lbound1 = dv.first[k].lbounds[nestLeveli-1];
+        if (lbound1 > 0) {
+          flg = true;
+          //        break;
+        }
+        //    }
+        raw = true;
+        if (raw) {
+          std::set<int> s = itMap->second;
+          s.insert(2); // raw == 2
+          rMap.erase(itMap);
+          rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+          if (lbound[1] > dv.first[k].lbounds[nestLeveli-1])
+            lbound[1] = dv.first[k].lbounds[nestLeveli-1];
+          if(ubound[1] < dv.first[k].ubounds[nestLeveli-1])
+            ubound[1] = dv.first[k].ubounds[nestLeveli-1];
+        }
+      } else if (dv.first[k].type == DEP_W2W) {
+        waw = true;
+        std::set<int> s = itMap->second;
+        s.insert(3); // waw == 3
+        rMap.erase(itMap);
+        rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+        if (lbound[2] > dv.first[k].lbounds[nestLeveli-1])
+          lbound[2] = dv.first[k].lbounds[nestLeveli-1];
+        if(ubound[2] < dv.first[k].ubounds[nestLeveli-1])
+          ubound[2] = dv.first[k].ubounds[nestLeveli-1];
+      }
+//              std::cout<< "Manu:: Flags:: " << "raw " << raw << ", war " << war << ", waw " << waw << "\n";
+    }
+    flg = false;
+    for (int k = 0; k < dv.second.size(); k++) {
+      if ((dv.second[k].lbounds[nestLeveli-1] == 0) && (dv.second[k].ubounds[nestLeveli-1] == 0))
+        continue;
+      itMap = rMap.find(ref2Stmt[i]);
+      if (dv.second[k].type == DEP_R2W) {
+        war = true;
+        std::set<int> s = itMap->second;
+        s.insert(1); // war == 1
+        rMap.erase(itMap);
+        rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+        if (lbound[0] > dv.second[k].lbounds[nestLeveli-1])
+          lbound[0] = dv.second[k].lbounds[nestLeveli-1];
+        if (ubound[0] < dv.second[k].ubounds[nestLeveli-1])
+          ubound[0] = dv.second[k].ubounds[nestLeveli-1];
+        
+      } else if (dv.second[k].type == DEP_W2R) {
+        //    for (int k1 = 0; k1 < dv.second[k].lbounds.size(); k1++) {
+        //omega::coef_t lbound = dv.second[k].lbounds[k1];
+        omega::coef_t lbound1 = dv.second[k].lbounds[nestLeveli-1];
+        if (lbound1 > 0) {
+          flg = true;
+          //        break;
+        }
+        //    }
+        raw = true;
+        if (raw) {
+          std::set<int> s = itMap->second;
+          s.insert(2); // raw == 2
+          rMap.erase(itMap);
+          rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+          if (lbound[1] > dv.second[k].lbounds[nestLeveli-1])
+            lbound[1] = dv.second[k].lbounds[nestLeveli-1];
+          if (ubound[1] < dv.second[k].ubounds[nestLeveli-1])
+            ubound[1] = dv.second[k].ubounds[nestLeveli-1];
+          
+        }
+        
+      } else if (dv.second[k].type == DEP_W2W) {
+        waw = true;
+        std::set<int> s = itMap->second;
+        s.insert(3); // waw == 3
+        rMap.erase(itMap);
+        rMap.insert(std::pair<int,std::set<int> >(ref2Stmt[i],s));
+        if (lbound[2] > dv.second[k].lbounds[nestLeveli-1])
+          lbound[2] = dv.second[k].lbounds[nestLeveli-1];
+        if (ubound[2] < dv.second[k].ubounds[nestLeveli-1])
+          ubound[2] = dv.second[k].ubounds[nestLeveli-1];
+        
+      }
+//              std::cout<< "Manu:: Flags:: " << "raw " << raw << ", war " << war << ", waw " << waw << "\n";
+    }
+    
+//            if ((rMap.find(ref2Stmt[i])->second).size() == 3) {
+    if(DEP_DEBUG){
+      std::cout << "lbounds: " << lbound[0] << ", " << lbound[1] << ", " <<lbound[2] << "\n";
+      std::cout << "ubounds: " << ubound[0] << ", " << ubound[1] << ", " <<ubound[2] << "\n";
+    }
+    if (((rMap.find(ref2Stmt[i])->second).size() == 3) && (lbound[0] == lbound[1]) && (lbound[1] == lbound[2])
+        && (ubound[0] == ubound[1]) && (ubound[1] == ubound[2])) {
+//              std::cout << "Manu:: All dependences present 1 \n";
+      for (int k = 0; k < dv.second.size(); k++)
+        dv.second[k].is_reduction_cand = true;
+      for (int k = 0; k < dv.first.size(); k++)
+        dv.first[k].is_reduction_cand = true;
+      trMap.insert(std::pair<int,DVPair>(ref2Stmt[i],DVPair(dv.first,dv.second)));
+    }
+  } else {
+    //  tempArrayRefId[i] = tempArrayRefId[j] = 0;
+    for (int k = 0; k < dv.second.size(); k++)
+      dv.second[k].is_reduction_cand = false;
+    for (int k = 0; k < dv.first.size(); k++)
+      dv.first[k].is_reduction_cand = false;
+//            reductionCand = false;
+    ittrMap = trMap.find(ref2Stmt[i]);
+    if (ittrMap != trMap.end()) {
+      DVPair tdv = ittrMap->second;
+      for (int k = 0; k < (tdv.first).size(); k++)
+        tdv.first[k].is_reduction_cand = false;
+      for (int k = 0; k < (tdv.second).size(); k++)
+        tdv.second[k].is_reduction_cand = false;
+      trMap.erase(ittrMap);
+      trMap.insert(std::pair<int,DVPair>(ref2Stmt[i],DVPair(tdv.first,tdv.second)));
+    }
+  }
+  
+}
+
+
+
+void print_control(  IR_Control *con ) {
+  IR_CONTROL_TYPE type = con->type();
+  fprintf(stderr, "this is IR_Control of type %s\n", chill_ir_control_type_string( type ).c_str());
+
+  switch (type) {
+  case IR_CONTROL_BLOCK:  
+  case IR_CONTROL_LOOP:   
+  case IR_CONTROL_IF:     
+  case IR_CONTROL_WHILE:  
+  default:  return; 
+  }
+
+}
diff --git a/src/loop.cc b/src/loop.cc
index 19378a4..5f863f2 100644
--- a/src/loop.cc
+++ b/src/loop.cc
@@ -26,6 +26,8 @@
 #include <math.h>
 #include <code_gen/codegen.h>
 #include <code_gen/CG_utils.h>
+#include <code_gen/CG_stringRepr.h>
+#include <code_gen/CG_chillRepr.h>   // Mark.  Bad idea.  TODO 
 #include <iostream>
 #include <algorithm>
 #include <map>
@@ -35,11 +37,258 @@
 #include "chill_error.hh"
 #include <string.h>
 #include <list>
+
+// TODO 
+#define _DEBUG_ true
+
+
+
 using namespace omega;
 
 const std::string Loop::tmp_loop_var_name_prefix = std::string("chill_t"); // Manu:: In fortran, first character of a variable name must be a letter, so this change
 const std::string Loop::overflow_var_name_prefix = std::string("over");
 
+void echocontroltype( const IR_Control *control ) { 
+  switch(control->type()) { 
+  case IR_CONTROL_BLOCK: {
+    fprintf(stderr, "IR_CONTROL_BLOCK\n"); 
+    break;
+  }
+  case IR_CONTROL_LOOP: {
+    fprintf(stderr, "IR_CONTROL_LOOP\n"); 
+    break;
+  }
+  case IR_CONTROL_IF: {
+    fprintf(stderr, "IR_CONTROL_IF\n"); 
+    break;
+  }
+  default:
+    fprintf(stderr, "just a bunch of statements?\n"); 
+    
+  } // switch
+}
+
+omega::Relation Loop::getNewIS(int stmt_num) const {
+  
+  omega::Relation result;
+  
+  if (stmt[stmt_num].xform.is_null()) {
+    omega::Relation known = omega::Extend_Set(omega::copy(this->known),
+                                              stmt[stmt_num].IS.n_set() - this->known.n_set());
+    result = omega::Intersection(omega::copy(stmt[stmt_num].IS), known);
+  } else {
+    omega::Relation known = omega::Extend_Set(omega::copy(this->known),
+                                              stmt[stmt_num].xform.n_out() - this->known.n_set());
+    result = omega::Intersection(
+                                 omega::Range(
+                                              omega::Restrict_Domain(
+                                                                     omega::copy(stmt[stmt_num].xform),
+                                                                     omega::copy(stmt[stmt_num].IS))), known);
+  }
+  
+  result.simplify(2, 4);
+  
+  return result;
+}
+
+
+
+void Loop::reduce(int stmt_num, 
+                  std::vector<int> &level, 
+                  int param,
+                  std::string func_name, 
+                  std::vector<int> &seq_levels,
+                  std::vector<int> cudaized_levels, 
+                  int bound_level) {
+
+  // illegal instruction?? fprintf(stderr, " Loop::reduce( stmt %d, param %d, func_name (encrypted)...)\n", stmt, param); // , func_name.c_str()); 
+  
+  //std::cout << "Reducing stmt# " << stmt_num << " at level " << level << "\n";
+  //ir->printStmt(stmt[stmt_num].code);
+  
+  if (stmt[stmt_num].reduction != 1) {
+    std::cout << "loop.cc Cannot reduce this statement\n";
+    return;
+  }
+  fprintf(stderr, "loop.cc CAN reduce this statment?\n"); 
+
+  /*for (int i = 0; i < level.size(); i++)
+    if (stmt[stmt_num].loop_level[level[i] - 1].segreducible != true) {
+    std::cout << "Cannot reduce this statement\n";
+    return;
+    }
+    for (int i = 0; i < seq_levels.size(); i++)
+    if (stmt[stmt_num].loop_level[seq_levels[i] - 1].segreducible != true) {
+    std::cout << "Cannot reduce this statement\n";
+    return;
+    }
+  */
+  //  std::pair<int, std::string> to_insert(level, func_name);
+  //  reduced_statements.insert(std::pair<int, std::pair<int, std::string> >(stmt_num, to_insert ));
+  // invalidate saved codegen computation
+  delete last_compute_cgr_;
+  last_compute_cgr_ = NULL;
+  delete last_compute_cg_;
+  last_compute_cg_ = NULL;
+  fprintf(stderr, "set last_compute_cg_ = NULL;\n");
+  
+  omega::CG_outputBuilder *ocg = ir->builder();
+  
+  omega::CG_outputRepr *funCallRepr;
+  std::vector<omega::CG_outputRepr *> arg_repr_list;
+  apply_xform(stmt_num);
+  std::vector<IR_ArrayRef *> access = ir->FindArrayRef(stmt[stmt_num].code);
+  std::set<std::string> names;
+  for (int i = 0; i < access.size(); i++) {
+    std::vector<IR_ArrayRef *> access2;
+    for (int j = 0; j < access[i]->n_dim(); j++) {
+      std::vector<IR_ArrayRef *> access3 = ir->FindArrayRef(
+                                                            access[i]->index(j));
+      access2.insert(access2.end(), access3.begin(), access3.end());
+    }
+    if (access2.size() == 0) {
+      if (names.find(access[i]->name()) == names.end()) {
+        arg_repr_list.push_back(
+                                ocg->CreateAddressOf(access[i]->convert()));
+        names.insert(access[i]->name());
+        if (access[i]->is_write())
+          reduced_write_refs.insert(access[i]->name());
+      }
+    } else {
+      if (names.find(access[i]->name()) == names.end()) {
+        arg_repr_list.push_back(ocg->CreateAddressOf(ocg->CreateArrayRefExpression(ocg->CreateIdent(access[i]->name()),
+                                                                                   ocg->CreateInt(0))));
+        names.insert(access[i]->name());
+        if (access[i]->is_write())
+          reduced_write_refs.insert(access[i]->name());
+      }
+    }
+  }
+  
+  for (int i = 0; i < seq_levels.size(); i++)
+    arg_repr_list.push_back(
+                            ocg->CreateIdent(
+                                             stmt[stmt_num].IS.set_var(seq_levels[i])->name()));
+  
+  if (bound_level != -1) {
+    
+    omega::Relation new_IS = copy(stmt[stmt_num].IS);
+    new_IS.copy_names(stmt[stmt_num].IS);
+    new_IS.setup_names();
+    new_IS.simplify();
+    int dim = bound_level;
+    //omega::Relation r = getNewIS(stmt_num);
+    for (int j = dim + 1; j <= new_IS.n_set(); j++)
+      new_IS = omega::Project(new_IS, new_IS.set_var(j));
+    
+    new_IS.simplify(2, 4);
+    
+    omega::Relation bound_ = get_loop_bound(copy(new_IS), dim - 1);
+    omega::Variable_ID v = bound_.set_var(dim);
+    std::vector<omega::CG_outputRepr *> ubList;
+    for (omega::GEQ_Iterator e(
+                               const_cast<omega::Relation &>(bound_).single_conjunct()->GEQs());
+         e; e++) {
+      if ((*e).get_coef(v) < 0) {
+        //  && (*e).is_const_except_for_global(v))
+        omega::CG_outputRepr *UPPERBOUND =
+          omega::output_upper_bound_repr(ir->builder(), *e, v,
+                                         bound_,
+                                         std::vector<
+                                           std::pair<omega::CG_outputRepr *, int> >(
+                                                                                    bound_.n_set(),
+                                                                                    std::make_pair(
+                                                                                                   static_cast<omega::CG_outputRepr *>(NULL),
+                                                                                                   0)), uninterpreted_symbols[stmt_num]);
+        if (UPPERBOUND != NULL)
+          ubList.push_back(UPPERBOUND);
+        
+      }
+      
+    }
+    
+    omega::CG_outputRepr * ubRepr;
+    if (ubList.size() > 1) {
+      
+      ubRepr = ir->builder()->CreateInvoke("min", ubList);
+      arg_repr_list.push_back(ubRepr);
+    } else if (ubList.size() == 1)
+      arg_repr_list.push_back(ubList[0]);
+  }
+  
+  funCallRepr = ocg->CreateInvoke(func_name, arg_repr_list);
+  stmt[stmt_num].code = funCallRepr;
+  for (int i = 0; i < level.size(); i++) {
+    //stmt[*i].code = outputStatement(ocg, stmt[*i].code, 0, mapping, known, std::vector<CG_outputRepr *>(mapping.n_out(), NULL));
+    std::vector<std::string> loop_vars;
+    loop_vars.push_back(stmt[stmt_num].IS.set_var(level[i])->name());
+    
+    std::vector<omega::CG_outputRepr *> subs;
+    subs.push_back(ocg->CreateInt(0));
+    
+    stmt[stmt_num].code = ocg->CreateSubstitutedStmt(0, stmt[stmt_num].code,
+                                                     loop_vars, subs);
+    
+  }
+  
+  omega::Relation new_IS = copy(stmt[stmt_num].IS);
+  new_IS.copy_names(stmt[stmt_num].IS);
+  new_IS.setup_names();
+  new_IS.simplify();
+  int old_size = new_IS.n_set();
+  
+  omega::Relation R = omega::copy(stmt[stmt_num].IS);
+  R.copy_names(stmt[stmt_num].IS);
+  R.setup_names();
+  
+  for (int i = level.size() - 1; i >= 0; i--) {
+    int j;
+    
+    for (j = 0; j < cudaized_levels.size(); j++) {
+      if (cudaized_levels[j] == level[i])
+        break;
+      
+    }
+    
+    if (j == cudaized_levels.size()) {
+      R = omega::Project(R, level[i], omega::Input_Var);
+      R.simplify();
+      
+    }
+    //
+    
+  }
+  
+  omega::F_And *f_Root = R.and_with_and();
+  for (int i = level.size() - 1; i >= 0; i--) {
+    int j;
+    
+    for (j = 0; j < cudaized_levels.size(); j++) {
+      if (cudaized_levels[j] == level[i])
+        break;
+      
+    }
+    
+    if (j == cudaized_levels.size()) {
+      
+      omega::EQ_Handle h = f_Root->add_EQ();
+      
+      h.update_coef(R.set_var(level[i]), 1);
+      h.update_const(-1);
+    }
+    //
+    
+  }
+  
+  R.simplify();
+  stmt[stmt_num].IS = R;
+}
+
+
+
+
+
+
 //-----------------------------------------------------------------------------
 // Class Loop
 //-----------------------------------------------------------------------------
@@ -53,11 +302,24 @@ bool Loop::isInitialized() const {
 
 bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
                      std::vector<ir_tree_node *> &ir_stmt) {
+  
+  fprintf(stderr, "\n                                                  Loop::init_loop()\n");
+  
+  fprintf(stderr, "extract_ir_stmts()\n");
+  fprintf(stderr, "ir_tree has %d statements\n", ir_tree.size()); 
 
   ir_stmt = extract_ir_stmts(ir_tree);
+  
+  fprintf(stderr,"nesting level stmt size = %d\n", (int)ir_stmt.size());
   stmt_nesting_level_.resize(ir_stmt.size());
+  
   std::vector<int> stmt_nesting_level(ir_stmt.size());
+  
+  fprintf(stderr, "%d statements?\n", (int)ir_stmt.size()); 
+  
+  // find out how deeply nested each statement is.  (how can these be different?) 
   for (int i = 0; i < ir_stmt.size(); i++) {
+    fprintf(stderr, "i %d\n", i); 
     ir_stmt[i]->payload = i;
     int t = 0;
     ir_tree_node *itn = ir_stmt[i];
@@ -68,145 +330,240 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
     }
     stmt_nesting_level_[i] = t;
     stmt_nesting_level[i] = t;
+    fprintf(stderr, "stmt_nesting_level[%d] = %d\n", i, t); 
   }
-
+  
+  if (actual_code.size() == 0)
+    actual_code = std::vector<CG_outputRepr*>(ir_stmt.size());
+  
   stmt = std::vector<Statement>(ir_stmt.size());
+  fprintf(stderr, "in init_loop, made %d stmts\n", (int)ir_stmt.size());
+  
+  uninterpreted_symbols =             std::vector<std::map<std::string, std::vector<omega::CG_outputRepr * > > >(ir_stmt.size());
+  uninterpreted_symbols_stringrepr =  std::vector<std::map<std::string, std::vector<omega::CG_outputRepr * > > >(ir_stmt.size());
+  
   int n_dim = -1;
   int max_loc;
   //std::vector<std::string> index;
   for (int i = 0; i < ir_stmt.size(); i++) {
     int max_nesting_level = -1;
     int loc;
-    for (int j = 0; j < ir_stmt.size(); j++)
+    
+    // find the max nesting level and remember the statement that was at that level
+    for (int j = 0; j < ir_stmt.size(); j++) {
       if (stmt_nesting_level[j] > max_nesting_level) {
         max_nesting_level = stmt_nesting_level[j];
         loc = j;
       }
-
+    }
+    
+    fprintf(stderr, "max nesting level %d at location %d\n", max_nesting_level, loc); 
+    
     // most deeply nested statement acting as a reference point
     if (n_dim == -1) {
+      fprintf(stderr, "loop.cc L356  n_dim now max_nesting_level %d\n", max_nesting_level); 
       n_dim = max_nesting_level;
       max_loc = loc;
-
+      
       index = std::vector<std::string>(n_dim);
-
+      
       ir_tree_node *itn = ir_stmt[loc];
+      fprintf(stderr, "itn = stmt[%d]\n", loc); 
       int cur_dim = n_dim - 1;
       while (itn->parent != NULL) {
+        fprintf(stderr, "parent\n"); 
+        
         itn = itn->parent;
         if (itn->content->type() == IR_CONTROL_LOOP) {
-          index[cur_dim] =
-            static_cast<IR_Loop *>(itn->content)->index()->name();
+          fprintf(stderr, "IR_CONTROL_LOOP  cur_dim %d\n", cur_dim); 
+          IR_Loop *IRL = static_cast<IR_Loop *>(itn->content);
+          index[cur_dim] = IRL->index()->name();
+          fprintf(stderr, "index[%d] = '%s'\n", cur_dim, index[cur_dim].c_str());
           itn->payload = cur_dim--;
         }
       }
     }
-
+    
+    fprintf(stderr, "align loops by names,\n"); 
     // align loops by names, temporary solution
-    ir_tree_node *itn = ir_stmt[loc];
+    ir_tree_node *itn = ir_stmt[loc];  // defined outside loops?? 
     int depth = stmt_nesting_level_[loc] - 1;
+    
     for (int t = depth; t >= 0; t--) {
       int y = t;
-      ir_tree_node *itn = ir_stmt[loc];
-
+      itn = ir_stmt[loc];
+      
       while ((itn->parent != NULL) && (y >= 0)) {
         itn = itn->parent;
         if (itn->content->type() == IR_CONTROL_LOOP)
           y--;
       }
-
+      
       if (itn->content->type() == IR_CONTROL_LOOP && itn->payload == -1) {
         CG_outputBuilder *ocg = ir->builder();
-
+        
         itn->payload = depth - t;
-
+        
         CG_outputRepr *code =
           static_cast<IR_Block *>(ir_stmt[loc]->content)->extract();
-
+        
         std::vector<CG_outputRepr *> index_expr;
         std::vector<std::string> old_index;
         CG_outputRepr *repl = ocg->CreateIdent(index[itn->payload]);
         index_expr.push_back(repl);
         old_index.push_back(
-          static_cast<IR_Loop *>(itn->content)->index()->name());
+                            static_cast<IR_Loop *>(itn->content)->index()->name());
         code = ocg->CreateSubstitutedStmt(0, code, old_index,
                                           index_expr);
-
+        
         replace.insert(std::pair<int, CG_outputRepr*>(loc, code));
+        //stmt[loc].code = code;
+        
       }
     }
-
+    
+    fprintf(stderr, "\nset relation variable names                      ****\n");
     // set relation variable names
+    
+    // this finds the loop variables for loops enclosing this statement and puts
+    // them in an Omega Relation (just their names, which could fail) 
+    
+    fprintf(stderr, "Relation r(%d)\n", n_dim); 
     Relation r(n_dim);
     F_And *f_root = r.add_and();
     itn = ir_stmt[loc];
     int temp_depth = depth;
     while (itn->parent != NULL) {
-
+      
       itn = itn->parent;
       if (itn->content->type() == IR_CONTROL_LOOP) {
+        fprintf(stderr, "it's a loop.  temp_depth %d\n", temp_depth); 
+        fprintf(stderr, "r.name_set_var( %d, %s )\n", itn->payload + 1, index[temp_depth].c_str());
         r.name_set_var(itn->payload + 1, index[temp_depth]);
-
+        
         temp_depth--;
       }
+      //static_cast<IR_Loop *>(itn->content)->index()->name());
     }
-
+    fprintf(stderr, "Relation r   "); r.print(); fflush(stdout); 
+    //fprintf(stderr, "f_root   "); f_root->print(stderr); fprintf(stderr, "\n"); 
+    
+    /*while (itn->parent != NULL) {
+      itn = itn->parent;
+      if (itn->content->type() == IR_CONTROL_LOOP)
+      r.name_set_var(itn->payload+1, static_cast<IR_Loop *>(itn->content)->index()->name());
+      }*/
+    
+    
+    
+    
+    fprintf(stderr, "extract information from loop/if structures\n"); 
     // extract information from loop/if structures
     std::vector<bool> processed(n_dim, false);
     std::vector<std::string> vars_to_be_reversed;
+    
+    std::vector<std::string> insp_lb;
+    std::vector<std::string> insp_ub;
+    
     itn = ir_stmt[loc];
-    while (itn->parent != NULL) {
+    while (itn->parent != NULL) { // keep heading upward 
       itn = itn->parent;
-
+      
       switch (itn->content->type()) {
       case IR_CONTROL_LOOP: {
+        fprintf(stderr, "loop.cc l 462  IR_CONTROL_LOOP\n"); 
         IR_Loop *lp = static_cast<IR_Loop *>(itn->content);
         Variable_ID v = r.set_var(itn->payload + 1);
         int c;
-
+        
         try {
           c = lp->step_size();
+          //fprintf(stderr, "step size %d\n", c); 
           if (c > 0) {
             CG_outputRepr *lb = lp->lower_bound();
+            fprintf(stderr, "loop.cc, got the lower bound. it is:\n"); 
+            lb->dump(); printf("\n"); fflush(stdout); 
+            
             exp2formula(ir, r, f_root, freevar, lb, v, 's',
-                        IR_COND_GE, true);
+                        IR_COND_GE, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
+            
             CG_outputRepr *ub = lp->upper_bound();
+            //fprintf(stderr, "loop.cc, got the upper bound. it is:\n");
+            //ub->dump(); printf("\n"); fflush(stdout); 
+            
+            
+            
             IR_CONDITION_TYPE cond = lp->stop_cond();
             if (cond == IR_COND_LT || cond == IR_COND_LE)
               exp2formula(ir, r, f_root, freevar, ub, v, 's',
-                          cond, true);
+                          cond, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
             else
               throw ir_error("loop condition not supported");
-
+            
+            
+            if ((ir->QueryExpOperation(lp->lower_bound())
+                 == IR_OP_ARRAY_VARIABLE)
+                && (ir->QueryExpOperation(lp->lower_bound())
+                    == ir->QueryExpOperation(
+                                             lp->upper_bound()))) {
+              
+              fprintf(stderr, "loop.cc lower and upper are both IR_OP_ARRAY_VARIABLE?\n"); 
+              
+              std::vector<CG_outputRepr *> v =
+                ir->QueryExpOperand(lp->lower_bound());
+              IR_ArrayRef *ref =
+                static_cast<IR_ArrayRef *>(ir->Repr2Ref(
+                                                        v[0]));
+              std::string s0 = ref->name();
+              std::vector<CG_outputRepr *> v2 =
+                ir->QueryExpOperand(lp->upper_bound());
+              IR_ArrayRef *ref2 =
+                static_cast<IR_ArrayRef *>(ir->Repr2Ref(
+                                                        v2[0]));
+              std::string s1 = ref2->name();
+              
+              if (s0 == s1) {
+                insp_lb.push_back(s0);
+                insp_ub.push_back(s1);
+                
+              }
+              
+            }
+            
+            
           } else if (c < 0) {
             CG_outputBuilder *ocg = ir->builder();
             CG_outputRepr *lb = lp->lower_bound();
             lb = ocg->CreateMinus(NULL, lb);
             exp2formula(ir, r, f_root, freevar, lb, v, 's',
-                        IR_COND_GE, true);
+                        IR_COND_GE, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
             CG_outputRepr *ub = lp->upper_bound();
             ub = ocg->CreateMinus(NULL, ub);
             IR_CONDITION_TYPE cond = lp->stop_cond();
             if (cond == IR_COND_GE)
               exp2formula(ir, r, f_root, freevar, ub, v, 's',
-                          IR_COND_LE, true);
+                          IR_COND_LE, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
             else if (cond == IR_COND_GT)
               exp2formula(ir, r, f_root, freevar, ub, v, 's',
-                          IR_COND_LT, true);
+                          IR_COND_LT, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
             else
               throw ir_error("loop condition not supported");
-
+            
             vars_to_be_reversed.push_back(lp->index()->name());
           } else
             throw ir_error("loop step size zero");
         } catch (const ir_error &e) {
+          actual_code[loc] =
+            static_cast<IR_Block *>(ir_stmt[loc]->content)->extract();
           for (int i = 0; i < itn->children.size(); i++)
             delete itn->children[i];
           itn->children = std::vector<ir_tree_node *>();
           itn->content = itn->content->convert();
           return false;
         }
-
+        
+        // check for loop increment or decrement that is not 1
+        //fprintf(stderr, "abs(c)\n"); 
         if (abs(c) != 1) {
           F_Exists *f_exists = f_root->add_exists();
           Variable_ID e = f_exists->declare();
@@ -219,22 +576,28 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
           h.update_coef(v, -1);
           CG_outputRepr *lb = lp->lower_bound();
           exp2formula(ir, r, f_and, freevar, lb, e, 's', IR_COND_EQ,
-                      true);
+                      true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
         }
-
+        
         processed[itn->payload] = true;
         break;
       }
+        
+        
       case IR_CONTROL_IF: {
+        fprintf(stderr, "IR_CONTROL_IF\n"); 
+        IR_If *theif = static_cast<IR_If *>(itn->content);
+        
         CG_outputRepr *cond =
           static_cast<IR_If *>(itn->content)->condition();
+        
         try {
           if (itn->payload % 2 == 1)
-            exp2constraint(ir, r, f_root, freevar, cond, true);
+            exp2constraint(ir, r, f_root, freevar, cond, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
           else {
             F_Not *f_not = f_root->add_not();
             F_And *f_and = f_not->add_and();
-            exp2constraint(ir, r, f_and, freevar, cond, true);
+            exp2constraint(ir, r, f_and, freevar, cond, true,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
           }
         } catch (const ir_error &e) {
           std::vector<ir_tree_node *> *t;
@@ -258,10 +621,11 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
           }
           return false;
         }
-
+        
         break;
       }
       default:
+        //fprintf(stderr, "default?\n"); 
         for (int i = 0; i < itn->children.size(); i++)
           delete itn->children[i];
         itn->children = std::vector<ir_tree_node *>();
@@ -269,7 +633,9 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
         return false;
       }
     }
-
+    
+    
+    //fprintf(stderr, "add information for missing loops   n_dim(%d)\n", n_dim);
     // add information for missing loops
     for (int j = 0; j < n_dim; j++)
       if (!processed[j]) {
@@ -280,32 +646,138 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
               && itn->payload == j)
             break;
         }
-
+        
         Variable_ID v = r.set_var(j + 1);
         if (loc < max_loc) {
-
+          
           CG_outputBuilder *ocg = ir->builder();
-
+          
           CG_outputRepr *lb =
             static_cast<IR_Loop *>(itn->content)->lower_bound();
-
+          
           exp2formula(ir, r, f_root, freevar, lb, v, 's', IR_COND_EQ,
-                      false);
-
+                      false,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
+          
+          /*    if (ir->QueryExpOperation(
+                static_cast<IR_Loop *>(itn->content)->lower_bound())
+                == IR_OP_VARIABLE) {
+                IR_ScalarRef *ref =
+                static_cast<IR_ScalarRef *>(ir->Repr2Ref(
+                static_cast<IR_Loop *>(itn->content)->lower_bound()));
+                std::string name_ = ref->name();
+                
+                for (int i = 0; i < index.size(); i++)
+                if (index[i] == name_) {
+                exp2formula(ir, r, f_root, freevar, lb, v, 's',
+                IR_COND_GE, false);
+                
+                CG_outputRepr *ub =
+                static_cast<IR_Loop *>(itn->content)->upper_bound();
+                IR_CONDITION_TYPE cond =
+                static_cast<IR_Loop *>(itn->content)->stop_cond();
+                if (cond == IR_COND_LT || cond == IR_COND_LE)
+                exp2formula(ir, r, f_root, freevar, ub, v,
+                's', cond, false);
+                
+                
+                
+                }
+                
+                }
+          */
+          
         } else { // loc > max_loc
-
+          
           CG_outputBuilder *ocg = ir->builder();
           CG_outputRepr *ub =
             static_cast<IR_Loop *>(itn->content)->upper_bound();
-
+          
           exp2formula(ir, r, f_root, freevar, ub, v, 's', IR_COND_EQ,
-                      false);
+                      false,uninterpreted_symbols[i],uninterpreted_symbols_stringrepr[i]);
+          /*if (ir->QueryExpOperation(
+            static_cast<IR_Loop *>(itn->content)->upper_bound())
+            == IR_OP_VARIABLE) {
+            IR_ScalarRef *ref =
+            static_cast<IR_ScalarRef *>(ir->Repr2Ref(
+            static_cast<IR_Loop *>(itn->content)->upper_bound()));
+            std::string name_ = ref->name();
+            
+            for (int i = 0; i < index.size(); i++)
+            if (index[i] == name_) {
+            
+            CG_outputRepr *lb =
+            static_cast<IR_Loop *>(itn->content)->lower_bound();
+            
+            exp2formula(ir, r, f_root, freevar, lb, v, 's',
+            IR_COND_GE, false);
+            
+            CG_outputRepr *ub =
+            static_cast<IR_Loop *>(itn->content)->upper_bound();
+            IR_CONDITION_TYPE cond =
+            static_cast<IR_Loop *>(itn->content)->stop_cond();
+            if (cond == IR_COND_LT || cond == IR_COND_LE)
+            exp2formula(ir, r, f_root, freevar, ub, v,
+            's', cond, false);
+            
+            
+            }
+            }
+          */
         }
       }
-
+    
     r.setup_names();
     r.simplify();
-
+    
+    // THIS IS MISSING IN PROTONU's
+    for (int j = 0; j < insp_lb.size(); j++) {
+      
+      std::string lb = insp_lb[j] + "_";
+      std::string ub = lb + "_";
+      
+      Global_Var_ID u, l;
+      bool found_ub = false;
+      bool found_lb = false;
+      for (DNF_Iterator di(copy(r).query_DNF()); di; di++)
+        for (Constraint_Iterator ci = (*di)->constraints(); ci; ci++)
+          
+          for (Constr_Vars_Iter cvi(*ci); cvi; cvi++) {
+            Variable_ID v = cvi.curr_var();
+            if (v->kind() == Global_Var)
+              if (v->get_global_var()->arity() > 0) {
+                
+                std::string name =
+                  v->get_global_var()->base_name();
+                if (name == lb) {
+                  l = v->get_global_var();
+                  found_lb = true;
+                } else if (name == ub) {
+                  u = v->get_global_var();
+                  found_ub = true;
+                }
+              }
+            
+          }
+      
+      if (found_lb && found_ub) {
+        Relation known_(copy(r).n_set());
+        known_.copy_names(copy(r));
+        known_.setup_names();
+        Variable_ID index_lb = known_.get_local(l, Input_Tuple);
+        Variable_ID index_ub = known_.get_local(u, Input_Tuple);
+        F_And *fr = known_.add_and();
+        GEQ_Handle g = fr->add_GEQ();
+        g.update_coef(index_ub, 1);
+        g.update_coef(index_lb, -1);
+        g.update_const(-1);
+        addKnown(known_);
+        
+      }
+      
+    }
+    
+    
+    fprintf(stderr, "loop.cc L441 insert the statement\n");
     // insert the statement
     CG_outputBuilder *ocg = ir->builder();
     std::vector<CG_outputRepr *> reverse_expr;
@@ -314,51 +786,96 @@ bool Loop::init_loop(std::vector<ir_tree_node *> &ir_tree,
       repl = ocg->CreateMinus(NULL, repl);
       reverse_expr.push_back(repl);
     }
+    fprintf(stderr, "loop.cc before extract\n"); 
     CG_outputRepr *code =
       static_cast<IR_Block *>(ir_stmt[loc]->content)->extract();
+    fprintf(stderr, "code =  ocg->CreateSubstitutedStmt(...)\n");
+    ((CG_chillRepr *)code)->Dump(); fflush(stdout);
+    
     code = ocg->CreateSubstitutedStmt(0, code, vars_to_be_reversed,
                                       reverse_expr);
+    fprintf(stderr, "stmt\n");
+    ((CG_chillRepr *)code)->Dump(); fflush(stdout);
+
     stmt[loc].code = code;
     stmt[loc].IS = r;
+    
+    //Anand: Add Information on uninterpreted function constraints to
+    //Known relation
+    
+    fprintf(stderr, "loop.cc stmt[%d].loop_level has size n_dim %d\n", loc, n_dim); 
+
     stmt[loc].loop_level = std::vector<LoopLevel>(n_dim);
     stmt[loc].ir_stmt_node = ir_stmt[loc];
-    for (int i = 0; i < n_dim; i++) {
-      stmt[loc].loop_level[i].type = LoopLevelOriginal;
-      stmt[loc].loop_level[i].payload = i;
-      stmt[loc].loop_level[i].parallel_level = 0;
+    stmt[loc].has_inspector = false;
+    fprintf(stderr, "for int i < n_dim(%d)\n", n_dim); 
+    for (int ii = 0; ii < n_dim; ii++) {
+      stmt[loc].loop_level[ii].type = LoopLevelOriginal;
+      stmt[loc].loop_level[ii].payload = ii;
+      stmt[loc].loop_level[ii].parallel_level = 0;
     }
-
+    fprintf(stderr, "whew\n"); 
+    
     stmt_nesting_level[loc] = -1;
   }
+  dump();
+  fprintf(stderr, "                                        loop.cc   Loop::init_loop() END\n\n");
 
   return true;
 }
 
-Loop::Loop(const IR_Control *control) {
 
+
+Loop::Loop(const IR_Control *control) {
+  
+  fprintf(stderr, "\nLoop::Loop(const IR_Control *control)\n");
+  fprintf(stderr, "control type is %d   ", control->type()); 
+  echocontroltype(control);
+  
   last_compute_cgr_ = NULL;
   last_compute_cg_ = NULL;
+  fprintf(stderr, "2set last_compute_cg_ = NULL; \n"); 
 
-  ir = const_cast<IR_Code *>(control->ir_);
+  ir = const_cast<IR_Code *>(control->ir_); // point to the CHILL IR that this loop came from
+  if (ir == 0) { 
+    fprintf(stderr, "ir gotten from control = 0x%x\n", (long)ir);
+    fprintf(stderr, "loop.cc GONNA DIE SOON *******************************\n\n");
+  }
+  
   init_code = NULL;
   cleanup_code = NULL;
   tmp_loop_var_name_counter = 1;
   overflow_var_name_counter = 1;
   known = Relation::True(0);
-
+  
+  fprintf(stderr, "in Loop::Loop, calling  build_ir_tree()\n"); 
+  fprintf(stderr, "\nloop.cc, Loop::Loop() about to clone control\n"); 
   ir_tree = build_ir_tree(control->clone(), NULL);
+  //fprintf(stderr,"in Loop::Loop. ir_tree has %ld parts\n", ir_tree.size()); 
+  
+  //    std::vector<ir_tree_node *> ir_stmt;
+  //fprintf(stderr, "loop.cc after build_ir_tree() %ld statements\n",  stmt.size()); 
+  
+  int count = 0;
+  //fprintf(stderr, "before init_loops, %d freevar\n", freevar.size()); 
+  //fprintf(stderr, "count %d\n", count++); 
+  //fprintf(stderr, "loop.cc before init_loop, %ld statements\n",  stmt.size()); 
   while (!init_loop(ir_tree, ir_stmt)) {
+    //fprintf(stderr, "count %d\n", count++); 
   }
-
+  fprintf(stderr, "after init_loop, %d freevar\n", (int)freevar.size()); 
+  
+  
+  fprintf(stderr, "loop.cc after init_loop, %d statements\n",  (int)stmt.size()); 
   for (int i = 0; i < stmt.size(); i++) {
     std::map<int, CG_outputRepr*>::iterator it = replace.find(i);
-
+    
     if (it != replace.end())
       stmt[i].code = it->second;
     else
       stmt[i].code = stmt[i].code;
   }
-
+  
   if (stmt.size() != 0)
     dep = DependenceGraph(stmt[0].IS.n_set());
   else
@@ -366,82 +883,194 @@ Loop::Loop(const IR_Control *control) {
   // init the dependence graph
   for (int i = 0; i < stmt.size(); i++)
     dep.insert();
-
-  for (int i = 0; i < stmt.size(); i++)
+  
+  fprintf(stderr, "this really REALLY needs some comments\n"); 
+  // this really REALLY needs some comments
+  for (int i = 0; i < stmt.size(); i++) {
+    fprintf(stderr, "i %d\n", i); 
+    stmt[i].reduction = 0; // Manu -- initialization
     for (int j = i; j < stmt.size(); j++) {
+      fprintf(stderr, "j %d\n", j); 
       std::pair<std::vector<DependenceVector>,
-        std::vector<DependenceVector> > dv = test_data_dependences(
-          ir, stmt[i].code, stmt[i].IS, stmt[j].code, stmt[j].IS,
-          freevar, index, stmt_nesting_level_[i],
-          stmt_nesting_level_[j]);
-
+                std::vector<DependenceVector> > dv = test_data_dependences(
+                                                                           ir, 
+                                                                           stmt[i].code, 
+                                                                           stmt[i].IS, 
+                                                                           stmt[j].code, 
+                                                                           stmt[j].IS,
+                                                                           freevar, 
+                                                                           index, 
+                                                                           stmt_nesting_level_[i],
+                                                                           stmt_nesting_level_[j],
+                                                                           uninterpreted_symbols[ i ],
+                                                                           uninterpreted_symbols_stringrepr[ i ]);
+      
+      fprintf(stderr, "dv.first.size() %d\n", (int)dv.first.size()); 
       for (int k = 0; k < dv.first.size(); k++) {
+        fprintf(stderr, "k1 %d\n", k); 
         if (is_dependence_valid(ir_stmt[i], ir_stmt[j], dv.first[k],
                                 true))
           dep.connect(i, j, dv.first[k]);
         else {
           dep.connect(j, i, dv.first[k].reverse());
         }
-
+        
       }
-      for (int k = 0; k < dv.second.size(); k++)
+      
+      for (int k = 0; k < dv.second.size(); k++) { 
+        fprintf(stderr, "k2 %d\n", k); 
         if (is_dependence_valid(ir_stmt[j], ir_stmt[i], dv.second[k],
                                 false))
           dep.connect(j, i, dv.second[k]);
         else {
           dep.connect(i, j, dv.second[k].reverse());
         }
+      }
     }
-
-
+  }
+  
+  fprintf(stderr, "\n\n*** LOTS OF REDUCTIONS ***\n\n"); 
+  
+  // TODO: Reduction check
+  // Manu:: Initial implementation / algorithm
+  std::set<int> reducCand = std::set<int>();
+  std::vector<int> canReduce = std::vector<int>();
+  fprintf(stderr, "\ni range %d\n", stmt.size()); 
+  for (int i = 0; i < stmt.size(); i++) {
+    fprintf(stderr, "i %d\n", i); 
+    if (!dep.hasEdge(i, i)) {
+      continue;
+    }
+    fprintf(stderr, "dep.hasEdge(%d, %d)\n", i, i); 
+
+    // for each statement check if it has all the three dependences (RAW, WAR, WAW)
+    // If there is such a statement, it is a reduction candidate. Mark all reduction candidates.
+    std::vector<DependenceVector> tdv = dep.getEdge(i, i);
+    fprintf(stderr, "tdv size %d\n", tdv.size()); 
+    for (int j = 0; j < tdv.size(); j++) {
+      fprintf(stderr, "ij %d %d\n", i, j); 
+      if (tdv[j].is_reduction_cand) { 
+        fprintf(stderr, "reducCand.insert( %d )\n", i); 
+        reducCand.insert(i);
+      }
+    }
+  }
+  
+  fprintf(stderr, "loop.cc reducCand.size() %d\n", reducCand.size()); 
+  bool reduc;
+  std::set<int>::iterator it;
+  int counter = 0; 
+  for (it = reducCand.begin(); it != reducCand.end(); it++) {
+    fprintf(stderr, "counter %d\n", counter); 
+    reduc = true;
+    for (int j = 0; j < stmt.size(); j++) {
+      fprintf(stderr, "j %d\n", j); 
+      if ((*it != j)
+          && (stmt_nesting_level_[*it] < stmt_nesting_level_[j])) {
+        if (dep.hasEdge(*it, j) || dep.hasEdge(j, *it)) {
+          fprintf(stderr, "counter %d j %d  reduc = false\n", counter, j); 
+          reduc = false;
+          break;
+        }
+      }
+      counter += 1;
+    }
+    
+    if (reduc) {
+      fprintf(stderr, "canReduce.push_back()\n"); 
+      canReduce.push_back(*it);
+      stmt[*it].reduction = 2; // First, assume that reduction is possible with some processing
+    }
+  }
+  
+  
+  // If reduction is possible without processing, update the value of the reduction variable to 1
+  fprintf(stderr, "loop.cc canReduce.size() %d\n", canReduce.size()); 
+  for (int i = 0; i < canReduce.size(); i++) {
+    // Here, assuming that stmtType returns 1 when there is a single statement within stmt[i]
+    if (stmtType(ir, stmt[canReduce[i]].code) == 1) {
+      stmt[canReduce[i]].reduction = 1;
+      IR_OPERATION_TYPE opType;
+      opType = getReductionOperator(ir, stmt[canReduce[i]].code);
+      stmt[canReduce[i]].reductionOp = opType;
+    }
+  }
+  
+  // printing out stuff for debugging
+  
+  if (DEP_DEBUG) {
+    std::cout << "STATEMENTS THAT CAN BE REDUCED: \n";
+    for (int i = 0; i < canReduce.size(); i++) {
+      std::cout << "------- " << canReduce[i] << " ------- "
+                << stmt[canReduce[i]].reduction << "\n";
+      ir->printStmt(stmt[canReduce[i]].code); // Manu
+      if (stmt[canReduce[i]].reductionOp == IR_OP_PLUS)
+        std::cout << "Reduction type:: + \n";
+      else if (stmt[canReduce[i]].reductionOp == IR_OP_MINUS)
+        std::cout << "Reduction type:: - \n";
+      else if (stmt[canReduce[i]].reductionOp == IR_OP_MULTIPLY)
+        std::cout << "Reduction type:: * \n";
+      else if (stmt[canReduce[i]].reductionOp == IR_OP_DIVIDE)
+        std::cout << "Reduction type:: / \n";
+      else
+        std::cout << "Unknown reduction type\n";
+    }
+  }
+  // cleanup the IR tree
+  
+  fprintf(stderr, "init dumb transformation relations\n"); 
 
   // init dumb transformation relations e.g. [i, j] -> [ 0, i, 0, j, 0]
   for (int i = 0; i < stmt.size(); i++) {
     int n = stmt[i].IS.n_set();
     stmt[i].xform = Relation(n, 2 * n + 1);
     F_And *f_root = stmt[i].xform.add_and();
-
+    
     for (int j = 1; j <= n; j++) {
       EQ_Handle h = f_root->add_EQ();
       h.update_coef(stmt[i].xform.output_var(2 * j), 1);
       h.update_coef(stmt[i].xform.input_var(j), -1);
     }
-
+    
     for (int j = 1; j <= 2 * n + 1; j += 2) {
       EQ_Handle h = f_root->add_EQ();
       h.update_coef(stmt[i].xform.output_var(j), 1);
     }
     stmt[i].xform.simplify();
   }
-
+  //fprintf(stderr, "done with dumb\n");
+  
   if (stmt.size() != 0)
     num_dep_dim = stmt[0].IS.n_set();
   else
     num_dep_dim = 0;
-// Debug output
-//  for (int i = 0; i < stmt.size(); i++) {
-//    std::cout << i << ": ";
-//    stmt[i].xform.print();
-//    stmt[i].IS.print();
-//    std::cout << std::endl;
-//
-//    }
+  // debug
+  /*for (int i = 0; i < stmt.size(); i++) {
+    std::cout << i << ": ";
+    //stmt[i].xform.print();
+    stmt[i].IS.print();
+    std::cout << std::endl;
+    
+    }*/
+  //end debug
+  fprintf(stderr, "                                                  at bottom of Loop::Loop, printCode\n");
+  printCode(); // this dies  TODO figure out why 
 }
 
 Loop::~Loop() {
-
+  
   delete last_compute_cgr_;
   delete last_compute_cg_;
-
+  
   for (int i = 0; i < stmt.size(); i++)
     if (stmt[i].code != NULL) {
       stmt[i].code->clear();
       delete stmt[i].code;
     }
-
+  
   for (int i = 0; i < ir_tree.size(); i++)
     delete ir_tree[i];
-
+  
   if (init_code != NULL) {
     init_code->clear();
     delete init_code;
@@ -452,13 +1081,16 @@ Loop::~Loop() {
   }
 }
 
+
+
+
 int Loop::get_dep_dim_of(int stmt_num, int level) const {
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument("invaid statement " + to_string(stmt_num));
-
+  
   if (level < 1 || level > stmt[stmt_num].loop_level.size())
     return -1;
-
+  
   int trip_count = 0;
   while (true) {
     switch (stmt[stmt_num].loop_level[level - 1].type) {
@@ -469,36 +1101,35 @@ int Loop::get_dep_dim_of(int stmt_num, int level) const {
       if (level < 1)
         return -1;
       if (level > stmt[stmt_num].loop_level.size())
-        throw loop_error(
-          "incorrect loop level information for statement "
-          + to_string(stmt_num));
+        throw loop_error("incorrect loop level information for statement "
+                         + to_string(stmt_num));
       break;
     default:
       throw loop_error(
-        "unknown loop level information for statement "
-        + to_string(stmt_num));
+                       "unknown loop level information for statement "
+                       + to_string(stmt_num));
     }
     trip_count++;
     if (trip_count >= stmt[stmt_num].loop_level.size())
       throw loop_error(
-        "incorrect loop level information for statement "
-        + to_string(stmt_num));
+                       "incorrect loop level information for statement "
+                       + to_string(stmt_num));
   }
 }
 
 int Loop::get_last_dep_dim_before(int stmt_num, int level) const {
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument("invaid statement " + to_string(stmt_num));
-
+  
   if (level < 1)
     return -1;
   if (level > stmt[stmt_num].loop_level.size())
     level = stmt[stmt_num].loop_level.size() + 1;
-
+  
   for (int i = level - 1; i >= 1; i--)
     if (stmt[stmt_num].loop_level[i - 1].type == LoopLevelOriginal)
       return stmt[stmt_num].loop_level[i - 1].payload;
-
+  
   return -1;
 }
 
@@ -530,53 +1161,96 @@ void Loop::print_internal_loop_structure() const {
   }
 }
 
+void Loop::debugRelations() const { 
+  const int m = stmt.size(); 
+  {
+    std::vector<Relation> IS(m);
+    std::vector<Relation> xforms(m);
+    
+    for (int i = 0; i < m; i++) {
+      IS[i] = stmt[i].IS;
+      xforms[i] = stmt[i].xform;  // const stucks
+    }
+    
+    printf("\nxforms:\n"); 
+    for (int i = 0; i < m; i++) { xforms[i].print();  printf("\n"); }
+    printf("\nIS:\n"); 
+    for (int i = 0; i < m; i++) {      IS[i].print();  printf("\n"); }
+    fflush(stdout); 
+  }
+}
+
+
 CG_outputRepr *Loop::getCode(int effort) const {
+  fprintf(stderr,"\nloop.cc Loop::getCode(  effort %d )\n", effort ); 
+  
   const int m = stmt.size();
   if (m == 0)
     return NULL;
   const int n = stmt[0].xform.n_out();
-
+  
   if (last_compute_cg_ == NULL) {
+    fprintf(stderr, "Loop::getCode() last_compute_cg_ == NULL\n"); 
+    
     std::vector<Relation> IS(m);
     std::vector<Relation> xforms(m);
     for (int i = 0; i < m; i++) {
       IS[i] = stmt[i].IS;
       xforms[i] = stmt[i].xform;
     }
+    
+    debugRelations(); 
+    
+    
     Relation known = Extend_Set(copy(this->known), n - this->known.n_set());
-
+    printf("\nknown:\n"); known.print(); printf("\n\n"); fflush(stdout); 
+    
     last_compute_cg_ = new CodeGen(xforms, IS, known);
     delete last_compute_cgr_;
     last_compute_cgr_ = NULL;
   }
+  else {
+    fprintf(stderr, "Loop::getCode() last_compute_cg_ NOT NULL\n"); 
+  }
 
+  
   if (last_compute_cgr_ == NULL || last_compute_effort_ != effort) {
     delete last_compute_cgr_;
     last_compute_cgr_ = last_compute_cg_->buildAST(effort);
     last_compute_effort_ = effort;
   }
-
+  
   std::vector<CG_outputRepr *> stmts(m);
+  fprintf(stderr, "%d stmts\n", m); 
   for (int i = 0; i < m; i++)
     stmts[i] = stmt[i].code;
   CG_outputBuilder *ocg = ir->builder();
-  CG_outputRepr *repr = last_compute_cgr_->printRepr(ocg, stmts);
 
+  fprintf(stderr, "calling last_compute_cgr_->printRepr()\n"); 
+  CG_outputRepr *repr = last_compute_cgr_->printRepr(ocg, stmts, 
+                                                     uninterpreted_symbols);
+  
   if (init_code != NULL)
     repr = ocg->StmtListAppend(init_code->clone(), repr);
   if (cleanup_code != NULL)
     repr = ocg->StmtListAppend(repr, cleanup_code->clone());
-
+  
+  fprintf(stderr,"\nloop.cc Loop::getCode( effort %d )   DONE\n", effort ); 
   return repr;
 }
 
+
+
+
 void Loop::printCode(int effort) const {
+  fprintf(stderr,"\nloop.cc Loop::printCode(  effort %d )\n", effort ); 
   const int m = stmt.size();
   if (m == 0)
     return;
   const int n = stmt[0].xform.n_out();
-
+  
   if (last_compute_cg_ == NULL) {
+    fprintf(stderr, "Loop::printCode(), last_compute_cg_ == NULL\n"); 
     std::vector<Relation> IS(m);
     std::vector<Relation> xforms(m);
     for (int i = 0; i < m; i++) {
@@ -584,19 +1258,22 @@ void Loop::printCode(int effort) const {
       xforms[i] = stmt[i].xform;
     }
     Relation known = Extend_Set(copy(this->known), n - this->known.n_set());
-
+    
     last_compute_cg_ = new CodeGen(xforms, IS, known);
     delete last_compute_cgr_;
     last_compute_cgr_ = NULL;
   }
-
+  else fprintf(stderr, "Loop::printCode(), last_compute_cg_ NOT NULL\n"); 
+  
   if (last_compute_cgr_ == NULL || last_compute_effort_ != effort) {
     delete last_compute_cgr_;
     last_compute_cgr_ = last_compute_cg_->buildAST(effort);
     last_compute_effort_ = effort;
   }
-
-  std::string repr = last_compute_cgr_->printString();
+  
+  std::string repr = last_compute_cgr_->printString(
+                                                    uninterpreted_symbols_stringrepr);
+  fprintf(stderr, "leaving Loop::printCode()\n"); 
   std::cout << repr << std::endl;
 }
 
@@ -620,66 +1297,59 @@ void Loop::printDependenceGraph() const {
   }
 }
 
-Relation Loop::getNewIS(int stmt_num) const {
-  Relation result;
-
-  if (stmt[stmt_num].xform.is_null()) {
-    Relation known = Extend_Set(copy(this->known),
-                                stmt[stmt_num].IS.n_set() - this->known.n_set());
-    result = Intersection(copy(stmt[stmt_num].IS), known);
-  } else {
-    Relation known = Extend_Set(copy(this->known),
-                                stmt[stmt_num].xform.n_out() - this->known.n_set());
-    result = Intersection(
-      Range(
-        Restrict_Domain(copy(stmt[stmt_num].xform),
-                        copy(stmt[stmt_num].IS))), known);
-  }
-
-  result.simplify(2, 4);
-
-  return result;
-}
-
 std::vector<Relation> Loop::getNewIS() const {
   const int m = stmt.size();
-
+  
   std::vector<Relation> new_IS(m);
   for (int i = 0; i < m; i++)
     new_IS[i] = getNewIS(i);
-
+  
   return new_IS;
 }
 
+// pragmas are tied to loops only ??? 
 void Loop::pragma(int stmt_num, int level, const std::string &pragmaText) {
-	// check sanity of parameters
-	if(stmt_num < 0)
-		throw std::invalid_argument("invalid statement " + to_string(stmt_num));
-
-	CG_outputBuilder *ocg = ir->builder();
-	CG_outputRepr *code = stmt[stmt_num].code;
-	ocg->CreatePragmaAttribute(code, level, pragmaText);
+  // check sanity of parameters
+  if(stmt_num < 0)
+    throw std::invalid_argument("invalid statement " + to_string(stmt_num));
+  
+  CG_outputBuilder *ocg = ir->builder();
+  CG_outputRepr *code = stmt[stmt_num].code;
+  ocg->CreatePragmaAttribute(code, level, pragmaText);
 }
 
-void Loop::prefetch(int stmt_num, int level, const std::string &arrName, int hint) {
-	// check sanity of parameters
-	if(stmt_num < 0)
-		throw std::invalid_argument("invalid statement " + to_string(stmt_num));
 
-	CG_outputBuilder *ocg = ir->builder();
-	CG_outputRepr *code = stmt[stmt_num].code;
-	ocg->CreatePrefetchAttribute(code, level, arrName, hint);
+/*
+  void Loop::prefetch(int stmt_num, int level, const std::string &arrName, const std::string &indexName, int offset, int hint) {
+  // check sanity of parameters
+  if(stmt_num < 0)
+  throw std::invalid_argument("invalid statement " + to_string(stmt_num));
+  
+  CG_outputBuilder *ocg = ir->builder();
+  CG_outputRepr *code = stmt[stmt_num].code;
+  ocg->CreatePrefetchAttribute(code, level, arrName, indexName, int offset, hint);
+  }
+*/
+
+void Loop::prefetch(int stmt_num, int level, const std::string &arrName, int hint) {
+  // check sanity of parameters
+  if(stmt_num < 0)
+    throw std::invalid_argument("invalid statement " + to_string(stmt_num));
+  
+  CG_outputBuilder *ocg = ir->builder();
+  CG_outputRepr *code = stmt[stmt_num].code;
+  ocg->CreatePrefetchAttribute(code, level, arrName, hint);
 }
 
 std::vector<int> Loop::getLexicalOrder(int stmt_num) const {
   assert(stmt_num < stmt.size());
-
+  
   const int n = stmt[stmt_num].xform.n_out();
   std::vector<int> lex(n, 0);
-
+  
   for (int i = 0; i < n; i += 2)
     lex[i] = get_const(stmt[stmt_num].xform, i, Output_Var);
-
+  
   return lex;
 }
 
@@ -688,13 +1358,13 @@ std::vector<int> Loop::getLexicalOrder(int stmt_num) const {
 std::set<int> Loop::getSubLoopNest(int stmt_num, int level) const {
   assert(stmt_num >= 0 && stmt_num < stmt.size());
   assert(level > 0 && level <= stmt[stmt_num].loop_level.size());
-
+  
   std::set<int> working;
   for (int i = 0; i < stmt.size(); i++)
     if (const_cast<Loop *>(this)->stmt[i].IS.is_upper_bound_satisfiable()
         && stmt[i].loop_level.size() >= level)
       working.insert(i);
-
+  
   for (int i = 1; i <= level; i++) {
     int a = getLexicalOrder(stmt_num, i);
     for (std::set<int>::iterator j = working.begin(); j != working.end();) {
@@ -705,14 +1375,14 @@ std::set<int> Loop::getSubLoopNest(int stmt_num, int level) const {
         ++j;
     }
   }
-
+  
   return working;
 }
 
 int Loop::getLexicalOrder(int stmt_num, int level) const {
   assert(stmt_num >= 0 && stmt_num < stmt.size());
   assert(level > 0 && level <= stmt[stmt_num].loop_level.size()+1);
-
+  
   Relation &r = const_cast<Loop *>(this)->stmt[stmt_num].xform;
   for (EQ_Iterator e(r.single_conjunct()->EQs()); e; e++)
     if (abs((*e).get_coef(r.output_var(2 * level - 1))) == 1) {
@@ -727,15 +1397,15 @@ int Loop::getLexicalOrder(int stmt_num, int level) const {
         return (*e).get_coef(r.output_var(2 * level - 1)) > 0 ? -t : t;
       }
     }
-
+  
   throw loop_error(
-    "can't find lexical order for statement " + to_string(stmt_num)
-    + "'s loop level " + to_string(level));
+                   "can't find lexical order for statement " + to_string(stmt_num)
+                   + "'s loop level " + to_string(level));
 }
 
 std::set<int> Loop::getStatements(const std::vector<int> &lex, int dim) const {
   const int m = stmt.size();
-
+  
   std::set<int> same_loops;
   for (int i = 0; i < m; i++) {
     if (dim < 0)
@@ -749,32 +1419,32 @@ std::set<int> Loop::getStatements(const std::vector<int> &lex, int dim) const {
       if (j > dim)
         same_loops.insert(i);
     }
-
+    
   }
-
+  
   return same_loops;
 }
 
 void Loop::shiftLexicalOrder(const std::vector<int> &lex, int dim, int amount) {
   const int m = stmt.size();
-
+  
   if (amount == 0)
     return;
-
+  
   for (int i = 0; i < m; i++) {
     std::vector<int> lex2 = getLexicalOrder(i);
-
+    
     bool need_shift = true;
-
+    
     for (int j = 0; j < dim; j++)
       if (lex2[j] != lex[j]) {
         need_shift = false;
         break;
       }
-
+    
     if (!need_shift)
       continue;
-
+    
     if (amount > 0) {
       if (lex2[dim] < lex[dim])
         continue;
@@ -782,14 +1452,14 @@ void Loop::shiftLexicalOrder(const std::vector<int> &lex, int dim, int amount) {
       if (lex2[dim] > lex[dim])
         continue;
     }
-
+    
     assign_const(stmt[i].xform, dim, lex2[dim] + amount);
   }
 }
 
 std::vector<std::set<int> > Loop::sort_by_same_loops(std::set<int> active,
                                                      int level) {
-
+  
   std::set<int> not_nested_at_this_level;
   std::map<ir_tree_node*, std::set<int> > sorted_by_loop;
   std::map<int, std::set<int> > sorted_by_lex_order;
@@ -797,73 +1467,79 @@ std::vector<std::set<int> > Loop::sort_by_same_loops(std::set<int> active,
   bool lex_order_already_set = false;
   for (std::set<int>::iterator it = active.begin(); it != active.end();
        it++) {
-
+    
     if (stmt[*it].ir_stmt_node == NULL)
       lex_order_already_set = true;
   }
-
+  
   if (lex_order_already_set) {
-
+    
     for (std::set<int>::iterator it = active.begin(); it != active.end();
          it++) {
       std::map<int, std::set<int> >::iterator it2 =
         sorted_by_lex_order.find(
-          get_const(stmt[*it].xform, 2 * (level - 1),
-                    Output_Var));
-
+                                 get_const(stmt[*it].xform, 2 * (level - 1),
+                                           Output_Var));
+      
       if (it2 != sorted_by_lex_order.end())
         it2->second.insert(*it);
       else {
-
+        
         std::set<int> to_insert;
-
+        
         to_insert.insert(*it);
-
+        
         sorted_by_lex_order.insert(
-          std::pair<int, std::set<int> >(
-            get_const(stmt[*it].xform, 2 * (level - 1),
-                      Output_Var), to_insert));
-
+                                   std::pair<int, std::set<int> >(
+                                                                  get_const(stmt[*it].xform, 2 * (level - 1),
+                                                                            Output_Var), to_insert));
+        
       }
-
+      
     }
-
+    
     for (std::map<int, std::set<int> >::iterator it2 =
            sorted_by_lex_order.begin(); it2 != sorted_by_lex_order.end();
          it2++)
       to_return.push_back(it2->second);
-
+    
   } else {
-
+    
     for (std::set<int>::iterator it = active.begin(); it != active.end();
          it++) {
-
+      
       ir_tree_node* itn = stmt[*it].ir_stmt_node;
       itn = itn->parent;
-      while ((itn != NULL) && (itn->payload != level - 1))
+      //while (itn->content->type() != IR_CONTROL_LOOP && itn != NULL)
+      //  itn = itn->parent;
+      
+      while ((itn != NULL) && (itn->payload != level - 1)) {
         itn = itn->parent;
-
+        while (itn != NULL && itn->content->type() != IR_CONTROL_LOOP )
+          itn = itn->parent;
+      }
+      
       if (itn == NULL)
         not_nested_at_this_level.insert(*it);
       else {
         std::map<ir_tree_node*, std::set<int> >::iterator it2 =
           sorted_by_loop.find(itn);
-
+        
         if (it2 != sorted_by_loop.end())
           it2->second.insert(*it);
         else {
           std::set<int> to_insert;
-
+          
           to_insert.insert(*it);
-
+          
           sorted_by_loop.insert(
-            std::pair<ir_tree_node*, std::set<int> >(itn,
-                                                     to_insert));
-
+                                std::pair<ir_tree_node*, std::set<int> >(itn,
+                                                                         to_insert));
+          
         }
-
+        
       }
-
+      
     }
     if (not_nested_at_this_level.size() > 0) {
       for (std::set<int>::iterator it = not_nested_at_this_level.begin();
@@ -871,7 +1547,7 @@ std::vector<std::set<int> > Loop::sort_by_same_loops(std::set<int> active,
         std::set<int> temp;
         temp.insert(*it);
         to_return.push_back(temp);
-
+        
       }
     }
     for (std::map<ir_tree_node*, std::set<int> >::iterator it2 =
@@ -881,37 +1557,46 @@ std::vector<std::set<int> > Loop::sort_by_same_loops(std::set<int> active,
   return to_return;
 }
 
-void update_successors(int n, int node_num[], int cant_fuse_with[],
-                       Graph<std::set<int>, bool> &g, std::list<int> &work_list) {
-
+void update_successors(int n, 
+                       int node_num[], 
+                       int cant_fuse_with[],
+                       Graph<std::set<int>, bool> &g, 
+                       std::list<int> &work_list,
+                       std::list<bool> &type_list, 
+                       std::vector<bool> types) {
+  
   std::set<int> disconnect;
   for (Graph<std::set<int>, bool>::EdgeList::iterator i =
          g.vertex[n].second.begin(); i != g.vertex[n].second.end(); i++) {
     int m = i->first;
-
+    
     if (node_num[m] != -1)
       throw loop_error("Graph input for fusion has cycles not a DAG!!");
-
+    
     std::vector<bool> check_ = g.getEdge(n, m);
-
+    
     bool has_bad_edge_path = false;
     for (int i = 0; i < check_.size(); i++)
       if (!check_[i]) {
         has_bad_edge_path = true;
         break;
       }
-    if (has_bad_edge_path)
-      cant_fuse_with[m] = std::max(cant_fuse_with[m], node_num[n]);
-    else
+    if (!types[m]) {
       cant_fuse_with[m] = std::max(cant_fuse_with[m], cant_fuse_with[n]);
+    } else {
+      if (has_bad_edge_path)
+        cant_fuse_with[m] = std::max(cant_fuse_with[m], node_num[n]);
+      else
+        cant_fuse_with[m] = std::max(cant_fuse_with[m], cant_fuse_with[n]);
+    }
     disconnect.insert(m);
   }
-
-
+  
+  
   for (std::set<int>::iterator i = disconnect.begin(); i != disconnect.end();
        i++) {
     g.disconnect(n, *i);
-
+    
     bool no_incoming_edges = true;
     for (int j = 0; j < g.vertex.size(); j++)
       if (j != *i)
@@ -919,23 +1604,44 @@ void update_successors(int n, int node_num[], int cant_fuse_with[],
           no_incoming_edges = false;
           break;
         }
-
-
-    if (no_incoming_edges)
+    
+    if (no_incoming_edges) {
       work_list.push_back(*i);
+      type_list.push_back(types[*i]);
+    }
   }
+}
+
 
+
+int Loop::getMinLexValue(std::set<int> stmts, int level) {
+  
+  int min;
+  
+  std::set<int>::iterator it = stmts.begin();
+  min = getLexicalOrder(*it, level);
+  
+  for (; it != stmts.end(); it++) {
+    int curr = getLexicalOrder(*it, level);
+    if (curr < min)
+      min = curr;
+  }
+  
+  return min;
 }
 
+
+
+
 Graph<std::set<int>, bool> Loop::construct_induced_graph_at_level(
-  std::vector<std::set<int> > s, DependenceGraph dep, int dep_dim) {
+                                                                  std::vector<std::set<int> > s, DependenceGraph dep, int dep_dim) {
   Graph<std::set<int>, bool> g;
-
+  
   for (int i = 0; i < s.size(); i++)
     g.insert(s[i]);
-
+  
   for (int i = 0; i < s.size(); i++) {
-
+    
     for (int j = i + 1; j < s.size(); j++) {
       bool has_true_edge_i_to_j = false;
       bool has_true_edge_j_to_i = false;
@@ -943,32 +1649,32 @@ Graph<std::set<int>, bool> Loop::construct_induced_graph_at_level(
       bool is_connected_j_to_i = false;
       for (std::set<int>::iterator ii = s[i].begin(); ii != s[i].end();
            ii++) {
-
+        
         for (std::set<int>::iterator jj = s[j].begin();
              jj != s[j].end(); jj++) {
-
+          
           std::vector<DependenceVector> dvs = dep.getEdge(*ii, *jj);
           for (int k = 0; k < dvs.size(); k++)
             if (dvs[k].is_control_dependence()
                 || (dvs[k].is_data_dependence()
                     && dvs[k].has_been_carried_at(dep_dim))) {
-
+              
               if (dvs[k].is_data_dependence()
                   && dvs[k].has_negative_been_carried_at(
-                    dep_dim)) {
+                                                         dep_dim)) {
                 //g.connect(i, j, false);
                 is_connected_i_to_j = true;
                 break;
               } else {
                 //g.connect(i, j, true);
-
+                
                 has_true_edge_i_to_j = true;
                 //break
               }
             }
-
+          
           //if (is_connected)
-
+          
           //    break;
           //        if (has_true_edge_i_to_j && !is_connected_i_to_j)
           //                g.connect(i, j, true);
@@ -977,142 +1683,226 @@ Graph<std::set<int>, bool> Loop::construct_induced_graph_at_level(
             if (dvs[k].is_control_dependence()
                 || (dvs[k].is_data_dependence()
                     && dvs[k].has_been_carried_at(dep_dim))) {
-
+              
               if (is_connected_i_to_j || has_true_edge_i_to_j)
                 throw loop_error(
-                  "Graph input for fusion has cycles not a DAG!!");
-
+                                 "Graph input for fusion has cycles not a DAG!!");
+              
               if (dvs[k].is_data_dependence()
                   && dvs[k].has_negative_been_carried_at(
-                    dep_dim)) {
+                                                         dep_dim)) {
+                //g.connect(i, j, false);
                 is_connected_j_to_i = true;
                 break;
               } else {
+                //g.connect(i, j, true);
+                
                 has_true_edge_j_to_i = true;
+                //break;
               }
             }
+          
+          //    if (is_connected)
+          //break;
+          //    if (is_connected)
+          //break;
         }
+        
+        //if (is_connected)
+        //  break;
       }
-
-
+      
+      
       if (is_connected_i_to_j)
         g.connect(i, j, false);
       else if (has_true_edge_i_to_j)
         g.connect(i, j, true);
-
+      
       if (is_connected_j_to_i)
         g.connect(j, i, false);
       else if (has_true_edge_j_to_i)
         g.connect(j, i, true);
-
-
+      
     }
   }
   return g;
 }
 
-std::vector<std::set<int> > Loop::typed_fusion(Graph<std::set<int>, bool> g) {
 
-  bool roots[g.vertex.size()];
 
+std::vector<std::set<int> > Loop::typed_fusion(Graph<std::set<int>, bool> g,
+                                               std::vector<bool> &types) {
+  
+  bool roots[g.vertex.size()];
+  
   for (int i = 0; i < g.vertex.size(); i++)
     roots[i] = true;
-
+  
   for (int i = 0; i < g.vertex.size(); i++)
     for (int j = i + 1; j < g.vertex.size(); j++) {
-
+      
       if (g.hasEdge(i, j))
         roots[j] = false;
-
+      
       if (g.hasEdge(j, i))
         roots[i] = false;
-
+      
     }
-
+  
   std::list<int> work_list;
+  std::list<bool> type_list;
   int cant_fuse_with[g.vertex.size()];
+  int fused = 0;
+  int lastfused = 0;
+  int lastnum = 0;
   std::vector<std::set<int> > s;
   //Each Fused set's representative node
-
+  
   int node_to_fused_nodes[g.vertex.size()];
   int node_num[g.vertex.size()];
+  int next[g.vertex.size()];
+  
   for (int i = 0; i < g.vertex.size(); i++) {
-    if (roots[i] == true)
+    if (roots[i] == true) {
       work_list.push_back(i);
+      type_list.push_back(types[i]);
+    }
     cant_fuse_with[i] = 0;
     node_to_fused_nodes[i] = 0;
     node_num[i] = -1;
+    next[i] = 0;
   }
+  
+  
   // topological sort according to chun's permute algorithm
+  //   std::vector<std::set<int> > s = g.topoSort();
   std::vector<std::set<int> > s2 = g.topoSort();
   if (work_list.empty() || (s2.size() != g.vertex.size())) {
+    
     std::cout << s2.size() << "\t" << g.vertex.size() << std::endl;
     throw loop_error("Input for fusion not a DAG!!");
+    
+    
   }
   int fused_nodes_counter = 0;
   while (!work_list.empty()) {
     int n = work_list.front();
+    bool type = type_list.front();
+    //int n_ = g.vertex[n].first;
     work_list.pop_front();
+    type_list.pop_front();
     int node;
-    if (cant_fuse_with[n] == 0)
+    /*if (cant_fuse_with[n] == 0)
       node = 0;
-    else
+      else
       node = cant_fuse_with[n];
-
-    if ((fused_nodes_counter != 0) && (node != fused_nodes_counter)) {
-      int rep_node = node_to_fused_nodes[node];
-      node_num[n] = node_num[rep_node];
-
-      try {
-        update_successors(n, node_num, cant_fuse_with, g, work_list);
-      } catch (const loop_error &e) {
-
-        throw loop_error(
-          "statements cannot be fused together due to negative dependence");
-
-
+    */
+    int p;
+    if (type) {
+      //if ((fused_nodes_counter != 0) && (node != fused_nodes_counter)) {
+      if (cant_fuse_with[n] == 0)
+        p = fused;
+      else
+        p = next[cant_fuse_with[n]];
+      
+      if (p != 0) {
+        int rep_node = node_to_fused_nodes[p];
+        node_num[n] = node_num[rep_node];
+        
+        try {
+          update_successors(n, node_num, cant_fuse_with, g, work_list,
+                            type_list, types);
+        } catch (const loop_error &e) {
+          
+          throw loop_error(
+                           "statements cannot be fused together due to negative dependence");
+          
+        }
+        for (std::set<int>::iterator it = g.vertex[n].first.begin();
+             it != g.vertex[n].first.end(); it++)
+          s[node_num[n] - 1].insert(*it);
+      } else {
+        //std::set<int> new_node;
+        //new_node.insert(n_);
+        s.push_back(g.vertex[n].first);
+        lastnum = lastnum + 1;
+        node_num[n] = lastnum;
+        node_to_fused_nodes[node_num[n]] = n;
+        
+        if (lastfused == 0) {
+          fused = lastnum;
+          lastfused = fused;
+        } else {
+          next[lastfused] = lastnum;
+          lastfused = lastnum;
+          
+        }
+        
+        try {
+          update_successors(n, node_num, cant_fuse_with, g, work_list,
+                            type_list, types);
+        } catch (const loop_error &e) {
+          
+          throw loop_error(
+                           "statements cannot be fused together due to negative dependence");
+          
+        }
+        fused_nodes_counter++;
       }
-      for (std::set<int>::iterator it = g.vertex[n].first.begin();
-           it != g.vertex[n].first.end(); it++)
-        s[node].insert(*it);
+      
     } else {
       s.push_back(g.vertex[n].first);
-      node_to_fused_nodes[node] = n;
-      node_num[n] = ++node;
+      lastnum = lastnum + 1;
+      node_num[n] = lastnum;
+      node_to_fused_nodes[node_num[n]] = n;
+      
       try {
-        update_successors(n, node_num, cant_fuse_with, g, work_list);
+        update_successors(n, node_num, cant_fuse_with, g, work_list,
+                          type_list, types);
       } 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");
+        
       }
-      fused_nodes_counter++;
+      //fused_nodes_counter++;
+      
     }
+    
   }
-
+  
   return s;
 }
 
+
+
+
 void Loop::setLexicalOrder(int dim, const std::set<int> &active,
                            int starting_order, std::vector<std::vector<std::string> > idxNames) {
+  fprintf(stderr, "Loop::setLexicalOrder()  %d idxNames     active size %d  starting_order %d\n", idxNames.size(), active.size(), starting_order); 
   if (active.size() == 0)
     return;
 
+  for (int i=0; i< idxNames.size(); i++) { 
+    std::vector<std::string> what = idxNames[i];
+    for (int j=0; j<what.size(); j++) { 
+      fprintf(stderr, "%2d %2d %s\n", i,j, what[j].c_str()); 
+    }
+  }
+
   // check for sanity of parameters
   if (dim < 0 || dim % 2 != 0)
     throw std::invalid_argument(
-      "invalid constant loop level to set lexicographical order");
+                                "invalid constant loop level to set lexicographical order");
   std::vector<int> lex;
   int ref_stmt_num;
   for (std::set<int>::iterator i = active.begin(); i != active.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 (dim >= stmt[*i].xform.n_out())
       throw std::invalid_argument(
-        "invalid constant loop level to set lexicographical order");
+                                  "invalid constant loop level to set lexicographical order");
     if (i == active.begin()) {
       lex = getLexicalOrder(*i);
       ref_stmt_num = *i;
@@ -1121,11 +1911,11 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
       for (int j = 0; j < dim; j += 2)
         if (lex[j] != lex2[j])
           throw std::invalid_argument(
-            "statements are not in the same sub loop nest");
+                                      "statements are not in the same sub loop nest");
     }
   }
-
-  // sepearate statements by current loop level types
+  
+  // separate statements by current loop level types
   int level = (dim + 2) / 2;
   std::map<std::pair<LoopLevelType, int>, std::set<int> > active_by_level_type;
   std::set<int> active_by_no_level;
@@ -1134,10 +1924,10 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
       active_by_no_level.insert(*i);
     else
       active_by_level_type[std::make_pair(
-          stmt[*i].loop_level[level - 1].type,
-          stmt[*i].loop_level[level - 1].payload)].insert(*i);
+                                          stmt[*i].loop_level[level - 1].type,
+                                          stmt[*i].loop_level[level - 1].payload)].insert(*i);
   }
-
+  
   // further separate statements due to control dependences
   std::vector<std::set<int> > active_by_level_type_splitted;
   for (std::map<std::pair<LoopLevelType, int>, std::set<int> >::iterator i =
@@ -1164,16 +1954,16 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
       }
       if (controlled.size() != 0 && not_controlled.size() != 0) {
         active_by_level_type_splitted.erase(
-          active_by_level_type_splitted.begin() + j);
+                                            active_by_level_type_splitted.begin() + j);
         active_by_level_type_splitted.push_back(controlled);
         active_by_level_type_splitted.push_back(not_controlled);
       }
     }
-
+  
   // set lexical order separating loops with different loop types first
   if (active_by_level_type_splitted.size() + active_by_no_level.size() > 1) {
     int dep_dim = get_last_dep_dim_before(ref_stmt_num, level) + 1;
-
+    
     Graph<std::set<int>, Empty> g;
     for (std::vector<std::set<int> >::iterator i =
            active_by_level_type_splitted.begin();
@@ -1198,7 +1988,7 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
               if (dvs[k].is_control_dependence()
                   || (dvs[k].is_data_dependence()
                       && !dvs[k].has_been_carried_before(
-                        dep_dim))) {
+                                                         dep_dim))) {
                 g.connect(i, j);
                 connected = true;
                 break;
@@ -1222,7 +2012,7 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
               if (dvs[k].is_control_dependence()
                   || (dvs[k].is_data_dependence()
                       && !dvs[k].has_been_carried_before(
-                        dep_dim))) {
+                                                         dep_dim))) {
                 g.connect(j, i);
                 connected = true;
                 break;
@@ -1234,13 +2024,13 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
             break;
         }
       }
-
+    
     std::vector<std::set<int> > s = g.topoSort();
     if (s.size() != g.vertex.size())
       throw loop_error(
-        "cannot separate statements with different loop types at loop level "
-        + to_string(level));
-
+                       "cannot separate statements with different loop types at loop level "
+                       + to_string(level));
+    
     // assign lexical order
     int order = starting_order;
     for (int i = 0; i < s.size(); i++) {
@@ -1252,19 +2042,20 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
         for (int j = dim + 2; j < stmt[cur_stmt].xform.n_out(); j += 2)
           assign_const(stmt[cur_stmt].xform, j, 0);
         order++;
-      } else {
+      } else { // recurse ! 
+        fprintf(stderr, "Loop:setLexicalOrder() recursing\n"); 
         setLexicalOrder(dim, cur_scc, order, idxNames);
         order += sz;
       }
     }
   }
-  // set lexical order seperating single iteration statements and loops
-  else {
+  else { // set lexical order separating single iteration statements and loops
+
     std::set<int> true_singles;
     std::set<int> nonsingles;
     std::map<coef_t, std::set<int> > fake_singles;
     std::set<int> fake_singles_;
-
+    
     // sort out statements that do not require loops
     for (std::set<int>::iterator i = active.begin(); i != active.end();
          i++) {
@@ -1282,7 +2073,7 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
           fake_singles_.insert(*i);
           try {
             fake_singles[get_const(cur_IS, dim + 1, Set_Var)].insert(
-              *i);
+                                                                     *i);
           } catch (const std::exception &e) {
             fake_singles[posInfinity].insert(*i);
           }
@@ -1290,58 +2081,199 @@ void Loop::setLexicalOrder(int dim, const std::set<int> &active,
       } else
         nonsingles.insert(*i);
     }
-
-
+    
+    
     // split nonsingles forcibly according to negative dependences present (loop unfusible)
     int dep_dim = get_dep_dim_of(ref_stmt_num, level);
-
+    
     if (dim < stmt[ref_stmt_num].xform.n_out() - 1) {
-
+      
+      bool dummy_level_found = false;
+      
       std::vector<std::set<int> > s;
-
+      
       s = sort_by_same_loops(active, level);
       bool further_levels_exist = false;
-
+      
       if (!idxNames.empty())
         if (level <= idxNames[ref_stmt_num].size())
           if (idxNames[ref_stmt_num][level - 1].length() == 0) {
-            // Dummy level found
+            //  && s.size() == 1) {
             int order1 = 0;
-
+            dummy_level_found = true;
+            
             for (int i = level; i < idxNames[ref_stmt_num].size();
                  i++)
               if (idxNames[ref_stmt_num][i].length() > 0)
                 further_levels_exist = true;
-
+            
           }
-
+      
+      //if (!dummy_level_found) {
+      
       if (s.size() > 1) {
-
+        
+        std::vector<bool> types;
+        for (int i = 0; i < s.size(); i++)
+          types.push_back(true);
+        
         Graph<std::set<int>, bool> g = construct_induced_graph_at_level(
-          s, dep, dep_dim);
-        s = typed_fusion(g);
+                                                                        s, dep, dep_dim);
+        s = typed_fusion(g, types);
       }
-      int order = 0;
+      int order = starting_order;
       for (int i = 0; i < s.size(); i++) {
-
+        
         for (std::set<int>::iterator it = s[i].begin();
-             it != s[i].end(); it++)
+             it != s[i].end(); it++) {
           assign_const(stmt[*it].xform, dim, order);
-
-        if ((dim + 2) <= (stmt[ref_stmt_num].xform.n_out() - 1))
+          stmt[*it].xform.simplify();
+        }
+        
+        if ((dim + 2) <= (stmt[ref_stmt_num].xform.n_out() - 1)) {  // recurse ! 
+          fprintf(stderr, "Loop:setLexicalOrder() recursing\n"); 
           setLexicalOrder(dim + 2, s[i], order, idxNames);
-
+        }
+        
         order++;
       }
+      //}
+      /*    else {
+            
+            int order1 = 0;
+            int order = 0;
+            for (std::set<int>::iterator i = active.begin();
+            i != active.end(); i++) {
+            if (!further_levels_exist)
+            assign_const(stmt[*i].xform, dim, order1++);
+            else
+            assign_const(stmt[*i].xform, dim, order1);
+            
+            }
+            
+            if ((dim + 2) <= (stmt[ref_stmt_num].xform.n_out() - 1) && further_levels_exist)
+            setLexicalOrder(dim + 2, active, order, idxNames);
+            }
+      */
     } else {
       int dummy_order = 0;
       for (std::set<int>::iterator i = active.begin(); i != active.end();
-           i++)
+           i++) {
         assign_const(stmt[*i].xform, dim, dummy_order++);
+        stmt[*i].xform.simplify();
+      }
+    }
+    /*for (int i = 0; i < g2.vertex.size(); i++)
+      for (int j = i+1; j < g2.vertex.size(); j++) {
+      std::vector<DependenceVector> dvs = dep.getEdge(g2.vertex[i].first, g2.vertex[j].first);
+      for (int k = 0; k < dvs.size(); k++)
+      if (dvs[k].is_control_dependence() ||
+      (dvs[k].is_data_dependence() && dvs[k].has_negative_been_carried_at(dep_dim))) {
+      g2.connect(i, j);
+      break;
+      }
+      dvs = dep.getEdge(g2.vertex[j].first, g2.vertex[i].first);
+      for (int k = 0; k < dvs.size(); k++)
+      if (dvs[k].is_control_dependence() ||
+      (dvs[k].is_data_dependence() && dvs[k].has_negative_been_carried_at(dep_dim))) {
+      g2.connect(j, i);
+      break;
+      }
+      }
+      
+      std::vector<std::set<int> > s2 = g2.packed_topoSort();
+      
+      std::vector<std::set<int> > splitted_nonsingles;
+      for (int i = 0; i < s2.size(); i++) {
+      std::set<int> cur_scc;
+      for (std::set<int>::iterator j = s2[i].begin(); j != s2[i].end(); j++)
+      cur_scc.insert(g2.vertex[*j].first);
+      splitted_nonsingles.push_back(cur_scc);
+      }
+    */
+    //convert to dependence graph for grouped statements
+    //dep_dim = get_last_dep_dim_before(ref_stmt_num, level) + 1;
+    /*int order = 0;
+      for (std::set<int>::iterator j = active.begin(); j != active.end();
+      j++) {
+      std::set<int> continuous;
+      std::cout<< active.size()<<std::endl;
+      while (nonsingles.find(*j) != nonsingles.end() && j != active.end()) {
+      continuous.insert(*j);
+      j++;
+      }
+      
+      printf("continuous size is %d\n", continuous.size());
+      
+      
+      
+      if (continuous.size() > 0) {
+      std::vector<std::set<int> > s = typed_fusion(continuous, dep,
+      dep_dim);
+      
+      for (int i = 0; i < s.size(); i++) {
+      for (std::set<int>::iterator l = s[i].begin();
+      l != s[i].end(); l++) {
+      assign_const(stmt[*l].xform, dim + 2, order);
+      setLexicalOrder(dim + 2, s[i]);
+      }
+      order++;
+      }
+      }
+      
+      if (j != active.end()) {
+      assign_const(stmt[*j].xform, dim + 2, order);
+      
+      for (int k = dim + 4; k < stmt[*j].xform.n_out(); k += 2)
+      assign_const(stmt[*j].xform, k, 0);
+      order++;
+      }
+      
+      if( j == active.end())
+      break;
+      }
+    */
+    
+    
+    // assign lexical order
+    /*int order = starting_order;
+      for (int i = 0; i < s.size(); i++) {
+      // translate each SCC into original statements
+      std::set<int> cur_scc;
+      for (std::set<int>::iterator j = s[i].begin(); j != s[i].end(); j++)
+      copy(s[i].begin(), s[i].end(),
+      inserter(cur_scc, cur_scc.begin()));
+      
+      // now assign the constant
+      for (std::set<int>::iterator j = cur_scc.begin();
+      j != cur_scc.end(); j++)
+      assign_const(stmt[*j].xform, dim, order);
+      
+      if (cur_scc.size() > 1)
+      setLexicalOrder(dim + 2, cur_scc);
+      else if (cur_scc.size() == 1) {
+      int cur_stmt = *(cur_scc.begin());
+      for (int j = dim + 2; j < stmt[cur_stmt].xform.n_out(); j += 2)
+      assign_const(stmt[cur_stmt].xform, j, 0);
+      }
+      
+      if (cur_scc.size() > 0)
+      order++;
+      }
+    */
+  }
+
+  fprintf(stderr, "LEAVING Loop::setLexicalOrder()  %d idxNames\n", idxNames.size()); 
+  for (int i=0; i< idxNames.size(); i++) { 
+    std::vector<std::string> what = idxNames[i];
+    for (int j=0; j<what.size(); j++) { 
+      fprintf(stderr, "%2d %2d %s\n", i,j, what[j].c_str()); 
     }
   }
 }
 
+
+
 void Loop::apply_xform() {
   std::set<int> active;
   for (int i = 0; i < stmt.size(); i++)
@@ -1350,56 +2282,206 @@ void Loop::apply_xform() {
 }
 
 void Loop::apply_xform(int stmt_num) {
+  fprintf(stderr, "apply_xform( %d )\n", stmt_num); 
   std::set<int> active;
   active.insert(stmt_num);
   apply_xform(active);
 }
 
 void Loop::apply_xform(std::set<int> &active) {
+  fflush(stdout); 
+  fprintf(stderr, "loop.cc apply_xform( set )\n");
+  
   int max_n = 0;
-
-  CG_outputBuilder *ocg = ir->builder();
+  
+  omega::CG_outputBuilder *ocg = ir->builder();
   for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
     int n = stmt[*i].loop_level.size();
     if (n > max_n)
       max_n = n;
-
+    
     std::vector<int> lex = getLexicalOrder(*i);
-
-    Relation mapping(2 * n + 1, n);
-    F_And *f_root = mapping.add_and();
+    
+    omega::Relation mapping(2 * n + 1, n);
+    omega::F_And *f_root = mapping.add_and();
     for (int j = 1; j <= n; j++) {
-      EQ_Handle h = f_root->add_EQ();
+      omega::EQ_Handle h = f_root->add_EQ();
       h.update_coef(mapping.output_var(j), 1);
       h.update_coef(mapping.input_var(2 * j), -1);
     }
-    mapping = Composition(mapping, stmt[*i].xform);
+    mapping = omega::Composition(mapping, stmt[*i].xform);
     mapping.simplify();
-
+    
     // match omega input/output variables to variable names in the code
     for (int j = 1; j <= stmt[*i].IS.n_set(); j++)
       mapping.name_input_var(j, stmt[*i].IS.set_var(j)->name());
     for (int j = 1; j <= n; j++)
       mapping.name_output_var(j,
                               tmp_loop_var_name_prefix
-                              + to_string(tmp_loop_var_name_counter + j - 1));
+                              + omega::to_string(
+                                                 tmp_loop_var_name_counter + j - 1));
     mapping.setup_names();
-
-    Relation known = Extend_Set(copy(this->known),
-                                mapping.n_out() - this->known.n_set());
+    mapping.print();   //   "{[I] -> [_t1] : I = _t1 }
+    fflush(stdout); 
+    
+    omega::Relation known = Extend_Set(copy(this->known),
+                                       mapping.n_out() - this->known.n_set());
+    //stmt[*i].code = outputStatement(ocg, stmt[*i].code, 0, mapping, known, std::vector<CG_outputRepr *>(mapping.n_out(), NULL));
+    
+    omega::CG_outputBuilder *ocgr = ir->builder(); 
+    
+    
+    //this is probably CG_chillBuilder; 
+    
+    omega::CG_stringBuilder *ocgs = new omega::CG_stringBuilder;
+    if (uninterpreted_symbols[*i].size() == 0) {
+      
+      
+      std::set<std::string> globals;
+      
+      for (omega::DNF_Iterator di(stmt[*i].IS.query_DNF()); di; di++) {
+        
+        for (omega::Constraint_Iterator e(*di); e; e++) {
+          for (omega::Constr_Vars_Iter cvi(*e); cvi; cvi++) {
+            omega::Variable_ID v = cvi.curr_var();
+            if (v->kind() == omega::Global_Var
+                && v->get_global_var()->arity() > 0
+                && globals.find(v->name()) == globals.end()) {
+              omega::Global_Var_ID g = v->get_global_var();
+              globals.insert(v->name());
+              std::vector<omega::CG_outputRepr *> reprs;
+              std::vector<omega::CG_outputRepr *> reprs2;
+              
+              for (int l = 1; l <= g->arity(); l++) {
+                omega::CG_outputRepr *temp = ocgr->CreateIdent(
+                                                               stmt[*i].IS.set_var(l)->name());
+                omega::CG_outputRepr *temp2 = ocgs->CreateIdent(
+                                                                stmt[*i].IS.set_var(l)->name());
+                
+                reprs.push_back(temp);
+                reprs2.push_back(temp2);
+              }
+              uninterpreted_symbols[*i].insert(
+                                               std::pair<std::string,
+                                                         std::vector<omega::CG_outputRepr *> >(
+                                                                                               v->get_global_var()->base_name(),
+                                                                                               reprs));
+              uninterpreted_symbols_stringrepr[*i].insert(
+                                                          std::pair<std::string,
+                                                                    std::vector<omega::CG_outputRepr *> >(
+                                                                                                          v->get_global_var()->base_name(),
+                                                                                                          reprs2));
+            }
+          }
+        }
+      }
+    }
+    
     std::vector<std::string> loop_vars;
-    for (int j = 1; j <= stmt[*i].IS.n_set(); j++)
+    for (int j = 1; j <= stmt[*i].IS.n_set(); j++) {
       loop_vars.push_back(stmt[*i].IS.set_var(j)->name());
+    }
+    for (int j = 0; j<loop_vars.size(); j++) { 
+      fprintf(stderr, "loop vars %d %s\n", j, loop_vars[j].c_str()); 
+    }
     std::vector<CG_outputRepr *> subs = output_substitutions(ocg,
                                                              Inverse(copy(mapping)),
-                                                             std::vector<std::pair<CG_outputRepr *, int> >(mapping.n_out(),
-                                                                                                           std::make_pair(static_cast<CG_outputRepr *>(NULL), 0)));
+                                                             std::vector<std::pair<CG_outputRepr *, int> >(
+                                                                                                           mapping.n_out(),
+                                                                                                           std::make_pair(
+                                                                                                                          static_cast<CG_outputRepr *>(NULL), 0)),
+                                                             uninterpreted_symbols[*i]);
+    
+    std::vector<CG_outputRepr *> subs2;
+    for (int l = 0; l < subs.size(); l++)
+      subs2.push_back(subs[l]->clone());
+    
+    fprintf(stderr, "%d uninterpreted symbols\n", (int)uninterpreted_symbols.size());
+    for (int j = 0; j<loop_vars.size(); j++) {
+      fprintf(stderr, "loop vars %d %s\n", j, loop_vars[j].c_str()); 
+    } 
+    
+    
+    int count = 0; 
+    for (std::map<std::string, std::vector<CG_outputRepr *> >::iterator it =
+           uninterpreted_symbols[*i].begin();
+         it != uninterpreted_symbols[*i].end(); it++) {
+      fprintf(stderr, "\ncount %d\n", count); 
+      
+      std::vector<CG_outputRepr *> reprs_ = it->second;
+      fprintf(stderr, "%d reprs_\n", (int)reprs_.size()); 
+      
+      std::vector<CG_outputRepr *> reprs_2;
+      for (int k = 0; k < reprs_.size(); k++) {
+        fprintf(stderr, "k %d\n", k); 
+        std::vector<CG_outputRepr *> subs;
+        for (int l = 0; l < subs2.size(); l++) {
+          fprintf(stderr, "l %d\n", l); 
+          subs.push_back(subs2[l]->clone());
+        }
+        
+        fprintf(stderr, "clone\n");
+        CG_outputRepr *c =  reprs_[k]->clone(); 
+        c->dump(); fflush(stdout); 
+        
+        fprintf(stderr, "createsub\n"); 
+        CG_outputRepr *s = ocgr->CreateSubstitutedStmt(0, c,
+                                                       loop_vars, subs, true);
+        
+        fprintf(stderr, "push back\n"); 
+        reprs_2.push_back( s ); 
+        
+      }
+      
+      it->second = reprs_2;
+      count++;
+      fprintf(stderr, "bottom\n"); 
+    }
+     
+    std::vector<CG_outputRepr *> subs3 = output_substitutions(
+                                                              ocgs, Inverse(copy(mapping)),
+                                                              std::vector<std::pair<CG_outputRepr *, int> >(
+                                                                                                            mapping.n_out(),
+                                                                                                            std::make_pair(
+                                                                                                                           static_cast<CG_outputRepr *>(NULL), 0)),
+                                                              uninterpreted_symbols_stringrepr[*i]);
+    
+    for (std::map<std::string, std::vector<CG_outputRepr *> >::iterator it =
+           uninterpreted_symbols_stringrepr[*i].begin();
+         it != uninterpreted_symbols_stringrepr[*i].end(); it++) {
+      
+      std::vector<CG_outputRepr *> reprs_ = it->second;
+      std::vector<CG_outputRepr *> reprs_2;
+      for (int k = 0; k < reprs_.size(); k++) {
+        std::vector<CG_outputRepr *> subs;
+        /*  for (int l = 0; l < subs3.size(); l++)
+            subs.push_back(subs3[l]->clone());
+            reprs_2.push_back(
+            ocgs->CreateSubstitutedStmt(0, reprs_[k]->clone(),
+            loop_vars, subs));
+        */
+        reprs_2.push_back(subs3[k]->clone());
+      }
+      
+      it->second = reprs_2;
+      
+    }
+    
+    
+    fprintf(stderr, "loop.cc stmt[*i].code =\n"); 
+    //stmt[*i].code->dump(); 
+    //fprintf(stderr, "\n"); 
     stmt[*i].code = ocg->CreateSubstitutedStmt(0, stmt[*i].code, loop_vars,
                                                subs);
-    stmt[*i].IS = Range(Restrict_Domain(mapping, stmt[*i].IS));
+    //fprintf(stderr, "loop.cc substituted code =\n"); 
+    //stmt[*i].code->dump(); 
+    //fprintf(stderr, "\n"); 
+    
+    stmt[*i].IS = omega::Range(Restrict_Domain(mapping, stmt[*i].IS));
     stmt[*i].IS.simplify();
-
+    
     // replace original transformation relation with straight 1-1 mapping
+    //fprintf(stderr, "replace original transformation relation with straight 1-1 mapping\n"); 
     mapping = Relation(n, 2 * n + 1);
     f_root = mapping.add_and();
     for (int j = 1; j <= n; j++) {
@@ -1413,29 +2495,46 @@ void Loop::apply_xform(std::set<int> &active) {
       h.update_const(-lex[j - 1]);
     }
     stmt[*i].xform = mapping;
+    
+    //fprintf(stderr, "\ncode is: \n"); 
+    //stmt[*i].code->dump(); 
+    //fprintf(stderr, "\n\n"); 
+    
   }
-
+  
   tmp_loop_var_name_counter += max_n;
+  fflush(stdout); 
+  fprintf(stderr, "loop.cc LEAVING apply_xform( set )\n\n"); 
+  //for (std::set<int>::iterator i = active.begin(); i != active.end(); i++) {
+  //  fprintf(stderr, "\nloop.cc stmt[i].code =\n"); 
+  //  stmt[*i].code->dump(); 
+  //  fprintf(stderr, "\n\n"); 
+  //} 
+  
 }
 
-void Loop::addKnown(const Relation &cond) {
 
+
+
+void Loop::addKnown(const Relation &cond) {
+  
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
-
+  fprintf(stderr, "Loop::addKnown(), SETTING last_compute_cg_ = NULL\n");
+  
   int n1 = this->known.n_set();
-
+  
   Relation r = copy(cond);
   int n2 = r.n_set();
-
+  
   if (n1 < n2)
     this->known = Extend_Set(this->known, n2 - n1);
   else if (n1 > n2)
     r = Extend_Set(r, n1 - n2);
-
+  
   this->known = Intersection(this->known, r);
 }
 
@@ -1443,11 +2542,11 @@ void Loop::removeDependence(int stmt_num_from, int stmt_num_to) {
   // check for sanity of parameters
   if (stmt_num_from >= stmt.size())
     throw std::invalid_argument(
-      "invalid statement number " + to_string(stmt_num_from));
+                                "invalid statement number " + to_string(stmt_num_from));
   if (stmt_num_to >= stmt.size())
     throw std::invalid_argument(
-      "invalid statement number " + to_string(stmt_num_to));
-
+                                "invalid statement number " + to_string(stmt_num_to));
+  
   dep.disconnect(stmt_num_from, stmt_num_to);
 }
 
@@ -1482,16 +2581,16 @@ void Loop::dump() const {
 bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
   if (stmt.size() == 0)
     return true;
-
+  
   // check for sanity of parameters
   for (int i = 0; i < stmt.size(); i++) {
     if (stmt[i].loop_level.size() != num_dep_dim)
       throw std::invalid_argument(
-        "nonsingular loop transformations must be applied to original perfect loop nest");
+                                  "nonsingular loop transformations must be applied to original perfect loop nest");
     for (int j = 0; j < stmt[i].loop_level.size(); j++)
       if (stmt[i].loop_level[j].type != LoopLevelOriginal)
         throw std::invalid_argument(
-          "nonsingular loop transformations must be applied to original perfect loop nest");
+                                    "nonsingular loop transformations must be applied to original perfect loop nest");
   }
   if (T.size() != num_dep_dim)
     throw std::invalid_argument("invalid transformation matrix");
@@ -1503,6 +2602,8 @@ bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
   last_compute_cgr_ = NULL;
   delete last_compute_cg_;
   last_compute_cg_ = NULL;
+  fprintf(stderr, "Loop::nonsingular(), SETTING last_compute_cg_ = NULL\n");
+
   // build relation from matrix
   Relation mapping(2 * num_dep_dim + 1, 2 * num_dep_dim + 1);
   F_And *f_root = mapping.add_and();
@@ -1520,11 +2621,11 @@ bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
     h.update_coef(mapping.output_var(i), -1);
     h.update_coef(mapping.input_var(i), 1);
   }
-
+  
   // update transformation relations
   for (int i = 0; i < stmt.size(); i++)
     stmt[i].xform = Composition(copy(mapping), stmt[i].xform);
-
+  
   // update dependence graph
   for (int i = 0; i < dep.vertex.size(); i++)
     for (DependenceGraph::EdgeList::iterator j =
@@ -1539,7 +2640,7 @@ bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
         case DEP_W2W:
         case DEP_R2R: {
           std::vector<coef_t> lbounds(num_dep_dim), ubounds(
-            num_dep_dim);
+                                                            num_dep_dim);
           for (int p = 0; p < num_dep_dim; p++) {
             coef_t lb = 0;
             coef_t ub = 0;
@@ -1579,7 +2680,7 @@ bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
           }
           dv.lbounds = lbounds;
           dv.ubounds = ubounds;
-
+          
           break;
         }
         default:
@@ -1588,13 +2689,13 @@ bool Loop::nonsingular(const std::vector<std::vector<int> > &T) {
       }
       j->second = dvs;
     }
-
+  
   // set constant loop values
   std::set<int> active;
   for (int i = 0; i < stmt.size(); i++)
     active.insert(i);
   setLexicalOrder(0, active);
-
+  
   return true;
 }
 
@@ -1612,7 +2713,7 @@ bool Loop::is_dependence_valid_based_on_lex_order(int i, int j,
     last_dim = last_dim / 2;
     if (last_dim == 0)
       return true;
-
+    
     for (int i = 0; i < last_dim; i++) {
       if (dv.lbounds[i] > 0)
         return true;
@@ -1622,8 +2723,1713 @@ bool Loop::is_dependence_valid_based_on_lex_order(int i, int j,
   }
   if (before)
     return true;
-
+  
   return false;
+  
+}
+
+// Manu:: reduction operation
+
+void Loop::scalar_expand(int stmt_num, const std::vector<int> &levels,
+                         std::string arrName, int memory_type, int padding_alignment,
+                         int assign_then_accumulate, int padding_stride) {
+   
+  //std::cout << "In scalar_expand function: " << stmt_num << ", " << arrName << "\n";
+  //std::cout.flush(); 
+
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  // check for sanity of parameters
+  bool found_non_constant_size_dimension = false;
+  
+  if (stmt_num < 0 || stmt_num >= stmt.size())
+    throw std::invalid_argument(
+                                "invalid statement number " + to_string(stmt_num));
+  //Anand: adding check for privatized levels
+  //if (arrName != "RHS")
+  //  throw std::invalid_argument(
+  //      "invalid 3rd argument: only 'RHS' supported " + arrName);
+  for (int i = 0; i < levels.size(); i++) {
+    if (levels[i] <= 0 || levels[i] > stmt[stmt_num].loop_level.size())
+      throw std::invalid_argument(
+                                  "1invalid loop level " + to_string(levels[i]));
+    
+    if (i > 0) {
+      if (levels[i] < levels[i - 1])
+        throw std::invalid_argument(
+                                    "loop levels must be in ascending order");
+    }
+  }
+  //end --adding check for privatized levels
+  
+  delete last_compute_cgr_;
+  last_compute_cgr_ = NULL;
+  delete last_compute_cg_;
+  last_compute_cg_ = NULL;
+  fprintf(stderr, "Loop::scalar_expand(), SETTING last_compute_cg_ = NULL\n");
+
+  fprintf(stderr, "\nloop.cc finding array accesses in stmt %d of the code\n",stmt_num ); 
+  std::vector<IR_ArrayRef *> access = ir->FindArrayRef(stmt[stmt_num].code);
+  fprintf(stderr, "loop.cc L2726  %d access\n", access.size()); 
+
+  IR_ArraySymbol *sym = NULL;
+  fprintf(stderr, "arrName %s\n", arrName.c_str()); 
+  if (arrName == "RHS") { 
+    fprintf(stderr, "sym RHS\n"); 
+    sym = access[0]->symbol();
+  }
+  else {
+    fprintf(stderr, "looking for array %s in access\n", arrName.c_str()); 
+    for (int k = 0; k < access.size(); k++) { // BUH
+
+      //fprintf(stderr, "access[%d] = %s ", k, access[k]->getTypeString()); access[k]->print(0,stderr); fprintf(stderr, "\n"); 
+
+      std::string name = access[k]->symbol()->name();
+      //fprintf(stderr, "comparing %s to %s\n", name.c_str(), arrName.c_str()); 
+
+      if (access[k]->symbol()->name() == arrName) {
+        fprintf(stderr, "found it   sym access[ k=%d ]\n", k); 
+        sym = access[k]->symbol();
+      }      
+    }
+  }
+  if (!sym) fprintf(stderr, "DIDN'T FIND IT\n"); 
+  fprintf(stderr, "sym %p\n", sym); 
+
+  // collect array references by name
+  std::vector<int> lex = getLexicalOrder(stmt_num);
+  int dim = 2 * levels[levels.size() - 1] - 1;
+  std::set<int> same_loop = getStatements(lex, dim - 1);
+  
+  //Anand: shifting this down
+  //  assign_const(stmt[newStmt_num].xform, 2*level+1, 1);
+  
+  //  std::cout << " before temp array name \n ";
+  // create a temporary variable
+  IR_Symbol *tmp_sym;
+  
+  // get the loop upperbound, that would be the size of the temp array.
+  omega::coef_t lb[levels.size()], ub[levels.size()], size[levels.size()];
+  
+  //Anand Adding apply xform so that tiled loop bounds are reflected
+  fprintf(stderr, "Adding apply xform so that tiled loop bounds are reflected\n");
+  apply_xform(same_loop);
+  fprintf(stderr, "loop.cc, back from apply_xform()\n"); 
+  
+  //Anand commenting out the folowing 4 lines
+  /*  copy(stmt[stmt_num].IS).query_variable_bounds(
+      copy(stmt[stmt_num].IS).set_var(level), lb, ub);
+      std::cout << "Upper Bound = " << ub << "\n";
+      std::cout << "lower Bound = " << lb << "\n";
+  */
+  // testing testing -- Manu ////////////////////////////////////////////////
+  /*
+  // int n_dim = sym->n_dim();
+  // std::cout << "------- n_dim ----------- " << n_dim << "\n";
+  std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(stmt[stmt_num].IS, stmt[stmt_num].IS.set_var(level));
+  omega::coef_t  index_stride;
+  if (result.second != NULL) {
+  index_stride = abs(result.first.get_coef(result.second))/gcd(abs(result.first.get_coef(result.second)), abs(result.first.get_coef(stmt[stmt_num].IS.set_var(level))));
+  std::cout << "simplest_stride :: " << index_stride << ", " << result.first.get_coef(result.second) << ", " << result.first.get_coef(stmt[stmt_num].IS.set_var(level))<< "\n";
+  }
+  Relation bound;
+  // bound = get_loop_bound(stmt[stmt_num].IS, level);
+  bound = SimpleHull(stmt[stmt_num].IS,true, true);
+  bound.print();
+  
+  bound = copy(stmt[stmt_num].IS);
+  for (int i = 1; i < level; i++) {
+  bound = Project(bound, i, Set_Var);
+  std::cout << "-------------------------------\n";
+  bound.print();
+  }
+  
+  bound.simplify();
+  bound.print();
+  // bound = get_loop_bound(bound, level);
+  
+  copy(bound).query_variable_bounds(copy(bound).set_var(level), lb, ub);
+  std::cout << "Upper Bound = " << ub << "\n";
+  std::cout << "lower Bound = " << lb << "\n";
+  
+  result = find_simplest_stride(bound, bound.set_var(level));
+  if (result.second != NULL)
+  index_stride = abs(result.first.get_coef(result.second))/gcd(abs(result.first.get_coef(result.second)), abs(result.first.get_coef(bound.set_var(level))));
+  else
+  index_stride = 1;
+  std::cout << "simplest_stride 11:: " << index_stride << "\n";
+  */
+  ////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////// copied datacopy code here /////////////////////////////////////////////
+
+  //std::cout << "In scalar_expand function 2: " << stmt_num << ", " << arrName << "\n";
+  //std::cout.flush(); 
+
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+
+
+  int n_dim = levels.size();
+  Relation copy_is = copy(stmt[stmt_num].IS);
+  // extract temporary array information
+  CG_outputBuilder *ocg1 = ir->builder();
+  std::vector<CG_outputRepr *> index_lb(n_dim); // initialized to NULL
+  std::vector<coef_t> index_stride(n_dim);
+  std::vector<bool> is_index_eq(n_dim, false);
+  std::vector<std::pair<int, CG_outputRepr *> > index_sz(0);
+  Relation reduced_copy_is = copy(copy_is);
+  std::vector<CG_outputRepr *> size_repr;
+  std::vector<int> size_int;
+  Relation xform = copy(stmt[stmt_num].xform);
+  for (int i = 0; i < n_dim; i++) {
+    
+    dim = 2 * levels[i] - 1;
+    //Anand: Commenting out the lines below: not required
+    //    if (i != 0)
+    //    reduced_copy_is = Project(reduced_copy_is, level - 1 + i, Set_Var);
+    Relation bound = get_loop_bound(copy(reduced_copy_is), levels[i] - 1);
+    
+    // extract stride
+    std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(bound,
+                                                                    bound.set_var(levels[i]));
+    if (result.second != NULL)
+      index_stride[i] = abs(result.first.get_coef(result.second))
+        / gcd(abs(result.first.get_coef(result.second)),
+              abs(
+                  result.first.get_coef(
+                                        bound.set_var(levels[i]))));
+    else
+      index_stride[i] = 1;
+    //  std::cout << "simplest_stride 11:: " << index_stride[i] << "\n";
+    
+    // check if this array index requires loop
+    Conjunct *c = bound.query_DNF()->single_conjunct();
+    for (EQ_Iterator ei(c->EQs()); ei; ei++) {
+      if ((*ei).has_wildcards())
+        continue;
+      
+      int coef = (*ei).get_coef(bound.set_var(levels[i]));
+      if (coef != 0) {
+        int sign = 1;
+        if (coef < 0) {
+          coef = -coef;
+          sign = -1;
+        }
+        
+        CG_outputRepr *op = NULL;
+        for (Constr_Vars_Iter ci(*ei); ci; ci++) {
+          switch ((*ci).var->kind()) {
+          case Input_Var: {
+            if ((*ci).var != bound.set_var(levels[i]))
+              if ((*ci).coef * sign == 1)
+                op = ocg1->CreateMinus(op,
+                                       ocg1->CreateIdent((*ci).var->name()));
+              else if ((*ci).coef * sign == -1)
+                op = ocg1->CreatePlus(op,
+                                      ocg1->CreateIdent((*ci).var->name()));
+              else if ((*ci).coef * sign > 1) { 
+                op = ocg1->CreateMinus(op,
+                                       ocg1->CreateTimes(
+                                                         ocg1->CreateInt(
+                                                                         abs((*ci).coef)),
+                                                         ocg1->CreateIdent(
+                                                                           (*ci).var->name())));
+              }
+              else
+                // (*ci).coef*sign < -1
+                op = ocg1->CreatePlus(op,
+                                      ocg1->CreateTimes(
+                                                        ocg1->CreateInt(
+                                                                        abs((*ci).coef)),
+                                                        ocg1->CreateIdent(
+                                                                          (*ci).var->name())));
+            break;
+          }
+          case Global_Var: {
+            Global_Var_ID g = (*ci).var->get_global_var();
+            if ((*ci).coef * sign == 1)
+              op = ocg1->CreateMinus(op,
+                                     ocg1->CreateIdent(g->base_name()));
+            else if ((*ci).coef * sign == -1)
+              op = ocg1->CreatePlus(op,
+                                    ocg1->CreateIdent(g->base_name()));
+            else if ((*ci).coef * sign > 1)
+              op = ocg1->CreateMinus(op,
+                                     ocg1->CreateTimes(
+                                                       ocg1->CreateInt(abs((*ci).coef)),
+                                                       ocg1->CreateIdent(g->base_name())));
+            else
+              // (*ci).coef*sign < -1
+              op = ocg1->CreatePlus(op,
+                                    ocg1->CreateTimes(
+                                                      ocg1->CreateInt(abs((*ci).coef)),
+                                                      ocg1->CreateIdent(g->base_name())));
+            break;
+          }
+          default:
+            throw loop_error("unsupported array index expression");
+          }
+        }
+        if ((*ei).get_const() != 0)
+          op = ocg1->CreatePlus(op,
+                                ocg1->CreateInt(-sign * ((*ei).get_const())));
+        if (coef != 1)
+          op = ocg1->CreateIntegerFloor(op, ocg1->CreateInt(coef));
+        
+        index_lb[i] = op;
+        is_index_eq[i] = true;
+        break;
+      }
+    }
+    if (is_index_eq[i])
+      continue;
+    
+    // separate lower and upper bounds
+    std::vector<GEQ_Handle> lb_list, ub_list;
+    std::set<Variable_ID> excluded_floor_vars;
+    excluded_floor_vars.insert(bound.set_var(levels[i]));
+    for (GEQ_Iterator gi(c->GEQs()); gi; gi++) {
+      int coef = (*gi).get_coef(bound.set_var(levels[i]));
+      if (coef != 0 && (*gi).has_wildcards()) {
+        bool clean_bound = true;
+        GEQ_Handle h;
+        for (Constr_Vars_Iter cvi(*gi, true); gi; gi++)
+          if (!find_floor_definition(bound, (*cvi).var,
+                                     excluded_floor_vars).first) {
+            clean_bound = false;
+            break;
+          }
+          else 
+            h= find_floor_definition(bound, (*cvi).var,
+                                     excluded_floor_vars).second;
+        
+        if (!clean_bound)
+          continue;
+        else{
+          if (coef > 0)
+            lb_list.push_back(h);
+          else if (coef < 0)
+            ub_list.push_back(h);
+          continue;  
+        }    
+        
+      }
+      
+      if (coef > 0)
+        lb_list.push_back(*gi);
+      else if (coef < 0)
+        ub_list.push_back(*gi);
+    }
+    if (lb_list.size() == 0 || ub_list.size() == 0)
+      throw loop_error("failed to calcuate array footprint size");
+    
+    // build lower bound representation
+    std::vector<CG_outputRepr *> lb_repr_list;
+    /*     for (int j = 0; j < lb_list.size(); j++){
+           if(this->known.n_set() == 0)
+           lb_repr_list.push_back(output_lower_bound_repr(ocg1, lb_list[j], bound.set_var(level-1+i+1), result.first, result.second, bound, Relation::True(bound.n_set()), std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0))));
+           else
+           lb_repr_list.push_back(output_lower_bound_repr(ocg1, lb_list[j], bound.set_var(level-1+i+1), result.first, result.second, bound, this->known, std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0))));
+           
+           }
+    */
+    if (lb_repr_list.size() > 1)
+      index_lb[i] = ocg1->CreateInvoke("max", lb_repr_list);
+    else if (lb_repr_list.size() == 1)
+      index_lb[i] = lb_repr_list[0];
+    
+    // build temporary array size representation
+    {
+      Relation cal(copy_is.n_set(), 1);
+      F_And *f_root = cal.add_and();
+      for (int j = 0; j < ub_list.size(); j++)
+        for (int k = 0; k < lb_list.size(); k++) {
+          GEQ_Handle h = f_root->add_GEQ();
+          
+          for (Constr_Vars_Iter ci(ub_list[j]); ci; ci++) {
+            switch ((*ci).var->kind()) {
+            case Input_Var: {
+              int pos = (*ci).var->get_position();
+              h.update_coef(cal.input_var(pos), (*ci).coef);
+              break;
+            }
+            case Global_Var: {
+              Global_Var_ID g = (*ci).var->get_global_var();
+              Variable_ID v;
+              if (g->arity() == 0)
+                v = cal.get_local(g);
+              else
+                v = cal.get_local(g, (*ci).var->function_of());
+              h.update_coef(v, (*ci).coef);
+              break;
+            }
+            default:
+              throw loop_error(
+                               "cannot calculate temporay array size statically");
+            }
+          }
+          h.update_const(ub_list[j].get_const());
+          
+          for (Constr_Vars_Iter ci(lb_list[k]); ci; ci++) {
+            switch ((*ci).var->kind()) {
+            case Input_Var: {
+              int pos = (*ci).var->get_position();
+              h.update_coef(cal.input_var(pos), (*ci).coef);
+              break;
+            }
+            case Global_Var: {
+              Global_Var_ID g = (*ci).var->get_global_var();
+              Variable_ID v;
+              if (g->arity() == 0)
+                v = cal.get_local(g);
+              else
+                v = cal.get_local(g, (*ci).var->function_of());
+              h.update_coef(v, (*ci).coef);
+              break;
+            }
+            default:
+              throw loop_error(
+                               "cannot calculate temporay array size statically");
+            }
+          }
+          h.update_const(lb_list[k].get_const());
+          
+          h.update_const(1);
+          h.update_coef(cal.output_var(1), -1);
+        }
+      
+      cal = Restrict_Domain(cal, copy(copy_is));
+      for (int j = 1; j <= cal.n_inp(); j++) {
+        cal = Project(cal, j, Input_Var);
+      }
+      cal.simplify();
+      
+      // pad temporary array size
+      // TODO: for variable array size, create padding formula
+      //int padding_stride = 0;
+      Conjunct *c = cal.query_DNF()->single_conjunct();
+      bool is_index_bound_const = false;
+      if (padding_stride != 0 && i == n_dim - 1) {
+        //size = (size + index_stride[i] - 1) / index_stride[i];
+        size_repr.push_back(ocg1->CreateInt(padding_stride));
+      } else {
+        for (GEQ_Iterator gi(c->GEQs()); gi && !is_index_bound_const;
+             gi++)
+          if ((*gi).is_const(cal.output_var(1))) {
+            coef_t size = (*gi).get_const()
+              / (-(*gi).get_coef(cal.output_var(1)));
+            
+            if (padding_alignment > 1 && i == n_dim - 1) { // align to boundary for data packing
+              int residue = size % padding_alignment;
+              if (residue)
+                size = size + padding_alignment - residue;
+            }
+            
+            index_sz.push_back(
+                               std::make_pair(i, ocg1->CreateInt(size)));
+            is_index_bound_const = true;
+            size_int.push_back(size);
+            size_repr.push_back(ocg1->CreateInt(size));
+            
+            //  std::cout << "============================== size :: "
+            //      << size << "\n";
+            
+          }
+        
+        if (!is_index_bound_const) {
+          
+          found_non_constant_size_dimension = true;
+          Conjunct *c = bound.query_DNF()->single_conjunct();
+          for (GEQ_Iterator gi(c->GEQs());
+               gi && !is_index_bound_const; gi++) {
+            int coef = (*gi).get_coef(bound.set_var(levels[i]));
+            if (coef < 0) {
+              
+              size_repr.push_back(
+                                  ocg1->CreatePlus(
+                                                   output_upper_bound_repr(ocg1, *gi,
+                                                                           bound.set_var(levels[i]),
+                                                                           bound,
+                                                                           std::vector<
+                                                                             std::pair<
+                                                                               CG_outputRepr *,
+                                                                               int> >(
+                                                                                      bound.n_set(),
+                                                                                      std::make_pair(
+                                                                                                     static_cast<CG_outputRepr *>(NULL),
+                                                                                                     0)),
+                                                                           uninterpreted_symbols[stmt_num]),
+                                                   ocg1->CreateInt(1)));
+              
+              /*CG_outputRepr *op = NULL;
+                for (Constr_Vars_Iter ci(*gi); ci; ci++) {
+                if ((*ci).var != cal.output_var(1)) {
+                switch ((*ci).var->kind()) {
+                case Global_Var: {
+                Global_Var_ID g =
+                (*ci).var->get_global_var();
+                if ((*ci).coef == 1)
+                op = ocg1->CreatePlus(op,
+                ocg1->CreateIdent(
+                g->base_name()));
+                else if ((*ci).coef == -1)
+                op = ocg1->CreateMinus(op,
+                ocg1->CreateIdent(
+                g->base_name()));
+                else if ((*ci).coef > 1)
+                op =
+                ocg1->CreatePlus(op,
+                ocg1->CreateTimes(
+                ocg1->CreateInt(
+                (*ci).coef),
+                ocg1->CreateIdent(
+                g->base_name())));
+                else
+                // (*ci).coef < -1
+                op =
+                ocg1->CreateMinus(op,
+                ocg1->CreateTimes(
+                ocg1->CreateInt(
+                -(*ci).coef),
+                ocg1->CreateIdent(
+                g->base_name())));
+                break;
+                }
+                default:
+                throw loop_error(
+                "failed to generate array index bound code");
+                }
+                }
+                }
+                int c = (*gi).get_const();
+                if (c > 0)
+                op = ocg1->CreatePlus(op, ocg1->CreateInt(c));
+                else if (c < 0)
+                op = ocg1->CreateMinus(op, ocg1->CreateInt(-c));
+              */
+              /*            if (padding_stride != 0) {
+                            if (i == fastest_changing_dimension) {
+                            coef_t g = gcd(index_stride[i], static_cast<coef_t>(padding_stride));
+                            coef_t t1 = index_stride[i] / g;
+                            if (t1 != 1)
+                            op = ocg->CreateIntegerFloor(ocg->CreatePlus(op, ocg->CreateInt(t1-1)), ocg->CreateInt(t1));
+                            coef_t t2 = padding_stride / g;
+                            if (t2 != 1)
+                            op = ocg->CreateTimes(op, ocg->CreateInt(t2));
+                            }
+                            else if (index_stride[i] != 1) {
+                            op = ocg->CreateIntegerFloor(ocg->CreatePlus(op, ocg->CreateInt(index_stride[i]-1)), ocg->CreateInt(index_stride[i]));
+                            }
+                            }
+              */
+              //index_sz.push_back(std::make_pair(i, op));
+              //break;
+            }
+          }
+        }
+      }
+    }
+    //size[i] = ub[i];
+    
+  }
+  /////////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  
+  //Anand: Creating IS of new statement
+  
+  //for(int l = dim; l < stmt[stmt_num].xform.n_out(); l+=2)
+  //std::cout << "In scalar_expand function 3: " << stmt_num << ", " << arrName << "\n";
+  //std::cout.flush(); 
+
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  
+  shiftLexicalOrder(lex, dim + 1, 1);
+  Statement s = stmt[stmt_num];
+  s.ir_stmt_node = NULL;
+  int newStmt_num = stmt.size();
+
+  fprintf(stderr, "loop.cc L3249 adding stmt %d\n", stmt.size()); 
+  stmt.push_back(s);
+  
+  fprintf(stderr, "uninterpreted_symbols.push_back()  newStmt_num %d\n", newStmt_num); 
+  uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
+  uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[stmt_num]);
+  stmt[newStmt_num].code = stmt[stmt_num].code->clone();
+  stmt[newStmt_num].IS = copy(stmt[stmt_num].IS);
+  stmt[newStmt_num].xform = xform;
+  stmt[newStmt_num].reduction = stmt[stmt_num].reduction;
+  stmt[newStmt_num].reductionOp = stmt[stmt_num].reductionOp;
+
+
+  //fprintf(stderr, "\nafter clone, %d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+
+
+  //assign_const(stmt[newStmt_num].xform, stmt[stmt_num].xform.n_out(), 1);//Anand: change from 2*level + 1 to stmt[stmt_num].xform.size()
+  //Anand-End creating IS of new statement
+  
+  CG_outputRepr * tmpArrSz;
+  CG_outputBuilder *ocg = ir->builder();
+  
+  //for(int k =0; k < levels.size(); k++ )
+  //    size_repr.push_back(ocg->CreateInt(size[k]));//Anand: copying apply_xform functionality to prevent IS modification
+  //due to side effects with uninterpreted function symbols and failures in omega
+  
+  //int n = stmt[stmt_num].loop_level.size();
+  
+  /*Relation mapping(2 * n + 1, n);
+    F_And *f_root = mapping.add_and();
+    for (int j = 1; j <= n; j++) {
+    EQ_Handle h = f_root->add_EQ();
+    h.update_coef(mapping.output_var(j), 1);
+    h.update_coef(mapping.input_var(2 * j), -1);
+    }
+    mapping = Composition(mapping, copy(stmt[stmt_num].xform));
+    mapping.simplify();
+    
+    // match omega input/output variables to variable names in the code
+    for (int j = 1; j <= stmt[stmt_num].IS.n_set(); j++)
+    mapping.name_input_var(j, stmt[stmt_num].IS.set_var(j)->name());
+    for (int j = 1; j <= n; j++)
+    mapping.name_output_var(j,
+    tmp_loop_var_name_prefix
+    + to_string(tmp_loop_var_name_counter + j - 1));
+    mapping.setup_names();
+    
+    Relation size_ = omega::Range(Restrict_Domain(mapping, copy(stmt[stmt_num].IS)));
+    size_.simplify();
+  */
+  
+  //Anand -commenting out tmp sym creation as symbol may have more than one dimension
+  //tmp_sym = ir->CreateArraySymbol(tmpArrSz, sym);
+  std::vector<CG_outputRepr *> lhs_index;
+  CG_outputRepr *arr_ref_repr;
+  arr_ref_repr = ocg->CreateIdent(
+                                  stmt[stmt_num].IS.set_var(levels[levels.size() - 1])->name());
+  
+  CG_outputRepr *total_size = size_repr[0];
+  fprintf(stderr, "total_size = ");   total_size->dump(); fflush(stdout); 
+
+  for (int i = 1; i < size_repr.size(); i++) {
+    fprintf(stderr, "total_size now "); total_size->dump(); fflush(stdout); fprintf(stderr, " times  something\n\n"); 
+
+    total_size = ocg->CreateTimes(total_size->clone(),
+                                  size_repr[i]->clone());
+    
+  }
+  
+  // COMMENT NEEDED 
+  //fprintf(stderr, "\nloop.cc COMMENT NEEDED\n"); 
+  for (int k = levels.size() - 2; k >= 0; k--) {
+    CG_outputRepr *temp_repr =ocg->CreateIdent(stmt[stmt_num].IS.set_var(levels[k])->name());
+    for (int l = k + 1; l < levels.size(); l++) { 
+      //fprintf(stderr, "\nloop.cc CREATETIMES\n"); 
+      temp_repr = ocg->CreateTimes(temp_repr->clone(),
+                                   size_repr[l]->clone());
+    }
+    
+    //fprintf(stderr, "\nloop.cc CREATEPLUS\n"); 
+    arr_ref_repr = ocg->CreatePlus(arr_ref_repr->clone(),
+                                   temp_repr->clone());
+  }
+  
+
+  //fprintf(stderr, "loop.cc, about to die\n"); 
+  std::vector<CG_outputRepr *> to_push;
+  to_push.push_back(total_size);
+
+  if (!found_non_constant_size_dimension) { 
+    fprintf(stderr, "constant size dimension\n"); 
+    tmp_sym = ir->CreateArraySymbol(sym, to_push, memory_type);
+  }
+  else {
+    fprintf(stderr, "NON constant size dimension?\n"); 
+    //tmp_sym = ir->CreatePointerSymbol(sym, to_push);
+    tmp_sym = ir->CreatePointerSymbol(sym, to_push);
+
+    static_cast<IR_PointerSymbol *>(tmp_sym)->set_size(0, total_size); // ?? 
+    ptr_variables.push_back(static_cast<IR_PointerSymbol *>(tmp_sym));
+    fprintf(stderr, "ptr_variables now has %d entries\n", ptr_variables.size()); 
+  }
+  
+  // add tmp_sym to Loop symtables ??
+  
+
+  //  std::cout << " temp array name == " << tmp_sym->name().c_str() << "\n";
+  
+  // get loop index variable at the given "level"
+  // Relation R = omega::Range(Restrict_Domain(copy(stmt[stmt_num].xform), copy(stmt[stmt_num].IS)));
+  //  stmt[stmt_num].IS.print();
+  //stmt[stmt_num].IS.
+  //  std::cout << stmt[stmt_num].IS.n_set() << std::endl;
+  //  std::string v = stmt[stmt_num].IS.set_var(level)->name();
+  //  std::cout << "loop index variable is '" << v.c_str() << "'\n";
+  
+  // create a reference for the temporary array
+  fprintf(stderr, "create a reference for the temporary array\n"); 
+  //std::cout << "In scalar_expand function 4: " << stmt_num << ", " << arrName << "\n";
+  //std::cout.flush(); 
+
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  
+
+  std::vector<CG_outputRepr *> to_push2;
+  to_push2.push_back(arr_ref_repr); // can have only one entry
+
+  //lhs_index[0] = ocg->CreateIdent(v);
+
+
+  IR_ArrayRef *tmp_array_ref;
+  IR_PointerArrayRef * tmp_ptr_array_ref;  // was IR_PointerArrayref
+
+  if (!found_non_constant_size_dimension) {
+    fprintf(stderr, "constant size\n");
+
+    tmp_array_ref = ir->CreateArrayRef(
+                                       static_cast<IR_ArraySymbol *>(tmp_sym), to_push2);
+  }
+  else { 
+    fprintf(stderr, "NON constant size\n"); 
+    tmp_ptr_array_ref = ir->CreatePointerArrayRef(
+                                       static_cast<IR_PointerSymbol *>(tmp_sym), to_push2);
+    // TODO static_cast<IR_PointerSymbol *>(tmp_sym), to_push2);
+  }
+  fflush(stdout); 
+
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+
+  //std::string stemp;
+  //stemp = tmp_array_ref->name();
+  //std::cout << "Created array reference --> " << stemp.c_str() << "\n";
+  
+  // get the RHS expression
+  fprintf(stderr, "get the RHS expression   arrName %s\n", arrName.c_str()); 
+
+  CG_outputRepr *rhs;
+  if (arrName == "RHS") {
+    rhs = ir->GetRHSExpression(stmt[stmt_num].code);
+    
+    std::vector<IR_ArrayRef *> symbols = ir->FindArrayRef(rhs);
+  }
+  std::set<std::string> sym_names;
+  
+  //for (int i = 0; i < symbols.size(); i++)
+  //  sym_names.insert(symbols[i]->symbol()->name());
+  
+  fflush(stdout); 
+
+  //fprintf(stderr, "\nbefore if (arrName == RHS)\n%d statements\n", stmt.size()); // problem is after here 
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  if (arrName == "RHS") {
+    
+    std::vector<IR_ArrayRef *> symbols = ir->FindArrayRef(rhs);
+    
+    for (int i = 0; i < symbols.size(); i++)
+      sym_names.insert(symbols[i]->symbol()->name());
+  } 
+  else {
+
+    fprintf(stderr, "finding array refs in stmt_num %d\n", stmt_num); 
+    //fprintf(stderr, "\n%d statements\n", stmt.size());
+    //for (int i=0; i<stmt.size(); i++) { 
+    //  fprintf(stderr, "%2d   ", i); 
+    //  ((CG_chillRepr *)stmt[i].code)->Dump();
+    //} 
+    //fprintf(stderr, "\n"); 
+
+    std::vector<IR_ArrayRef *> refs = ir->FindArrayRef(stmt[stmt_num].code);
+    fprintf(stderr, "\n%d refs\n", refs.size()); 
+
+    
+    bool found = false;
+
+    for (int j = 0; j < refs.size(); j++) {
+      CG_outputRepr* to_replace;
+
+      fprintf(stderr, "j %d   build new assignment statement with temporary array\n",j); 
+      // build new assignment statement with temporary array
+      if (!found_non_constant_size_dimension) {
+        to_replace = tmp_array_ref->convert();
+      } else {
+        to_replace = tmp_ptr_array_ref->convert();
+      }
+      //fprintf(stderr, "to_replace  %p\n", to_replace); 
+      //CG_chillRepr *CR = (CG_chillRepr *) to_replace;
+      //CR->Dump(); 
+
+      if (refs[j]->name() == arrName) {
+        fflush(stdout); 
+        fprintf(stderr, "loop.cc L353\n");  // problem is after here 
+        //fprintf(stderr, "\n%d statements\n", stmt.size());
+        //for (int i=0; i<stmt.size(); i++) { 
+        //  fprintf(stderr, "%2d   ", i); 
+        //  ((CG_chillRepr *)stmt[i].code)->Dump();
+        //} 
+        //fprintf(stderr, "\n"); 
+        
+
+        sym_names.insert(refs[j]->symbol()->name());
+        
+        if (!found) {
+          if (!found_non_constant_size_dimension) { 
+            fprintf(stderr, "constant size2\n"); 
+            omega::CG_outputRepr * t =  tmp_array_ref->convert();
+            omega::CG_outputRepr * r = refs[j]->convert()->clone();
+            //CR = (CG_chillRepr *) t;
+            //CR->Dump(); 
+            //CR = (CG_chillRepr *) r;
+            //CR->Dump(); 
+
+            //fprintf(stderr, "lhs t %p   lhs r %p\n", t, r); 
+            stmt[newStmt_num].code =
+              ir->builder()->CreateAssignment(0,
+                                              t, // tmp_array_ref->convert(),
+                                              r); // refs[j]->convert()->clone()
+          }
+          else { 
+            fprintf(stderr, "NON constant size2\n"); 
+            omega::CG_outputRepr * t =  tmp_ptr_array_ref->convert(); // this fails
+            omega::CG_outputRepr * r = refs[j]->convert()->clone();
+
+            //omega::CG_chillRepr *CR = (omega::CG_chillRepr *) t;
+            //CR->Dump(); 
+            //CR = (omega::CG_chillRepr *) r;
+            //CR->Dump(); 
+
+            //fprintf(stderr, "lhs t %p   lhs r %p\n", t, r); 
+            stmt[newStmt_num].code =
+              ir->builder()->CreateAssignment(0,
+                                              t, // tmp_ptr_array_ref->convert(),
+                                              r ); // refs[j]->convert()->clone());
+          }
+          found = true;
+          
+        }
+        
+        // refs[j] has no parent?
+        fprintf(stderr, "replacing refs[%d]\n", j ); 
+        ir->ReplaceExpression(refs[j], to_replace);
+      }
+      
+    }
+    
+  }
+  //ToDo need to update the dependence graph
+  //Anand adding dependence graph update
+  fprintf(stderr, "adding dependence graph update\n");   // problem is before here 
+  //fprintf(stderr, "\n%d statements\n", stmt.size());
+  //for (int i=0; i<stmt.size(); i++) { 
+  //  fprintf(stderr, "%2d   ", i); 
+  //  ((CG_chillRepr *)stmt[i].code)->Dump();
+  //} 
+  //fprintf(stderr, "\n"); 
+
+  dep.insert();
+  
+  //Anand:Copying Dependence checks from datacopy code, might need to be a separate function/module
+  // in the future
+  
+  /*for (int i = 0; i < newStmt_num; i++) {
+    std::vector<std::vector<DependenceVector> > D;
+    
+    for (DependenceGraph::EdgeList::iterator j =
+    dep.vertex[i].second.begin(); j != dep.vertex[i].second.end();
+    ) {
+    if (same_loop.find(i) != same_loop.end()
+    && same_loop.find(j->first) == same_loop.end()) {
+    std::vector<DependenceVector> dvs1, dvs2;
+    for (int k = 0; k < j->second.size(); k++) {
+    DependenceVector dv = j->second[k];
+    if (dv.sym != NULL
+    && sym_names.find(dv.sym->name()) != sym_names.end()
+    && (dv.type == DEP_R2R || dv.type == DEP_R2W))
+    dvs1.push_back(dv);
+    else
+    dvs2.push_back(dv);
+    }
+    j->second = dvs2;
+    if (dvs1.size() > 0)
+    dep.connect(newStmt_num, j->first, dvs1);
+    } else if (same_loop.find(i) == same_loop.end()
+    && same_loop.find(j->first) != same_loop.end()) {
+    std::vector<DependenceVector> dvs1, dvs2;
+    for (int k = 0; k < j->second.size(); k++) {
+    DependenceVector dv = j->second[k];
+    if (dv.sym != NULL
+    && sym_names.find(dv.sym->name()) != sym_names.end()
+    && (dv.type == DEP_R2R || dv.type == DEP_W2R))
+    dvs1.push_back(dv);
+    else
+    dvs2.push_back(dv);
+    }
+    j->second = dvs2;
+    if (dvs1.size() > 0)
+    D.push_back(dvs1);
+    }
+    
+    if (j->second.size() == 0)
+    dep.vertex[i].second.erase(j++);
+    else
+    j++;
+    }
+    
+    for (int j = 0; j < D.size(); j++)
+    dep.connect(i, newStmt_num, D[j]);
+    }
+  */
+  //Anand--end dependence check
+  if (arrName == "RHS") {
+    
+    // build new assignment statement with temporary array
+    if (!found_non_constant_size_dimension) {
+      if (assign_then_accumulate) {
+        stmt[newStmt_num].code = ir->builder()->CreateAssignment(0,
+                                                                 tmp_array_ref->convert(), rhs);
+        fprintf(stderr, "ir->ReplaceRHSExpression( stmt_ num %d )\n", stmt_num); 
+        ir->ReplaceRHSExpression(stmt[stmt_num].code, tmp_array_ref);
+      } else {
+        CG_outputRepr *temp = tmp_array_ref->convert()->clone();
+        if (ir->QueryExpOperation(stmt[stmt_num].code)
+            != IR_OP_PLUS_ASSIGNMENT)
+          throw ir_error(
+                         "Statement is not a += accumulation statement");
+
+        fprintf(stderr, "replacing in a +=\n"); 
+        stmt[newStmt_num].code = ir->builder()->CreatePlusAssignment(0,
+                                                                     temp->clone(), rhs);
+        
+        CG_outputRepr * lhs = ir->GetLHSExpression(stmt[stmt_num].code);
+        
+        CG_outputRepr *assignment = ir->builder()->CreateAssignment(0,
+                                                                    lhs, temp->clone());
+        Statement init_ = stmt[newStmt_num]; // copy ??
+        init_.ir_stmt_node = NULL;
+        
+        init_.code = stmt[newStmt_num].code->clone();
+        init_.IS = copy(stmt[newStmt_num].IS);
+        init_.xform = copy(stmt[newStmt_num].xform);
+        init_.has_inspector = false; // ?? 
+
+        Relation mapping(init_.IS.n_set(), init_.IS.n_set());
+        
+        F_And *f_root = mapping.add_and();
+        
+        for (int i = 1; i <= mapping.n_inp(); i++) {
+          EQ_Handle h = f_root->add_EQ();
+          //if (i < levels[0]) {
+          if (i <= levels[levels.size() - 1]) {
+            h.update_coef(mapping.input_var(i), 1);
+            h.update_coef(mapping.output_var(i), -1);
+          } else {
+            h.update_const(-1);
+            h.update_coef(mapping.output_var(i), 1);
+          }
+          
+          /*else {
+            int j;
+            for (j = 0; j < levels.size(); j++)
+            if (i == levels[j])
+            break;
+            
+            if (j == levels.size()) {
+            
+            h.update_coef(mapping.output_var(i), 1);
+            h.update_const(-1);
+            
+            } else {
+            
+            
+            h.update_coef(mapping.input_var(i), 1);
+            h.update_coef(mapping.output_var(i), -1);
+            
+            
+            }
+          */
+          //}
+        }
+        
+        mapping.simplify();
+        // match omega input/output variables to variable names in the code
+        for (int j = 1; j <= init_.IS.n_set(); j++)
+          mapping.name_output_var(j, init_.IS.set_var(j)->name());
+        for (int j = 1; j <= init_.IS.n_set(); j++)
+          mapping.name_input_var(j, init_.IS.set_var(j)->name());
+        
+        mapping.setup_names();
+        
+        init_.IS = omega::Range(
+                                omega::Restrict_Domain(mapping, init_.IS));
+        std::vector<int> lex = getLexicalOrder(newStmt_num);
+        int dim = 2 * levels[0] - 1;
+        //init_.IS.print();
+        //  init_.xform.print();
+        //stmt[newStmt_num].xform.print();
+        //  shiftLexicalOrder(lex, dim + 1, 1);
+        shiftLexicalOrder(lex, dim + 1, 1);
+        init_.reduction = stmt[newStmt_num].reduction;
+        init_.reductionOp = stmt[newStmt_num].reductionOp;
+        
+        init_.code = ir->builder()->CreateAssignment(0, temp->clone(),
+                                                     ir->builder()->CreateInt(0));
+
+        fprintf(stderr, "loop.cc L3693 adding stmt %d\n", stmt.size()); 
+        stmt.push_back(init_);
+
+        uninterpreted_symbols.push_back(uninterpreted_symbols[newStmt_num]);
+        uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[newStmt_num]);
+        stmt[stmt_num].code = assignment;
+      }
+    } else {
+      if (assign_then_accumulate) {
+        stmt[newStmt_num].code = ir->builder()->CreateAssignment(0,
+                                                                 tmp_ptr_array_ref->convert(), rhs);
+        ir->ReplaceRHSExpression(stmt[stmt_num].code,
+                                 tmp_ptr_array_ref);
+      } else {
+        CG_outputRepr *temp = tmp_ptr_array_ref->convert()->clone();
+        if (ir->QueryExpOperation(stmt[stmt_num].code)
+            != IR_OP_PLUS_ASSIGNMENT)
+          throw ir_error(
+                         "Statement is not a += accumulation statement");
+        stmt[newStmt_num].code = ir->builder()->CreatePlusAssignment(0,
+                                                                     temp->clone(), rhs);
+        
+        CG_outputRepr * lhs = ir->GetLHSExpression(stmt[stmt_num].code);
+        
+        CG_outputRepr *assignment = ir->builder()->CreateAssignment(0,
+                                                                    lhs, temp->clone());
+        
+        stmt[stmt_num].code = assignment;
+      }
+      // call function to replace rhs with temporary array
+    }
+  }
+  
+  //std::cout << "End of scalar_expand function!! \n";
+  
+  //  if(arrName == "RHS"){
+  DependenceVector dv;
+  std::vector<DependenceVector> E;
+  dv.lbounds = std::vector<omega::coef_t>(4);
+  dv.ubounds = std::vector<omega::coef_t>(4);
+  dv.type = DEP_W2R;
+  
+  for (int k = 0; k < 4; k++) {
+    dv.lbounds[k] = 0;
+    dv.ubounds[k] = 0;
+    
+  }
+  
+  //std::vector<IR_ArrayRef*> array_refs = ir->FindArrayRef(stmt[newStmt_num].code);
+  dv.sym = tmp_sym->clone();
+  
+  E.push_back(dv);
+  
+  dep.connect(newStmt_num, stmt_num, E);
+  // }
+  
+}
+
+
 
+
+std::pair<Relation, Relation> createCSRstyleISandXFORM(CG_outputBuilder *ocg,
+                                                       std::vector<Relation> &outer_loop_bounds, std::string index_name,
+                                                       std::map<int, Relation> &zero_loop_bounds,
+                                                       std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols,
+                                                       std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols_string,
+                                                       Loop *this_loop) {
+  
+  Relation IS(outer_loop_bounds.size() + 1 + zero_loop_bounds.size());
+  Relation XFORM(outer_loop_bounds.size() + 1 + zero_loop_bounds.size(),
+                 2 * (outer_loop_bounds.size() + 1 + zero_loop_bounds.size()) + 1);
+  
+  F_And * f_r_ = IS.add_and();
+  F_And * f_root = XFORM.add_and();
+  
+  if (outer_loop_bounds.size() > 0) {
+    for (int it = 0; it < IS.n_set(); it++) {
+      IS.name_set_var(it + 1,
+                      const_cast<Relation &>(outer_loop_bounds[0]).set_var(it + 1)->name());
+      XFORM.name_input_var(it + 1,
+                           const_cast<Relation &>(outer_loop_bounds[0]).set_var(it + 1)->name());
+      
+    }
+  } else if (zero_loop_bounds.size() > 0) {
+    for (int it = 0; it < IS.n_set(); it++) {
+      IS.name_set_var(it + 1,
+                      const_cast<Relation &>(zero_loop_bounds.begin()->second).set_var(
+                                                                                       it + 1)->name());
+      XFORM.name_input_var(it + 1,
+                           const_cast<Relation &>(zero_loop_bounds.begin()->second).set_var(
+                                                                                            it + 1)->name());
+      
+    }
+    
+  }
+  
+  for (int i = 0; i < outer_loop_bounds.size(); i++)
+    IS = replace_set_var_as_another_set_var(IS, outer_loop_bounds[i], i + 1,
+                                            i + 1);
+  
+  int count = 1;
+  for (std::map<int, Relation>::iterator i = zero_loop_bounds.begin();
+       i != zero_loop_bounds.end(); i++, count++)
+    IS = replace_set_var_as_another_set_var(IS, i->second,
+                                            outer_loop_bounds.size() + 1 + count, i->first);
+  
+  if (outer_loop_bounds.size() > 0) {
+    Free_Var_Decl *lb = new Free_Var_Decl(index_name + "_", 1); // index_
+    Variable_ID csr_lb = IS.get_local(lb, Input_Tuple);
+    
+    Free_Var_Decl *ub = new Free_Var_Decl(index_name + "__", 1); // index__
+    Variable_ID csr_ub = IS.get_local(ub, Input_Tuple);
+    
+    //lower bound
+    
+    F_And * f_r = IS.and_with_and();
+    GEQ_Handle lower_bound = f_r->add_GEQ();
+    lower_bound.update_coef(csr_lb, -1);
+    lower_bound.update_coef(IS.set_var(outer_loop_bounds.size() + 1), 1);
+    
+    //upper bound
+    
+    GEQ_Handle upper_bound = f_r->add_GEQ();
+    upper_bound.update_coef(csr_ub, 1);
+    upper_bound.update_coef(IS.set_var(outer_loop_bounds.size() + 1), -1);
+    upper_bound.update_const(-1);
+    
+    omega::CG_stringBuilder *ocgs = new CG_stringBuilder;
+    
+    std::vector<omega::CG_outputRepr *> reprs;
+    std::vector<omega::CG_outputRepr *> reprs2;
+    
+    std::vector<omega::CG_outputRepr *> reprs3;
+    std::vector<omega::CG_outputRepr *> reprs4;
+    
+    reprs.push_back(
+                    ocg->CreateIdent(IS.set_var(outer_loop_bounds.size())->name()));
+    reprs2.push_back(
+                     ocgs->CreateIdent(
+                                       IS.set_var(outer_loop_bounds.size())->name()));
+    uninterpreted_symbols.insert(
+                                 std::pair<std::string, std::vector<CG_outputRepr *> >(
+                                                                                       index_name + "_", reprs));
+    uninterpreted_symbols_string.insert(
+                                        std::pair<std::string, std::vector<CG_outputRepr *> >(
+                                                                                              index_name + "_", reprs2));
+    
+    std::string arg = "(" + IS.set_var(outer_loop_bounds.size())->name()
+      + ")";
+    std::vector< std::string > argvec;
+    argvec.push_back( arg ); 
+    
+    CG_outputRepr *repr = ocg->CreateArrayRefExpression(index_name,
+                                                        ocg->CreateIdent(IS.set_var(outer_loop_bounds.size())->name()));
+    
+    //fprintf(stderr, "( VECTOR _)\n"); 
+    //fprintf(stderr, "loop.cc calling CreateDefineMacro( %s, argvec, repr)\n", (index_name + "_").c_str()); 
+    this_loop->ir->CreateDefineMacro(index_name + "_", argvec, repr);
+    
+    Relation known_(copy(IS).n_set());
+    known_.copy_names(copy(IS));
+    known_.setup_names();
+    Variable_ID index_lb = known_.get_local(lb, Input_Tuple);
+    Variable_ID index_ub = known_.get_local(ub, Input_Tuple);
+    F_And *fr = known_.add_and();
+    GEQ_Handle g = fr->add_GEQ();
+    g.update_coef(index_ub, 1);
+    g.update_coef(index_lb, -1);
+    g.update_const(-1);
+    this_loop->addKnown(known_);
+    
+    reprs3.push_back(
+                     
+                     ocg->CreateIdent(IS.set_var(outer_loop_bounds.size())->name()));
+    reprs4.push_back(
+                     
+                     ocgs->CreateIdent(IS.set_var(outer_loop_bounds.size())->name()));
+    
+    CG_outputRepr *repr2 = ocg->CreateArrayRefExpression(index_name,
+                                                         ocg->CreatePlus(
+                                                                         ocg->CreateIdent(
+                                                                                          IS.set_var(outer_loop_bounds.size())->name()),
+                                                                         ocg->CreateInt(1)));
+    
+    //fprintf(stderr, "( VECTOR __)\n"); 
+    //fprintf(stderr, "loop.cc calling CreateDefineMacro( %s, argvec, repr)\n", (index_name + "__").c_str()); 
+    
+    this_loop->ir->CreateDefineMacro(index_name + "__", argvec, repr2);
+    
+    uninterpreted_symbols.insert(
+                                 std::pair<std::string, std::vector<CG_outputRepr *> >(
+                                                                                       index_name + "__", reprs3));
+    uninterpreted_symbols_string.insert(
+                                        std::pair<std::string, std::vector<CG_outputRepr *> >(
+                                                                                              index_name + "__", reprs4));
+  } else {
+    Free_Var_Decl *ub = new Free_Var_Decl(index_name);
+    Variable_ID csr_ub = IS.get_local(ub);
+    F_And * f_r = IS.and_with_and();
+    GEQ_Handle upper_bound = f_r->add_GEQ();
+    upper_bound.update_coef(csr_ub, 1);
+    upper_bound.update_coef(IS.set_var(outer_loop_bounds.size() + 1), -1);
+    upper_bound.update_const(-1);
+    
+    GEQ_Handle lower_bound = f_r->add_GEQ();
+    lower_bound.update_coef(IS.set_var(outer_loop_bounds.size() + 1), 1);
+    
+  }
+  
+  for (int j = 1; j <= XFORM.n_inp(); j++) {
+    omega::EQ_Handle h = f_root->add_EQ();
+    h.update_coef(XFORM.output_var(2 * j), 1);
+    h.update_coef(XFORM.input_var(j), -1);
+  }
+  
+  for (int j = 1; j <= XFORM.n_out(); j += 2) {
+    omega::EQ_Handle h = f_root->add_EQ();
+    h.update_coef(XFORM.output_var(j), 1);
+  }
+  
+  if (_DEBUG_) {
+    IS.print();
+    XFORM.print();
+    
+  }
+  
+  return std::pair<Relation, Relation>(IS, XFORM);
+  
 }
 
+std::pair<Relation, Relation> construct_reduced_IS_And_XFORM(IR_Code *ir,
+                                                             const Relation &is, const Relation &xform, const std::vector<int> loops,
+                                                             std::vector<int> &lex_order, Relation &known,
+                                                             std::map<std::string, std::vector<CG_outputRepr *> > &uninterpreted_symbols) {
+  
+  Relation IS(loops.size());
+  Relation XFORM(loops.size(), 2 * loops.size() + 1);
+  int count_ = 1;
+  std::map<int, int> pos_mapping;
+  
+  int n = is.n_set();
+  Relation is_and_known = Intersection(copy(is),
+                                       Extend_Set(copy(known), n - known.n_set()));
+  
+  for (int it = 0; it < loops.size(); it++, count_++) {
+    IS.name_set_var(count_,
+                    const_cast<Relation &>(is).set_var(loops[it])->name());
+    XFORM.name_input_var(count_,
+                         const_cast<Relation &>(xform).input_var(loops[it])->name());
+    XFORM.name_output_var(2 * count_,
+                          const_cast<Relation &>(xform).output_var((loops[it]) * 2)->name());
+    XFORM.name_output_var(2 * count_ - 1,
+                          const_cast<Relation &>(xform).output_var((loops[it]) * 2 - 1)->name());
+    pos_mapping.insert(std::pair<int, int>(count_, loops[it]));
+  }
+  
+  XFORM.name_output_var(2 * loops.size() + 1,
+                        const_cast<Relation &>(xform).output_var(is.n_set() * 2 + 1)->name());
+  
+  F_And * f_r = IS.add_and();
+  for (std::map<int, int>::iterator it = pos_mapping.begin();
+       it != pos_mapping.end(); it++)
+    IS = replace_set_var_as_another_set_var(IS, is_and_known, it->first,
+                                            it->second);
+  /*
+    for (std::map<std::string, std::vector<CG_outputRepr *> >::iterator it2 =
+    uninterpreted_symbols.begin();
+    it2 != uninterpreted_symbols.end(); it2++) {
+    std::vector<CG_outputRepr *> reprs_ = it2->second;
+    //std::vector<CG_outputRepr *> reprs_2;
+    
+    for (int k = 0; k < reprs_.size(); k++) {
+    std::vector<IR_ScalarRef *> refs = ir->FindScalarRef(reprs_[k]);
+    bool exception_found = false;
+    for (int m = 0; m < refs.size(); m++){
+    
+    if (refs[m]->name()
+    == const_cast<Relation &>(is).set_var(it->second)->name())
+    try {
+    ir->ReplaceExpression(refs[m],
+    ir->builder()->CreateIdent(
+    IS.set_var(it->first)->name()));
+    } catch (ir_error &e) {
+    
+    reprs_[k] = ir->builder()->CreateIdent(
+    IS.set_var(it->first)->name());
+    exception_found = true;
+    }
+    if(exception_found)
+    break;
+    }
+    
+    }
+    it2->second = reprs_;
+    }
+    
+    }
+  */
+  if (_DEBUG_) {
+    std::cout << "relation debug" << std::endl;
+    IS.print();
+  }
+  
+  F_And *f_root = XFORM.add_and();
+  
+  count_ = 1;
+  
+  for (int j = 1; j <= loops.size(); j++) {
+    omega::EQ_Handle h = f_root->add_EQ();
+    h.update_coef(XFORM.output_var(2 * j), 1);
+    h.update_coef(XFORM.input_var(j), -1);
+  }
+  for (int j = 0; j < loops.size(); j++, count_++) {
+    omega::EQ_Handle h = f_root->add_EQ();
+    h.update_coef(XFORM.output_var(count_ * 2 - 1), 1);
+    h.update_const(-lex_order[count_ * 2 - 2]);
+  }
+  
+  omega::EQ_Handle h = f_root->add_EQ();
+  h.update_coef(XFORM.output_var((loops.size()) * 2 + 1), 1);
+  h.update_const(-lex_order[xform.n_out() - 1]);
+  
+  if (_DEBUG_) {
+    std::cout << "relation debug" << std::endl;
+    IS.print();
+    XFORM.print();
+  }
+  
+  return std::pair<Relation, Relation>(IS, XFORM);
+  
+}
+
+std::set<std::string> inspect_repr_for_scalars(IR_Code *ir,
+                                               CG_outputRepr * repr, std::set<std::string> ignore) {
+  
+  std::vector<IR_ScalarRef *> refs = ir->FindScalarRef(repr);
+  std::set<std::string> loop_vars;
+  
+  for (int i = 0; i < refs.size(); i++)
+    if (ignore.find(refs[i]->name()) == ignore.end())
+      loop_vars.insert(refs[i]->name());
+  
+  return loop_vars;
+  
+}
+
+std::set<std::string> inspect_loop_bounds(IR_Code *ir, const Relation &R,
+                                          int pos,
+                                          std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols) {
+  
+  if (!R.is_set())
+    throw loop_error("Input R has to be a set not a relation!");
+  
+  std::set<std::string> vars;
+  
+  std::vector<CG_outputRepr *> refs;
+  Variable_ID v = const_cast<Relation &>(R).set_var(pos);
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (GEQ_Iterator gi = (*di)->GEQs(); gi; gi++) {
+      if ((*gi).get_coef(v) != 0 && (*gi).is_const_except_for_global(v)) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+            
+          case Global_Var: {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() > 0) {
+              
+              std::string s = g->base_name();
+              std::copy(
+                        uninterpreted_symbols.find(s)->second.begin(),
+                        uninterpreted_symbols.find(s)->second.end(),
+                        back_inserter(refs));
+              
+            }
+            
+            break;
+          }
+          default:
+            break;
+          }
+        }
+        
+      }
+    }
+  }
+  
+  for (int i = 0; i < refs.size(); i++) {
+    std::vector<IR_ScalarRef *> refs_ = ir->FindScalarRef(refs[i]);
+    
+    for (int j = 0; j < refs_.size(); j++)
+      vars.insert(refs_[j]->name());
+    
+  }
+  return vars;
+}
+
+CG_outputRepr * create_counting_loop_body(IR_Code *ir, const Relation &R,
+                                          int pos, CG_outputRepr * count,
+                                          std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols) {
+  
+  if (!R.is_set())
+    throw loop_error("Input R has to be a set not a relation!");
+  
+  CG_outputRepr *ub, *lb;
+  ub = NULL;
+  lb = NULL;
+  std::vector<CG_outputRepr *> refs;
+  Variable_ID v = const_cast<Relation &>(R).set_var(pos);
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (GEQ_Iterator gi = (*di)->GEQs(); gi; gi++) {
+      if ((*gi).get_coef(v) != 0 && (*gi).is_const_except_for_global(v)) {
+        bool same_ge_1 = false;
+        bool same_ge_2 = false;
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+            
+          case Global_Var: {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() > 0) {
+              
+              std::string s = g->base_name();
+              
+              if ((*gi).get_coef(v) > 0) {
+                if (ub != NULL)
+                  throw ir_error(
+                                 "bound expression too complex!");
+                
+                ub = ir->builder()->CreateInvoke(s,
+                                                 uninterpreted_symbols.find(s)->second);
+                //ub = ir->builder()->CreateMinus(ub->clone(), ir->builder()->CreateInt(-(*gi).get_const()));
+                same_ge_1 = true;
+                
+              } else {
+                if (lb != NULL)
+                  throw ir_error(
+                                 "bound expression too complex!");
+                lb = ir->builder()->CreateInvoke(s,
+                                                 uninterpreted_symbols.find(s)->second);
+                same_ge_2 = true;
+                
+              }
+            }
+            
+            break;
+          }
+          default:
+            break;
+          }
+        }
+        
+        if (same_ge_1 && same_ge_2)
+          lb = ir->builder()->CreatePlus(lb->clone(),
+                                         ir->builder()->CreateInt(-(*gi).get_const()));
+        else if (same_ge_1)
+          ub = ir->builder()->CreatePlus(ub->clone(),
+                                         ir->builder()->CreateInt(-(*gi).get_const()));
+        else if (same_ge_2)
+          lb = ir->builder()->CreatePlus(lb->clone(),
+                                         ir->builder()->CreateInt(-(*gi).get_const()));
+      }
+    }
+    
+  }
+  
+  return ir->builder()->CreatePlusAssignment(0, count,
+                                             ir->builder()->CreatePlus(
+                                                                       ir->builder()->CreateMinus(ub->clone(), lb->clone()),
+                                                                       ir->builder()->CreateInt(1)));
+}
+
+
+
+std::map<std::string, std::vector<std::string> > recurse_on_exp_for_arrays(
+                                                                           IR_Code * ir, CG_outputRepr * exp) {
+  
+  std::map<std::string, std::vector<std::string> > arr_index_to_ref;
+  switch (ir->QueryExpOperation(exp)) {
+    
+  case IR_OP_ARRAY_VARIABLE: {
+    IR_ArrayRef *ref = dynamic_cast<IR_ArrayRef *>(ir->Repr2Ref(exp));
+    IR_PointerArrayRef *ref_ =
+      dynamic_cast<IR_PointerArrayRef *>(ir->Repr2Ref(exp));
+    if (ref == NULL && ref_ == NULL)
+      throw loop_error("Array symbol unidentifiable!");
+    
+    if (ref != NULL) {
+      std::vector<std::string> s0;
+      
+      for (int i = 0; i < ref->n_dim(); i++) {
+        CG_outputRepr * index = ref->index(i);
+        std::map<std::string, std::vector<std::string> > a0 =
+          recurse_on_exp_for_arrays(ir, index);
+        std::vector<std::string> s;
+        for (std::map<std::string, std::vector<std::string> >::iterator j =
+               a0.begin(); j != a0.end(); j++) {
+          if (j->second.size() != 1 && (j->second)[0] != "")
+            throw loop_error(
+                             "indirect array references not allowed in guard!");
+          s.push_back(j->first);
+        }
+        std::copy(s.begin(), s.end(), back_inserter(s0));
+      }
+      arr_index_to_ref.insert(
+                              std::pair<std::string, std::vector<std::string> >(
+                                                                                ref->name(), s0));
+    } else {
+      std::vector<std::string> s0;
+      for (int i = 0; i < ref_->n_dim(); i++) {
+        CG_outputRepr * index = ref_->index(i);
+        std::map<std::string, std::vector<std::string> > a0 =
+          recurse_on_exp_for_arrays(ir, index);
+        std::vector<std::string> s;
+        for (std::map<std::string, std::vector<std::string> >::iterator j =
+               a0.begin(); j != a0.end(); j++) {
+          if (j->second.size() != 1 && (j->second)[0] != "")
+            throw loop_error(
+                             "indirect array references not allowed in guard!");
+          s.push_back(j->first);
+        }
+        std::copy(s.begin(), s.end(), back_inserter(s0));
+      }
+      arr_index_to_ref.insert(
+                              std::pair<std::string, std::vector<std::string> >(
+                                                                                ref_->name(), s0));
+    }
+    break;
+  }
+  case IR_OP_PLUS:
+  case IR_OP_MINUS:
+  case IR_OP_MULTIPLY:
+  case IR_OP_DIVIDE: {
+    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(exp);
+    std::map<std::string, std::vector<std::string> > a0 =
+      recurse_on_exp_for_arrays(ir, v[0]);
+    std::map<std::string, std::vector<std::string> > a1 =
+      recurse_on_exp_for_arrays(ir, v[1]);
+    arr_index_to_ref.insert(a0.begin(), a0.end());
+    arr_index_to_ref.insert(a1.begin(), a1.end());
+    break;
+    
+  }
+  case IR_OP_POSITIVE:
+  case IR_OP_NEGATIVE: {
+    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(exp);
+    std::map<std::string, std::vector<std::string> > a0 =
+      recurse_on_exp_for_arrays(ir, v[0]);
+    
+    arr_index_to_ref.insert(a0.begin(), a0.end());
+    break;
+    
+  }
+  case IR_OP_VARIABLE: {
+    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(exp);
+    IR_ScalarRef *ref = static_cast<IR_ScalarRef *>(ir->Repr2Ref(v[0]));
+    
+    std::string s = ref->name();
+    std::vector<std::string> to_insert;
+    to_insert.push_back("");
+    arr_index_to_ref.insert(
+                            std::pair<std::string, std::vector<std::string> >(s,
+                                                                              to_insert));
+    break;
+  }
+  case IR_OP_CONSTANT:
+    break;
+    
+  default: {
+    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(exp);
+    
+    for (int i = 0; i < v.size(); i++) {
+      std::map<std::string, std::vector<std::string> > a0 =
+        recurse_on_exp_for_arrays(ir, v[i]);
+      
+      arr_index_to_ref.insert(a0.begin(), a0.end());
+    }
+    
+    break;
+  }
+  }
+  return arr_index_to_ref;
+}
+
+
+
+std::vector<CG_outputRepr *> find_guards(IR_Code *ir, IR_Control *code) {
+  fprintf(stderr, "find_guards()\n"); 
+  std::vector<CG_outputRepr *> guards;
+  switch (code->type()) {
+  case IR_CONTROL_IF: {
+    fprintf(stderr, "find_guards() it's an if\n"); 
+    CG_outputRepr *cond = dynamic_cast<IR_If*>(code)->condition();
+    
+    std::vector<CG_outputRepr *> then_body;
+    std::vector<CG_outputRepr *> else_body;
+    IR_Block *ORTB = dynamic_cast<IR_If*>(code)->then_body(); 
+    if (ORTB != NULL) {
+      fprintf(stderr, "recursing on then\n"); 
+      then_body = find_guards(ir, ORTB); 
+      //dynamic_cast<IR_If*>(code)->then_body());
+    }
+    if (dynamic_cast<IR_If*>(code)->else_body() != NULL) {
+      fprintf(stderr, "recursing on then\n"); 
+      else_body = find_guards(ir,
+                              dynamic_cast<IR_If*>(code)->else_body());
+    }
+    
+    guards.push_back(cond);
+    if (then_body.size() > 0)
+      std::copy(then_body.begin(), then_body.end(),
+                back_inserter(guards));
+    if (else_body.size() > 0)
+      std::copy(else_body.begin(), else_body.end(),
+                back_inserter(guards));
+    break;
+  }
+  case IR_CONTROL_BLOCK: {
+    fprintf(stderr, "find_guards() it's a control block\n"); 
+    IR_Block*  IRCB = dynamic_cast<IR_Block*>(code);
+    fprintf(stderr, "find_guards() calling ir->FindOneLevelControlStructure(IRCB);\n"); 
+    std::vector<IR_Control *> stmts = ir->FindOneLevelControlStructure(IRCB); 
+
+    for (int i = 0; i < stmts.size(); i++) {
+      std::vector<CG_outputRepr *> stmt_repr = find_guards(ir, stmts[i]);
+      std::copy(stmt_repr.begin(), stmt_repr.end(),
+                back_inserter(guards));
+    }
+    break;
+  }
+  case IR_CONTROL_LOOP: {
+    fprintf(stderr, "find_guards() it's a control loop\n"); 
+    std::vector<CG_outputRepr *> body = find_guards(ir,
+                                                    dynamic_cast<IR_Loop*>(code)->body());
+    if (body.size() > 0)
+      std::copy(body.begin(), body.end(), back_inserter(guards));
+    break;
+  } // loop 
+  } // switch 
+  return guards;
+}
+
+bool sort_helper(std::pair<std::string, std::vector<std::string> > i,
+                 std::pair<std::string, std::vector<std::string> > j) {
+  int c1 = 0;
+  int c2 = 0;
+  for (int k = 0; k < i.second.size(); k++)
+    if (i.second[k] != "")
+      c1++;
+  
+  for (int k = 0; k < j.second.size(); k++)
+    if (j.second[k] != "")
+      c2++;
+  return (c1 < c2);
+  
+}
+
+bool sort_helper_2(std::pair<int, int> i, std::pair<int, int> j) {
+  
+  return (i.second < j.second);
+  
+}
+
+std::vector<std::string> construct_iteration_order(
+                                                   std::map<std::string, std::vector<std::string> > & input) {
+  std::vector<std::string> arrays;
+  std::vector<std::string> scalars;
+  std::vector<std::pair<std::string, std::vector<std::string> > > input_aid;
+  
+  for (std::map<std::string, std::vector<std::string> >::iterator j =
+         input.begin(); j != input.end(); j++)
+    input_aid.push_back(
+                        std::pair<std::string, std::vector<std::string> >(j->first,
+                                                                          j->second));
+  
+  std::sort(input_aid.begin(), input_aid.end(), sort_helper);
+  
+  for (int j = 0; j < input_aid[input_aid.size() - 1].second.size(); j++)
+    if (input_aid[input_aid.size() - 1].second[j] != "") {
+      arrays.push_back(input_aid[input_aid.size() - 1].second[j]);
+      
+    }
+  
+  if (arrays.size() > 0) {
+    for (int i = input_aid.size() - 2; i >= 0; i--) {
+      
+      int max_count = 0;
+      for (int j = 0; j < input_aid[i].second.size(); j++)
+        if (input_aid[i].second[j] != "") {
+          max_count++;
+        }
+      if (max_count > 0) {
+        for (int j = 0; j < max_count; j++) {
+          std::string s = input_aid[i].second[j];
+          bool found = false;
+          for (int k = 0; k < max_count; k++)
+            if (s == arrays[k])
+              found = true;
+          if (!found)
+            throw loop_error("guard condition not solvable");
+        }
+      } else {
+        bool found = false;
+        for (int k = 0; k < arrays.size(); k++)
+          if (arrays[k] == input_aid[i].first)
+            found = true;
+        if (!found)
+          arrays.push_back(input_aid[i].first);
+      }
+    }
+  } else {
+    
+    for (int i = input_aid.size() - 1; i >= 0; i--) {
+      arrays.push_back(input_aid[i].first);
+    }
+  }
+  return arrays;
+}
+
+
+
diff --git a/src/loop_basic.cc b/src/loop_basic.cc
index cf72c97..a058598 100644
--- a/src/loop_basic.cc
+++ b/src/loop_basic.cc
@@ -11,6 +11,8 @@
 #include "omegatools.hh"
 #include <string.h>
 
+#include <code_gen/CG_utils.h>
+
 using namespace omega;
 
 void Loop::permute(const std::vector<int> &pi) {
@@ -26,6 +28,7 @@ void Loop::original() {
   for (int i = 0; i < stmt.size(); i++)
     active.insert(i);
   setLexicalOrder(0, active);
+  //apply_xform();
 }
 void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
   // check for sanity of parameters
@@ -35,7 +38,7 @@ void Loop::permute(int stmt_num, int level, const std::vector<int> &pi) {
       "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("invalid loop level " + to_string(level));
+    throw std::invalid_argument("3invalid loop level " + to_string(level));
   else if (level == 0) {
     for (int i = 0; i < stmt.size(); i++)
       active.insert(i);
@@ -436,8 +439,7 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
           break;
         case LoopLevelTile: {
           new_loop_level[j - 1].type = LoopLevelTile;
-          int ref_level = stmt[*i].loop_level[reverse_pi[j - level]
-                                              - 1].payload;
+          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];
@@ -485,12 +487,18 @@ void Loop::permute(const std::set<int> &active, const std::vector<int> &pi) {
   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));
+}
+
+
 std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
   // check for sanity of parameters
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument("invalid statement " + to_string(stmt_num));
   if (level <= 0 || level > stmt[stmt_num].loop_level.size())
-    throw std::invalid_argument("invalid loop level " + to_string(level));
+    throw std::invalid_argument("4invalid loop level " + to_string(level));
   
   std::set<int> result;
   int dim = 2 * level - 1;
@@ -784,8 +792,17 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
       
       stmt[*i].IS = part1;
       
-      if (Intersection(copy(part2),
-                       Extend_Set(copy(this->known), n - this->known.n_set())).is_upper_bound_satisfiable()) {
+      int n1 = part2.n_set();
+      int m = this->known.n_set();
+      Relation test;
+      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();
         new_stmt.IS = part2;
@@ -793,14 +810,23 @@ std::set<int> Loop::split(int stmt_num, int level, const Relation &cond) {
         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()); 
         stmt.push_back(new_stmt);
+
+        uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
+        uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[stmt_num]);
         dep.insert();
         what_stmt_num[*i] = stmt.size() - 1;
         if (*i == stmt_num)
@@ -898,7 +924,7 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
         "invalid statement number " + to_string(*i));
     if (level < 1 || level > stmt[*i].loop_level.size())
       throw std::invalid_argument(
-        "invalid 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");
@@ -952,76 +978,56 @@ void Loop::skew(const std::set<int> &stmt_nums, int level,
                 int cur_dep_dim = get_dep_dim_of(*i, kk + 1);
                 if (skew_amount[kk] > 0) {
                   if (lb != -posInfinity
-                      && stmt[*i].loop_level[kk].type
-                      == LoopLevelOriginal
-                      && dv.lbounds[cur_dep_dim]
-                      != -posInfinity)
-                    lb += skew_amount[kk]
-                      * dv.lbounds[cur_dep_dim];
+                      && stmt[*i].loop_level[kk].type == LoopLevelOriginal
+                      && dv.lbounds[cur_dep_dim] != -posInfinity)
+                    lb += skew_amount[kk] * dv.lbounds[cur_dep_dim];
                   else {
                     if (cur_dep_dim != -1
-                        && !(dv.lbounds[cur_dep_dim]
-                             == 0
-                             && dv.ubounds[cur_dep_dim]
-                             == 0))
+                        && !(dv.lbounds[cur_dep_dim] == 0
+                             && dv.ubounds[cur_dep_dim]== 0))
                       lb = -posInfinity;
                   }
                   if (ub != posInfinity
-                      && stmt[*i].loop_level[kk].type
-                      == LoopLevelOriginal
-                      && dv.ubounds[cur_dep_dim]
-                      != posInfinity)
-                    ub += skew_amount[kk]
-                      * dv.ubounds[cur_dep_dim];
+                      && stmt[*i].loop_level[kk].type == LoopLevelOriginal
+                      && dv.ubounds[cur_dep_dim] != posInfinity)
+                    ub += skew_amount[kk] * dv.ubounds[cur_dep_dim];
                   else {
                     if (cur_dep_dim != -1
-                        && !(dv.lbounds[cur_dep_dim]
-                             == 0
-                             && dv.ubounds[cur_dep_dim]
-                             == 0))
+                        && !(dv.lbounds[cur_dep_dim] == 0
+                             && dv.ubounds[cur_dep_dim] == 0))
                       ub = posInfinity;
                   }
                 } else if (skew_amount[kk] < 0) {
                   if (lb != -posInfinity
-                      && stmt[*i].loop_level[kk].type
-                      == LoopLevelOriginal
-                      && dv.ubounds[cur_dep_dim]
-                      != posInfinity)
-                    lb += skew_amount[kk]
-                      * dv.ubounds[cur_dep_dim];
+                      && stmt[*i].loop_level[kk].type == LoopLevelOriginal
+                      && dv.ubounds[cur_dep_dim] != posInfinity)
+                    lb += skew_amount[kk] * dv.ubounds[cur_dep_dim];
                   else {
                     if (cur_dep_dim != -1
-                        && !(dv.lbounds[cur_dep_dim]
-                             == 0
-                             && dv.ubounds[cur_dep_dim]
-                             == 0))
+                        && !(dv.lbounds[cur_dep_dim] == 0
+                             && dv.ubounds[cur_dep_dim] == 0))
                       lb = -posInfinity;
                   }
                   if (ub != posInfinity
-                      && stmt[*i].loop_level[kk].type
-                      == LoopLevelOriginal
-                      && dv.lbounds[cur_dep_dim]
-                      != -posInfinity)
-                    ub += skew_amount[kk]
-                      * dv.lbounds[cur_dep_dim];
+                      && stmt[*i].loop_level[kk].type == LoopLevelOriginal
+                      && dv.lbounds[cur_dep_dim] != -posInfinity)
+                    ub += skew_amount[kk] * dv.lbounds[cur_dep_dim];
                   else {
                     if (cur_dep_dim != -1
-                        && !(dv.lbounds[cur_dep_dim]
-                             == 0
-                             && dv.ubounds[cur_dep_dim]
-                             == 0))
+                        && !(dv.lbounds[cur_dep_dim] == 0
+                             && dv.ubounds[cur_dep_dim] == 0))
                       ub = posInfinity;
                   }
                 }
               }
               dv.lbounds[dep_dim] = lb;
               dv.ubounds[dep_dim] = ub;
-              if ((dv.isCarried(dep_dim)
-                   && dv.hasPositive(dep_dim)) && dv.quasi)
+              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)
+              if ((dv.isCarried(dep_dim) && dv.hasNegative(dep_dim)) 
+                  && !dv.quasi)
                 throw loop_error(
                   "loop error: Skewing is illegal, dependence violation!");
               dv.lbounds[dep_dim] = lb;
@@ -1085,7 +1091,7 @@ void Loop::shift(const std::set<int> &stmt_nums, int level, int shift_amount) {
         "invalid statement number " + to_string(*i));
     if (level < 1 || level > stmt[*i].loop_level.size())
       throw std::invalid_argument(
-        "invalid loop level " + to_string(level));
+        "6invalid loop level " + to_string(level));
   }
   
   // do nothing
@@ -1185,16 +1191,25 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
   // check for sanity of parameters
   std::vector<int> ref_lex;
   int ref_stmt_num;
+  apply_xform(); 
   for (std::set<int>::const_iterator i = stmt_nums.begin();
        i != stmt_nums.end(); i++) {
-    if (*i < 0 || *i >= stmt.size())
+    if (*i < 0 || *i >= stmt.size()) {
+      fprintf(stderr, "statement number %d   should be in [0, %d)\n", *i, stmt.size()); 
       throw std::invalid_argument(
-        "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\n", stmt[*i].loop_level.size());
       throw std::invalid_argument(
-        "invalid loop level " + to_string(level));
+        "FUSE invalid loop level " + to_string(level));
+    }
     if (ref_lex.size() == 0) {
       ref_lex = getLexicalOrder(*i);
       ref_stmt_num = *i;
@@ -1258,14 +1273,66 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
   
   std::vector<std::set<int> > s = sort_by_same_loops(same_loop, level);
   
-  std::set<int> s1;
-  std::set<int> s2;
-  std::set<int> s4;
-  std::vector<std::set<int> > s3;
+  std::vector<bool> s2;
+
+  for (int i = 0; i < s.size(); i++) {
+    s2.push_back(false);
+  }
+
   for (std::set<int>::iterator kk = stmt_nums.begin(); kk != stmt_nums.end();
        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");
+    
+  }
+  
+  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++) {
+      assign_const(stmt[*it].xform, 2 * level - 2, order);
+    }
+    order++;
+  }
+
+
+  //plan for selective typed fusion
+  
+  /*
+    1. sort the lex values of the statements
+    2. construct induced graph on sorted statements
+    3. pick a node from the graph, check if it is before/after from the candidate set for fusion
+    equal-> set the max fused node of this node to be the start/target node for fusion
+    before -> augment and continue
+    
+    4. once target node identified and is on work queue update successors and other nodes to start node
+    5. augment and continue
+    6. if all candidate nodes dont end up in start node throw error
+    7. Get nodes and update lexical values
+    
+  */
+
+  /* for (std::set<int>::iterator kk = stmt_nums.begin(); kk != stmt_nums.end();
+       kk++)
+    for (int i = 0; i < s.size(); i++)
+      if (s[i].find(*kk) != s[i].end()) {
         s1.insert(s[i].begin(), s[i].end());
         s2.insert(i);
       }
@@ -1282,10 +1349,12 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
     s5.push_back(s4);
     
     //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(s3, dep,
                                                                     dep_dim);
-    
+    std::cout<< g;
     s = typed_fusion(g);
   } catch (const loop_error &e) {
     
@@ -1346,7 +1415,7 @@ void Loop::fuse(const std::set<int> &stmt_nums, int level) {
     
   } else
     throw loop_error("Typed Fusion Error");
-  
+  */
 }
 
 
@@ -1354,7 +1423,9 @@ 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;
-  
+  fprintf(stderr, "Loop::distribute()\n");
+
+
   // invalidate saved codegen computation
   delete last_compute_cgr_;
   last_compute_cgr_ = NULL;
@@ -1369,11 +1440,12 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
     if (*i < 0 || *i >= stmt.size())
       throw std::invalid_argument(
         "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(
-        "invalid loop level " + to_string(level));
+        "8invalid loop level " + to_string(level));
     if (ref_lex.size() == 0) {
       ref_lex = getLexicalOrder(*i);
       ref_stmt_num = *i;
@@ -1386,6 +1458,7 @@ void Loop::distribute(const std::set<int> &stmt_nums, int level) {
             + to_string(level) + " subloop");
     }
   }
+
   // find SCC in the to-be-distributed loop
   int dep_dim = get_dep_dim_of(ref_stmt_num, level);
   std::set<int> same_loop = getStatements(ref_lex, dim - 1);
@@ -1491,6 +1564,276 @@ 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;
+  for (int i = 0; i < arr_refs.size(); i++)
+    if (!ir->parent_is_array(arr_refs[i])) {
+      int j;
+      for (j = 0; j < to_return.size(); j++)
+        if (*to_return[j] == *arr_refs[i])
+          break;
+      if (j == to_return.size())
+        to_return.push_back(arr_refs[i]);
+    }
+  return to_return;
+}
+
+
+
+
+
+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::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");
+    
+    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]));
+      per_index.push_back(ref->name());
+      int j;
+      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()) { 
+        to_return.push_back(per_index);
+        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){
+  
+  std::vector<CG_outputRepr *> to_return;
+  
+  for(int i =0; i < indices.size(); i++)
+  ir->CreateVariableDeclaration(indices[i][0]);
+  return to_return;
+  }
+  
+  
+  CG_outputRepr* constructInspectorFunction(IR_Code* ir, std::vector<std::vector<std::string> >  &indices){
+  
+  CG_outputRepr *to_return;
+  
+  
+  
+  return to_return;
+  }
+  
+*/
+
+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);
+      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);
+      
+      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 *class_def) {
+  
+  fprintf(stderr, "generatePointerAssignments()\n");
+  CG_outputRepr *list = NULL;
+
+  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()); 
+    
+    // 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));
+  
+  if (loop_level <= 0)
+    throw std::invalid_argument(
+      "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));
+  
+  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,
+                                                                  bound.set_var(loop_level));
+  if (result.second == NULL)
+    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))));
+  
+  if (stride != 1)
+    throw loop_error(
+      "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++)
+      if (j != 2 * loop_level) {
+        EQ_Handle h = f_root->add_EQ();
+        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();
+        Variable_ID v;
+        if (g->arity() == 0)
+          v = stmt[stmt_num].xform.get_local(g);
+        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!");
+  
+}
+
diff --git a/src/loop_datacopy.cc b/src/loop_datacopy.cc
index 1ccd444..12d74fd 100644
--- a/src/loop_datacopy.cc
+++ b/src/loop_datacopy.cc
@@ -21,8 +21,15 @@
 
 using namespace omega;
 
+//
+// data copy function by referring arrays by numbers.
+// e.g. A[i] = A[i-1] + B[i]
+//      parameter array_ref_num=[0,2] means to copy data touched by A[i-1] and A[i]
+//
 bool Loop::datacopy(const std::vector<std::pair<int, std::vector<int> > > &array_ref_nums, int level,
                     bool allow_extra_read, int fastest_changing_dimension, int padding_stride, int padding_alignment, int memory_type) {
+  //fprintf(stderr, "Loop::datacopy()\n"); 
+
   // check for sanity of parameters
   std::set<int> same_loop;
   for (int i = 0; i < array_ref_nums.size(); i++) {
@@ -67,11 +74,22 @@ bool Loop::datacopy(const std::vector<std::pair<int, std::vector<int> > > &array
     throw std::invalid_argument("found no array references to copy");
   
   // do the copy
-  return datacopy_privatized(selected_refs, level, std::vector<int>(), allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  bool whatever = datacopy_privatized(selected_refs, level, std::vector<int>(), allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  return whatever;
 }
 
+//
+// data copy function by referring arrays by name.
+// e.g. A[i] = A[i-1] + B[i]
+//      parameter array_name=A means to copy data touched by A[i-1] and A[i]
+//
 bool Loop::datacopy(int stmt_num, int level, const std::string &array_name,
                     bool allow_extra_read, int fastest_changing_dimension, int padding_stride, int padding_alignment, int memory_type) {
+
+  fflush(stdout); 
+  //fprintf(stderr, "Loop::datacopy2()\n"); 
+  //fprintf(stderr, "array name %s   stmt num %d\n", array_name.c_str(), stmt_num);
+
   // check for sanity of parameters
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument("invalid statement number " + to_string(stmt_num));
@@ -95,16 +113,38 @@ bool Loop::datacopy(int stmt_num, int level, const std::string &array_name,
     if (t.size() != 0)
       selected_refs.push_back(std::make_pair(*i, t)); 
   }
+
+  //fprintf(stderr, "selected refs:\n"); 
+  //for (int i=0; i<selected_refs.size(); i++) { 
+  //  //fprintf(stderr, "%d  0x%x  ", selected_refs[i].first, selected_refs[i].second[0]); 
+  //  selected_refs[i].second[0]->Dump(); printf("\n"); fflush(stdout); 
+  //} 
+
   if (selected_refs.size() == 0)
     throw std::invalid_argument("found no array references with name " + to_string(array_name) + " to copy");
   
+  IR_ArrayRef *AR = selected_refs[0].second[0];
+  //IR_roseArrayRef *RAR = (IR_roseArrayRef *)AR; 
+  //fprintf(stderr, "before datacopy_privatized,   ");
+  //AR->Dump();
+  
   // do the copy
-  return datacopy_privatized(selected_refs, level, std::vector<int>(), allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  //fprintf(stderr, "\nLoop::datacopy2 calling privatized\n"); 
+
+  bool whatever =  datacopy_privatized(selected_refs, level, std::vector<int>(), allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+
+  //AR = selected_refs[0].second[0];
+  //fprintf(stderr, "after datacopy_privatized,   ");
+  //AR->Dump();
+  
+  return whatever;
 }
 
 
 bool Loop::datacopy_privatized(int stmt_num, int level, const std::string &array_name, const std::vector<int> &privatized_levels,
                                bool allow_extra_read, int fastest_changing_dimension, int padding_stride, int padding_alignment, int memory_type) {
+  //fprintf(stderr, "Loop::datacopy_privatized()\n"); 
+
   // check for sanity of parameters
   if (stmt_num < 0 || stmt_num >= stmt.size())
     throw std::invalid_argument("invalid statement number " + to_string(stmt_num));
@@ -131,11 +171,14 @@ bool Loop::datacopy_privatized(int stmt_num, int level, const std::string &array
     throw std::invalid_argument("found no array references with name " + to_string(array_name) + " to copy");
   
   // do the copy
-  return datacopy_privatized(selected_refs, level, privatized_levels, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  bool whatever = datacopy_privatized(selected_refs, level, privatized_levels, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  return whatever;
 }
 
 
 bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<int> > > &array_ref_nums, int level, const std::vector<int> &privatized_levels, bool allow_extra_read, int fastest_changing_dimension, int padding_stride, int padding_alignment, int memory_type) {
+  //fprintf(stderr, "Loop::datacopy_privatized2()\n"); 
+
   // check for sanity of parameters
   std::set<int> same_loop;
   for (int i = 0; i < array_ref_nums.size(); i++) {
@@ -180,13 +223,28 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<int>
     throw std::invalid_argument("found no array references to copy");
   
   // do the copy
-  return datacopy_privatized(selected_refs, level, privatized_levels, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  bool whatever = datacopy_privatized(selected_refs, level, privatized_levels, allow_extra_read, fastest_changing_dimension, padding_stride, padding_alignment, memory_type);
+  return whatever; 
 }
 
-bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_ArrayRef *> > > &stmt_refs, int level,
+
+//
+// Implement low level datacopy function with lots of options.
+//
+
+bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_ArrayRef *> > > &stmt_refs, 
+                               int level,
                                const std::vector<int> &privatized_levels,
-                               bool allow_extra_read, int fastest_changing_dimension,
-                               int padding_stride, int padding_alignment, int memory_type) {
+                               bool allow_extra_read, 
+                               int fastest_changing_dimension,
+                               int padding_stride, 
+                               int padding_alignment, 
+                               int memory_type) {
+
+  //fprintf(stderr, "\nLoop::datacopy_privatized3()                                        *****\n"); 
+  //fprintf(stderr, "privatized_levels.size() %d\n", privatized_levels.size()); 
+  //fprintf(stderr, "level %d\n", level); 
+
   if (stmt_refs.size() == 0)
     return true;
   
@@ -233,6 +291,12 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       }
     }
   }
+
+  //fprintf(stderr, "sym %p\n", sym);
+  if (!sym) { 
+    fprintf(stderr, "sym NULL, gonna die\n"); int *i=0; int j=i[0]; 
+  }
+
   if (!(fastest_changing_dimension >= -1 && fastest_changing_dimension < sym->n_dim()))
     throw std::invalid_argument("invalid fastest changing dimension for the array to be copied");
   if (padding_stride < 0)
@@ -255,6 +319,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     default:
       throw loop_error("unsupported array layout");
     }
+  // OK, parameter sanity checked
 
   
   // invalidate saved codegen computation
@@ -264,20 +329,58 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
   last_compute_cg_ = NULL;
   
   // build iteration spaces for all reads and for all writes separately
+  //fprintf(stderr, "dp3: before apply_xform() ARRAY REFS\n"); 
+  //for (int i = 0; i < stmt_refs.size(); i++) {
+  //  for (int j = 0; j < stmt_refs[i].second.size(); j++) {
+  //    IR_ArrayRef *AR = stmt_refs[i].second[j];
+  //    fprintf(stderr, "array ref ij %d %d   ", i, j); AR->Dump(); fprintf(stderr, "\n"); 
+  //  }
+  //} 
+  //for (int i=0; i<stmt.size(); i++) {
+  //  fprintf(stderr, "stmt %d = ", i);
+  //  stmt[i].code->dump(); 
+  //  fprintf(stderr, "\n"); 
+  //} 
+
   apply_xform(active);
+  //fprintf(stderr, "dp3: back from apply_xform() ARRAY REFS\n"); 
+
+  //for (int i = 0; i < stmt_refs.size(); i++) {
+  //  for (int j = 0; j < stmt_refs[i].second.size(); j++) {
+  //    IR_ArrayRef *AR = stmt_refs[i].second[j];
+  //    fprintf(stderr, "array ref ij %d %d   ", i, j);
+  //    AR->Dump();
+  //    fprintf(stderr, "\n"); 
+  //  }
+  //} 
+
+  //for (int i=0; i<stmt.size(); i++) {
+  //  fprintf(stderr, "stmt %d = ", i);
+  //  stmt[i].code->dump(); 
+  //  fprintf(stderr, "\n"); 
+  //} 
+
   
   bool has_write_refs = false;
   bool has_read_refs = false;
   Relation wo_copy_is = Relation::False(level-1+privatized_levels.size()+n_dim);
   Relation ro_copy_is = Relation::False(level-1+privatized_levels.size()+n_dim);
+  //fprintf(stderr, "\n\ni range: 0-%d\n", -1 + stmt_refs.size()); 
+  int stmt_num = stmt_refs[0].first;
   for (int i = 0; i < stmt_refs.size(); i++) {
     int stmt_num = stmt_refs[i].first;
     
+    //fprintf(stderr, "j range: 0-%d\n", -1 + stmt_refs[i].second.size()); 
+
     for (int j = 0; j < stmt_refs[i].second.size(); j++) {
+      //fprintf(stderr, "ij %d %d\n", i, j);
+
       Relation mapping(stmt[stmt_num].IS.n_set(), level-1+privatized_levels.size()+n_dim);
       for (int k = 1; k <= mapping.n_inp(); k++)
         mapping.name_input_var(k, stmt[stmt_num].IS.set_var(k)->name());
       mapping.setup_names();
+      mapping.print();  fflush(stdout);  //   "{[I] -> [_t1] : I = _t1 }
+
       F_And *f_root = mapping.add_and();
       for (int k = 1; k <= level-1; k++) {
         EQ_Handle h = f_root->add_EQ();
@@ -290,12 +393,28 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
         h.update_coef(mapping.output_var(level+k), -1);
       }
       for (int k = 0; k < n_dim; k++) {
+        IR_ArrayRef *AR = stmt_refs[i].second[j];
+        //fprintf(stderr, "array ref ");
+        AR->Dump();
+
         CG_outputRepr *repr = stmt_refs[i].second[j]->index(k);
-        exp2formula(ir, mapping, f_root, freevar, repr, mapping.output_var(level-1+privatized_levels.size()+k+1), 'w', IR_COND_EQ, false);
+        //fprintf(stderr, "k %d  j %d   repr  ", k, j); repr->dump(); fflush(stdout); 
+
+        exp2formula(ir, 
+                    mapping, 
+                    f_root, 
+                    freevar, 
+                    repr, 
+                    mapping.output_var(level-1+privatized_levels.size()+k+1), 
+                    'w', 
+                    IR_COND_EQ, 
+                    false,
+                    uninterpreted_symbols[stmt_num],
+                    uninterpreted_symbols_stringrepr[stmt_num]);
         repr->clear();
         delete repr;
       }
-      Relation r = Range(Restrict_Domain(mapping, Intersection(copy(stmt[stmt_num].IS), Extend_Set(copy(this->known), stmt[stmt_num].IS.n_set() - this->known.n_set()))));
+      Relation r = omega::Range(Restrict_Domain(mapping, Intersection(copy(stmt[stmt_num].IS), Extend_Set(copy(this->known), stmt[stmt_num].IS.n_set() - this->known.n_set()))));
       if (stmt_refs[i].second[j]->is_write()) {
         has_write_refs = true;
         wo_copy_is = Union(wo_copy_is, r);
@@ -312,6 +431,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     }
   }
   
+  //fprintf(stderr, "dp3: simplify\n"); 
   // simplify read and write footprint iteration space
   {
     if (allow_extra_read)
@@ -356,6 +476,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     ro_copy_is.setup_names();
   }
   
+  //fprintf(stderr, "\ndp3: build merged\n"); 
   // build merged footprint iteration space for calculating temporary array size
   Relation copy_is = SimpleHull(Union(copy(ro_copy_is), copy(wo_copy_is)), true, true);
   
@@ -368,37 +489,48 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
   Relation reduced_copy_is = copy(copy_is);
   
   for (int i = 0; i < n_dim; i++) {
+    //fprintf(stderr, "i %d/%d\n", i, n_dim); 
     if (i != 0)
       reduced_copy_is = Project(reduced_copy_is, level-1+privatized_levels.size()+i, Set_Var);
     Relation bound = get_loop_bound(reduced_copy_is, level-1+privatized_levels.size()+i);
     
+    //fprintf(stderr, "dp3: extract stride\n"); 
     // extract stride
     std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(bound, bound.set_var(level-1+privatized_levels.size()+i+1));
     if (result.second != NULL)
       index_stride[i] = abs(result.first.get_coef(result.second))/gcd(abs(result.first.get_coef(result.second)), abs(result.first.get_coef(bound.set_var(level-1+privatized_levels.size()+i+1))));
     else
       index_stride[i] = 1;
+    //fprintf(stderr, "dp3: index_stride[%d] = %d\n", i,  index_stride[i]); 
     
-    // check if this arary index requires loop
+    // check if this array index requires loop
     Conjunct *c = bound.query_DNF()->single_conjunct();
     for (EQ_Iterator ei(c->EQs()); ei; ei++) {
+      //fprintf(stderr, "dp3: for\n"); 
       if ((*ei).has_wildcards())
         continue;
       
+      //fprintf(stderr, "dp3: no wildcards\n"); 
       int coef = (*ei).get_coef(bound.set_var(level-1+privatized_levels.size()+i+1));
       if (coef != 0) {
+        //fprintf(stderr, "coef != 0\n"); 
         int sign = 1;
         if (coef < 0) {
+          //fprintf(stderr, "coef < 0\n"); 
           coef = -coef;
           sign = -1;
         }
         
         CG_outputRepr *op = NULL;
         for (Constr_Vars_Iter ci(*ei); ci; ci++) {
+          //fprintf(stderr, "dp3: ci\n"); 
           switch ((*ci).var->kind()) {
           case Input_Var:
           {
-            if ((*ci).var != bound.set_var(level-1+privatized_levels.size()+i+1))
+            //fprintf(stderr, "dp3: Input_Var\n"); 
+            if ((*ci).var != bound.set_var(level-1+privatized_levels.size()+i+1)) {
+              //fprintf(stderr, "dp3: IF sign %d\n",(*ci).coef*sign); 
+
               if ((*ci).coef*sign == 1)
                 op = ocg->CreateMinus(op, ocg->CreateIdent((*ci).var->name()));
               else if ((*ci).coef*sign == -1)
@@ -407,10 +539,12 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
                 op = ocg->CreateMinus(op, ocg->CreateTimes(ocg->CreateInt(abs((*ci).coef)), ocg->CreateIdent((*ci).var->name())));
               else // (*ci).coef*sign < -1
                 op = ocg->CreatePlus(op, ocg->CreateTimes(ocg->CreateInt(abs((*ci).coef)), ocg->CreateIdent((*ci).var->name())));
+            }
             break;
           }
           case Global_Var:
           {
+            //fprintf(stderr, "dp3: Global_Var\n"); 
             Global_Var_ID g = (*ci).var->get_global_var();
             if ((*ci).coef*sign == 1)
               op = ocg->CreateMinus(op, ocg->CreateIdent(g->base_name()));
@@ -439,7 +573,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     if (is_index_eq[i])
       continue;
     
-    // seperate lower and upper bounds
+    //fprintf(stderr, "dp3: separate lower and upper bounds\n"); 
+    // separate lower and upper bounds
     std::vector<GEQ_Handle> lb_list, ub_list;
     std::set<Variable_ID> excluded_floor_vars;
     excluded_floor_vars.insert(bound.set_var(level-1+privatized_levels.size()+i+1));
@@ -465,19 +600,41 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     if (lb_list.size() == 0 || ub_list.size() == 0)
       throw loop_error("failed to calcuate array footprint size");
     
+    //fprintf(stderr, "dp3: build lower bound representation\n"); 
     // build lower bound representation
     std::vector<CG_outputRepr *> lb_repr_list;
     for (int j = 0; j < lb_list.size(); j++){
-      if(this->known.n_set() == 0)
-        lb_repr_list.push_back(output_lower_bound_repr(ocg, lb_list[j], bound.set_var(level-1+privatized_levels.size()+i+1), result.first, result.second, bound, Relation::True(bound.n_set()), std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0))));
-      else
-        lb_repr_list.push_back(output_lower_bound_repr(ocg, lb_list[j], bound.set_var(level-1+privatized_levels.size()+i+1), result.first, result.second, bound, this->known, std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0))));
+      if(this->known.n_set() == 0) { 
+        lb_repr_list.push_back(output_lower_bound_repr(ocg, 
+                                                       lb_list[j], 
+                                                       bound.set_var(level-1+privatized_levels.size()+i+1), 
+                                                       result.first, 
+                                                       result.second, 
+                                                       bound, 
+                                                       Relation::True(bound.n_set()), 
+                                                       std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0)),
+                                                       uninterpreted_symbols[stmt_num]));
+      }
+      else {
+        lb_repr_list.push_back(output_lower_bound_repr(ocg, 
+                                                       lb_list[j], 
+                                                       bound.set_var(level-1+privatized_levels.size()+i+1), 
+                                                       result.first, 
+                                                       result.second, 
+                                                       bound, 
+                                                       this->known, 
+                                                       std::vector<std::pair<CG_outputRepr *, int> >(bound.n_set(), std::make_pair(static_cast<CG_outputRepr *>(NULL), 0)),
+                                                       uninterpreted_symbols[stmt_num]));
+      }
     }
-    if (lb_repr_list.size() > 1)
+    if (lb_repr_list.size() > 1) { 
+      //fprintf(stderr, "loop_datacopy.cc dp3 createInvoke( max )\n"); 
       index_lb[i] = ocg->CreateInvoke("max", lb_repr_list);
+    }
     else if (lb_repr_list.size() == 1)
       index_lb[i] = lb_repr_list[0];
     
+    //fprintf(stderr, "dp3: build temporary array size representation\n"); 
     // build temporary array size representation
     {
       Relation cal(copy_is.n_set(), 1);
@@ -545,6 +702,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
         cal = Project(cal, j, Input_Var);
       cal.simplify();
       
+      //fprintf(stderr, "dp3: pad temporary array size\n"); 
       // pad temporary array size
       // TODO: for variable array size, create padding formula
       Conjunct *c = cal.query_DNF()->single_conjunct();
@@ -626,8 +784,9 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     }
   }
   
+  //fprintf(stderr, "dp3: change the temporary array index order\n"); 
   // change the temporary array index order
-  for (int i = 0; i < index_sz.size(); i++)
+  for (int i = 0; i < index_sz.size(); i++) {
     if (index_sz[i].first == fastest_changing_dimension)
       switch (sym->layout_type()) {
       case IR_ARRAY_LAYOUT_ROW_MAJOR:
@@ -639,36 +798,53 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       default:
         throw loop_error("unsupported array layout");
       }
-  
+  }
+
+  //fprintf(stderr, "dp3: declare temporary array or scalar\n"); 
   // declare temporary array or scalar
   IR_Symbol *tmp_sym;
   if (index_sz.size() == 0) {
+    //fprintf(stderr, "tmp_sym is a scalar\n"); 
     tmp_sym = ir->CreateScalarSymbol(sym, memory_type);
   }
   else {
+    //fprintf(stderr, "tmp_sym is an array\n"); 
     std::vector<CG_outputRepr *> tmp_array_size(index_sz.size());
-    for (int i = 0; i < index_sz.size(); i++)
+    for (int i = 0; i < index_sz.size(); i++) { 
       tmp_array_size[i] = index_sz[i].second->clone();
+      index_sz[i].second->dump();  // THIS PRINTF
+    }
     tmp_sym = ir->CreateArraySymbol(sym, tmp_array_size, memory_type);
   }
   
+  //fprintf(stderr, "dp3: create temporary array read initialization code\n"); 
   // create temporary array read initialization code
   CG_outputRepr *copy_code_read;
-  if (has_read_refs)
+  if (has_read_refs) { 
+    //fprintf(stderr, "has read refs\n");
     if (index_sz.size() == 0) {
-      IR_ScalarRef *tmp_scalar_ref = ir->CreateScalarRef(static_cast<IR_ScalarSymbol *>(tmp_sym));
+         //fprintf(stderr, "if\n"); 
       
+      //fprintf(stderr, "tmp sym %s\n", tmp_sym->name().c_str()); 
+      IR_ScalarRef *tmp_scalar_ref = ir->CreateScalarRef(static_cast<IR_ScalarSymbol *>(tmp_sym)); // create ref from symbol
+      // tmp_scalar_ref is incomplete 
+
       std::vector<CG_outputRepr *> rhs_index(n_dim);
-      for (int i = 0; i < index_lb.size(); i++)
+      for (int i = 0; i < index_lb.size(); i++) { 
+        //fprintf(stderr, "i %d\n", i); 
         if (is_index_eq[i])
           rhs_index[i] = index_lb[i]->clone();
         else
           rhs_index[i] = ir->builder()->CreateIdent(copy_is.set_var(level-1+privatized_levels.size()+i+1)->name());
+      }
       IR_ArrayRef *copied_array_ref = ir->CreateArrayRef(sym, rhs_index);
       
+      // IR_ScalarRef tmp_scalar_ref has no actual reference yet. It only has the variable definition. 
       copy_code_read = ir->builder()->CreateAssignment(0, tmp_scalar_ref->convert(), copied_array_ref->convert());
+      //fprintf(stderr, "if ends\n"); 
     }
     else {
+      //fprintf(stderr, "else\n"); 
       std::vector<CG_outputRepr *> lhs_index(index_sz.size());
       for (int i = 0; i < index_sz.size(); i++) {
         int cur_index_num = index_sz[i].first;
@@ -693,7 +869,9 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
         lhs_index[i] = cur_index_repr;
       }
       
+      //fprintf(stderr, "dp3: making tmp_array_ref\n"); 
       IR_ArrayRef *tmp_array_ref = ir->CreateArrayRef(static_cast<IR_ArraySymbol *>(tmp_sym), lhs_index);
+      //fprintf(stderr, "dp3: DONE making tmp_array_ref\n"); 
       
       std::vector<CG_outputRepr *> rhs_index(n_dim);
       for (int i = 0; i < index_lb.size(); i++)
@@ -703,13 +881,22 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
           rhs_index[i] = ir->builder()->CreateIdent(copy_is.set_var(level-1+privatized_levels.size()+i+1)->name());
       IR_ArrayRef *copied_array_ref = ir->CreateArrayRef(sym, rhs_index);
       
-      copy_code_read = ir->builder()->CreateAssignment(0, tmp_array_ref->convert(), copied_array_ref->convert());
+      //fprintf(stderr, "dp3: loop_datacopy.cc  copy_code_read = CreateAssignment\n"); 
+      //copy_code_read = ir->builder()->CreateAssignment(0, tmp_array_ref->convert(), copied_array_ref->convert());
+      CG_outputRepr *lhs = tmp_array_ref->convert();
+      CG_outputRepr *rhs = copied_array_ref->convert();
+      copy_code_read = ir->builder()->CreateAssignment(0, lhs, rhs); //tmp_array_ref->convert(), copied_array_ref->convert());
+      //fprintf(stderr, "dp3: loop_datacopy.cc  copy_code_read = CreateAssignment DONE\n\n"); 
     }
+  } // has read refs 
   
+  //fprintf(stderr, "dp3: create temporary array write back code\n");   
   // create temporary array write back code
   CG_outputRepr *copy_code_write;
-  if (has_write_refs)
+  if (has_write_refs) { 
+    //fprintf(stderr, "has_write_refs\n"); 
     if (index_sz.size() == 0) {
+      //fprintf(stderr, "index_sz.size() == 0\n"); 
       IR_ScalarRef *tmp_scalar_ref = ir->CreateScalarRef(static_cast<IR_ScalarSymbol *>(tmp_sym));
       
       std::vector<CG_outputRepr *> rhs_index(n_dim);
@@ -723,6 +910,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       copy_code_write = ir->builder()->CreateAssignment(0, copied_array_ref->convert(), tmp_scalar_ref->convert());
     }
     else {
+      //fprintf(stderr, "index_sz.size() NOT = 0\n"); 
+      
       std::vector<CG_outputRepr *> lhs_index(n_dim);
       for (int i = 0; i < index_lb.size(); i++)
         if (is_index_eq[i])
@@ -758,9 +947,11 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       
       copy_code_write = ir->builder()->CreateAssignment(0, copied_array_ref->convert(), tmp_array_ref->convert());
     }
+  }   // has write refs 
   
   // now we can remove those loops for array indexes that are
   // dependent on others
+  //fprintf(stderr, "dp3: now we can remove those loops\n"); 
   if (!(index_sz.size() == n_dim && (sym->layout_type() == IR_ARRAY_LAYOUT_ROW_MAJOR || n_dim <= 1))) {
     Relation mapping(level-1+privatized_levels.size()+n_dim, level-1+privatized_levels.size()+index_sz.size());
     F_And *f_root = mapping.add_and();
@@ -793,8 +984,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
         cur_index++;
       }
     
-    wo_copy_is = Range(Restrict_Domain(copy(mapping), wo_copy_is));
-    ro_copy_is = Range(Restrict_Domain(copy(mapping), ro_copy_is));
+    wo_copy_is = omega::Range(Restrict_Domain(copy(mapping), wo_copy_is));
+    ro_copy_is = omega::Range(Restrict_Domain(copy(mapping), ro_copy_is));
     for (int i = 1; i <= level-1+privatized_levels.size(); i++) {
       wo_copy_is.name_set_var(i, copy_is.set_var(i)->name());
       ro_copy_is.name_set_var(i, copy_is.set_var(i)->name());
@@ -808,6 +999,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
   }
   
   // insert read copy statement
+  //fprintf(stderr, "dp3: insert read copy statement\n"); 
+  
   int old_num_stmt = stmt.size();
   int ro_copy_stmt_num = -1;
   if (has_read_refs) {
@@ -834,8 +1027,10 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     copy_stmt_read.IS = ro_copy_is;
     copy_stmt_read.xform = copy_xform;
     copy_stmt_read.code = copy_code_read;
+    //fprintf(stderr, "dp3: copy_stmt_read.code = \n"); 
     copy_stmt_read.loop_level = std::vector<LoopLevel>(ro_copy_is.n_set());
     copy_stmt_read.ir_stmt_node = NULL;
+    copy_stmt_read.has_inspector = false;
     for (int i = 0; i < level-1; i++) {
       copy_stmt_read.loop_level[i].type = stmt[*(active.begin())].loop_level[i].type;
       if (stmt[*(active.begin())].loop_level[i].type == LoopLevelTile &&
@@ -859,12 +1054,12 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       copy_stmt_read.loop_level[level-1+i].parallel_level = stmt[*(active.begin())].loop_level[privatized_levels[i]].parallel_level;
     }
     int left_num_dim = num_dep_dim - (get_last_dep_dim_before(*(active.begin()), level) + 1);
-    for (int i = 0; i < min(left_num_dim, static_cast<int>(index_sz.size())); i++) {
+    for (int i = 0; i < std::min(left_num_dim, static_cast<int>(index_sz.size())); i++) {
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].type = LoopLevelOriginal;
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].payload = num_dep_dim-left_num_dim+i;
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].parallel_level = 0;
     }
-    for (int i = min(left_num_dim, static_cast<int>(index_sz.size())); i < index_sz.size(); i++) {
+    for (int i = std::min(left_num_dim, static_cast<int>(index_sz.size())); i < index_sz.size(); i++) {
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].type = LoopLevelUnknown;
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].payload = -1;
       copy_stmt_read.loop_level[level-1+privatized_levels.size()+i].parallel_level = 0;
@@ -872,11 +1067,17 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     
     
     shiftLexicalOrder(lex, dim-1, 1);
+
+    fprintf(stderr, "loop_datacopy.cc L1071 adding stmt %d\n", stmt.size()); 
     stmt.push_back(copy_stmt_read);
+
+    uninterpreted_symbols.push_back(uninterpreted_symbols[*(active.begin())]);
+    uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[*(active.begin())]);
     ro_copy_stmt_num = stmt.size() - 1;
     dep.insert();
   }
   
+  //fprintf(stderr, "dp3: insert write copy statement\n"); 
   // insert write copy statement
   int wo_copy_stmt_num = -1;
   if (has_write_refs) {
@@ -905,6 +1106,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     copy_stmt_write.code = copy_code_write;
     copy_stmt_write.loop_level = std::vector<LoopLevel>(wo_copy_is.n_set());
     copy_stmt_write.ir_stmt_node = NULL;
+    copy_stmt_write.has_inspector = false;
     
     for (int i = 0; i < level-1; i++) {
       copy_stmt_write.loop_level[i].type = stmt[*(active.begin())].loop_level[i].type;
@@ -929,28 +1131,35 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       copy_stmt_write.loop_level[level-1+i].parallel_level = stmt[*(active.begin())].loop_level[privatized_levels[i]].parallel_level;
     }
     int left_num_dim = num_dep_dim - (get_last_dep_dim_before(*(active.begin()), level) + 1);
-    for (int i = 0; i < min(left_num_dim, static_cast<int>(index_sz.size())); i++) {
+    for (int i = 0; i < std::min(left_num_dim, static_cast<int>(index_sz.size())); i++) {
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].type = LoopLevelOriginal;
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].payload = num_dep_dim-left_num_dim+i;
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].parallel_level = 0;
     }
-    for (int i = min(left_num_dim, static_cast<int>(index_sz.size())); i < index_sz.size(); i++) {
+    for (int i = std::min(left_num_dim, static_cast<int>(index_sz.size())); i < index_sz.size(); i++) {
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].type = LoopLevelUnknown;
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].payload = -1;
       copy_stmt_write.loop_level[level-1+privatized_levels.size()+i].parallel_level = 0;
     }
     lex[dim-1]++;
     shiftLexicalOrder(lex, dim-1, -2);
+
+    fprintf(stderr, "loop_datacopy.cc L1147 adding stmt %d\n", stmt.size()); 
     stmt.push_back(copy_stmt_write);
+
+    uninterpreted_symbols.push_back(uninterpreted_symbols[*(active.begin())]);
+    uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[*(active.begin())]);
     wo_copy_stmt_num = stmt.size() - 1;
     dep.insert();
   }
   
+  //fprintf(stderr, "replace original array accesses with temporary array accesses\n"); 
   // replace original array accesses with temporary array accesses
   for (int i =0; i < stmt_refs.size(); i++)
     for (int j = 0; j < stmt_refs[i].second.size(); j++) {
       if (index_sz.size() == 0) {
         IR_ScalarRef *tmp_scalar_ref = ir->CreateScalarRef(static_cast<IR_ScalarSymbol *>(tmp_sym));
+        //fprintf(stderr, "dp3: loop_datacopy.cc calling ReplaceExpression  i%d j%d\n", i, j); 
         ir->ReplaceExpression(stmt_refs[i].second[j], tmp_scalar_ref->convert());
       }
       else {
@@ -980,11 +1189,14 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
         }
         
         IR_ArrayRef *tmp_array_ref = ir->CreateArrayRef(static_cast<IR_ArraySymbol *>(tmp_sym), index_repr);
+        //fprintf(stderr, "loop_datacopy.cc  ir->ReplaceExpression( ... )\n");
         ir->ReplaceExpression(stmt_refs[i].second[j], tmp_array_ref->convert());
       }
     }
   
   // update dependence graph
+  //fprintf(stderr, "update dependence graph\n"); 
+
   int dep_dim = get_last_dep_dim_before(*(active.begin()), level) + 1;
   if (ro_copy_stmt_num != -1) {
     for (int i = 0; i < old_num_stmt; i++) {
@@ -1029,6 +1241,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     }
     
     // insert dependences from copy statement loop to copied statements
+    //fprintf(stderr, "insert dependences from copy statement loop to copied statements\n"); 
+
     DependenceVector dv;
     dv.type = DEP_W2R;
     dv.sym = tmp_sym->clone();
@@ -1085,6 +1299,8 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
     }
     
     // insert dependences from copied statements to write statements
+    //fprintf(stderr, "dp3: insert dependences from copied statements to write statements\n"); 
+
     DependenceVector dv;
     dv.type = DEP_W2R;
     dv.sym = tmp_sym->clone();
@@ -1133,6 +1349,7 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
       }
     }
   
+  //fprintf(stderr, "Loop::datacopy_privatized3() cleanup\n"); 
   // cleanup
   delete sym;
   delete tmp_sym;
@@ -1147,3 +1364,6 @@ bool Loop::datacopy_privatized(const std::vector<std::pair<int, std::vector<IR_A
   
   return true;
 }
+
+
+
diff --git a/src/loop_unroll.cc b/src/loop_unroll.cc
index 911d900..86ffd84 100644
--- a/src/loop_unroll.cc
+++ b/src/loop_unroll.cc
@@ -20,6 +20,7 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
                            std::vector<std::vector<std::string> > idxNames,
                            int cleanup_split_level) {
   // check for sanity of parameters
+  // check for sanity of parameters
   if (unroll_amount < 0)
     throw std::invalid_argument(
       "invalid unroll amount " + to_string(unroll_amount));
@@ -70,6 +71,16 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
             }
             dim2 = stmt[*i].loop_level[dim2].payload;
             
+            /*if (dv.isCarried(dim2)
+              && (dv.hasNegative(dim2) && !dv.quasi))
+              throw loop_error(
+              "loop error: Unrolling is illegal, dependence violation!");
+              
+              if (dv.isCarried(dim2)
+              && (dv.hasPositive(dim2) && dv.quasi))
+              throw loop_error(
+              "loop error: Unrolling is illegal, dependence violation!");
+            */
             bool safe = false;
             
             if (dv.isCarried(dim2) && dv.hasPositive(dim2)) {
@@ -78,11 +89,20 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
                   "loop error: a quasi dependence with a positive carried distance");
               if (!dv.quasi) {
                 if (dv.lbounds[dim2] != posInfinity) {
+                  //if (dv.lbounds[dim2] != negInfinity)
                   if (dv.lbounds[dim2] > unroll_amount)
                     safe = true;
                 } else
                   safe = true;
-              }
+              }/* else {
+                  if (dv.ubounds[dim2] != negInfinity) {
+                  if (dv.ubounds[dim2] != posInfinity)
+                  if ((-(dv.ubounds[dim2])) > unroll_amount)
+                  safe = true;
+                  } else
+                  safe = true;
+                  }*/
+              
               if (!safe) {
                 for (int l = level + 1; l <= (n - 1) / 2; l++) {
                   int dim3 = l - 1;
@@ -131,7 +151,7 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
         h.update_coef(mapping.output_var(j), -1);
       }
       hull = Intersection(hull,
-                          Range(Restrict_Domain(mapping, copy(stmt[*i].IS))));
+                          omega::Range(Restrict_Domain(mapping, copy(stmt[*i].IS))));
       hull.simplify(2, 4);
       
     }
@@ -288,7 +308,8 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
           overflow_table[i][j][NULL] = int_mod_hat(
             overflow_table[i][j][NULL], unroll_amount);
           
-          // Since we don't have MODULO instruction in SUIF yet (only MOD), make all coef positive in the final formula
+          // Since we don't have MODULO instruction in SUIF yet (only MOD), 
+          // make all coef positive in the final formula
           for (std::map<Variable_ID, int>::iterator k =
                  overflow_table[i][j].begin();
                k != overflow_table[i][j].end(); k++)
@@ -437,14 +458,16 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
     std::vector<CG_outputRepr *> lb_repr_list, ub_repr_list;
     for (int i = 0; i < lb_list.size(); i++) {
       lb_repr_list.push_back(
-        output_lower_bound_repr(ocg, lb_list[i],
+        output_lower_bound_repr(ocg, 
+                                lb_list[i],
                                 bound.set_var(dim + 1), result.first, result.second,
                                 bound, Relation::True(bound.n_set()),
                                 std::vector<std::pair<CG_outputRepr *, int> >(
                                   bound.n_set(),
                                   std::make_pair(
                                     static_cast<CG_outputRepr *>(NULL),
-                                    0))));
+                                    0)),
+                                uninterpreted_symbols[stmt_num]));
       GEQ_Handle h = cond_lower.and_with_GEQ(lb_list[i]);
     }
     for (int i = 0; i < ub_list.size(); i++) {
@@ -455,21 +478,28 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
                                   bound.n_set(),
                                   std::make_pair(
                                     static_cast<CG_outputRepr *>(NULL),
-                                    0))));
+                                    0)),
+                                uninterpreted_symbols[stmt_num]));
       GEQ_Handle h = cond_upper.and_with_GEQ(ub_list[i]);
       h.update_coef(cond_upper.get_local(over_free_var), -stride);
     }
     
-    CG_outputRepr *lbRepr, *ubRepr;
-    if (lb_repr_list.size() > 1)
+    CG_outputRepr *lbRepr, *ubRepr; 
+    if (lb_repr_list.size() > 1) {
+      //fprintf(stderr, "loop_unroll.cc createInvoke( max )\n"); 
       lbRepr = ocg->CreateInvoke("max", lb_repr_list);
-    else if (lb_repr_list.size() == 1)
+    }
+    else if (lb_repr_list.size() == 1) {
       lbRepr = lb_repr_list[0];
+    }
     
-    if (ub_repr_list.size() > 1)
+    if (ub_repr_list.size() > 1) {
+      //fprintf(stderr, "loop_unroll.cc createInvoke( min )\n"); 
       ubRepr = ocg->CreateInvoke("min", ub_repr_list);
-    else if (ub_repr_list.size() == 1)
+    }
+    else if (ub_repr_list.size() == 1) {
       ubRepr = ub_repr_list[0];
+    }
     
     // create overflow assignment
     CG_outputRepr *rhs = ocg->CreatePlus(ocg->CreateMinus(ubRepr, lbRepr),
@@ -503,7 +533,7 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
       h.update_coef(mapping.output_var(i), 1);
       h.update_coef(mapping.input_var(i), -1);
     }
-    Relation overflow_IS = Range(Restrict_Domain(mapping, copy(hull)));
+    Relation overflow_IS = omega::Range(Restrict_Domain(mapping, copy(hull)));
     for (int i = 1; i < cleanup_split_level; i++)
       overflow_IS.name_set_var(i, hull.set_var(i)->name());
     overflow_IS.setup_names();
@@ -548,7 +578,11 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
         stmt[stmt_num].loop_level[i].parallel_level;
     }
     
+    fprintf(stderr, "loop_unroll.cc L581 adding stmt %d\n", stmt.size()); 
     stmt.push_back(overflow_stmt);
+
+    uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
+    uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[stmt_num]);
     dep.insert();
     overflow_stmt_num = stmt.size() - 1;
     overflow[overflow_stmt_num] = over_var_list;
@@ -567,8 +601,7 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
     dv.type = DEP_W2W;
     {
       IR_ScalarSymbol *overflow_sym = NULL;
-      std::vector<IR_ScalarRef *> scalars = ir->FindScalarRef(
-        overflow_code);
+      std::vector<IR_ScalarRef *> scalars = ir->FindScalarRef(overflow_code);
       for (int i = scalars.size() - 1; i >= 0; i--)
         if (scalars[i]->is_write()) {
           overflow_sym = scalars[i]->symbol();
@@ -703,7 +736,12 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
         
         new_stmt.loop_level = stmt[*i].loop_level;
         new_stmt.ir_stmt_node = NULL;
+
+        fprintf(stderr, "loop_unroll.cc L740 adding stmt %d\n", stmt.size()); 
         stmt.push_back(new_stmt);
+
+        uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
+        uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[stmt_num]);
         dep.insert();
         what_stmt_num[*i].push_back(stmt.size() - 1);
       }
@@ -990,33 +1028,70 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
     
     Statement new_stmt;
     new_stmt.code = NULL;
-    for (int j = 1; j < unroll_amount; j++)
+    for (int j = 1; j < unroll_amount; j++) { 
       for (int i = 0; i < stmt_order.size(); i++) {
         std::vector<std::string> loop_vars;
         std::vector<CG_outputRepr *> subs;
+
+        //fprintf(stderr, "loop_unroll.cc, will replace '%s with '%s+%d' ??\n",
+        //        stmt[stmt_order[i].second].IS.set_var(level)->name().c_str(),
+        //        stmt[stmt_order[i].second].IS.set_var(level)->name().c_str(), j * stride); 
+        
         loop_vars.push_back(
           stmt[stmt_order[i].second].IS.set_var(level)->name());
         subs.push_back(
-          ocg->CreatePlus(
-            ocg->CreateIdent(
-              stmt[stmt_order[i].second].IS.set_var(
-                level)->name()),
-            ocg->CreateInt(j * stride)));
+          ocg->CreatePlus(ocg->CreateIdent(stmt[stmt_order[i].second].IS.set_var(level)->name()),
+                          ocg->CreateInt(j * stride)));  // BUG HERE
+        //fprintf(stderr, "loop_unroll.cc subs  now has %d parts\n", subs.size());
+        //for (int k=0; k< subs.size(); k++) //fprintf(stderr, "subs[%d] = 0x%x\n", k, subs[k]); 
+
+        //fprintf(stderr, "ij %d %d  ", i, j);
+        //fprintf(stderr, "old src was =\n");
+        //stmt[stmt_order[i].second].code->dump(); fflush(stdout); //fprintf(stderr, "\n"); 
+
+
+
         CG_outputRepr *code = ocg->CreateSubstitutedStmt(0,
-                                                         stmt[stmt_order[i].second].code->clone(), loop_vars,
+                                                         stmt[stmt_order[i].second].code->clone(), 
+                                                         loop_vars,
                                                          subs);
+
+        //fprintf(stderr, "old src is =\n");
+        //stmt[stmt_order[i].second].code->dump(); fflush(stdout); //fprintf(stderr, "\n"); 
+
+        //fprintf(stderr, "substituted copy is =\n"); 
+        //code->dump(); //fprintf(stderr, "\n\n"); 
+
+
         new_stmt.code = ocg->StmtListAppend(new_stmt.code, code);
+        //fprintf(stderr, "appended code =\n");
+        //new_stmt.code->dump();
+
       }
+    }
     
+
+
+    //fprintf(stderr, "new_stmt.IS = \n"); 
     new_stmt.IS = copy(stmt[stmt_num].IS);
     new_stmt.xform = copy(stmt[stmt_num].xform);
     assign_const(new_stmt.xform, 2 * max_level,
                  stmt_order[stmt_order.size() - 1].first + 1);
     new_stmt.loop_level = stmt[stmt_num].loop_level;
     new_stmt.ir_stmt_node = NULL;
+
+    new_stmt.has_inspector = false; //  ?? or from copied stmt?
+    if (stmt[stmt_num].has_inspector) fprintf(stderr, "OLD STMT HAS INSPECTOR\n");
+    else fprintf(stderr, "OLD STMT DOES NOT HAVE INSPECTOR\n");
+
+    fprintf(stderr, "loop_unroll.cc L1083 adding stmt %d\n", stmt.size()); 
     stmt.push_back(new_stmt);
+
+    uninterpreted_symbols.push_back(uninterpreted_symbols[stmt_num]);
+    uninterpreted_symbols_stringrepr.push_back(uninterpreted_symbols_stringrepr[stmt_num]);
     dep.insert();
     
+    //fprintf(stderr, "update dependence graph\n"); 
     // update dependence graph
     if (stmt[stmt_num].loop_level[level - 1].type == LoopLevelOriginal) {
       int dep_dim = stmt[stmt_num].loop_level[level - 1].payload;
@@ -1140,6 +1215,7 @@ std::set<int> Loop::unroll(int stmt_num, int level, int unroll_amount,
     }
   }
   
+  //fprintf(stderr, "                                                  loop_unroll.cc returning new_stmts\n");
   return new_stmts;
 }
 
diff --git a/src/omegatools.cc b/src/omegatools.cc
index 3aac404..0322182 100644
--- a/src/omegatools.cc
+++ b/src/omegatools.cc
@@ -14,10 +14,15 @@
 *****************************************************************************/
 
 #include <code_gen/codegen.h>
+
 #include "omegatools.hh"
 #include "ir_code.hh"
 #include "chill_error.hh"
 
+#include "chill_ast.hh"
+#include "code_gen/CG_chillRepr.h"
+#include <code_gen/CG_utils.h>
+
 using namespace omega;
 
 namespace {
@@ -41,471 +46,855 @@ std::string tmp_e() {
   return std::string("e")+to_string(counter++);
 }
 
-void exp2formula(IR_Code *ir, Relation &r, F_And *f_root, std::vector<Free_Var_Decl*> &freevars,
-                 CG_outputRepr *repr, Variable_ID lhs, char side, IR_CONDITION_TYPE rel, bool destroy) {
+
+
+//-----------------------------------------------------------------------------
+// Convert expression tree to omega relation.  "destroy" means shallow
+// deallocation of "repr", not freeing the actual code inside.
+// -----------------------------------------------------------------------------
+void exp2formula(IR_Code *ir, 
+                 Relation &r, 
+                 F_And *f_root, 
+                 std::vector<Free_Var_Decl*> &freevars,
+                 CG_outputRepr *repr, 
+                 Variable_ID lhs, 
+                 char side, 
+                 IR_CONDITION_TYPE rel, 
+                 bool destroy,
+                 std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols,
+                 std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols_stringrepr
+                 ) {
   
-  switch (ir->QueryExpOperation(repr)) {
-  case IR_OP_CONSTANT:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[0]));
-    if (!ref->is_integer())
-      throw ir_exp_error("non-integer constant coefficient");
+  fprintf(stderr, "\n*** exp2formula()\n");
+  //repr->dump();  /* printf("\n"); */fflush(stdout); 
+  fprintf(stderr, "repr  "); r.print(); printf("\n"); fflush(stdout); 
+  
+  
+  IR_OPERATION_TYPE optype = ir->QueryExpOperation(repr);
+  
+  switch (optype) {
     
-    coef_t c = ref->integer();
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_root->add_GEQ();
-      h.update_coef(lhs, 1);
-      if (rel == IR_COND_GE)
+    
+    
+    
+  case IR_OP_CONSTANT:
+    {
+      fprintf(stderr, "IR_OP_CONSTANT\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[0]));
+      if (!ref->is_integer())
+        throw ir_exp_error("non-integer constant coefficient");
+      
+      coef_t c = ref->integer();
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, 1);
+        if (rel == IR_COND_GE)
+          h.update_const(-c);
+        else
+          h.update_const(-c-1);
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, -1);
+        if (rel == IR_COND_LE)
+          h.update_const(c);
+        else
+          h.update_const(c-1);
+      }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_root->add_EQ();
+        h.update_coef(lhs, 1);
         h.update_const(-c);
+      }
       else
-        h.update_const(-c-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_root->add_GEQ();
-      h.update_coef(lhs, -1);
-      if (rel == IR_COND_LE)
-        h.update_const(c);
-      else
-        h.update_const(c-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_root->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_const(-c);
+        throw std::invalid_argument("unsupported condition type");
+      
+      delete v[0];
+      delete ref;
+      if (destroy)
+        delete repr;
+      
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
     
-    delete v[0];
-    delete ref;
-    if (destroy)
-      delete repr;
-    break;
-  }
   case IR_OP_VARIABLE:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    IR_ScalarRef *ref = static_cast<IR_ScalarRef *>(ir->Repr2Ref(v[0]));
-    
-    std::string s = ref->name();
-    Variable_ID e = find_index(r, s, side);
-    
-    if (e == NULL) { // must be free variable
-      Free_Var_Decl *t = NULL;
-      for (unsigned i = 0; i < freevars.size(); i++) {
-        std::string ss = freevars[i]->base_name();
-        if (s == ss) {
-          t = freevars[i];
-          break;
+    {
+      fprintf(stderr, "IR_OP_VARIABLE\n");
+      //fprintf(stderr, "repr  "); repr->dump(); fflush(stdout); 
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      //fprintf(stderr, "v     "); v[0]->dump(); fflush(stdout); 
+      IR_ScalarRef *ref = static_cast<IR_ScalarRef *>(ir->Repr2Ref(v[0]));
+      
+      //fprintf(stderr, "omegatools.cc calling ref->name()\n"); 
+      std::string s = ref->name();
+      Variable_ID e = find_index(r, s, side);
+      //fprintf(stderr, "s %s\n", s.c_str()); 
+      
+      
+      if (e == NULL) { // must be free variable
+        Free_Var_Decl *t = NULL;
+        for (unsigned i = 0; i < freevars.size(); i++) {
+          std::string ss = freevars[i]->base_name();
+          if (s == ss) {
+            t = freevars[i];
+            break;
+          }
+        }
+        
+        if (t == NULL) {
+          t = new Free_Var_Decl(s);
+          freevars.insert(freevars.end(), t);
         }
+        
+        e = r.get_local(t);
       }
       
-      if (t == NULL) {
-        t = new Free_Var_Decl(s);
-        freevars.insert(freevars.end(), t);
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -1);
+        if (rel == IR_COND_GT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, -1);
+        h.update_coef(e, 1);
+        if (rel == IR_COND_LT)
+          h.update_const(-1);
       }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_root->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -1);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
       
-      e = r.get_local(t);
-    }
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_root->add_GEQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, -1);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_root->add_GEQ();
-      h.update_coef(lhs, -1);
-      h.update_coef(e, 1);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
+      //  delete v[0];
+      delete ref;
+      if (destroy)
+        delete repr;
+      break;
     }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_root->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, -1);
+
+  case IR_OP_ASSIGNMENT:
+    {
+      fprintf(stderr, "IR_OP_ASSIGNMENT\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      exp2formula(ir, r, f_root, freevars, v[0], lhs, side, rel, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
     
-    //  delete v[0];
-    delete ref;
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_OP_ASSIGNMENT:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    exp2formula(ir, r, f_root, freevars, v[0], lhs, side, rel, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
   case IR_OP_PLUS:
-  {
-    F_Exists *f_exists = f_root->add_exists();
-    Variable_ID e1 = f_exists->declare(tmp_e());
-    Variable_ID e2 = f_exists->declare(tmp_e());
-    F_And *f_and = f_exists->add_and();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e1, -1);
-      h.update_coef(e2, -1);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, -1);
-      h.update_coef(e1, 1);
-      h.update_coef(e2, 1);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e1, -1);
-      h.update_coef(e2, -1);
+    {
+      fprintf(stderr, "IR_OP_PLUS\n");
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e1 = f_exists->declare(tmp_e());
+      Variable_ID e2 = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e1, -1);
+        h.update_coef(e2, -1);
+        if (rel == IR_COND_GT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, -1);
+        h.update_coef(e1, 1);
+        h.update_coef(e2, 1);
+        if (rel == IR_COND_LT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e1, -1);
+        h.update_coef(e2, -1);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      exp2formula(ir, r, f_and, freevars, v[0], e1, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      exp2formula(ir, r, f_and, freevars, v[1], e2, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
-    
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    exp2formula(ir, r, f_and, freevars, v[0], e1, side, IR_COND_EQ, true);
-    exp2formula(ir, r, f_and, freevars, v[1], e2, side, IR_COND_EQ, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
   case IR_OP_MINUS:
-  {
-    F_Exists *f_exists = f_root->add_exists();
-    Variable_ID e1 = f_exists->declare(tmp_e());
-    Variable_ID e2 = f_exists->declare(tmp_e());
-    F_And *f_and = f_exists->add_and();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e1, -1);
-      h.update_coef(e2, 1);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, -1);
-      h.update_coef(e1, 1);
-      h.update_coef(e2, -1);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e1, -1);
-      h.update_coef(e2, 1);
+    {
+      fprintf(stderr, "IR_OP_MINUS\n");
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e1 = f_exists->declare(tmp_e());
+      Variable_ID e2 = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e1, -1);
+        h.update_coef(e2, 1);
+        if (rel == IR_COND_GT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, -1);
+        h.update_coef(e1, 1);
+        h.update_coef(e2, -1);
+        if (rel == IR_COND_LT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e1, -1);
+        h.update_coef(e2, 1);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      fprintf(stderr, "IR_OP_MINUS v has %d parts\n", (int)v.size()); 
+      fprintf(stderr, "IR_OP_MINUS recursing 1\n"); 
+      exp2formula(ir, r, f_and, freevars, v[0], e1, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      
+      if (v.size() > 1) { 
+        fprintf(stderr, "IR_OP_MINUS recursing 2\n");  // dies here because it's unary minus? 
+        exp2formula(ir, r, f_and, freevars, v[1], e2, side, IR_COND_EQ, true,
+                    uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      }  
+      
+      
+      if (destroy)
+        delete repr;
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
-    
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    exp2formula(ir, r, f_and, freevars, v[0], e1, side, IR_COND_EQ, true);
-    exp2formula(ir, r, f_and, freevars, v[1], e2, side, IR_COND_EQ, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
+
+
   case IR_OP_MULTIPLY:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    
-    coef_t coef;
-    CG_outputRepr *term;
-    if (ir->QueryExpOperation(v[0]) == IR_OP_CONSTANT) {
-      IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[0]));
-      coef = ref->integer();
-      delete v[0];
-      delete ref;
-      term = v[1];
+    {    
+      fprintf(stderr, "IR_OP_MULTIPLY\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      coef_t coef;
+      CG_outputRepr *term;
+      if (ir->QueryExpOperation(v[0]) == IR_OP_CONSTANT) {
+        IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[0]));
+        coef = ref->integer();
+        delete v[0];
+        delete ref;
+        term = v[1];
+      }
+      else if (ir->QueryExpOperation(v[1]) == IR_OP_CONSTANT) {
+        IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[1]));
+        coef = ref->integer();
+        delete v[1];
+        delete ref;
+        term = v[0];
+      }
+      else
+        throw ir_exp_error("not presburger expression");
+      
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -coef);
+        if (rel == IR_COND_GT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_and->add_GEQ();
+        h.update_coef(lhs, -1);
+        h.update_coef(e, coef);
+        if (rel == IR_COND_LT)
+          h.update_const(-1);
+      }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -coef);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      exp2formula(ir, r, f_and, freevars, term, e, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      break;
     }
-    else if (ir->QueryExpOperation(v[1]) == IR_OP_CONSTANT) {
+
+  case IR_OP_DIVIDE:
+    {
+      fprintf(stderr, "IR_OP_DIVIDE\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      assert(ir->QueryExpOperation(v[1]) == IR_OP_CONSTANT);
       IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[1]));
-      coef = ref->integer();
+      coef_t coef = ref->integer();
       delete v[1];
       delete ref;
-      term = v[0];
-    }
-    else
-      throw ir_exp_error("not presburger expression");
-    
-    F_Exists *f_exists = f_root->add_exists();
-    Variable_ID e = f_exists->declare(tmp_e());
-    F_And *f_and = f_exists->add_and();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, -coef);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, -1);
-      h.update_coef(e, coef);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, -coef);
-    }
-    else
-      throw std::invalid_argument("unsupported condition type");
-    
-    exp2formula(ir, r, f_and, freevars, term, e, side, IR_COND_EQ, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_OP_DIVIDE:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    
-    assert(ir->QueryExpOperation(v[1]) == IR_OP_CONSTANT);
-    IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[1]));
-    coef_t coef = ref->integer();
-    delete v[1];
-    delete ref;
-    
-    F_Exists *f_exists = f_root->add_exists();
-    Variable_ID e = f_exists->declare(tmp_e());
-    F_And *f_and = f_exists->add_and();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, coef);
-      h.update_coef(e, -1);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, -coef);
-      h.update_coef(e, 1);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(lhs, coef);
-      h.update_coef(e, -1);
-    }
-    else
-      throw std::invalid_argument("unsupported condition type");
-    
-    exp2formula(ir, r, f_and, freevars, v[0], e, side, IR_COND_EQ, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_OP_POSITIVE:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    
-    exp2formula(ir, r, f_root, freevars, v[0], lhs, side, rel, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_OP_NEGATIVE:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    
-    F_Exists *f_exists = f_root->add_exists();
-    Variable_ID e = f_exists->declare(tmp_e());
-    F_And *f_and = f_exists->add_and();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, 1);
-      if (rel == IR_COND_GT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      GEQ_Handle h = f_and->add_GEQ();
-      h.update_coef(lhs, -1);
-      h.update_coef(e, -1);
-      if (rel == IR_COND_LT)
-        h.update_const(-1);
-    }
-    else if (rel == IR_COND_EQ) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(lhs, 1);
-      h.update_coef(e, 1);
-    }
-    else
-      throw std::invalid_argument("unsupported condition type");
-    
-    exp2formula(ir, r, f_and, freevars, v[0], e, side, IR_COND_EQ, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_OP_MIN:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
-    
-    F_Exists *f_exists = f_root->add_exists();
-    
-    if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      F_Or *f_or = f_exists->add_and()->add_or();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());
-        F_And *f_and = f_or->add_and();
+      
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
         GEQ_Handle h = f_and->add_GEQ();
-        h.update_coef(lhs, 1);
+        h.update_coef(lhs, coef);
         h.update_coef(e, -1);
         if (rel == IR_COND_GT)
           h.update_const(-1);
-        
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true);
       }
-    }
-    else if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      F_And *f_and = f_exists->add_and();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());        
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
         GEQ_Handle h = f_and->add_GEQ();
-        h.update_coef(lhs, -1);
+        h.update_coef(lhs, -coef);
         h.update_coef(e, 1);
         if (rel == IR_COND_LT)
           h.update_const(-1);
-        
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true);
       }
+      else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(lhs, coef);
+        h.update_coef(e, -1);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      exp2formula(ir, r, f_and, freevars, v[0], e, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      break;
     }
-    else if (rel == IR_COND_EQ) {
-      F_Or *f_or = f_exists->add_and()->add_or();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());
-        F_And *f_and = f_or->add_and();
+    
+  case IR_OP_MOD:
+    {
+      fprintf(stderr, "IR_OP_MOD\n");
+      /* the left hand of a mod can be a var but the right must be a const */
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      assert(ir->QueryExpOperation(v[1]) == IR_OP_CONSTANT);
+      IR_ConstantRef *ref = static_cast<IR_ConstantRef *>(ir->Repr2Ref(v[1]));
+      coef_t coef = ref->integer();
+      delete v[1];
+      delete ref;
+      
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e = f_exists->declare(tmp_e());
+      Variable_ID b = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      
+      if (rel == IR_COND_EQ)
+        {
+          EQ_Handle h = f_and->add_EQ();
+          h.update_coef(lhs, 1);
+          h.update_coef(b, coef);
+          h.update_coef(e, -1);
+        } 
+      
+      else  if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        //i = CONST alpha + beta && beta >= const ( handled higher up ) && beta < CONST
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(b, coef);
+        h.update_coef(e, -1);
         
+        GEQ_Handle k = f_and->add_GEQ();
+        k.update_coef(lhs, -1 );
+        k.update_const(coef-1);
+        
+      } 
+      
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        //i = CONST alpha + beta && beta <= const ( handled higher up ) && beta >= 0
         EQ_Handle h = f_and->add_EQ();
         h.update_coef(lhs, 1);
+        h.update_coef(b, coef);
         h.update_coef(e, -1);
         
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, false);
+        GEQ_Handle k = f_and->add_GEQ();
+        k.update_coef(lhs, 1 );
         
-        for (int j = 0; j < v.size(); j++)
-          if (j != i) {
-            Variable_ID e2 = f_exists->declare(tmp_e());
-            GEQ_Handle h2 = f_and->add_GEQ();
-            h2.update_coef(e, -1);
-            h2.update_coef(e2, 1);
-            
-            exp2formula(ir, r, f_and, freevars, v[j], e2, side, IR_COND_EQ, false);
-          }
       }
       
-      for (int i = 0; i < v.size(); i++)
-        delete v[i];
+      exp2formula(ir, r, f_and, freevars, v[0], e, side, IR_COND_EQ, true, 
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
     
-    if (destroy)
-      delete repr;
-  }
-  case IR_OP_MAX:
-  {
-    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
     
-    F_Exists *f_exists = f_root->add_exists();
+  case IR_OP_POSITIVE:
+    {
+      fprintf(stderr, "IR_OP_POSITIVE\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      exp2formula(ir, r, f_root, freevars, v[0], lhs, side, rel, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      
+      if (destroy)
+        delete repr;
+      break;
+    }  
+    
     
-    if (rel == IR_COND_LE || rel == IR_COND_LT) {
-      F_Or *f_or = f_exists->add_and()->add_or();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());
-        F_And *f_and = f_or->add_and();
+  case IR_OP_NEGATIVE:
+    {
+      fprintf(stderr, "IR_OP_NEGATIVE\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      F_Exists *f_exists = f_root->add_exists();
+      Variable_ID e = f_exists->declare(tmp_e());
+      F_And *f_and = f_exists->add_and();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
         GEQ_Handle h = f_and->add_GEQ();
-        h.update_coef(lhs, -1);
+        h.update_coef(lhs, 1);
         h.update_coef(e, 1);
-        if (rel == IR_COND_LT)
+        if (rel == IR_COND_GT)
           h.update_const(-1);
-        
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true);
       }
-    }
-    else if (rel == IR_COND_GE || rel == IR_COND_GT) {
-      F_And *f_and = f_exists->add_and();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());        
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
         GEQ_Handle h = f_and->add_GEQ();
-        h.update_coef(lhs, 1);
+        h.update_coef(lhs, -1);
         h.update_coef(e, -1);
-        if (rel == IR_COND_GT)
+        if (rel == IR_COND_LT)
           h.update_const(-1);
-        
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true);
       }
-    }
-    else if (rel == IR_COND_EQ) {
-      F_Or *f_or = f_exists->add_and()->add_or();
-      for (int i = 0; i < v.size(); i++) {
-        Variable_ID e = f_exists->declare(tmp_e());
-        F_And *f_and = f_or->add_and();
-        
+      else if (rel == IR_COND_EQ) {
         EQ_Handle h = f_and->add_EQ();
         h.update_coef(lhs, 1);
-        h.update_coef(e, -1);
+        h.update_coef(e, 1);
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      exp2formula(ir, r, f_and, freevars, v[0], e, side, IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      if (destroy)
+        delete repr;
+      break;
+    }
+
+
+  case IR_OP_MIN:
+    {
+      fprintf(stderr, "IR_OP_MIN\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      F_Exists *f_exists = f_root->add_exists();
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        F_Or *f_or = f_exists->add_and()->add_or();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());
+          F_And *f_and = f_or->add_and();
+          GEQ_Handle h = f_and->add_GEQ();
+          h.update_coef(lhs, 1);
+          h.update_coef(e, -1);
+          if (rel == IR_COND_GT)
+            h.update_const(-1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+        }
+      }
+      else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        F_And *f_and = f_exists->add_and();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());        
+          GEQ_Handle h = f_and->add_GEQ();
+          h.update_coef(lhs, -1);
+          h.update_coef(e, 1);
+          if (rel == IR_COND_LT)
+            h.update_const(-1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+        }
+      }
+      else if (rel == IR_COND_EQ) {
+        F_Or *f_or = f_exists->add_and()->add_or();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());
+          F_And *f_and = f_or->add_and();
+          
+          EQ_Handle h = f_and->add_EQ();
+          h.update_coef(lhs, 1);
+          h.update_coef(e, -1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, false,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+          
+          for (int j = 0; j < v.size(); j++)
+            if (j != i) {
+              Variable_ID e2 = f_exists->declare(tmp_e());
+              GEQ_Handle h2 = f_and->add_GEQ();
+              h2.update_coef(e, -1);
+              h2.update_coef(e2, 1);
+              
+              exp2formula(ir, r, f_and, freevars, v[j], e2, side, 
+                          IR_COND_EQ, false,
+                          uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+            }
+        }
         
-        exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, false);
+        for (int i = 0; i < v.size(); i++)
+          delete v[i];
+      }
+      else
+        throw std::invalid_argument("unsupported condition type");
+      
+      if (destroy)
+        delete repr;
+      break;
+    }
+
+  case IR_OP_MAX:
+    {
+      fprintf(stderr, "IR_OP_MAX\n");
+      std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+      
+      F_Exists *f_exists = f_root->add_exists();
+      
+      if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        F_Or *f_or = f_exists->add_and()->add_or();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());
+          F_And *f_and = f_or->add_and();
+          GEQ_Handle h = f_and->add_GEQ();
+          h.update_coef(lhs, -1);
+          h.update_coef(e, 1);
+          if (rel == IR_COND_LT)
+            h.update_const(-1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+        }
+      }
+      else if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        F_And *f_and = f_exists->add_and();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());        
+          GEQ_Handle h = f_and->add_GEQ();
+          h.update_coef(lhs, 1);
+          h.update_coef(e, -1);
+          if (rel == IR_COND_GT)
+            h.update_const(-1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, true,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+          
+        }
+      }
+      else if (rel == IR_COND_EQ) {
+        F_Or *f_or = f_exists->add_and()->add_or();
+        for (int i = 0; i < v.size(); i++) {
+          Variable_ID e = f_exists->declare(tmp_e());
+          F_And *f_and = f_or->add_and();
+          
+          EQ_Handle h = f_and->add_EQ();
+          h.update_coef(lhs, 1);
+          h.update_coef(e, -1);
+          
+          exp2formula(ir, r, f_and, freevars, v[i], e, side, IR_COND_EQ, false,
+                      uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+          
+          for (int j = 0; j < v.size(); j++)
+            if (j != i) {
+              Variable_ID e2 = f_exists->declare(tmp_e());
+              GEQ_Handle h2 = f_and->add_GEQ();
+              h2.update_coef(e, 1);
+              h2.update_coef(e2, -1);
+              
+              exp2formula(ir, r, f_and, freevars, v[j], e2, side, IR_COND_EQ, false,
+                          uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+            }
+        }
         
-        for (int j = 0; j < v.size(); j++)
-          if (j != i) {
-            Variable_ID e2 = f_exists->declare(tmp_e());
-            GEQ_Handle h2 = f_and->add_GEQ();
-            h2.update_coef(e, 1);
-            h2.update_coef(e2, -1);
-            
-            exp2formula(ir, r, f_and, freevars, v[j], e2, side, IR_COND_EQ, false);
-          }
+        for (int i = 0; i < v.size(); i++)
+          delete v[i];
       }
+      else
+        throw std::invalid_argument("unsupported condition type");
       
-      for (int i = 0; i < v.size(); i++)
-        delete v[i];
+      if (destroy)
+        delete repr;
+      break;
     }
-    else
-      throw std::invalid_argument("unsupported condition type");
     
-    if (destroy)
-      delete repr;
+  case IR_OP_ARRAY_VARIABLE: {                      //                                  *****
+    fprintf(stderr, "\nomegatools.cc IR_OP_ARRAY_VARIABLE     ARRAY! \n");
+    
+    // temp for printing 
+    //CG_chillRepr *CR = (CG_chillRepr *)repr;
+    //fprintf(stderr, "repr  "); CR->dump(); fflush(stdout); 
+    
+    //fprintf(stderr, "repr  "); repr->dump();  /* printf("\n"); */fflush(stdout); 
+    
+    std::vector<CG_outputRepr *> v = ir->QueryExpOperand(repr);
+    IR_Ref *ref = static_cast<IR_ScalarRef *>(ir->Repr2Ref(v[0]));
+    
+    
+    CG_chillRepr *CR = (CG_chillRepr *)v[0]; // cheat for now.  we should not know this is a chillRepr  
+    //fprintf(stderr, "v     "); CR->dump(); fflush(stdout); 
+    //fprintf(stderr, "v     "); v[0]->dump(); /* printf("\n"); */ fflush(stdout); 
+    chillAST_node* node = CR->GetCode(); 
+    
+    
+    //fprintf(stderr, "\n**** walking parents!\n"); 
+    //std::vector<chillAST_VarDecl*> loopvars;
+    //node->gatherLoopIndeces( loopvars ); 
+    //fprintf(stderr, "in omegatools, %d loop vars\n", (int)loopvars.size()); 
+    
+    
+    std::string s = ref->name();
+    //fprintf(stderr, "array variable s is %s\n", s.c_str()); 
+    
+    int max_dim = 0;
+    bool need_new_fsymbol = false;
+    std::set<std::string> vars;
+    //fprintf(stderr, "ref->n_dim %d\n", ref->n_dim()); 
+    for (int i = 0; i < ref->n_dim(); i++) {
+      //fprintf(stderr, "dimension %d\n", i); 
+      Relation temp(r.n_inp());
+      
+      // r is enclosing relation, we build another that will include this 
+      r.setup_names();
+      if (r.is_set())
+        for (int j = 1; j <= r.n_set(); j++) {
+          temp.name_set_var(j, r.set_var(j)->name());
+        }
+      else
+        for (int j = 1; j <= r.n_inp(); j++) {
+          temp.name_input_var(j, r.input_var(j)->name());
+        }
+      
+      F_And *temp_root = temp.add_and();
+      
+      CG_outputRepr* repr;
+      if(dynamic_cast<IR_PointerArrayRef *>(ref) != NULL)
+        repr  = dynamic_cast<IR_PointerArrayRef *>(ref)->index(i); // i or i+1
+      else if(dynamic_cast<IR_ArrayRef *>(ref) != NULL)
+        repr  = dynamic_cast<IR_ArrayRef *>(ref)->index(i);
+      
+      std::vector<Free_Var_Decl*> freevars;
+      Free_Var_Decl *t = new Free_Var_Decl(s);
+      Variable_ID e = temp.get_local(t);
+      freevars.insert(freevars.end(), t);
+      
+      fprintf(stderr, "exp2formula recursing? \n"); 
+      exp2formula(ir, temp, temp_root, freevars, repr, e, side,
+                  IR_COND_EQ, false, uninterpreted_symbols,
+                  uninterpreted_symbols_stringrepr);
+      fprintf(stderr, "BACK FROM exp2formula recursing? \n"); 
+      
+      // temp is relation for the index of the array ?? 
+      for (DNF_Iterator di(temp.query_DNF()); di; di++) {
+        for (EQ_Iterator ei = (*di)->EQs(); ei; ei++) {
+          
+          if ((*ei).get_const() != 0)
+            need_new_fsymbol = true;
+          for (Constr_Vars_Iter cvi(*ei); cvi; cvi++)
+            if ((*cvi).var->kind() == Input_Var) {
+              if ((*cvi).var->get_position() > max_dim)
+                max_dim = (*cvi).var->get_position();
+              vars.insert(
+                          r.input_var((*cvi).var->get_position())->name());
+              
+            }
+        }
+        
+      }
+      
+      if (max_dim != ref->n_dim())
+        need_new_fsymbol = true;
+    }    
+    
+    //fprintf(stderr, "%d vars: ", (int)vars.size());
+    //for (int i=0; i<vars.size(); i++) fprintf(stderr, "%s", vars[i].c_str()); 
+    //for (std::set<std::string>::iterator it = vars.begin(); it != vars.end(); it++) {
+    //  fprintf(stderr, "%s ", (*it).c_str()); 
+    //} 
+    //fprintf(stderr, "\n"); 
+    
+    // r is enclosing relation, we build another that will include 
+    Variable_ID e = find_index(r, s, side); // s is the array named "index"
+    
+    std::vector<chillAST_node*> internals = ((CG_chillRepr *)v[0])->getChillCode();
+    int numnodes = internals.size(); // always 1?
+    std::vector<chillAST_DeclRefExpr *>dres;
+    std::vector<chillAST_VarDecl*> decls;
+    std::vector<chillAST_VarDecl*> sdecls;
+    for (int i=0; i<numnodes; i++) { 
+      internals[i]->gatherScalarVarDecls(sdecls);   // vardecls for scalars
+    }
+    
+    //fprintf(stderr, "%d scalar var decls()\n", sdecls.size()); 
+    //for (int i=0; i<sdecls.size(); i++) { 
+    //  fprintf(stderr, "vardecl %2d: ", i);  
+    //  sdecls[i]->print(); printf("\n"); fflush(stdout); 
+    //} 
+    
+    
+    //fprintf(stderr, "omegatools.cc, exp2formula()   NOW WHAT\n"); 
+    //exit(0); 
+    
+    if (e == NULL) { // s must be a free variable         
+      //fprintf(stderr, "'%s' must be free variable\n\n", s.c_str()); 
+      //fprintf(stderr, "SO WE WILL CREATE A MACRO ???\n");
+      
+      Free_Var_Decl *t = NULL;
+      
+      // keep adding underscores until we have created a unique name based on the original
+      do {
+        s += "_";
+        t = NULL;
+        for (unsigned i = 0; i < freevars.size(); i++) {
+          std::string ss = freevars[i]->base_name();
+          
+          if (s == ss) {
+            t = freevars[i];
+            break;
+          }
+        }
+      } while (t != NULL);
+      
+      if (!need_new_fsymbol)
+        t = new Free_Var_Decl(s, ref->n_dim());
+      else
+        t = new Free_Var_Decl(s, max_dim);
+      freevars.insert(freevars.end(), t);     // add index_____ to freevars
+      
+      
+      std::vector<  std::string > Vargs; // vector of args
+      std::string args;
+      std::vector<omega::CG_outputRepr *> reprs;
+      std::vector<omega::CG_outputRepr *> reprs2;
+      for (std::set<std::string>::iterator it = vars.begin();
+           it != vars.end(); it++) {
+        if (it == vars.begin())
+          args += "(";
+        else 
+          args += ",";
+        args += *it;
+        //fprintf(stderr, "an argument to the macro: %s\n", it->c_str()); 
+        Vargs.push_back( (*it) );
+        reprs.push_back(ir->builder()->CreateIdent(*it));
+        reprs2.push_back(ir->builder()->CreateIdent(*it));
+      }
+      args += ")";
+      
+      //fprintf(stderr, "args '%s'\n", args.c_str()); 
+      //fprintf(stderr, "Vargs ");
+      //for (int i=0; i<Vargs.size(); i++) fprintf(stderr, "%s ",Vargs[i].c_str());
+      //fprintf(stderr, "\n"); 
+      
+      //fprintf(stderr, "omegatools.cc ir->CreateDefineMacro( s (%s), args(%s), repr)\n", s.c_str(), args.c_str()); 
+      
+      // TODO repr, the rhs of the macro, needs to NOT refer to an actual variable ???
+      
+      
+      ir->CreateDefineMacro(s, Vargs, repr);
+      
+      
+      
+      // index_(i)   uses i outputrepr 
+      //fprintf(stderr,"omegatools.cc making uninterpreted symbol %s\n",s.c_str());
+      uninterpreted_symbols.insert(                                           // adding to uninterpreted_symbols
+                                   std::pair<std::string, std::vector<omega::CG_outputRepr *> >(
+                                                                                                s, reprs));
+      uninterpreted_symbols_stringrepr.insert(                     // adding to uninterpreted_symbols_stringrepr 
+                                              std::pair<std::string, std::vector<omega::CG_outputRepr *> >(s, reprs2));
+      
+      
+      e = r.get_local(t, Input_Tuple);
+      
+      if (rel == IR_COND_GE || rel == IR_COND_GT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -1);
+        if (rel == IR_COND_GT)
+          h.update_const(-1);
+      } else if (rel == IR_COND_LE || rel == IR_COND_LT) {
+        GEQ_Handle h = f_root->add_GEQ();
+        h.update_coef(lhs, -1);
+        h.update_coef(e, 1);
+        if (rel == IR_COND_LT)
+          h.update_const(-1);
+      } else if (rel == IR_COND_EQ) {
+        EQ_Handle h = f_root->add_EQ();
+        h.update_coef(lhs, 1);
+        h.update_coef(e, -1);
+      } else
+        throw std::invalid_argument("unsupported condition type");
+    } 
+    //  delete v[0];
+    delete ref;
+    if (destroy) delete repr;
+    
+    //fprintf(stderr, "FINALLY DONE with IR_OP_ARRAY_VARIABLE\n\n"); 
+    break;
   }
-  case IR_OP_NULL:
+
+
+  case IR_OP_NULL: 
+    fprintf(stderr, "IR_OP_NULL\n");
     break;
+
+
   default:
     throw ir_exp_error("unsupported operand type");
   }
 }
 
+
+
+
+//-----------------------------------------------------------------------------
+// Build dependence relation for two array references.
+// -----------------------------------------------------------------------------
 Relation arrays2relation(IR_Code *ir, std::vector<Free_Var_Decl*> &freevars,
                          const IR_ArrayRef *ref_src, const Relation &IS_w,
-                         const IR_ArrayRef *ref_dst, const Relation &IS_r) {
+                         const IR_ArrayRef *ref_dst, const Relation &IS_r,
+                         std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols,
+                         std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols_stringrepr) {
+  
+  //fprintf(stderr, "arrays2relation()\n"); 
+  //fprintf(stderr, "%d freevars\n", freevars.size()); 
+  //for (int i=0; i<freevars.size(); i++) fprintf(stderr, "freevar %d %s\n", i, (const char *)(freevars[i]->base_name())); 
+  
+  
   Relation &IS1 = const_cast<Relation &>(IS_w);
   Relation &IS2 = const_cast<Relation &>(IS_r);
   
+  //Relation *helper;
+  //helper = new Relation(IS1); fprintf(stderr, "IS1  "); helper->print(); fflush(stdout); 
+  //helper = new Relation(IS2); fprintf(stderr, "IS2  "); helper->print(); fflush(stdout); 
+  
   Relation r(IS1.n_set(), IS2.n_set());
+  //helper = new Relation(r); fprintf(stderr, "r    "); helper->print(); fflush(stdout);
   
   for (int i = 1; i <= IS1.n_set(); i++)
     r.name_input_var(i, IS1.set_var(i)->name());
@@ -513,9 +902,25 @@ Relation arrays2relation(IR_Code *ir, std::vector<Free_Var_Decl*> &freevars,
   for (int i = 1; i <= IS2.n_set(); i++)
     r.name_output_var(i, IS2.set_var(i)->name()+"'");
   
+  //fprintf(stderr, "omegatools.cc sym_src\n"); 
   IR_Symbol *sym_src = ref_src->symbol();
   IR_Symbol *sym_dst = ref_dst->symbol();
+  //fprintf(stderr, "omegatools.cc going to do IR_Symbol operator==\n"); 
+  //fprintf(stderr, "omegatools.cc comparing symbol 0x%x to symbol 0x%x\n", sym_src, sym_dst); 
+  
+  //if (!(*sym_src == *sym_dst))  fprintf(stderr, "!(*sym_src == *sym_dst)\n"); 
+  
+  //fprintf(stderr, "calling !=\n"); 
+  //if (*sym_src != *sym_dst)  fprintf(stderr, "omegatools.cc  (*sym_src != *sym_dst) TRUE\n"); 
+  //else fprintf(stderr, "omegatools.cc  (*sym_src != *sym_dst) FALSE\n"); 
+  
+  //fprintf(stderr, "calling ==\n"); 
+  //if ((*sym_src == *sym_dst))  fprintf(stderr, "(*sym_src == *sym_dst))  TRUE \n"); 
+  //else fprintf(stderr, "(*sym_src == *sym_dst) FALSE \n"); 
+  
   if (*sym_src != *sym_dst) {
+    //if (!(*sym_src == *sym_dst)) {
+    //fprintf(stderr, "False Relation\n"); 
     r.add_or(); // False Relation
     delete sym_src;
     delete sym_dst;
@@ -526,9 +931,13 @@ Relation arrays2relation(IR_Code *ir, std::vector<Free_Var_Decl*> &freevars,
     delete sym_dst;
   }
   
+  //fprintf(stderr, "f_root\n"); 
   F_And *f_root = r.add_and();
   
+  //fprintf(stderr, "omegatools.cc ref_src->n_dim() %d\n", ref_src->n_dim()); 
   for (int i = 0; i < ref_src->n_dim(); i++) {
+    //fprintf(stderr, "arrays2 i %d\n", i); 
+    
     F_Exists *f_exists = f_root->add_exists();
     Variable_ID e1 = f_exists->declare(tmp_e());
     Variable_ID e2 = f_exists->declare(tmp_e());
@@ -538,20 +947,29 @@ Relation arrays2relation(IR_Code *ir, std::vector<Free_Var_Decl*> &freevars,
     CG_outputRepr *repr_dst = ref_dst->index(i);
     
     bool has_complex_formula = false;
-    try {
-      exp2formula(ir, r, f_and, freevars, repr_src, e1, 'w', IR_COND_EQ, false);
-      exp2formula(ir, r, f_and, freevars, repr_dst, e2, 'r', IR_COND_EQ, false);
-    }
-    catch (const ir_exp_error &e) {
+    
+    if (ir->QueryExpOperation(repr_src) == IR_OP_ARRAY_VARIABLE
+        || ir->QueryExpOperation(repr_dst) == IR_OP_ARRAY_VARIABLE)
       has_complex_formula = true;
-    }
     
     if (!has_complex_formula) {
-      EQ_Handle h = f_and->add_EQ();
-      h.update_coef(e1, 1);
-      h.update_coef(e2, -1);
+      
+      try {
+        exp2formula(ir, r, f_and, freevars, repr_src, e1, 'w', IR_COND_EQ, false,
+                    uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+        exp2formula(ir, r, f_and, freevars, repr_dst, e2, 'r', IR_COND_EQ, false,
+                    uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      }
+      catch (const ir_exp_error &e) {
+        has_complex_formula = true;
+      }
+      
+      if (!has_complex_formula) {
+        EQ_Handle h = f_and->add_EQ();
+        h.update_coef(e1, 1);
+        h.update_coef(e2, -1);
+      }
     }
-    
     repr_src->clear();
     repr_dst->clear();
     delete repr_src;
@@ -566,32 +984,61 @@ Relation arrays2relation(IR_Code *ir, std::vector<Free_Var_Decl*> &freevars,
   for (int i = 1; i <= IS2.n_set(); i++)
     r.name_output_var(i, IS2.set_var(i)->name()+"'");
   
+  //helper = new Relation(r); fprintf(stderr, "r    "); helper->print(); fflush(stdout);  
+  //fprintf(stderr, "leaving arrays2relation\n"); 
   return r;
 }
 
-std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relation2dependences (const IR_ArrayRef *ref_src, const IR_ArrayRef *ref_dst, const Relation &r) {
+
+//-----------------------------------------------------------------------------
+// Convert array dependence relation into set of dependence vectors, assuming
+// ref_w is lexicographically before ref_r in the source code.
+// -----------------------------------------------------------------------------
+std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relation2dependences (
+                                                                                               const IR_ArrayRef *ref_src, 
+                                                                                               const IR_ArrayRef *ref_dst, 
+                                                                                               const Relation &r) {
+  //fprintf(stderr, "relation2dependences()\n"); 
   assert(r.n_inp() == r.n_out());
   
   std::vector<DependenceVector> dependences1, dependences2;  
+  //std::vector<DependenceVector*> dep1, dep2;  
   std::stack<DependenceLevel> working;
   working.push(DependenceLevel(r, r.n_inp()));
   
   while (!working.empty()) {
+    //fprintf(stderr, "!empty  size %d\n", working.size()); 
+    
     DependenceLevel dep = working.top();
     working.pop();
     
+    //if (!dep.r.is_satisfiable()) fprintf(stderr, "NOT dep.r.is_satisfiable()\n"); 
+    //else                         fprintf(stderr, "    dep.r.is_satisfiable()\n"); 
+    
     // No dependence exists, move on.
-    if (!dep.r.is_satisfiable())
+    if (!dep.r.is_satisfiable()) { 
+      //fprintf(stderr, "No dependence exists, move on.\n"); 
       continue;
+    }
     
+    //fprintf(stderr, "satisfiable\n"); 
+    //fprintf(stderr, "dep.level %d   r.n_inp() %d\n", dep.level, r.n_inp()); 
     if (dep.level == r.n_inp()) {
+      //fprintf(stderr, "dep.level == r.n_inp()\n"); 
       DependenceVector dv;
       
+      //fprintf(stderr, "\ndv created in if                                         ***\n"); 
+      //DependenceVector *dv2 = new DependenceVector; 
+      
+      //fprintf(stderr, "for loop independent dependence  dep.dir %d\n", dep.dir); 
       // for loop independent dependence, use lexical order to
       // determine the correct source and destination
       if (dep.dir == 0) {
-        if (*ref_src == *ref_dst)
+        //fprintf(stderr, "dep.dir == 0\n"); 
+        if (*ref_src == *ref_dst) {                             // c == c
+          //fprintf(stderr, "trivial\n"); 
           continue; // trivial self zero-dependence
+        }
         
         if (ref_src->is_write()) {
           if (ref_dst->is_write())
@@ -608,6 +1055,7 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
         
       }
       else if (dep.dir == 1) {
+        //fprintf(stderr, "dep.dir == 1\n"); 
         if (ref_src->is_write()) {
           if (ref_dst->is_write())
             dv.type = DEP_W2W;
@@ -622,6 +1070,7 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
         }
       }
       else { // dep.dir == -1
+        //fprintf(stderr, "dep.dir == -1\n"); 
         if (ref_dst->is_write()) {
           if (ref_src->is_write())
             dv.type = DEP_W2W;
@@ -638,27 +1087,74 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
       
       dv.lbounds = dep.lbounds;
       dv.ubounds = dep.ubounds;
+      
+      //fprintf(stderr, "omegatools.cc calling ref_src->symbol();\n"); 
       dv.sym = ref_src->symbol();
+      //fprintf(stderr, "dv.sym = %p\n", dv.sym); 
+      
+      //fprintf(stderr, "symbol %s  ADDING A DEPENDENCE OF TYPE ", dv.sym->name().c_str()); 
+      //switch (dv.type) { 
+      //case DEP_W2W: fprintf(stderr, "DEP_W2W to "); break; 
+      //case DEP_W2R: fprintf(stderr, "DEP_W2R to "); break; 
+      //case DEP_R2W: fprintf(stderr, "DEP_R2W to "); break; 
+      //case DEP_R2R: fprintf(stderr, "DEP_R2R to "); break; 
+      //default: fprintf(stderr, "DEP_UNKNOWN to "); break;
+      //} 
+      //if (dep.dir == 0 || dep.dir == 1) fprintf(stderr, "dependences1\n"); 
+      //else fprintf(stderr, "dependences2\n"); 
       
-      if (dep.dir == 0 || dep.dir == 1)
+      if (dep.dir == 0 || dep.dir == 1) {
+        //fprintf(stderr, "pushing dv\n"); 
         dependences1.push_back(dv);
-      else
+        //fprintf(stderr, "DONE pushing dv\n"); 
+        
+        //fprintf(stderr, "now %d dependences1\n", dependences1.size() ); 
+        //for (int i=0; i<dependences1.size(); i++) {
+        //  fprintf(stderr, "dependences1[%d]: ", i ); 
+        //  //fprintf(stderr, "symbol %p ", dependences1[i].sym);
+        //  fprintf(stderr, "symbol ");
+        //  fprintf(stderr, "%s\n", dependences1[i].sym->name().c_str()); 
+        //} 
+        //fprintf(stderr, "\n"); 
+      }
+      else { 
+        //fprintf(stderr, "pushing dv\n"); 
         dependences2.push_back(dv);
+        //fprintf(stderr, "DONE pushing dv\n"); 
+        
+        //fprintf(stderr, "now %d dependences2\n", dependences2.size() ); 
+        //for (int i=0; i<dependences2.size(); i++) {
+        //  fprintf(stderr, "dependences2[%d]: ", i); 
+        //  //fprintf(stderr, "symbol %p ", dependences2[i].sym);
+        //  fprintf(stderr, "symbol "); 
+        //  fprintf(stderr, "%s\n", dependences2[i].sym->name().c_str()); 
+        //} 
+        //fprintf(stderr, "\n"); 
+      }
+      
+      //fprintf(stderr, "dv goes out of scope                                      ***\n"); 
     }
     else {
+      //fprintf(stderr, "now work on the next dimension level\n"); 
       // now work on the next dimension level
       int level = ++dep.level;
+      //fprintf(stderr, "level %d\n", level); 
       
       coef_t lbound, ubound;
       Relation delta = Deltas(copy(dep.r));
+      //delta.print(); fflush(stdout); 
       delta.query_variable_bounds(delta.set_var(level), lbound, ubound);
+      //fprintf(stderr, "delta   lb " coef_fmt " 0x%llx    ub " coef_fmt " 0x%llx\n", lbound,lbound,ubound,ubound);
+      
       
       if (dep.dir == 0) {
+        //fprintf(stderr, "dep.dir == 0\n"); 
         if (lbound > 0) {
           dep.dir = 1;
           dep.lbounds[level-1] = lbound;
           dep.ubounds[level-1] = ubound;
           
+          //fprintf(stderr, "push 1\n"); 
           working.push(dep);
         }
         else if (ubound < 0) {
@@ -666,6 +1162,7 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
           dep.lbounds[level-1] = -ubound;
           dep.ubounds[level-1] = -lbound;
           
+          //fprintf(stderr, "push 2\n"); 
           working.push(dep);
         }
         else {
@@ -683,10 +1180,16 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
             h.update_coef(dep2.r.input_var(level), 1);
             h.update_coef(dep2.r.output_var(level), -1);
             
+            //fprintf(stderr, "push 3\n"); 
             working.push(dep2);
           }
           
-          if (lbound < 0 && *ref_src != *ref_dst) {
+          //fprintf(stderr, "lbound %lld 0x%llx\n", lbound, lbound); 
+          //if (lbound < 0LL) fprintf(stderr, "lbound < 0LL\n"); 
+          //if (*ref_src != *ref_dst) fprintf(stderr, "(*ref_src != *ref_dst)\n"); 
+          //else fprintf(stderr, "(*ref_src EQUAL *ref_dst)\n"); 
+          
+          if (lbound < 0LL && (*ref_src != *ref_dst)) {                // c == c
             DependenceLevel dep2 = dep;
             
             F_And *f_root = dep2.r.and_with_and();
@@ -702,12 +1205,14 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
                                         lbound, ubound);
             
             dep2.dir = -1;            
-            dep2.lbounds[level-1] = max(-ubound,static_cast<coef_t>(1)); // use max() to avoid Omega retardness
+            dep2.lbounds[level-1] = std::max(-ubound,static_cast<coef_t>(1)); // use max() to avoid Omega retardedness
             dep2.ubounds[level-1] = -lbound;
             
+            //fprintf(stderr, "push 4\n"); 
             working.push(dep2);
           }
           
+          //fprintf(stderr, "ubound %d\n", ubound); 
           if (ubound > 0) {
             DependenceLevel dep2 = dep;
             
@@ -723,9 +1228,10 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
             delta.query_variable_bounds(delta.set_var(level),
                                         lbound, ubound);
             dep2.dir = 1;
-            dep2.lbounds[level-1] = max(lbound,static_cast<coef_t>(1)); // use max() to avoid Omega retardness
+            dep2.lbounds[level-1] = std::max(lbound,static_cast<coef_t>(1)); // use max() to avoid Omega retardness
             dep2.ubounds[level-1] = ubound;
             
+            //fprintf(stderr, "push 5\n"); 
             working.push(dep2);
           }
         }
@@ -733,6 +1239,7 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
       // now deal with dependence vector with known direction
       // determined at previous levels
       else {
+        //fprintf(stderr, "else messy\n"); 
         // For messy bounds, further test to see if the dependence distance
         // can be reduced to positive/negative.  This is an omega hack.
         if (lbound == negInfinity && ubound == posInfinity) {
@@ -788,59 +1295,167 @@ std::pair<std::vector<DependenceVector>, std::vector<DependenceVector> > relatio
           dep.ubounds[level-1] = ubound;
         }
         
+        //fprintf(stderr, "push 6\n"); 
         working.push(dep);
       }
     }
+    //fprintf(stderr, "at bottom, size %d\n", working.size()); 
+    
   }
   
+  //fprintf(stderr, "leaving relation2dependences, %d and %d dependences\n", dependences1.size(), dependences2.size()); 
+  
+  
+  //for (int i=0; i<dependences1.size(); i++) {
+  //fprintf(stderr, "dependences1[%d]: ", i); 
+  //fprintf(stderr, "symbol %s\n", dependences1[i].sym->name().c_str()); 
+  
+  //fprintf(stderr, "symbol %s  HAS A left  DEPENDENCE OF TYPE ", dependences1[i].sym->name().c_str()); 
+  //switch (dependences1[i].type) { 
+  //case DEP_W2W: fprintf(stderr, "DEP_W2W\n");     break; 
+  //case DEP_W2R: fprintf(stderr, "DEP_W2R\n");     break; 
+  //case DEP_R2W: fprintf(stderr, "DEP_R2W\n");     break; 
+  //case DEP_R2R: fprintf(stderr, "DEP_R2R\n");     break; 
+  //default:      fprintf(stderr, "DEP_UNKNOWN\n"); break;
+  //} 
+  //} 
+  
+  
+  //for (int i=0; i<dependences2.size(); i++) {
+  
+  //fprintf(stderr, "symbol %s  HAS A right DEPENDENCE OF TYPE ", dependences2[i].sym->name().c_str()); 
+  //switch (dependences2[i].type) { 
+  //case DEP_W2W: fprintf(stderr, "DEP_W2W\n");     break; 
+  //case DEP_W2R: fprintf(stderr, "DEP_W2R\n");     break; 
+  //case DEP_R2W: fprintf(stderr, "DEP_R2W\n");     break; 
+  //case DEP_R2R: fprintf(stderr, "DEP_R2R\n");     break; 
+  //default:      fprintf(stderr, "DEP_UNKNOWN\n"); break;
+  //} 
+  //} 
+  
+  
+  
   return std::make_pair(dependences1, dependences2);
 }
 
+
+//-----------------------------------------------------------------------------
+// Convert a boolean expression to omega relation.  "destroy" means shallow
+// deallocation of "repr", not freeing the actual code inside.
+//-----------------------------------------------------------------------------
 void exp2constraint(IR_Code *ir, Relation &r, F_And *f_root,
                     std::vector<Free_Var_Decl *> &freevars,
-                    CG_outputRepr *repr, bool destroy) {
+                    CG_outputRepr *repr, 
+                    bool destroy,
+                    std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols,
+                    std::map<std::string, std::vector<omega::CG_outputRepr *> > &uninterpreted_symbols_stringrepr) 
+{
   IR_CONDITION_TYPE cond = ir->QueryBooleanExpOperation(repr);
   switch (cond) {
   case IR_COND_LT:
   case IR_COND_LE:
   case IR_COND_EQ:
   case IR_COND_GT:
-  case IR_COND_GE: {
-    F_Exists *f_exist = f_root->add_exists();
-    Variable_ID e = f_exist->declare();
-    F_And *f_and = f_exist->add_and();
-    std::vector<omega::CG_outputRepr *> op = ir->QueryExpOperand(repr);
-    exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, true);
-    exp2formula(ir, r, f_and, freevars, op[1], e, 's', cond, true);
-    if (destroy)
-      delete repr;
-    break;
-  }
-  case IR_COND_NE: {
-    F_Exists *f_exist = f_root->add_exists();
-    Variable_ID e = f_exist->declare();
-    F_Or *f_or = f_exist->add_or();
-    F_And *f_and = f_or->add_and();
-    std::vector<omega::CG_outputRepr *> op = ir->QueryExpOperand(repr);
-    exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, false);
-    exp2formula(ir, r, f_and, freevars, op[1], e, 's', IR_COND_GT, false);
-    
-    f_and = f_or->add_and();
-    exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, true);
-    exp2formula(ir, r, f_and, freevars, op[1], e, 's', IR_COND_LT, true);
-    
-    if (destroy)
-      delete repr;
-    break;
-  }    
+  case IR_COND_GE: 
+    {
+      F_Exists *f_exist = f_root->add_exists();
+      Variable_ID e = f_exist->declare();
+      F_And *f_and = f_exist->add_and();
+      std::vector<omega::CG_outputRepr *> op = ir->QueryExpOperand(repr);
+      exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      exp2formula(ir, r, f_and, freevars, op[1], e, 's', cond, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      
+      if (destroy)
+        delete repr;
+      break;
+    }
+  case IR_COND_NE: 
+    {
+      F_Exists *f_exist = f_root->add_exists();
+      Variable_ID e = f_exist->declare();
+      F_Or *f_or = f_exist->add_or();
+      F_And *f_and = f_or->add_and();
+      std::vector<omega::CG_outputRepr *> op = ir->QueryExpOperand(repr);
+      exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, false,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      exp2formula(ir, r, f_and, freevars, op[1], e, 's', IR_COND_GT, false,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      
+      f_and = f_or->add_and();
+      exp2formula(ir, r, f_and, freevars, op[0], e, 's', IR_COND_EQ, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      exp2formula(ir, r, f_and, freevars, op[1], e, 's', IR_COND_LT, true,
+                  uninterpreted_symbols, uninterpreted_symbols_stringrepr);
+      
+      if (destroy)
+        delete repr;
+      break;
+    }    
   default:
     throw ir_exp_error("unrecognized conditional expression");
   }
 }
 
-bool is_single_loop_iteration(const Relation &r, int level, const Relation &known) {
+
+
+
+
+//-----------------------------------------------------------------------------
+// Generate iteration space constraints
+//-----------------------------------------------------------------------------
+
+// void add_loop_stride_constraints(Relation &r, F_And *f_root,
+//                                  std::vector<Free_Var_Decl*> &freevars,
+//                                  tree_for *tnf, char side) {
+
+//   std::string name(tnf->index()->name());
+//   int dim = 0;
+//   for (;dim < r.n_set(); dim++)
+//     if (r.set_var(dim+1)->name() == name)
+//       break;
+
+//   Relation bound = get_loop_bound(r, dim);
+
+//   operand op = tnf->step_op();
+//   if (!op.is_null()) {
+//     if (op.is_immed()) {
+//       immed im = op.immediate();
+//       if (im.is_integer()) {
+//         int c = im.integer();
+
+//         if (c != 1 && c != -1)
+//           add_loop_stride(r, bound, dim, c);
+//       }
+//       else
+//         assert(0); // messy stride
+//     }
+//     else
+//       assert(0);  // messy stride
+//   }
+// }
+
+
+
+
+//-----------------------------------------------------------------------------
+// Determine whether the loop (starting from 0) in the iteration space
+// has only one iteration.
+//-----------------------------------------------------------------------------
+bool is_single_loop_iteration(const Relation &r, 
+                              int level, 
+                              const Relation &known) {
   int n = r.n_set();
-  Relation r1 = Intersection(copy(r), Extend_Set(copy(known), n-known.n_set()));
+  Relation r1;
+  if(n > known.n_set()) { 
+    r1 = Intersection(copy(r), Extend_Set(copy(known), n - known.n_set()));
+  }
+  else{
+    r1 = Intersection(copy(known), Extend_Set(copy(r), known.n_set() - n));
+    n = known.n_set();
+  }
+  
   
   Relation mapping(n, n);
   F_And *f_root = mapping.add_and();
@@ -869,6 +1484,8 @@ bool is_single_loop_iteration(const Relation &r, int level, const Relation &know
 }
 
 
+
+
 bool is_single_iteration(const Relation &r, int dim) {
   assert(r.is_set());
   const int n = r.n_set();
@@ -878,6 +1495,11 @@ bool is_single_iteration(const Relation &r, int dim) {
   
   Relation bound = get_loop_bound(r, dim);
   
+  //   if (!bound.has_single_conjunct())
+  //     return false;
+  
+  //   Conjunct *c = bound.query_DNF()->single_conjunct();
+  
   for (DNF_Iterator di(bound.query_DNF()); di; di++) {
     bool is_single = false;
     for (EQ_Iterator ei((*di)->EQs()); ei; ei++)
@@ -891,8 +1513,78 @@ bool is_single_iteration(const Relation &r, int dim) {
   }
   
   return true;
+  
+  
+  
+  
+  //   Relation r = copy(r_);
+  //   const int n = r.n_set();
+  
+  //   if (dim >= n)
+  //     return true;
+  
+  //   Relation bound = get_loop_bound(r, dim);
+  //   bound = Approximate(bound);
+  //   Conjunct *c = bound.query_DNF()->single_conjunct();
+  
+  //   return c->n_GEQs() == 0;
+  
+  
+  
+  
+  
+  //   Relation r = copy(r_);
+  //   r.simplify();
+  //   const int n = r.n_set();
+  
+  //   if (dim >= n)
+  //     return true;
+  
+  //   for (DNF_Iterator i(r.query_DNF()); i; i++) {
+  //     std::vector<bool> is_single(n);
+  //     for (int j = 0; j < dim; j++)
+  //       is_single[j] = true;
+  //     for (int j = dim; j < n; j++)
+  //       is_single[j] = false;
+  
+  //     bool found_new_single = true;
+  //     while (found_new_single) {
+  //       found_new_single = false;
+  
+  //       for (EQ_Iterator j = (*i)->EQs(); j; j++) {
+  //         int saved_pos = -1;
+  //         for (Constr_Vars_Iter k(*j); k; k++)
+  //           if ((*k).var->kind() == Set_Var || (*k).var->kind() == Input_Var) {
+  //             int pos = (*k).var->get_position() - 1;
+  //             if (!is_single[pos])
+  //               if (saved_pos == -1)
+  //                 saved_pos = pos;
+  //               else {
+  //                 saved_pos = -1;
+  //                 break;
+  //               }
+  //           }
+  
+  //         if (saved_pos != -1) {
+  //           is_single[saved_pos] = true;
+  //           found_new_single = true;
+  //         }
+  //       }
+  
+  //       if (is_single[dim])
+  //         break;
+  //     }
+  
+  //     if (!is_single[dim])
+  //       return false;
+  //   }
+  
+  //   return true;
 }
 
+//-----------------------------------------------------------------------------
+// Set/get the value of a variable which is know to be constant.
+//-----------------------------------------------------------------------------
 void assign_const(Relation &r, int dim, int val) {
   const int n = r.n_out();
   
@@ -917,10 +1609,14 @@ void assign_const(Relation &r, int dim, int val) {
 
 
 int get_const(const Relation &r, int dim, Var_Kind type) {
+  //  Relation rr = copy(r);
   Relation &rr = const_cast<Relation &>(r);
   
   Variable_ID v;
   switch (type) {
+    // case Set_Var:
+    //   v = rr.set_var(dim+1);
+    //   break;
   case Input_Var:
     v = rr.input_var(dim+1);
     break;
@@ -939,10 +1635,19 @@ int get_const(const Relation &r, int dim, Var_Kind type) {
   throw std::runtime_error("cannot get variable's constant value");
 }
 
+
+
+
+
+
+//---------------------------------------------------------------------------
+// Get the bound for a specific loop.
+//---------------------------------------------------------------------------
 Relation get_loop_bound(const Relation &r, int dim) {
   assert(r.is_set());
   const int n = r.n_set();
   
+  //  Relation r1 = project_onto_levels(copy(r), dim+1, true);
   Relation mapping(n,n);
   F_And *f_root = mapping.add_and();
   for (int i = 1; i <= dim+1; i++) {
@@ -959,9 +1664,20 @@ Relation get_loop_bound(const Relation &r, int dim) {
   return Gist(r1, r2, 1);
 }
 
+
+
 Relation get_loop_bound(const Relation &r, int level, const Relation &known) {
-  int n = r.n_set();
-  Relation r1 = Intersection(copy(r), Extend_Set(copy(known), n-known.n_set()));
+  int n1 = r.n_set();
+  int n = n1;
+  Relation r1;
+  if(n > known.n_set())
+    r1 = Intersection(copy(r),
+                      Extend_Set(copy(known), n - known.n_set()));
+  else{
+    r1 = Intersection(copy(known),
+                      Extend_Set(copy(r), known.n_set() - n));
+    n = known.n_set();
+  }
   
   Relation mapping(n, n);
   F_And *f_root = mapping.add_and();
@@ -974,7 +1690,7 @@ Relation get_loop_bound(const Relation &r, int level, const Relation &known) {
   Relation r2 = Project(copy(r1), level, Set_Var);
   r1 = Gist(r1, r2, 1);
   
-  for (int i = 1; i <= n; i++)
+  for (int i = 1; i <= n1; i++)
     r1.name_set_var(i, const_cast<Relation &>(r).set_var(i)->name());
   r1.setup_names();
   
@@ -1017,6 +1733,12 @@ Relation get_min_loop_bound(const std::vector<Relation> &r, int dim) {
   return res;
 }
 
+//-----------------------------------------------------------------------------
+// Add strident to a loop.
+// Issues:
+// - Don't work with relations with multiple disjuncts.
+// - Omega's dealing with max lower bound is awkward.
+//-----------------------------------------------------------------------------
 void add_loop_stride(Relation &r, const Relation &bound_, int dim, int stride) {
   F_And *f_root = r.and_with_and();
   Relation &bound = const_cast<Relation &>(bound_);
@@ -1042,30 +1764,32 @@ void add_loop_stride(Relation &r, const Relation &bound_, int dim, int stride) {
         for (Constr_Vars_Iter ci(*gi); ci; ci++) {
           switch ((*ci).var->kind()) {
             // case Set_Var:
-          case Input_Var: {
-            int pos = (*ci).var->get_position();
-            if (pos == dim + 1) {
-              h1.update_coef(e1, (*ci).coef);
-              h2.update_coef(e1, (*ci).coef);
-            }
-            else {
-              if (!r.is_set()) {
-                h1.update_coef(r.output_var(pos), (*ci).coef);
-                h2.update_coef(r.output_var(pos), (*ci).coef);
+          case Input_Var: 
+            {
+              int pos = (*ci).var->get_position();
+              if (pos == dim + 1) {
+                h1.update_coef(e1, (*ci).coef);
+                h2.update_coef(e1, (*ci).coef);
               }
               else {
-                h1.update_coef(r.set_var(pos), (*ci).coef);
-                h2.update_coef(r.set_var(pos), (*ci).coef);
-              }                
+                if (!r.is_set()) {
+                  h1.update_coef(r.output_var(pos), (*ci).coef);
+                  h2.update_coef(r.output_var(pos), (*ci).coef);
+                }
+                else {
+                  h1.update_coef(r.set_var(pos), (*ci).coef);
+                  h2.update_coef(r.set_var(pos), (*ci).coef);
+                }                
+              }
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = (*ci).var->get_global_var();
+              h1.update_coef(r.get_local(g, (*ci).var->function_of()), (*ci).coef);
+              h2.update_coef(r.get_local(g, (*ci).var->function_of()), (*ci).coef);
+              break;
             }
-            break;
-          }
-          case Global_Var: {
-            Global_Var_ID g = (*ci).var->get_global_var();
-            h1.update_coef(r.get_local(g, (*ci).var->function_of()), (*ci).coef);
-            h2.update_coef(r.get_local(g, (*ci).var->function_of()), (*ci).coef);
-            break;
-          }
           default:
             break;
           }
@@ -1078,8 +1802,18 @@ void add_loop_stride(Relation &r, const Relation &bound_, int dim, int stride) {
 }
 
 
-bool is_inner_loop_depend_on_level(const Relation &r, int level, const Relation &known) {
-  Relation r1 = Intersection(copy(r), Extend_Set(copy(known), r.n_set()-known.n_set()));
+bool is_inner_loop_depend_on_level(const Relation &r, 
+                                   int level,
+                                   const Relation &known) {
+  
+  Relation r1;
+  if(r.n_set() > known.n_set())
+    r1 = Intersection(copy(r),
+                      Extend_Set(copy(known), r.n_set() - known.n_set()));
+  else
+    r1 = Intersection(copy(known),
+                      Extend_Set(copy(r), known.n_set() - r.n_set()));
+  
   Relation r2 = copy(r1);
   for (int i = level+1; i <= r2.n_set(); i++)
     r2 = Project(r2, r2.set_var(i));
@@ -1100,6 +1834,15 @@ bool is_inner_loop_depend_on_level(const Relation &r, int level, const Relation
   return false;
 }
 
+
+//-----------------------------------------------------------------------------
+// Suppose loop dim is i. Replace i with i+adjustment in loop bounds.
+// e.g. do i = 1, n
+//        do j = i, n
+// after call with dim = 0 and adjustment = 1:
+//      do i = 1, n
+//        do j = i+1, n
+// -----------------------------------------------------------------------------
 Relation adjust_loop_bound(const Relation &r, int level, int adjustment) {
   if (adjustment == 0)
     return copy(r);
@@ -1136,6 +1879,236 @@ Relation adjust_loop_bound(const Relation &r, int level, int adjustment) {
   return r1;
 }
 
+
+// commented out on 07/14/2010
+// void adjust_loop_bound(Relation &r, int dim, int adjustment, std::vector<Free_Var_Decl *> globals) {
+//   assert(r.is_set());
+
+//   if (adjustment == 0)
+//     return;
+
+//   const int n = r.n_set();
+//   Tuple<std::string> name(n);
+//   for (int i = 1; i <= n; i++)
+//     name[i] = r.set_var(i)->name();
+
+//   Relation r1 = project_onto_levels(copy(r), dim+1, true);
+//   Relation r2 = Gist(copy(r), copy(r1));
+
+//   // remove old bogus global variable conditions since we are going to
+//   // update the value.
+//   if (globals.size() > 0)
+//     r1 = Gist(r1, project_onto_levels(copy(r), 0, true));
+
+//   Relation r4 = Relation::True(n);
+
+//     for (DNF_Iterator di(r2.query_DNF()); di; di++) {
+//       for (EQ_Iterator ei = (*di)->EQs(); ei; ei++) {
+//         EQ_Handle h = r4.and_with_EQ(*ei);
+
+//         Variable_ID v = r2.set_var(dim+1);
+//         coef_t c = (*ei).get_coef(v);
+//         if (c != 0)
+//           h.update_const(c*adjustment);
+
+//         for (int i = 0; i < globals.size(); i++) {  
+//           Variable_ID v = r2.get_local(globals[i]);
+//           coef_t c = (*ei).get_coef(v);
+//           if (c != 0)
+//             h.update_const(c*adjustment);
+//         }
+//       }
+
+//       for (GEQ_Iterator gi = (*di)->GEQs(); gi; gi++) {
+//         GEQ_Handle h = r4.and_with_GEQ(*gi);
+
+//         Variable_ID v = r2.set_var(dim+1);
+//         coef_t c = (*gi).get_coef(v);
+//         if (c != 0)
+//           h.update_const(c*adjustment);
+
+//         for (int i = 0; i < globals.size(); i++) {  
+//           Variable_ID v = r2.get_local(globals[i]);
+//           coef_t c = (*gi).get_coef(v);
+//           if (c != 0)
+//             h.update_const(c*adjustment);
+//         }
+//       }
+//     }
+//     r = Intersection(r1, r4);
+// //   }
+// //   else
+// //     r = Intersection(r1, r2);
+
+//   for (int i = 1; i <= n; i++)
+//     r.name_set_var(i, name[i]);
+//   r.setup_names();
+// }
+
+
+// void adjust_loop_bound(Relation &r, int dim, int adjustment) {
+//   assert(r.is_set());
+//   const int n = r.n_set();
+//   Tuple<String> name(n);
+//   for (int i = 1; i <= n; i++)
+//     name[i] = r.set_var(i)->name();
+
+//   Relation r1 = project_onto_levels(copy(r), dim+1, true);
+//   Relation r2 = Gist(r, copy(r1));
+
+//   Relation r3(n, n);
+//   F_And *f_root = r3.add_and();
+//   for (int i = 0; i < n; i++) {
+//     EQ_Handle h = f_root->add_EQ();
+//     h.update_coef(r3.output_var(i+1), 1);
+//     h.update_coef(r3.input_var(i+1), -1);
+//     if (i == dim)
+//       h.update_const(adjustment);
+//   }
+
+//   r2 = Range(Restrict_Domain(r3, r2));
+//   r = Intersection(r1, r2);
+
+//   for (int i = 1; i <= n; i++)
+//     r.name_set_var(i, name[i]);
+//   r.setup_names();
+// }  
+
+// void adjust_loop_bound(Relation &r, int dim, Free_Var_Decl *global_var, int adjustment) {
+//   assert(r.is_set());
+//   const int n = r.n_set();
+//   Tuple<String> name(n);
+//   for (int i = 1; i <= n; i++)
+//     name[i] = r.set_var(i)->name();
+
+//   Relation r1 = project_onto_levels(copy(r), dim+1, true);
+//   Relation r2 = Gist(r, copy(r1));
+
+//   Relation r3(n);
+//   Variable_ID v = r2.get_local(global_var);
+
+//   for (DNF_Iterator di(r2.query_DNF()); di; di++) {
+//     for (EQ_Iterator ei = (*di)->EQs(); ei; ei++) {
+//       coef_t c = (*ei).get_coef(v);
+//       EQ_Handle h = r3.and_with_EQ(*ei);
+//       if (c != 0)
+//         h.update_const(c*adjustment);
+//     }
+//     for (GEQ_Iterator gi = (*di)->GEQs(); gi; gi++) {
+//       coef_t c = (*gi).get_coef(v);
+//       GEQ_Handle h = r3.and_with_GEQ(*gi);
+//       if (c != 0)
+//         h.update_const(c*adjustment);
+//     }
+//   }
+
+//   r = Intersection(r1, r3);
+//   for (int i = 1; i <= n; i++)
+//     r.name_set_var(i, name[i]);
+//   r.setup_names();
+// }
+
+
+
+//------------------------------------------------------------------------------
+// If the dimension has value posInfinity, the statement should be privatized
+// at this dimension.
+//------------------------------------------------------------------------------
+// boolean is_private_statement(const Relation &r, int dim) {
+//   int n;
+//   if (r.is_set())
+//     n = r.n_set();
+//   else
+//     n = r.n_out();
+
+//   if (dim >= n)
+//     return false;
+
+//   try {
+//     coef_t c;
+//     if (r.is_set())
+//       c = get_const(r, dim, Set_Var);
+//     else
+//       c = get_const(r, dim, Output_Var);
+//     if (c == posInfinity)
+//       return true;
+//     else
+//       return false;
+//   }
+//   catch (loop_error e){
+//   }
+
+//   return false;
+// }
+
+
+
+// // ----------------------------------------------------------------------------
+// // Calculate v mod dividend based on equations inside relation r.
+// // Return posInfinity if it is not a constant.
+// // ----------------------------------------------------------------------------
+// static coef_t mod_(const Relation &r_, Variable_ID v, int dividend, std::set<Variable_ID> &working_on) {
+//   assert(dividend > 0);
+//   if (v->kind() == Forall_Var || v->kind() == Exists_Var || v->kind() == Wildcard_Var)
+//     return posInfinity;
+
+//   working_on.insert(v);
+
+//   Relation &r = const_cast<Relation &>(r_);
+//   Conjunct *c = r.query_DNF()->single_conjunct();
+
+//   for (EQ_Iterator ei(c->EQs()); ei; ei++) {
+//     int coef = mod((*ei).get_coef(v), dividend);
+//     if (coef != 1 && coef != dividend - 1 )
+//       continue;
+
+//     coef_t result = 0;
+//     for (Constr_Vars_Iter cvi(*ei); cvi; cvi++)
+//       if ((*cvi).var != v) {
+//         int p = mod((*cvi).coef, dividend);
+
+//         if (p == 0)
+//           continue;
+
+//         if (working_on.find((*cvi).var) != working_on.end()) {
+//           result = posInfinity;
+//           break;
+//         }
+
+//         coef_t q = mod_(r, (*cvi).var, dividend, working_on);
+//         if (q == posInfinity) {
+//           result = posInfinity;
+//           break;
+//         }
+//         result += p * q;
+//       }
+
+//     if (result != posInfinity) {
+//       result += (*ei).get_const();
+//       if (coef == 1)
+//         result = -result;
+//       working_on.erase(v);
+
+//       return mod(result, dividend);
+//     }
+//   }
+
+//   working_on.erase(v);
+//   return posInfinity;
+// }
+
+
+// coef_t mod(const Relation &r, Variable_ID v, int dividend) {
+//   std::set<Variable_ID> working_on = std::set<Variable_ID>();
+
+//   return mod_(r, v, dividend, working_on);
+// }
+
+
+
+//-----------------------------------------------------------------------------
+// Generate mapping relation for permuation.
+//-----------------------------------------------------------------------------
 Relation permute_relation(const std::vector<int> &pi) {
   const int n = pi.size();
   
@@ -1151,6 +2124,11 @@ Relation permute_relation(const std::vector<int> &pi) {
   return r;
 }
 
+
+
+//---------------------------------------------------------------------------
+// Find the position index variable in a Relation by name.
+//---------------------------------------------------------------------------
 Variable_ID find_index(Relation &r, const std::string &s, char side) {
   // Omega quirks: assure the names are propagated inside the relation
   r.setup_names();
@@ -1183,3 +2161,1104 @@ Variable_ID find_index(Relation &r, const std::string &s, char side) {
   return NULL;
 }
 
+// EQ_Handle get_eq(const Relation &r, int dim, Var_Kind type) {
+//   Variable_ID v;
+//   switch (type) {
+//   case Set_Var:
+//     v = r.set_var(dim+1);
+//     break;
+//   case Input_Var:
+//     v = r.input_var(dim+1);
+//     break;
+//   case Output_Var:
+//     v = r.output_var(dim+1);
+//     break;
+//   default:
+//     return NULL;
+//   }
+//   for (DNF_iterator di(r.query_DNF()); di; di++)
+//     for (EQ_Iterator ei = (*di)->EQs(); ei; ei++)
+//       if ((*ei).get_coef(v) != 0)
+//         return (*ei);
+
+//   return NULL;
+// }
+
+
+// std::Pair<Relation, Relation> split_loop(const Relation &r, const Relation &cond) {
+//   Relation r1 = Intersection(copy(r), copy(cond));
+//   Relation r2 = Intersection(copy(r), Complement(copy(cond)));
+
+//   return std::Pair<Relation, Relation>(r1, r2);
+// }
+
+
+
+//----------------------------------------------------------------------------
+//check if loop is normalized to zero
+//----------------------------------------------------------------------------
+bool lowerBoundIsZero(const omega::Relation &bound, int dim) {
+  Relation &IS = const_cast<Relation &>(bound);
+  Variable_ID v = IS.input_var(dim);
+  bool found = false;
+  for (DNF_Iterator di(IS.query_DNF()); di; di++) {
+    bool is_single = false;
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++)
+      if ((*gi).get_coef(v) >= 0 && !(*gi).is_const(v)
+          && (*gi).get_const() != 0) {
+        return false;
+      } 
+      else if ((*gi).get_coef(v) >= 0 && (*gi).is_const(v)
+               && (*gi).get_const() == 0)
+        found = true;
+  }
+  
+  return found;
+}
+
+
+
+Relation replicate_IS_and_add_bound(const omega::Relation &R, int level,
+                                    omega::Relation &bound) {
+  
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set());
+  
+  for (int i = 1; i <= R.n_set(); i++) {
+    r.name_set_var(i + 1, const_cast<Relation &>(R).set_var(i)->name());
+  }
+  
+  std::string new_var = bound.set_var(1)->name();
+  
+  r.name_set_var(level, new_var);
+  
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+      GEQ_Handle h = f_root->add_GEQ();
+      
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var:
+          
+          h.update_coef(r.input_var(v->get_position()),
+                        cvi.curr_coef());
+          
+          break;
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h.update_const((*gi).get_const());
+    }
+  }
+  
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h1 = f_root->add_EQ();
+      
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var:
+          
+          h1.update_coef(r.input_var(v->get_position()),
+                         cvi.curr_coef());
+          
+          break;
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h1.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h1.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h1.update_const((*gi).get_const());
+    }
+  }
+  
+  for (DNF_Iterator di(bound.query_DNF()); di; di++) {
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+      GEQ_Handle h = f_root->add_GEQ();
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var:
+          
+          h.update_coef(r.input_var(level), cvi.curr_coef());
+          
+          break;
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h.update_const((*gi).get_const());
+    }
+  }
+  
+  for (DNF_Iterator di(bound.query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h = f_root->add_EQ();
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var:
+          h.update_coef(r.input_var(level), cvi.curr_coef());
+          
+          break;
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h.update_const((*gi).get_const());
+    }
+  }
+  r.simplify();
+  r.setup_names();
+  return r;
+}
+
+
+
+
+// Replicates old_relation's bounds for set var at old_pos int o new_relation at new_pos, but position's bounds must involve constants
+//  only supports GEQs
+//
+Relation replace_set_var_as_another_set_var(const omega::Relation &new_relation,
+                                            const omega::Relation &old_relation, int new_pos, int old_pos) {
+  
+  Relation r = copy(new_relation);
+  r.copy_names(new_relation);
+  r.setup_names();
+  
+  F_Exists *f_exists = r.and_with_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  
+  for (DNF_Iterator di(const_cast<Relation &>(old_relation).query_DNF()); di;
+       di++)
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+      GEQ_Handle h = f_root->add_GEQ();
+      if (((*gi).get_coef(
+                          const_cast<Relation &>(old_relation).set_var(old_pos)) != 0)
+          && (*gi).is_const_except_for_global(
+                                              const_cast<Relation &>(old_relation).set_var(
+                                                                                           old_pos))) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var: 
+            {
+              
+              if (v->get_position() == old_pos)
+                h.update_coef(r.input_var(new_pos),
+                              cvi.curr_coef());
+              else
+                throw omega_error(
+                                  "relation contains set vars other than that to be replicated!");
+              break;
+              
+            }
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(
+                                                          old_relation, v, r, f_exists, f_root,
+                                                          exists_mapping);
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+        }
+        h.update_const((*gi).get_const());
+      }
+    }
+  return r;
+  
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Copy all relations from r and add new bound at position indicated by level.
+// -----------------------------------------------------------------------------
+
+Relation replicate_IS_and_add_at_pos(const omega::Relation &R, int level,
+                                     omega::Relation &bound) {
+  
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set() + 1);
+  
+  for (int i = 1; i <= R.n_set(); i++) {
+    if (i < level)
+      r.name_set_var(i, const_cast<Relation &>(R).set_var(i)->name());
+    else
+      r.name_set_var(i + 1, const_cast<Relation &>(R).set_var(i)->name());
+    
+  }
+  
+  std::string new_var = bound.set_var(1)->name();
+  
+  r.name_set_var(level, new_var);
+  
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  
+  for (int i = 1; i <= R.n_set(); i++)
+    for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+      for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+        GEQ_Handle h = f_root->add_GEQ();
+        if ((*gi).get_coef(const_cast<Relation &>(R).set_var(i)) != 0) {
+          for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+            Variable_ID v = cvi.curr_var();
+            switch (v->kind()) {
+            case Input_Var: 
+              {
+                if (i < level)
+                  h.update_coef(r.input_var(v->get_position()),
+                                cvi.curr_coef());
+                else
+                  h.update_coef(
+                                r.input_var(v->get_position() + 1),
+                                cvi.curr_coef());
+                break;
+              }
+            case Wildcard_Var: 
+              {
+                Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                            f_exists, f_root, exists_mapping);
+                h.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            case Global_Var: 
+              {
+                Global_Var_ID g = v->get_global_var();
+                Variable_ID v2;
+                if (g->arity() == 0)
+                  v2 = r.get_local(g);
+                else
+                  v2 = r.get_local(g, v->function_of());
+                h.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            default:
+              assert(false);
+            }
+            
+          }
+          h.update_const((*gi).get_const());
+        }
+      }
+    }
+  
+  for (int i = 1; i <= R.n_set(); i++)
+    for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+      for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+        EQ_Handle h1 = f_root->add_EQ();
+        if ((*gi).get_coef(const_cast<Relation &>(R).set_var(i)) != 0) {
+          for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+            Variable_ID v = cvi.curr_var();
+            switch (v->kind()) {
+            case Input_Var: 
+              {
+                if (i < level)
+                  h1.update_coef(r.input_var(v->get_position()),
+                                 cvi.curr_coef());
+                else
+                  h1.update_coef(
+                                 r.input_var(v->get_position() + 1),
+                                 cvi.curr_coef());
+                break;
+              }
+            case Wildcard_Var: 
+              {
+                Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                            f_exists, f_root, exists_mapping);
+                h1.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            case Global_Var: 
+              {
+                Global_Var_ID g = v->get_global_var();
+                Variable_ID v2;
+                if (g->arity() == 0)
+                  v2 = r.get_local(g);
+                else
+                  v2 = r.get_local(g, v->function_of());
+                h1.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            default:
+              assert(false);
+            }
+          }
+          h1.update_const((*gi).get_const());
+        }
+      }
+    }
+  
+  for (DNF_Iterator di(bound.query_DNF()); di; di++) {
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+      GEQ_Handle h = f_root->add_GEQ();
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var: 
+          {
+            if (cvi.curr_var()->get_position() < level)
+              h.update_coef(r.input_var(level), cvi.curr_coef());
+            else
+              h.update_coef(r.input_var(level), cvi.curr_coef());
+            break;
+          }
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+        h.update_const((*gi).get_const());
+      }
+    }
+  }
+  
+  for (DNF_Iterator di(bound.query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h = f_root->add_EQ();
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var: 
+          {
+            if (cvi.curr_var()->get_position() < level)
+              h.update_coef(r.input_var(level), cvi.curr_coef());
+            else
+              h.update_coef(r.input_var(level), cvi.curr_coef());
+            break;
+          }
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h.update_const((*gi).get_const());
+    }
+  }
+  r.simplify();
+  r.setup_names();
+  return r;
+}
+
+
+
+
+omega::Relation replace_set_var_as_Global(const omega::Relation &R, int pos,
+                                          std::vector<omega::Relation> &bound) {
+  
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set());
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  int count = 1;
+  for (int i = 1; i <= R.n_set(); i++) {
+    
+    if (i != pos) {
+      r.name_set_var(i, const_cast<Relation &>(R).set_var(i)->name());
+      
+    }
+    else
+      r.name_set_var(i, "void");
+  }
+  
+  Free_Var_Decl *repl = new Free_Var_Decl(
+                                          const_cast<Relation &>(R).set_var(pos)->name());
+  
+  Variable_ID v3 = r.get_local(repl);
+  
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h1 = f_root->add_EQ();
+      for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+        Variable_ID v = cvi.curr_var();
+        switch (v->kind()) {
+        case Input_Var: 
+          {
+            if (v->get_position() != pos)
+              h1.update_coef(r.input_var(v->get_position()),
+                             cvi.curr_coef());
+            else
+              
+              h1.update_coef(v3, cvi.curr_coef());
+            break;
+          }
+        case Wildcard_Var: 
+          {
+            Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                        f_exists, f_root, exists_mapping);
+            h1.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        case Global_Var: 
+          {
+            Global_Var_ID g = v->get_global_var();
+            Variable_ID v2;
+            if (g->arity() == 0)
+              v2 = r.get_local(g);
+            else
+              v2 = r.get_local(g, v->function_of());
+            h1.update_coef(v2, cvi.curr_coef());
+            break;
+          }
+        default:
+          assert(false);
+        }
+      }
+      h1.update_const((*gi).get_const());
+    }
+  }
+  
+  for (int i = 0; i < bound.size(); i++)
+    for (DNF_Iterator di(bound[i].query_DNF()); di; di++) {
+      for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+        GEQ_Handle h = f_root->add_GEQ();
+        if ((*gi).get_coef(bound[i].set_var(pos)) == 0) {
+          for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+            Variable_ID v = cvi.curr_var();
+            switch (v->kind()) {
+            case Input_Var: 
+              {
+                //if (i < level)
+                if (v->get_position() != pos)
+                  h.update_coef(r.input_var(v->get_position()),
+                                cvi.curr_coef());
+                else
+                  
+                  h.update_coef(v3, cvi.curr_coef());
+                break;
+                
+                //else
+                //  h.update_coef(
+                //      r.input_var(v->get_position() + 1),
+                //      cvi.curr_coef());
+                break;
+              }
+            case Wildcard_Var: 
+              {
+                Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                            f_exists, f_root, exists_mapping);
+                h.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            case Global_Var: 
+              {
+                Global_Var_ID g = v->get_global_var();
+                Variable_ID v2;
+                if (g->arity() == 0)
+                  v2 = r.get_local(g);
+                else
+                  v2 = r.get_local(g, v->function_of());
+                h.update_coef(v2, cvi.curr_coef());
+                break;
+              }
+            default:
+              assert(false);
+            }
+            
+          }
+          h.update_const((*gi).get_const());
+        }
+      }
+    }
+  return r;
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Replace an input variable's constraints as an existential in  order
+// to simplify other constraints in Relation
+// -----------------------------------------------------------------------------
+std::pair<Relation, bool> replace_set_var_as_existential(
+                                                         const omega::Relation &R, int pos,
+                                                         std::vector<omega::Relation> &bound) {
+  
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set());
+  for (int i = 1; i <= R.n_set(); i++)
+    r.name_set_var(i, const_cast<Relation &>(R).set_var(i)->name());
+  
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  int coef_in_equality = 0;
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++)
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++)
+      if (((*gi).get_coef(const_cast<Relation &>(R).set_var(pos)) != 0)
+          && (!(*gi).has_wildcards()))
+        if (coef_in_equality == 0)
+          coef_in_equality = (*gi).get_coef(
+                                            const_cast<Relation &>(R).set_var(pos));
+        else
+          return std::pair<Relation, bool>(copy(R), false);
+  
+  if (coef_in_equality < 0)
+    coef_in_equality = -coef_in_equality;
+  
+  std::pair<EQ_Handle, Variable_ID> result = find_simplest_stride(
+                                                                  const_cast<Relation &>(R), const_cast<Relation &>(R).set_var(pos));
+  
+  if (result.second == NULL && coef_in_equality != 1)
+    return std::pair<Relation, bool>(copy(R), false);
+  
+  if (result.second != NULL) {
+    if (result.first.get_coef(const_cast<Relation &>(R).set_var(pos)) != 1)
+      return std::pair<Relation, bool>(copy(R), false);
+    
+    if (result.first.get_coef(result.second) != coef_in_equality)
+      return std::pair<Relation, bool>(copy(R), false);
+  }
+  Variable_ID v3 = f_exists->declare();
+  
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h1 = f_root->add_EQ();
+      if ((*gi).get_coef(const_cast<Relation &>(R).set_var(pos)) == 0
+          || !(*gi).has_wildcards()) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var: 
+            {
+              if (v->get_position() != pos)
+                h1.update_coef(r.input_var(v->get_position()),
+                               cvi.curr_coef());
+              else
+                
+                h1.update_coef(v3, cvi.curr_coef());
+              break;
+            }
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                          f_exists, f_root, exists_mapping);
+              h1.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h1.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+        }
+        h1.update_const((*gi).get_const());
+      }
+    }
+  }
+  
+  for (int i = 0; i < bound.size(); i++)
+    for (DNF_Iterator di(bound[i].query_DNF()); di; di++) {
+      for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+        GEQ_Handle h = f_root->add_GEQ();
+        //if ((*gi).get_coef(const_cast<Relation &>(R).set_var(i)) != 0) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var: 
+            {
+              //if (i < level)
+              if (v->get_position() != pos)
+                
+                h.update_coef(r.set_var(v->get_position()),
+                              cvi.curr_coef());
+              else
+                
+                h.update_coef(v3, cvi.curr_coef());
+              
+              //else
+              //  h.update_coef(
+              //      r.input_var(v->get_position() + 1),
+              //      cvi.curr_coef());
+              break;
+            }
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                          f_exists, f_root, exists_mapping);
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+          
+        }
+        h.update_const((*gi).get_const());
+        //}
+      }
+    }
+  
+  //for (int i = 1; i <= R.n_set(); i++)
+  return std::pair<Relation, bool>(r, true);
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Copy all relations from r except those for set var v.
+// And with GEQ given by g
+// NOTE: This function only removes the relations involving v if they are simple relations
+// involving only v but not complex relations that have v in other variables' constraints
+// -----------------------------------------------------------------------------
+Relation and_with_relation_and_replace_var(const Relation &R, Variable_ID v1,
+                                           Relation &g) {
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set());
+  
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  EQ_Handle h = f_root->add_EQ();
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++) {
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++) {
+      EQ_Handle h = f_root->add_EQ();
+      if (!(*gi).is_const(v1) && !(*gi).is_const_except_for_global(v1)) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var: 
+            {
+              h.update_coef(r.input_var(v->get_position()),
+                            cvi.curr_coef());
+              break;
+            }
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                          f_exists, f_root, exists_mapping);
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+        }
+        
+        h.update_const((*gi).get_const());
+      }
+    }
+    
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++) {
+      GEQ_Handle h = f_root->add_GEQ();
+      if ((*gi).get_coef(v1) == 0) {
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var: 
+            {
+              h.update_coef(r.input_var(v->get_position()),
+                            cvi.curr_coef());
+              break;
+            }
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                          f_exists, f_root, exists_mapping);
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+        }
+        h.update_const((*gi).get_const());
+      }
+    }
+  }
+  for (DNF_Iterator di(const_cast<Relation &>(g).query_DNF()); di; di++)
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++)
+      r.and_with_GEQ(*gi);
+  
+  for (DNF_Iterator di(const_cast<Relation &>(g).query_DNF()); di; di++)
+    for (EQ_Iterator gi((*di)->EQs()); gi; gi++)
+      r.and_with_EQ(*gi);
+  
+  r.simplify();
+  r.copy_names(R);
+  r.setup_names();
+  return r;
+}
+
+
+
+
+
+omega::Relation extract_upper_bound(const Relation &R, Variable_ID v1) {
+  if (!R.is_set())
+    throw std::invalid_argument("Input R has to be a set not a relation!");
+  
+  Relation r(R.n_set());
+  
+  F_Exists *f_exists = r.add_and()->add_exists();
+  F_And *f_root = f_exists->add_and();
+  std::map<Variable_ID, Variable_ID> exists_mapping;
+  GEQ_Handle h = f_root->add_GEQ();
+  for (DNF_Iterator di(const_cast<Relation &>(R).query_DNF()); di; di++)
+    for (GEQ_Iterator gi((*di)->GEQs()); gi; gi++)
+      if ((*gi).get_coef(v1) < 0) {
+        
+        for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) {
+          Variable_ID v = cvi.curr_var();
+          switch (v->kind()) {
+          case Input_Var:
+            h.update_coef(r.input_var(v->get_position()),
+                          cvi.curr_coef());
+            break;
+          case Wildcard_Var: 
+            {
+              Variable_ID v2 = replicate_floor_definition(R, v, r,
+                                                          f_exists, f_root, exists_mapping);
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          case Global_Var: 
+            {
+              Global_Var_ID g = v->get_global_var();
+              Variable_ID v2;
+              if (g->arity() == 0)
+                v2 = r.get_local(g);
+              else
+                v2 = r.get_local(g, v->function_of());
+              h.update_coef(v2, cvi.curr_coef());
+              break;
+            }
+          default:
+            assert(false);
+          }
+        }
+        h.update_const((*gi).get_const());
+      }
+  
+  r.simplify();
+  
+  return r;
+  
+}
+
+/*CG_outputRepr * modified_output_subs_repr(CG_outputBuilder * ocg, const Relation &R, const EQ_Handle &h, Variable_ID v,const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly,
+  std::map<std::string, std::vector<CG_outputRepr *> > unin){
+  
+  
+  
+  
+  }
+*/
+
+
+
+
+
+CG_outputRepr * construct_int_floor(CG_outputBuilder * ocg, const Relation &R,
+                                    const GEQ_Handle &h, Variable_ID v,
+                                    const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly,
+                                    std::map<std::string, std::vector<CG_outputRepr *> > unin) {
+  
+  std::set<Variable_ID> excluded_floor_vars;
+  const_cast<Relation &>(R).setup_names(); // hack
+  assert(v->kind() == Set_Var);
+  
+  int a = h.get_coef(v);
+  
+  CG_outputRepr *lhs = ocg->CreateIdent(v->name());
+  excluded_floor_vars.insert(v);
+  std::vector<std::pair<bool, GEQ_Handle> > result2;
+  CG_outputRepr *repr = NULL;
+  for (Constr_Vars_Iter cvi(h); cvi; cvi++)
+    if (cvi.curr_var() != v) {
+      CG_outputRepr *t;
+      if (cvi.curr_var()->kind() == Wildcard_Var) {
+        std::pair<bool, GEQ_Handle> result = find_floor_definition(R,
+                                                                   cvi.curr_var(), excluded_floor_vars);
+        if (!result.first) {
+          coef_t coef_ = cvi.curr_coef();
+          result2 = find_floor_definition_temp(R, cvi.curr_var(),
+                                               excluded_floor_vars);
+          
+          for (Constr_Vars_Iter cvi_(
+                                     result2[result2.size() - 1].second); cvi_; cvi_++) {
+            if (cvi_.curr_var()->kind() != Wildcard_Var
+                && cvi_.curr_var()->kind() != Set_Var) {
+              t = output_ident(ocg, R, cvi_.curr_var(),
+                               assigned_on_the_fly, unin);
+              coef_t coef2 = cvi_.curr_coef();
+              assert(cvi_.curr_coef() == -1 && a == 1);
+              repr = ocg->CreateIntegerFloor(t,
+                                             ocg->CreateInt(-coef_));
+              repr = ocg->CreateTimes(ocg->CreateInt(-coef_),
+                                      repr);
+              
+              return repr;
+              
+            }
+            
+          }
+          
+        };
+        if (!result.first) {
+          delete repr;
+          throw omega_error(
+                            "Can't generate bound expression with wildcard not involved in floor definition");
+        }
+        
+        try {
+          t = output_inequality_repr(ocg, result.second,
+                                     cvi.curr_var(), R, assigned_on_the_fly, unin,
+                                     excluded_floor_vars);
+        } catch (const std::exception &e) {
+          delete repr;
+          throw e;
+        }
+      } 
+      else
+        t = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly,
+                         unin);
+      
+      coef_t coef = cvi.curr_coef();
+      if (a > 0) {
+        if (coef > 0) {
+          if (coef == 1)
+            repr = ocg->CreateMinus(repr, t);
+          else
+            repr = ocg->CreateMinus(repr,
+                                    ocg->CreateTimes(ocg->CreateInt(coef), t));
+        } 
+        else {
+          if (coef == -1)
+            repr = ocg->CreatePlus(repr, t);
+          else
+            repr = ocg->CreatePlus(repr,
+                                   ocg->CreateTimes(ocg->CreateInt(-coef), t));
+        }
+      } 
+      else {
+        if (coef > 0) {
+          if (coef == 1)
+            repr = ocg->CreatePlus(repr, t);
+          else
+            repr = ocg->CreatePlus(repr,
+                                   ocg->CreateTimes(ocg->CreateInt(coef), t));
+        } 
+        else {
+          if (coef == -1)
+            repr = ocg->CreateMinus(repr, t);
+          else
+            repr = ocg->CreateMinus(repr,
+                                    ocg->CreateTimes(ocg->CreateInt(-coef), t));
+        }
+      }
+    }
+  coef_t c = h.get_const();
+  if (c > 0) {
+    if (a > 0)
+      repr = ocg->CreateMinus(repr, ocg->CreateInt(c));
+    else
+      repr = ocg->CreatePlus(repr, ocg->CreateInt(c));
+  } 
+  else if (c < 0) {
+    if (a > 0)
+      repr = ocg->CreatePlus(repr, ocg->CreateInt(-c));
+    else
+      repr = ocg->CreateMinus(repr, ocg->CreateInt(-c));
+  }
+  
+  if (abs(a) == 1)
+    ocg->CreateAssignment(0, lhs, repr);
+  else if (a > 0)
+    return ocg->CreateAssignment(0, lhs,
+                                 ocg->CreateIntegerCeil(repr, ocg->CreateInt(a)));
+  else
+    // a < 0
+    return ocg->CreateAssignment(0, lhs,
+                                 ocg->CreateIntegerFloor(repr, ocg->CreateInt(-a)));
+  
+}
+
+
+
+