Index: /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/include/libdvo_astro.h
===================================================================
--- /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/include/libdvo_astro.h	(revision 38692)
+++ /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/include/libdvo_astro.h	(revision 38693)
@@ -56,6 +56,6 @@
   float dX;
   float dY;
-  float **dXv;
-  float **dYv;
+  float *dXv;
+  float *dYv;
   unsigned int tableID;
   unsigned int imageID;
@@ -65,4 +65,5 @@
 typedef struct {
   int Nmap;
+  int NMAP;
   AstromOffsetMap **map;
    int *imageIDtoTableSeq;
Index: /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapIO.c
===================================================================
--- /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapIO.c	(revision 38692)
+++ /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapIO.c	(revision 38693)
@@ -11,4 +11,5 @@
   FTable ftable;
   ftable.header = &theader;
+  ftable.buffer = NULL;
 
   FILE *f = fopen (filename, "r");
@@ -42,4 +43,15 @@
     int NrowsTotal = ftable.header[0].Naxis[1];
     int Nblocks = (NrowsTotal % Nrows) ? (int) (NrowsTotal / Nrows) + 1 : (NrowsTotal / Nrows);
+
+    // allocate the full array up front.  passes through AstromOffsetMapAppendToTable 
+    // check the current allocation and will bump the allocation as needed.
+    ALLOCATE (table, AstromOffsetTable, 1);
+    ALLOCATE (table->map, AstromOffsetMap *, NrowsTotal);
+    table->Nmap = 0;
+    table->NMAP = NrowsTotal;
+
+    // on each call to gfits_fread_ftable_range, we need to reset the FILE pointer to the
+    // beginning of the data block.  again this seems a little wrong.
+    off_t diskStart = ftello (f);
 
     int i;
@@ -51,8 +63,20 @@
 
       table = AstromOffsetMapAppendToTable (table, map_disk, Nmap);
-      gfits_free_table  (&ftable);
+
+      // XXX this is kind of hack-ish: gfits_fread_ftable_range modifies Naxis[1] to the
+      // number of rows actually read, but this makes a subsequent read invalid.  I'm
+      // resetting the value of Naxis[1] before the next read to deal with this problem.
+      // But is there a more consistent way to address this?
+
+      // Answer: the FTable structure could include information about the table
+      // representation on disk, including start,Nrows values.  I'm not going to mess
+      // around with that just now.
+
+      ftable.header[0].Naxis[1] = NrowsTotal;
+      fseeko (f, diskStart, SEEK_SET);
     }
     AstromOffsetTableSetIDs (table);
     gfits_free_header (ftable.header);
+    gfits_free_table  (&ftable);
   } else {
 
@@ -162,6 +186,6 @@
     table->map[i][0].Nx 	  = map_disk[i].Nx;
     table->map[i][0].Ny 	  = map_disk[i].Ny;
-    table->map[i][0].tableID = map_disk[i].tableID;
-    table->map[i][0].imageID = map_disk[i].imageID;
+    table->map[i][0].tableID      = map_disk[i].tableID;
+    table->map[i][0].imageID      = map_disk[i].imageID;
     
     // STORE THESE VALUES?
@@ -172,14 +196,14 @@
     table->map[i][0].keep 	  = TRUE;
 
-    ALLOCATE (table->map[i][0].dXv, float *, map_disk[i].Nx);
-    ALLOCATE (table->map[i][0].dYv, float *, map_disk[i].Nx);
-
-    for (j = 0; j < map_disk[i].Nx; j++) {
-      ALLOCATE (table->map[i][0].dXv[j], float, map_disk[i].Ny);
-      ALLOCATE (table->map[i][0].dYv[j], float, map_disk[i].Ny);
-
-      for (k = 0; k < map_disk[i].Ny; k++) {
-	table->map[i][0].dXv[j][k] = map_disk[i].dXv[j][k];
-	table->map[i][0].dYv[j][k] = map_disk[i].dYv[j][k];
+    int Nx = table->map[i][0].Nx;
+    int Ny = table->map[i][0].Ny;
+
+    ALLOCATE (table->map[i][0].dXv, float, Nx*Ny);
+    ALLOCATE (table->map[i][0].dYv, float, Nx*Ny);
+
+    for (j = 0; j < Nx; j++) {
+      for (k = 0; k < Ny; k++) {
+	table->map[i][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
+	table->map[i][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
       }
     }
@@ -209,8 +233,11 @@
     map_disk[Ndisk].dY 	    = table->map[i][0].dY;
 
-    for (j = 0; j < map_disk[Ndisk].Nx; j++) {
-      for (k = 0; k < map_disk[Ndisk].Ny; k++) {
-	map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j][k];
-	map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j][k];
+    int Nx = table->map[i][0].Nx;
+    int Ny = table->map[i][0].Ny;
+
+    for (j = 0; j < Nx; j++) {
+      for (k = 0; k < Ny; k++) {
+	map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j + k*Nx];
+	map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j + k*Nx];
       }
       for (k = map_disk[Ndisk].Ny; k < 6; k++) {
@@ -242,6 +269,9 @@
   } else {
     Nstart = table->Nmap;
+    if (table->Nmap + Nmap > table->NMAP) {
+      table->NMAP = table->Nmap + Nmap;
+      REALLOCATE (table->map, AstromOffsetMap *, table->NMAP);
+    }
     table->Nmap += Nmap;
-    REALLOCATE (table->map, AstromOffsetMap *, table->Nmap);
   }
 
@@ -264,14 +294,14 @@
     table->map[N][0].keep 	  = TRUE;
 
-    ALLOCATE (table->map[N][0].dXv, float *, map_disk[i].Nx);
-    ALLOCATE (table->map[N][0].dYv, float *, map_disk[i].Nx);
-
-    for (j = 0; j < map_disk[i].Nx; j++) {
-      ALLOCATE (table->map[N][0].dXv[j], float, map_disk[i].Ny);
-      ALLOCATE (table->map[N][0].dYv[j], float, map_disk[i].Ny);
-
-      for (k = 0; k < map_disk[i].Ny; k++) {
-	table->map[N][0].dXv[j][k] = map_disk[i].dXv[j][k];
-	table->map[N][0].dYv[j][k] = map_disk[i].dYv[j][k];
+    int Nx = table->map[N][0].Nx;
+    int Ny = table->map[N][0].Ny;
+
+    ALLOCATE (table->map[N][0].dXv, float, Nx*Ny);
+    ALLOCATE (table->map[N][0].dYv, float, Nx*Ny);
+
+    for (j = 0; j < Nx; j++) {
+      for (k = 0; k < Ny; k++) {
+	table->map[N][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
+	table->map[N][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
       }
     }
Index: /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapOps.c
===================================================================
--- /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapOps.c	(revision 38692)
+++ /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapOps.c	(revision 38693)
@@ -12,30 +12,33 @@
   // given x,y find the offset (x-direction) at that location from the map
 
-  float **V = xdir ? map->dXv : map->dYv;
+  int Nx = map->Nx;
+  int Ny = map->Ny;
+
+  float *V = xdir ? map->dXv : map->dYv;
 
   // if there is no spatial information, the value at the point is the value in the map
-  if ((map->Nx == 1) && (map->Ny == 1)) return V[0][0];
+  if ((Nx == 1) && (Ny == 1)) return V[0];
 
   // if there is no spatial information in 1D, the interpolation is 1D
-  if (map->Nx == 1) {
+  if (Nx == 1) {
     float ymo = y * map->dY - 0.5;
     int   ymi = floor(ymo);
-    ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
+    ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
 
     float ymf = ymo - ymi;
 
-    float value = ymf * V[0][ymi+1] + (1.0 - ymf) * V[0][ymi];
+    float value = ymf * V[ymi+1] + (1.0 - ymf) * V[ymi];
     return value;
   }
 
   // if there is no spatial information in 1D, the interpolation is 1D
-  if (map->Ny == 1) {
+  if (Ny == 1) {
     float xmo = x * map->dX - 0.5;
     int   xmi = floor(xmo);
-    xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
+    xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
 
     float xmf = xmo - xmi;
 
-    float value = xmf * V[xmi+1][0] + (1.0 - xmf) * V[xmi][0];
+    float value = xmf * V[xmi+1] + (1.0 - xmf) * V[xmi];
     return value;
   }
@@ -45,16 +48,16 @@
   float xmo = x * map->dX - 0.5;
   int   xmi = floor(xmo);
-  xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
+  xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
   float xmf = xmo - xmi;
 
   float ymo = y * map->dY - 0.5;
   int   ymi = floor(ymo);
-  ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
+  ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
   float ymf = ymo - ymi;
 
-  float V00 = V[xmi+0][ymi+0];
-  float V01 = V[xmi+0][ymi+1];
-  float V10 = V[xmi+1][ymi+0];
-  float V11 = V[xmi+1][ymi+1];
+  float V00 = V[xmi+0 + (ymi+0)*Nx];
+  float V01 = V[xmi+0 + (ymi+1)*Nx];
+  float V10 = V[xmi+1 + (ymi+0)*Nx];
+  float V11 = V[xmi+1 + (ymi+1)*Nx];
 
   float Vx0 = V10*xmf + V00*(1.0 - xmf);
@@ -78,5 +81,5 @@
 
   // choose to map direction:
-  float **V = xdir ? map->dXv : map->dYv;
+  float *Vptr = xdir ? map->dXv : map->dYv;
 
   // special cases:
@@ -88,5 +91,5 @@
 
     vstats_getstats_f (f, NULL, NULL, Npts, &stats);
-    V[0][0] = stats.mean;
+    Vptr[0] = stats.mean;
     return TRUE;
   }
@@ -352,5 +355,5 @@
     for (iy = 0; iy < Ny; iy++) {
       int I = ix + Nx * iy;
-      V[ix][iy] = B[I][0];
+      Vptr[I] = B[I][0];
       // error[ix][iy] = sqrt(A[I][I]);
     }
@@ -376,5 +379,5 @@
 
   // choose to map direction:
-  float **V = xdir ? map->dXv : map->dYv;
+  float *Vptr = xdir ? map->dXv : map->dYv;
 
   // measure clipped median in each bin
@@ -422,7 +425,7 @@
       if (Nvalue[I] > 5) {
 	vstats_getstats (values[I], NULL, NULL, Nvalue[I], &stats);
-	V[ix][iy] = stats.mean;
+	Vptr[I] = stats.mean;
       } else {
-	V[ix][iy] = NAN;
+	Vptr[I] = NAN;
       }
     }
@@ -453,10 +456,9 @@
   int ix, iy;
 
-  float **Vfix = NULL;
-  ALLOCATE (Vfix, float *, Nx);
+  float *Vfix = NULL;
+  ALLOCATE (Vfix, float, Nx*Ny);
   for (ix = 0; ix < Nx; ix++) {
-    ALLOCATE (Vfix[ix], float, Ny);
-    for (iy = 0; iy < Ny; iy++) {
-      Vfix[ix][iy] = NAN;
+    for (iy = 0; iy < Ny; iy++) {
+      Vfix[ix + iy*Nx] = NAN;
     }
   }
@@ -468,5 +470,6 @@
   for (ix = 0; ix < Nx; ix++) {
     for (iy = 0; iy < Ny; iy++) {
-      float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
+      int I = ix + iy*Nx;
+      float value = xdir ? map->dXv[I] : map->dYv[I];
       if (isnan(value)) continue;
       mean += value;
@@ -479,8 +482,8 @@
   for (ix = 0; ix < Nx; ix++) {
     for (iy = 0; iy < Ny; iy++) {
-
-      float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
+      int I = ix + iy*Nx;
+      float value = xdir ? map->dXv[I] : map->dYv[I];
       if (!isnan(value)) {
-	Vfix[ix][iy] = value;
+	Vfix[I] = value;
 	continue;
       }
@@ -499,5 +502,6 @@
 	  if (ny < 0) continue;
 	  if (ny >= Ny) continue;
-	  float value = xdir ? map->dXv[nx][ny] : map->dYv[nx][ny];
+	  int I = ix + iy*Nx;
+	  float value = xdir ? map->dXv[I] : map->dYv[I];
 	  if (isnan(value)) continue;
 
@@ -508,5 +512,5 @@
       // if there are no valid (non-NAN) local pixels, use global mean
       meanLocal = (npixLocal > 0.0) ? meanLocal / npixLocal : mean;
-      Vfix[ix][iy] = meanLocal;
+      Vfix[I] = meanLocal;
     }
   }
@@ -515,13 +519,11 @@
   for (ix = 0; ix < Ny; ix++) {
     for (iy = 0; iy < Ny; iy++) {
+      int I = ix + iy*Nx;
       if (xdir) {
-	map->dXv[ix][iy] = Vfix[ix][iy];
+	map->dXv[I] = Vfix[I];
       } else {
-	map->dYv[ix][iy] = Vfix[ix][iy];
-      }
-    }
-  }
-  for (ix = 0; ix < Nx; ix++) {
-    free (Vfix[ix]);
+	map->dYv[I] = Vfix[I];
+      }
+    }
   }
   free (Vfix);
Index: /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapUtils.c
===================================================================
--- /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapUtils.c	(revision 38692)
+++ /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapUtils.c	(revision 38693)
@@ -36,15 +36,12 @@
   map->keep = TRUE; // output map size
 
-  ALLOCATE (map->dXv, float *, map->Nx);
-  ALLOCATE (map->dYv, float *, map->Nx);
-
-  int j, k;
-  for (j = 0; j < map->Nx; j++) {
-    ALLOCATE (map->dXv[j], float, map->Ny);
-    ALLOCATE (map->dYv[j], float, map->Ny);
-
-    for (k = 0; k < map->Ny; k++) {
-      map->dXv[j][k] = 0.0;
-      map->dYv[j][k] = 0.0;
+  ALLOCATE (map->dXv, float, Nx*Ny);
+  ALLOCATE (map->dYv, float, Nx*Ny);
+
+  int j, k;
+  for (j = 0; j < Nx; j++) {
+    for (k = 0; k < Ny; k++) {
+      map->dXv[j + k*Nx] = 0.0;
+      map->dYv[j + k*Nx] = 0.0;
     }
   }
@@ -56,10 +53,4 @@
 
   if (!map) return;
-
-  int j;
-  for (j = 0; j < map->Nx; j++) {
-    if (map->dXv) free (map->dXv[j]);
-    if (map->dYv) free (map->dYv[j]);
-  }
 
   free (map->dXv);
@@ -76,8 +67,4 @@
 
   // rather than try to figure out how to resize, and free/allocate, lets just free the old arrays and make new ones
-  for (j = 0; j < map->Nx; j++) {
-    if (map->dXv) free (map->dXv[j]);
-    if (map->dYv) free (map->dYv[j]);
-  }
   free (map->dXv);
   free (map->dYv);
@@ -90,14 +77,11 @@
   map->keep = TRUE; // output map size
 
-  ALLOCATE (map->dXv, float *, map->Nx);
-  ALLOCATE (map->dYv, float *, map->Nx);
-
-  for (j = 0; j < map->Nx; j++) {
-    ALLOCATE (map->dXv[j], float, map->Ny);
-    ALLOCATE (map->dYv[j], float, map->Ny);
-
-    for (k = 0; k < map->Ny; k++) {
-      map->dXv[j][k] = 0.0;
-      map->dYv[j][k] = 0.0;
+  ALLOCATE (map->dXv, float, Nx*Ny);
+  ALLOCATE (map->dYv, float, Nx*Ny);
+
+  for (j = 0; j < Nx; j++) {
+    for (k = 0; k < Ny; k++) {
+      map->dXv[j + k*Nx] = 0.0;
+      map->dYv[j + k*Nx] = 0.0;
     }
   }
@@ -116,9 +100,12 @@
   tgt->tableID = map->tableID; 
 
-  int j, k;
-  for (j = 0; j < tgt->Nx; j++) {
-    for (k = 0; k < map->Ny; k++) {
-      tgt->dXv[j][k] = map->dXv[j][k];
-      tgt->dYv[j][k] = map->dYv[j][k];
+  int Nx = map->Nx;
+  int Ny = map->Ny;
+
+  int j, k;
+  for (j = 0; j < Nx; j++) {
+    for (k = 0; k < Ny; k++) {
+      tgt->dXv[j + k*Nx] = map->dXv[j + k*Nx];
+      tgt->dYv[j + k*Nx] = map->dYv[j + k*Nx];
     }
   }
@@ -139,9 +126,12 @@
   tgt->keep = src->keep; 
 
-  int j, k;
-  for (j = 0; j < tgt->Nx; j++) {
-    for (k = 0; k < src->Ny; k++) {
-      tgt->dXv[j][k] = src->dXv[j][k];
-      tgt->dYv[j][k] = src->dYv[j][k];
+  int Nx = src->dX;
+  int Ny = src->dY;
+
+  int j, k;
+  for (j = 0; j < Nx; j++) {
+    for (k = 0; k < Ny; k++) {
+      tgt->dXv[j + k*Nx] = src->dXv[j + k*Nx];
+      tgt->dYv[j + k*Nx] = src->dYv[j + k*Nx];
     }
   }
@@ -153,10 +143,6 @@
   if (!table) return;
 
-  int i, j;
+  int i;
   for (i = 0; i < table->Nmap; i++) {
-    for (j = 0; j < table->map[i][0].Nx; j++) {
-      free (table->map[i][0].dXv[j]);
-      free (table->map[i][0].dYv[j]);
-    }
     if (!table->map[i]) continue;
     FREE (table->map[i][0].dXv);
@@ -260,17 +246,20 @@
   }
 
+  int Nx = map->Nx;
+  int Ny = map->Ny;
+
   fprintf (f, "imageID: %d, tableID: %d (dX: %f, dY: %f), keep: %d\n", map->imageID, map->tableID, map->dX, map->dY, map->keep);
   int ix, iy;
   fprintf (f, "dXv map:\n");
-  for (ix = 0; ix < map->Nx; ix++) {
-    for (iy = 0; iy < map->Ny; iy++) {
-      fprintf (f, "%9.5f ", map->dXv[ix][iy]);
+  for (ix = 0; ix < Nx; ix++) {
+    for (iy = 0; iy < Ny; iy++) {
+      fprintf (f, "%9.5f ", map->dXv[ix + iy*Nx]);
     }
     fprintf (f, "\n");
   }
   fprintf (f, "dYv map:\n");
-  for (ix = 0; ix < map->Nx; ix++) {
-    for (iy = 0; iy < map->Ny; iy++) {
-      fprintf (f, "%9.5f ", map->dYv[ix][iy]);
+  for (ix = 0; ix < Nx; ix++) {
+    for (iy = 0; iy < Ny; iy++) {
+      fprintf (f, "%9.5f ", map->dYv[ix + iy*Nx]);
     }
     fprintf (f, "\n");
Index: /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/dvo_convert.c
===================================================================
--- /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/dvo_convert.c	(revision 38692)
+++ /branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/dvo_convert.c	(revision 38693)
@@ -77,4 +77,5 @@
     average = Average_PS1_V4alt_ToInternal (tmpAverage, *Naverage);
     free (tmpAverage);
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V4;
     return (average); 
@@ -91,19 +92,21 @@
     average = Average_PS1_V5alt_ToInternal (tmpAverage, *Naverage);
     free (tmpAverage);
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;
     return (average); 
   }
 
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
-  if (!strcmp (extname, NAME)) { \
-    Average_##TYPE *tmpAverage; \
-      tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
-    if (!tmpAverage) { \
-      fprintf (stderr, "ERROR: failed to read averages\n"); \
-      exit (2); \
-    } \
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
+  if (!strcmp (extname, NAME)) {					\
+    Average_##TYPE *tmpAverage;						\
+    tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
+    if (!tmpAverage) {							\
+      fprintf (stderr, "ERROR: failed to read averages\n");		\
+      exit (2);								\
+    }									\
     average = Average_##TYPE##_ToInternal (tmpAverage, *Naverage, primary); \
-    free (tmpAverage); \
-    *format = DVO_FORMAT_##FORMAT; \
+    free (tmpAverage);							\
+    ftable[0].buffer = NULL;						\
+    *format = DVO_FORMAT_##FORMAT;					\
     return (average); }
 
@@ -141,11 +144,11 @@
 int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, DVOCatFormat format, SecFilt *primary, int swapFromNative) {
   
-# define FORMAT_CASE(FORMAT, TYPE)		\
+# define FORMAT_CASE(FORMAT, TYPE)					\
   case DVO_FORMAT_##FORMAT: {						\
     Average_##TYPE *tmpAverage;						\
-      tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
-	gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
-	  free (tmpAverage);						\
-	  break; }
+    tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
+    gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
+    free (tmpAverage);							\
+    break; }
   
   /* convert from the internal format */
@@ -205,4 +208,5 @@
     measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure);
     free (tmpMeasure);
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V4;
     return (measure); 
@@ -222,19 +226,21 @@
     measure = Measure_PS1_V5alt_ToInternal (average, tmpMeasure, *Nmeasure);
     free (tmpMeasure);
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;
     return (measure); 
   }
 
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)		\
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)			\
   if (!strcmp (extname, NAME)) {					\
     Measure_##TYPE *tmpMeasure;						\
-      tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
-	if (!tmpMeasure) {						\
-	  fprintf (stderr, "ERROR: failed to read measures\n");		\
-	  exit (2);							\
-	}								\
-	myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
+    tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
+    if (!tmpMeasure) {							\
+      fprintf (stderr, "ERROR: failed to read measures\n");		\
+      exit (2);								\
+    }									\
+    myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
     measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, *Nmeasure); \
     free (tmpMeasure);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (measure); }
@@ -274,12 +280,12 @@
 int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)		\
-    case DVO_FORMAT_##FORMAT: { \
-      Measure_##TYPE *tmpMeasure; \
-      myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
-      tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
-	gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
-      free (tmpMeasure); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)				\
+  case DVO_FORMAT_##FORMAT: {						\
+    Measure_##TYPE *tmpMeasure;						\
+    myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
+    tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
+    gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
+    free (tmpMeasure);							\
+    break; }
 
   /* convert from the internal format */
@@ -324,12 +330,12 @@
   }
 
-# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)		\
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     fprintf (stderr, "ERROR: format %s not defined for missing, skipping\n", NAME); \
-    *Nmissing = 0; \
-    return NULL; \
-  }
-
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+    *Nmissing = 0;							\
+    return NULL;							\
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     Missing_##TYPE *tmpMissing;						\
@@ -339,6 +345,7 @@
       exit (2);								\
     }									\
-    missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing); \
+    missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing);	\
     free (tmpMissing);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (missing); }
@@ -410,4 +417,5 @@
     secfilt = SecFilt_PS1_V5alt_ToInternal (tmpSecFilt, *Nsecfilt);
     free (tmpSecFilt);
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;
     return (secfilt); 
@@ -415,15 +423,16 @@
 
 
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
-  if (!strcmp (extname, NAME)) { \
-    SecFilt_##TYPE *tmpSecFilt; \
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
+  if (!strcmp (extname, NAME)) {					\
+    SecFilt_##TYPE *tmpSecFilt;						\
     tmpSecFilt = gfits_table_get_SecFilt_##TYPE (ftable, Nsecfilt, NULL, &nativeBytes); \
-    if (!tmpSecFilt) { \
-      fprintf (stderr, "ERROR: failed to read secfilts\n"); \
-      exit (2); \
-    } \
-    secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt); \
-    free (tmpSecFilt); \
-    *format = DVO_FORMAT_##FORMAT; \
+    if (!tmpSecFilt) {							\
+      fprintf (stderr, "ERROR: failed to read secfilts\n");		\
+      exit (2);								\
+    }									\
+    secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt);	\
+    free (tmpSecFilt);							\
+    ftable[0].buffer = NULL;						\
+    *format = DVO_FORMAT_##FORMAT;					\
     return (secfilt); }
 
@@ -461,11 +470,11 @@
 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE) \
-    case DVO_FORMAT_##FORMAT: { \
-      SecFilt_##TYPE *tmpSecFilt; \
-      tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
-	gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
-      free (tmpSecFilt); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    SecFilt_##TYPE *tmpSecFilt;						\
+    tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt);		\
+    gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
+    free (tmpSecFilt);							\
+    break; }
 
   /* convert from the internal format */
@@ -519,4 +528,5 @@
     lensing = Lensing_PS1_V5_R0_ToInternal (tmpLensing, *Nlensing); 
     free (tmpLensing);							
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;					
     return (lensing); }
@@ -531,4 +541,5 @@
     lensing = Lensing_PS1_V5_R1_ToInternal (tmpLensing, *Nlensing); 
     free (tmpLensing);							
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;					
     return (lensing); }
@@ -543,15 +554,16 @@
     lensing = Lensing_PS1_V5_R2_ToInternal (tmpLensing, *Nlensing); 
     free (tmpLensing);							
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;					
     return (lensing); }
 
-# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)		\
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     fprintf (stderr, "ERROR: format %s not defined for lensing, skipping\n", NAME); \
-    *Nlensing = 0; \
-    return NULL; \
-  }
-
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+    *Nlensing = 0;							\
+    return NULL;							\
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     Lensing_##TYPE *tmpLensing;						\
@@ -561,6 +573,7 @@
       exit (2);								\
     }									\
-    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \
+    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing);	\
     free (tmpLensing);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (lensing); }
@@ -601,11 +614,11 @@
 int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE)		\
-    case DVO_FORMAT_##FORMAT: { \
-      Lensing_##TYPE *tmpLensing; \
-      tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \
-	gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
-      free (tmpLensing); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    Lensing_##TYPE *tmpLensing;						\
+    tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing);		\
+    gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
+    free (tmpLensing);							\
+    break; }
 
   /* convert from the internal format */
@@ -658,15 +671,16 @@
     lensobj = Lensobj_PS1_V5_R0_ToInternal (tmpLensobj, *Nlensobj); 
     free (tmpLensobj);							
+    ftable[0].buffer = NULL;
     *format = DVO_FORMAT_PS1_V5;					
     return (lensobj); }
 
-# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)		\
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     fprintf (stderr, "ERROR: format %s not defined for lensobj, skipping\n", NAME); \
-    *Nlensobj = 0; \
-    return NULL; \
-  }
-
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+    *Nlensobj = 0;							\
+    return NULL;							\
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     Lensobj_##TYPE *tmpLensobj;						\
@@ -676,6 +690,7 @@
       exit (2);								\
     }									\
-    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \
+    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj);	\
     free (tmpLensobj);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (lensobj); }
@@ -716,11 +731,11 @@
 int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE)		\
-    case DVO_FORMAT_##FORMAT: { \
-      Lensobj_##TYPE *tmpLensobj; \
-      tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \
-	gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
-      free (tmpLensobj); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    Lensobj_##TYPE *tmpLensobj;						\
+    tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj);		\
+    gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
+    free (tmpLensobj);							\
+    break; }
 
   /* convert from the internal format */
@@ -764,12 +779,12 @@
   }
 
-# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)		\
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     fprintf (stderr, "ERROR: format %s not defined for starpar, skipping\n", NAME); \
-    *Nstarpar = 0; \
-    return NULL; \
-  }
-
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+    *Nstarpar = 0;							\
+    return NULL;							\
+  }
+  
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     StarPar_##TYPE *tmpStarPar;						\
@@ -779,6 +794,7 @@
       exit (2);								\
     }									\
-    starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar); \
+    starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar);	\
     free (tmpStarPar);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (starpar); }
@@ -819,11 +835,11 @@
 int StarParToFtable (FTable *ftable, StarPar *starpar, off_t Nstarpar, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE)		\
-    case DVO_FORMAT_##FORMAT: { \
-      StarPar_##TYPE *tmpStarPar; \
-      tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar); \
-	gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
-      free (tmpStarPar); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    StarPar_##TYPE *tmpStarPar;						\
+    tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar);		\
+    gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
+    free (tmpStarPar);							\
+    break; }
 
   /* convert from the internal format */
@@ -868,12 +884,12 @@
   }
 
-# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)		\
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     fprintf (stderr, "ERROR: format %s not defined for galphot, skipping\n", NAME); \
-    *Ngalphot = 0; \
-    return NULL; \
-  }
-
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+    *Ngalphot = 0;							\
+    return NULL;							\
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
   if (!strcmp (extname, NAME)) {					\
     GalPhot_##TYPE *tmpGalPhot;						\
@@ -883,6 +899,7 @@
       exit (2);								\
     }									\
-    galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot); \
+    galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot);	\
     free (tmpGalPhot);							\
+    ftable[0].buffer = NULL;						\
     *format = DVO_FORMAT_##FORMAT;					\
     return (galphot); }
@@ -923,11 +940,11 @@
 int GalPhotToFtable (FTable *ftable, GalPhot *galphot, off_t Ngalphot, DVOCatFormat format, int swapFromNative) {
 
-# define FORMAT_CASE(FORMAT, TYPE)		\
-    case DVO_FORMAT_##FORMAT: { \
-      GalPhot_##TYPE *tmpGalPhot; \
-      tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot); \
-	gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
-      free (tmpGalPhot); \
-      break; }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    GalPhot_##TYPE *tmpGalPhot;						\
+    tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot);		\
+    gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
+    free (tmpGalPhot);							\
+    break; }
 
   /* convert from the internal format */
@@ -992,21 +1009,21 @@
   }
 
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
-  if (!strcmp (extname, NAME)) { \
-    Image_##TYPE *tmpimage; \
-    *format = DVO_FORMAT_##FORMAT; \
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)				\
+  if (!strcmp (extname, NAME)) {					\
+    Image_##TYPE *tmpimage;						\
+    *format = DVO_FORMAT_##FORMAT;					\
     tmpimage = gfits_table_get_Image_##TYPE (ftable, &Nimage, NULL, NULL); \
-    if (!tmpimage) { \
-      fprintf (stderr, "ERROR: failed to read images\n"); \
-      exit (2); \
-    } \
+    if (!tmpimage) {							\
+      fprintf (stderr, "ERROR: failed to read images\n");		\
+      exit (2);								\
+    }									\
     off_t Nalloc = gfits_data_pad_size(Nimage*sizeof(Image));		\
     ftable[0].buffer = (char *) Image_##TYPE##_ToInternal (tmpimage, Nimage, Nalloc); \
-    free (tmpimage); \
-    gfits_free_header (theader); \
-    gfits_table_mkheader_Image (theader); \
-    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
-    theader[0].Naxis[1] = Nimage; \
-    ftable[0].datasize = gfits_data_size (theader); \
+    free (tmpimage);							\
+    gfits_free_header (theader);					\
+    gfits_table_mkheader_Image (theader);				\
+    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);		\
+    theader[0].Naxis[1] = Nimage;					\
+    ftable[0].datasize = gfits_data_size (theader);			\
     return (TRUE); }
 
@@ -1037,29 +1054,29 @@
   Nimage = theader[0].Naxis[1];
 
-# define FORMAT_CASE(FORMAT, TYPE)		\
-  case DVO_FORMAT_##FORMAT: {			\
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
     Image_##TYPE *tmpImage;						\
-      tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
-	free (ftable[0].buffer);					\
-	gfits_free_header (ftable->header);				\
-	gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);	\
-	  free (tmpImage);						\
-	  break; }
+    tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
+    free (ftable[0].buffer);						\
+    gfits_free_header (ftable->header);					\
+    gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);	\
+    free (tmpImage);							\
+    break; }
 
   /* convert from the internal format */
   switch (format) {
-      FORMAT_CASE (ELIXIR, 	    Elixir);
-      FORMAT_CASE (LONEOS, 	    Loneos);
-      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
-      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
-      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
-      FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
-      FORMAT_CASE (PS1_V1,          PS1_V1);
-      FORMAT_CASE (PS1_V2,          PS1_V2);
-      FORMAT_CASE (PS1_V3,          PS1_V3);
-      FORMAT_CASE (PS1_V4,          PS1_V4);
-      FORMAT_CASE (PS1_V5,          PS1_V5);
-      FORMAT_CASE (PS1_REF,         PS1_REF);
-      FORMAT_CASE (PS1_SIM,         PS1_SIM);
+    FORMAT_CASE (ELIXIR, 	    Elixir);
+    FORMAT_CASE (LONEOS, 	    Loneos);
+    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
+    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
+    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
+    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
+    FORMAT_CASE (PS1_V1,          PS1_V1);
+    FORMAT_CASE (PS1_V2,          PS1_V2);
+    FORMAT_CASE (PS1_V3,          PS1_V3);
+    FORMAT_CASE (PS1_V4,          PS1_V4);
+    FORMAT_CASE (PS1_V5,          PS1_V5);
+    FORMAT_CASE (PS1_REF,         PS1_REF);
+    FORMAT_CASE (PS1_SIM,         PS1_SIM);
 
 # undef FORMAT_CASE
@@ -1078,39 +1095,39 @@
   Nrow = vtable[0].Nrow;
 
-# define FORMAT_CASE(FORMAT, TYPE) \
-  case DVO_FORMAT_##FORMAT: { \
-      Image_##TYPE *tmpImage; \
-      /* convert table rows from internal to external format */ \
-      for (i = 0; i < Nrow; i++) { \
-	  tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
-	  gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1); \
-	  free (vtable[0].buffer[i]); \
-	  vtable[0].buffer[i] = (char *) tmpImage; \
-      } \
-      /* convert header from old format to new format */ \
-      gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage); \
-      gfits_free_header (theader); \
-      gfits_table_mkheader_Image_##TYPE (theader); \
-      gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
-      theader[0].Naxis[1] = Nimage; \
-      vtable[0].datasize = gfits_data_size (theader); \
-      return (TRUE); }
+# define FORMAT_CASE(FORMAT, TYPE)					\
+  case DVO_FORMAT_##FORMAT: {						\
+    Image_##TYPE *tmpImage;						\
+    /* convert table rows from internal to external format */		\
+    for (i = 0; i < Nrow; i++) {					\
+      tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
+      gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1);	\
+      free (vtable[0].buffer[i]);					\
+      vtable[0].buffer[i] = (char *) tmpImage;				\
+    }									\
+    /* convert header from old format to new format */			\
+    gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage);		\
+    gfits_free_header (theader);					\
+    gfits_table_mkheader_Image_##TYPE (theader);			\
+    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);		\
+    theader[0].Naxis[1] = Nimage;					\
+    vtable[0].datasize = gfits_data_size (theader);			\
+    return (TRUE); }
 
 
   /* convert from the internal format */
   switch (format) {
-      FORMAT_CASE (ELIXIR, 	    Elixir);
-      FORMAT_CASE (LONEOS, 	    Loneos);
-      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
-      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
-      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
-      FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
-      FORMAT_CASE (PS1_V1,          PS1_V1);
-      FORMAT_CASE (PS1_V2,          PS1_V2);
-      FORMAT_CASE (PS1_V3,          PS1_V3);
-      FORMAT_CASE (PS1_V4,          PS1_V4);
-      FORMAT_CASE (PS1_V5,          PS1_V5);
-      FORMAT_CASE (PS1_REF,         PS1_REF);
-      FORMAT_CASE (PS1_SIM,         PS1_SIM);
+    FORMAT_CASE (ELIXIR, 	    Elixir);
+    FORMAT_CASE (LONEOS, 	    Loneos);
+    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
+    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
+    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
+    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
+    FORMAT_CASE (PS1_V1,          PS1_V1);
+    FORMAT_CASE (PS1_V2,          PS1_V2);
+    FORMAT_CASE (PS1_V3,          PS1_V3);
+    FORMAT_CASE (PS1_V4,          PS1_V4);
+    FORMAT_CASE (PS1_V5,          PS1_V5);
+    FORMAT_CASE (PS1_REF,         PS1_REF);
+    FORMAT_CASE (PS1_SIM,         PS1_SIM);
 
 # undef FORMAT_CASE