Index: trunk/Ohana/src/dvomerge/include/dvomerge.h
===================================================================
--- trunk/Ohana/src/dvomerge/include/dvomerge.h	(revision 39536)
+++ trunk/Ohana/src/dvomerge/include/dvomerge.h	(revision 39926)
@@ -61,4 +61,5 @@
 int    SKIP_MEASURE;
 int    SKIP_LENSING;
+int    SKIP_LENSOBJ;
 int    SKIP_STARPAR;
 int    SKIP_GALPHOT;
@@ -171,24 +172,29 @@
 off_t 	  *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
 off_t 	  *init_measure_links     PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
-int   	   add_meas_link     	  PROTO((Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE));
+int   	   add_measure_link    	  PROTO((Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE));
 Measure   *sort_measure     	  PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next));
 
 off_t 	  *build_lensing_links    PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
 off_t 	  *init_lensing_links     PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
-int   	   add_lens_link     	  PROTO((Average *average, off_t *next, off_t Nlensing, off_t NLENSING));
+int   	   add_lensing_link    	  PROTO((Average *average, off_t *next, off_t Nlensing, off_t NLENSING));
 Lensing   *sort_lensing     	  PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next));
+
+off_t 	  *build_lensobj_links    PROTO((Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj));
+off_t 	  *init_lensobj_links     PROTO((Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj));
+int   	   add_lensobj_link    	  PROTO((Average *average, off_t *next, off_t Nlensobj, off_t NLENSOBJ));
+Lensobj   *sort_lensobj     	  PROTO((Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj, off_t *next));
 
 off_t 	  *build_starpar_links    PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar));
 off_t 	  *init_starpar_links     PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar));
-int   	   add_star_link     	  PROTO((Average *average, off_t *next, off_t Nstarpar, off_t NSTARPAR));
+int   	   add_starpar_link     	  PROTO((Average *average, off_t *next, off_t Nstarpar, off_t NSTARPAR));
 StarPar   *sort_starpar     	  PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next));
 
 off_t 	  *build_galphot_links    PROTO((Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot));
 off_t 	  *init_galphot_links     PROTO((Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot));
-int   	   add_galp_link     	  PROTO((Average *average, off_t *next, off_t Ngalphot, off_t NGALPHOT));
+int   	   add_galphot_link     	  PROTO((Average *average, off_t *next, off_t Ngalphot, off_t NGALPHOT));
 GalPhot   *sort_galphot     	  PROTO((Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot, off_t *next));
 
 off_t 	  *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
-int   	   add_miss_link     	  PROTO((Average *average, off_t *next, off_t Nmissing));
+int   	   add_missing_link     	  PROTO((Average *average, off_t *next, off_t Nmissing));
 Missing   *sort_missing     	  PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss));
 
Index: trunk/Ohana/src/dvomerge/src/LoadCatalog.c
===================================================================
--- trunk/Ohana/src/dvomerge/src/LoadCatalog.c	(revision 39536)
+++ trunk/Ohana/src/dvomerge/src/LoadCatalog.c	(revision 39926)
@@ -9,7 +9,6 @@
 
   // always load all of the data (if any exists)
-  // XXXX TEMP HACK : skip GALPHOT
 
-  catalog[0].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT | DVO_LOAD_LENSOBJ;
+  catalog[0].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT;
 
   if (SKIP_MEASURE) {
@@ -23,4 +22,10 @@
   } else {
     catalog[0].catflags = catalog[0].catflags | DVO_LOAD_LENSING;
+  }
+
+  if (SKIP_LENSOBJ)  {
+    catalog[0].catflags = catalog[0].catflags | DVO_SKIP_LENSOBJ;
+  } else {
+    catalog[0].catflags = catalog[0].catflags | DVO_LOAD_LENSOBJ;
   }
 
Index: trunk/Ohana/src/dvomerge/src/args.c
===================================================================
--- trunk/Ohana/src/dvomerge/src/args.c	(revision 39536)
+++ trunk/Ohana/src/dvomerge/src/args.c	(revision 39926)
@@ -56,4 +56,9 @@
   if ((N = get_argument (*argc, argv, "-skip-lensing"))) {
     SKIP_LENSING = TRUE;
+    remove_argument (N, argc, argv);
+  }
+  SKIP_LENSOBJ = FALSE;
+  if ((N = get_argument (*argc, argv, "-skip-lensobj"))) {
+    SKIP_LENSOBJ = TRUE;
     remove_argument (N, argc, argv);
   }
@@ -340,4 +345,9 @@
     remove_argument (N, argc, argv);
   }
+  SKIP_LENSOBJ = FALSE;
+  if ((N = get_argument (*argc, argv, "-skip-lensobj"))) {
+    SKIP_LENSOBJ = TRUE;
+    remove_argument (N, argc, argv);
+  }
   SKIP_STARPAR = FALSE;
   if ((N = get_argument (*argc, argv, "-skip-starpar"))) {
Index: trunk/Ohana/src/dvomerge/src/build_links.c
===================================================================
--- trunk/Ohana/src/dvomerge/src/build_links.c	(revision 39536)
+++ trunk/Ohana/src/dvomerge/src/build_links.c	(revision 39926)
@@ -15,10 +15,10 @@
 data: they refer to the sequence number in the data blocks.
 
-next_meas is a list of the equivalent sequence of the measure block as if it were sorted.
+next_measure is a list of the equivalent sequence of the measure block as if it were sorted.
 
 to find the sequence of measurements for a given average:
 n_0 = average->measureOffset
-n_1 = next_meas[n_0]
-n_i = next_meas[n_i-1]
+n_1 = next_measure[n_0]
+n_i = next_measure[n_i-1]
 
 */
@@ -31,5 +31,5 @@
 
   off_t i, j, N;
-  off_t *next_meas;
+  off_t *next_measure;
 
   if (!measure) return NULL;
@@ -38,5 +38,5 @@
   N = 0;
 
-  ALLOCATE (next_meas, off_t, Nmeasure);
+  ALLOCATE (next_measure, off_t, Nmeasure);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Nmeasure) continue;
@@ -45,10 +45,10 @@
     for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
       myAssert (measure[m+j+1].averef == i, "not sorted");
-      next_meas[N] = N + 1;
+      next_measure[N] = N + 1;
       if (N >= Nmeasure) {
 	fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_meas[N] = -1;
+    next_measure[N] = -1;
     if (N >= Nmeasure) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -61,5 +61,5 @@
     N++;
   }
-  return (next_meas);
+  return (next_measure);
 }
 
@@ -74,7 +74,7 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_meas;
-
-  ALLOCATE (next_meas, off_t, Nmeasure);
+  off_t *next_measure;
+
+  ALLOCATE (next_measure, off_t, Nmeasure);
 
   /* reset the Nm, offset values for average */
@@ -87,5 +87,5 @@
     averef = measure[Nm].averef;
     m = average[averef].measureOffset;  
-    next_meas[Nm] = -1;
+    next_measure[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -95,6 +95,6 @@
     }
 
-    for (k = 0; next_meas[m] != -1; k++) {
-      m = next_meas[m];
+    for (k = 0; next_measure[m] != -1; k++) {
+      m = next_measure[m];
       if (m >= Nmeasure) {
 	fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -103,22 +103,22 @@
 
     average[averef].Nmeasure = k + 2;
-    next_meas[m] = Nm;
+    next_measure[m] = Nm;
     if (m >= Nmeasure) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_meas);
+  return (next_measure);
 }
 
 /* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
-int add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
+int add_measure_link (Average *average, off_t *next_measure, off_t Nmeasure, off_t NMEASURE) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
+  /* if we have trouble, check validity of next_measure[m] : m < Nmeasure */
   m = average[0].measureOffset;  
 
   for (k = 0; k < average[0].Nmeasure - 1; k++)  {
-    m = next_meas[m];
+    m = next_measure[m];
     if (m >= NMEASURE) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -127,5 +127,5 @@
 
   /* set up references */
-  next_meas[Nmeasure] = -1;
+  next_measure[Nmeasure] = -1;
   if (Nmeasure >= NMEASURE) {
     fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
@@ -136,5 +136,5 @@
     average[0].measureOffset = Nmeasure;
   } else {
-    next_meas[m] = Nmeasure;
+    next_measure[m] = Nmeasure;
     if (m >= NMEASURE) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -145,5 +145,5 @@
 }
 
-Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
+Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_measure) {
 
   off_t i, k, n, np, N;
@@ -169,5 +169,5 @@
       tmpmeasure[N].averef = i;
       np = n;
-      n = next_meas[n];
+      n = next_measure[n];
     }
   }
@@ -183,15 +183,15 @@
 
   off_t i, j, N;
-  off_t *next_miss;
+  off_t *next_missing;
 
   N = 0;
 
-  ALLOCATE (next_miss, off_t, Nmissing);
+  ALLOCATE (next_missing, off_t, Nmissing);
   for (i = 0; i < Naverage; i++) {
     for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
-      next_miss[N] = N + 1;
+      next_missing[N] = N + 1;
     }
     if (average[i].Nmissing > 0) {
-      next_miss[N] = -1;
+      next_missing[N] = -1;
       if (N >= Nmissing) {
 	fprintf (stderr, "overflow in init_missing_links");
@@ -202,8 +202,8 @@
 
   }
-  return (next_miss);
-}
-
-int add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
+  return (next_missing);
+}
+
+int add_missing_link (Average *average, off_t *next_missing, off_t Nmissing) {
 
   off_t k, m;
@@ -212,13 +212,13 @@
   if (average[0].Nmissing < 1) {
     average[0].missingOffset = Nmissing;
-    next_miss[Nmissing] = -1;
+    next_missing[Nmissing] = -1;
     return (TRUE);
   }
 
   m = average[0].missingOffset;  
-  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
+  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_missing[m];
   /* set up references */
-  next_miss[Nmissing] = -1;
-  next_miss[m] = Nmissing;
+  next_missing[Nmissing] = -1;
+  next_missing[m] = Nmissing;
   return (TRUE);
 }
@@ -227,5 +227,5 @@
    we must always save the missing table, if it exists */
 
-Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
+Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_missing) {
 
   off_t i, k, n, N;
@@ -240,5 +240,5 @@
     for (k = 0; k < average[i].Nmissing; k++, N++) {
       tmpmissing[N] = missing[n]; 
-      n = next_miss[n];
+      n = next_missing[n];
     }
   }
@@ -254,5 +254,5 @@
 
   off_t i, j, N;
-  off_t *next_lens;
+  off_t *next_lensing;
 
   if (!lensing) return NULL;
@@ -261,5 +261,5 @@
   N = 0;
 
-  ALLOCATE (next_lens, off_t, Nlensing);
+  ALLOCATE (next_lensing, off_t, Nlensing);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Nlensing) continue;
@@ -268,10 +268,10 @@
     for (j = 0; j < average[i].Nlensing - 1; j++, N++) {
       myAssert (lensing[m+j+1].averef == i, "not sorted");
-      next_lens[N] = N + 1;
+      next_lensing[N] = N + 1;
       if (N >= Nlensing) {
 	fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_lens[N] = -1;
+    next_lensing[N] = -1;
     if (N >= Nlensing) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -284,5 +284,5 @@
     N++;
   }
-  return (next_lens);
+  return (next_lensing);
 }
 
@@ -297,7 +297,7 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_lens;
-
-  ALLOCATE (next_lens, off_t, Nlensing);
+  off_t *next_lensing;
+
+  ALLOCATE (next_lensing, off_t, Nlensing);
 
   /* reset the Nm, offset values for average */
@@ -310,5 +310,5 @@
     averef = lensing[Nm].averef;
     m = average[averef].lensingOffset;  
-    next_lens[Nm] = -1;
+    next_lensing[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -318,6 +318,6 @@
     }
 
-    for (k = 0; next_lens[m] != -1; k++) {
-      m = next_lens[m];
+    for (k = 0; next_lensing[m] != -1; k++) {
+      m = next_lensing[m];
       if (m >= Nlensing) {
 	fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -326,22 +326,22 @@
 
     average[averef].Nlensing = k + 2;
-    next_lens[m] = Nm;
+    next_lensing[m] = Nm;
     if (m >= Nlensing) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_lens);
+  return (next_lensing);
 }
 
 /* average[].lensingOffset, average[].Nlensing are valid within an addstar run */
-int add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) {
+int add_lensing_link (Average *average, off_t *next_lensing, off_t Nlensing, off_t NLENSING) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_lens[m] : m < Nlensing */
+  /* if we have trouble, check validity of next_lensing[m] : m < Nlensing */
   m = average[0].lensingOffset;  
 
   for (k = 0; k < average[0].Nlensing - 1; k++)  {
-    m = next_lens[m];
+    m = next_lensing[m];
     if (m >= NLENSING) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -350,5 +350,5 @@
 
   /* set up references */
-  next_lens[Nlensing] = -1;
+  next_lensing[Nlensing] = -1;
   if (Nlensing >= NLENSING) {
     fprintf (stderr, "WARNING: Nlensing out of bounds (1)\n");
@@ -359,5 +359,5 @@
     average[0].lensingOffset = Nlensing;
   } else {
-    next_lens[m] = Nlensing;
+    next_lensing[m] = Nlensing;
     if (m >= NLENSING) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -368,5 +368,5 @@
 }
 
-Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens) {
+Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lensing) {
 
   off_t i, k, n, np, N;
@@ -392,9 +392,167 @@
       tmplensing[N].averef = i;
       np = n;
-      n = next_lens[n];
+      n = next_lensing[n];
     }
   }
   free (lensing);
   return (tmplensing);
+}
+
+/*** Lensobj ****************************************************************************************/
+
+/* build the initial links assuming the table is sorted, 
+   not partial, and has a correct set of average[].lensobjOffset,Nlensobj values */
+off_t *init_lensobj_links (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj) {
+
+  off_t i, j, N;
+  off_t *next_lensobj;
+
+  if (!lensobj) return NULL;
+  if (SKIP_LENSOBJ) return NULL;
+
+  N = 0;
+
+  ALLOCATE (next_lensobj, off_t, Nlensobj);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensobj) continue;
+    // off_t m = average[i].lensobjOffset;
+    // myAssert (lensobj[m].averef == i, "not sorted");
+    for (j = 0; j < average[i].Nlensobj - 1; j++, N++) {
+      // myAssert (lensobj[m+j+1].averef == i, "not sorted");
+      next_lensobj[N] = N + 1;
+      if (N >= Nlensobj) {
+	fprintf (stderr, "WARNING: N out of bounds (1)\n");
+      }
+    }
+    next_lensobj[N] = -1;
+    if (N >= Nlensobj) {
+      fprintf (stderr, "WARNING: N out of bounds (2)\n");
+    }
+
+    if (N >= Nlensobj) {
+      fprintf (stderr, "overflow in init_lensobj_links\n");
+      abort ();
+    }
+    N++;
+  }
+  return (next_lensobj);
+}
+
+/* construct lensobj links which are valid FOR THIS LOAD
+ * - if we have a full load, we will get links which can
+ *   be used by other programs (eg, relphot, etc)
+ * - if we have a partial load, the links are only valid
+ *   for that partial load
+ */ 
+
+off_t *build_lensobj_links (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj) {
+
+  fprintf (stderr, "input is not sorted but contains lensobj -- trouble\n");
+  exit (2);
+
+# if (0)
+
+  off_t i, m, k, Nm, averef;
+  off_t *next_lensobj;
+
+  ALLOCATE (next_lensobj, off_t, Nlensobj);
+
+  /* reset the Nm, offset values for average */
+  for (i = 0; i < Naverage; i++) {
+    average[i].lensobjOffset = -1;
+    average[i].Nlensobj     =  0;
+  }
+
+  for (Nm = 0; Nm < Nlensobj; Nm++) {
+    averef = lensobj[Nm].averef;
+    m = average[averef].lensobjOffset;  
+    next_lensobj[Nm] = -1;
+
+    if (m == -1) { /* no links yet for source */
+      average[averef].lensobjOffset = Nm;
+      average[averef].Nlensobj     = 1;
+      continue;
+    }
+
+    for (k = 0; next_lensobj[m] != -1; k++) {
+      m = next_lensobj[m];
+      if (m >= Nlensobj) {
+	fprintf (stderr, "WARNING: m out of bounds (1)\n");
+      }
+    }
+
+    average[averef].Nlensobj = k + 2;
+    next_lensobj[m] = Nm;
+    if (m >= Nlensobj) {
+      fprintf (stderr, "WARNING: m out of bounds (2)\n");
+    }
+  }
+  return (next_lensobj);
+# endif
+}
+
+/* average[].lensobjOffset, average[].Nlensobj are valid within an addstar run */
+int add_lensobj_link (Average *average, off_t *next_lensobj, off_t Nlensobj, off_t NLENSOBJ) {
+
+  off_t k, m;
+
+  /* if we have trouble, check validity of next_lensobj[m] : m < Nlensobj */
+  m = average[0].lensobjOffset;  
+
+  for (k = 0; k < average[0].Nlensobj - 1; k++)  {
+    m = next_lensobj[m];
+    if (m >= NLENSOBJ) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+
+  /* set up references */
+  next_lensobj[Nlensobj] = -1;
+  if (Nlensobj >= NLENSOBJ) {
+    fprintf (stderr, "WARNING: Nlensobj out of bounds (1)\n");
+  }
+
+  // if Nlensobj is 0, m may have been mis-set; add to the end
+  if ((average[0].Nlensobj == 0) || (m == -1)) {
+    average[0].lensobjOffset = Nlensobj;
+  } else {
+    next_lensobj[m] = Nlensobj;
+    if (m >= NLENSOBJ) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+
+  return (TRUE);
+}
+
+Lensobj *sort_lensobj (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj, off_t *next_lensobj) {
+
+  off_t i, k, n, np, N;
+  Lensobj *tmplensobj;
+
+  /* fix order of Lensobj (memory intensive, but fast) */
+  np = -1;
+  N = 0; 
+  ALLOCATE (tmplensobj, Lensobj, Nlensobj);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensobj) continue;
+    n = average[i].lensobjOffset;
+    average[i].lensobjOffset = N;
+    int myObjID = average[i].objID;
+    for (k = 0; k < average[i].Nlensobj; k++, N++) {
+      if (n == -1) {
+	fprintf (stderr, "entry after %d has a problem\n", (int) np);
+	abort();
+      }
+      tmplensobj[N] = lensobj[n]; 
+      // myAssert (lensobj[n].averef == i, "error in averef");
+      myAssert ((lensobj[n].objID == myObjID) || (lensobj[n].objID == -1), "error in objID?");
+      // tmplensobj[N].averef = i;
+      np = n;
+      n = next_lensobj[n];
+    }
+  }
+  free (lensobj);
+  return (tmplensobj);
 }
 
@@ -406,5 +564,5 @@
 
   off_t i, j, N;
-  off_t *next_star;
+  off_t *next_starpar;
 
   if (!starpar) return NULL;
@@ -415,6 +573,6 @@
   // NOTE that is we choose DVO_SKIP_STARPAR, catalog.starpar is NULL.
   // this code will let merge_catalogs_old.c do nothing for starpar
-  ALLOCATE (next_star, off_t, Nstarpar);
-  if (!starpar) return next_star;
+  ALLOCATE (next_starpar, off_t, Nstarpar);
+  if (!starpar) return next_starpar;
 
   for (i = 0; i < Naverage; i++) {
@@ -424,10 +582,10 @@
     for (j = 0; j < average[i].Nstarpar - 1; j++, N++) {
       myAssert (starpar[m+j+1].averef == i, "not sorted");
-      next_star[N] = N + 1;
+      next_starpar[N] = N + 1;
       if (N >= Nstarpar) {
 	fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_star[N] = -1;
+    next_starpar[N] = -1;
     if (N >= Nstarpar) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -440,5 +598,5 @@
     N++;
   }
-  return (next_star);
+  return (next_starpar);
 }
 
@@ -453,8 +611,8 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_star;
-
-  ALLOCATE (next_star, off_t, Nstarpar);
-  if (!starpar) return next_star;
+  off_t *next_starpar;
+
+  ALLOCATE (next_starpar, off_t, Nstarpar);
+  if (!starpar) return next_starpar;
 
   /* reset the Nm, offset values for average */
@@ -467,5 +625,5 @@
     averef = starpar[Nm].averef;
     m = average[averef].starparOffset;  
-    next_star[Nm] = -1;
+    next_starpar[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -475,6 +633,6 @@
     }
 
-    for (k = 0; next_star[m] != -1; k++) {
-      m = next_star[m];
+    for (k = 0; next_starpar[m] != -1; k++) {
+      m = next_starpar[m];
       if (m >= Nstarpar) {
 	fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -483,22 +641,22 @@
 
     average[averef].Nstarpar = k + 2;
-    next_star[m] = Nm;
+    next_starpar[m] = Nm;
     if (m >= Nstarpar) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_star);
+  return (next_starpar);
 }
 
 /* average[].starparOffset, average[].Nstarpar are valid within an addstar run */
-int add_star_link (Average *average, off_t *next_star, off_t Nstarpar, off_t NSTARPAR) {
+int add_starpar_link (Average *average, off_t *next_starpar, off_t Nstarpar, off_t NSTARPAR) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_star[m] : m < Nstarpar */
+  /* if we have trouble, check validity of next_starpar[m] : m < Nstarpar */
   m = average[0].starparOffset;  
 
   for (k = 0; k < average[0].Nstarpar - 1; k++)  {
-    m = next_star[m];
+    m = next_starpar[m];
     if (m >= NSTARPAR) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -507,5 +665,5 @@
 
   /* set up references */
-  next_star[Nstarpar] = -1;
+  next_starpar[Nstarpar] = -1;
   if (Nstarpar >= NSTARPAR) {
     fprintf (stderr, "WARNING: Nstarpar out of bounds (1)\n");
@@ -516,5 +674,5 @@
     average[0].starparOffset = Nstarpar;
   } else {
-    next_star[m] = Nstarpar;
+    next_starpar[m] = Nstarpar;
     if (m >= NSTARPAR) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -525,5 +683,5 @@
 }
 
-StarPar *sort_starpar (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next_star) {
+StarPar *sort_starpar (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next_starpar) {
 
   off_t i, k, n, np, N;
@@ -552,5 +710,5 @@
       tmpstarpar[N].averef = i;
       np = n;
-      n = next_star[n];
+      n = next_starpar[n];
     }
   }
@@ -566,5 +724,5 @@
 
   off_t i, j, N;
-  off_t *next_galp;
+  off_t *next_galphot;
 
   if (galphot) return NULL;
@@ -573,5 +731,5 @@
   N = 0;
 
-  ALLOCATE (next_galp, off_t, Ngalphot);
+  ALLOCATE (next_galphot, off_t, Ngalphot);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Ngalphot) continue;
@@ -580,10 +738,10 @@
     for (j = 0; j < average[i].Ngalphot - 1; j++, N++) {
       myAssert (galphot[m+j+1].averef == i, "not sorted");
-      next_galp[N] = N + 1;
+      next_galphot[N] = N + 1;
       if (N >= Ngalphot) {
 	fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_galp[N] = -1;
+    next_galphot[N] = -1;
     if (N >= Ngalphot) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -596,5 +754,5 @@
     N++;
   }
-  return (next_galp);
+  return (next_galphot);
 }
 
@@ -609,7 +767,7 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_galp;
-
-  ALLOCATE (next_galp, off_t, Ngalphot);
+  off_t *next_galphot;
+
+  ALLOCATE (next_galphot, off_t, Ngalphot);
 
   /* reset the Nm, offset values for average */
@@ -622,5 +780,5 @@
     averef = galphot[Nm].averef;
     m = average[averef].galphotOffset;  
-    next_galp[Nm] = -1;
+    next_galphot[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -630,6 +788,6 @@
     }
 
-    for (k = 0; next_galp[m] != -1; k++) {
-      m = next_galp[m];
+    for (k = 0; next_galphot[m] != -1; k++) {
+      m = next_galphot[m];
       if (m >= Ngalphot) {
 	fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -638,22 +796,22 @@
 
     average[averef].Ngalphot = k + 2;
-    next_galp[m] = Nm;
+    next_galphot[m] = Nm;
     if (m >= Ngalphot) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_galp);
+  return (next_galphot);
 }
 
 /* average[].galphotOffset, average[].Ngalphot are valid within an addstar run */
-int add_galp_link (Average *average, off_t *next_galp, off_t Ngalphot, off_t NGALPHOT) {
+int add_galphot_link (Average *average, off_t *next_galphot, off_t Ngalphot, off_t NGALPHOT) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_galp[m] : m < Ngalphot */
+  /* if we have trouble, check validity of next_galphot[m] : m < Ngalphot */
   m = average[0].galphotOffset;  
 
   for (k = 0; k < average[0].Ngalphot - 1; k++)  {
-    m = next_galp[m];
+    m = next_galphot[m];
     if (m >= NGALPHOT) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -662,5 +820,5 @@
 
   /* set up references */
-  next_galp[Ngalphot] = -1;
+  next_galphot[Ngalphot] = -1;
   if (Ngalphot >= NGALPHOT) {
     fprintf (stderr, "WARNING: Ngalphot out of bounds (1)\n");
@@ -671,5 +829,5 @@
     average[0].galphotOffset = Ngalphot;
   } else {
-    next_galp[m] = Ngalphot;
+    next_galphot[m] = Ngalphot;
     if (m >= NGALPHOT) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -680,5 +838,5 @@
 }
 
-GalPhot *sort_galphot (Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot, off_t *next_galp) {
+GalPhot *sort_galphot (Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot, off_t *next_galphot) {
 
   off_t i, k, n, np, N;
@@ -704,5 +862,5 @@
       tmpgalphot[N].averef = i;
       np = n;
-      n = next_galp[n];
+      n = next_galphot[n];
     }
   }
Index: trunk/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c
===================================================================
--- trunk/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c	(revision 39536)
+++ trunk/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c	(revision 39926)
@@ -336,4 +336,5 @@
     if (SKIP_MEASURE)               { strextend (&command, "-skip-measure"); }
     if (SKIP_LENSING)               { strextend (&command, "-skip-lensing"); }
+    if (SKIP_LENSOBJ)               { strextend (&command, "-skip-lensobj"); }
     if (SKIP_GALPHOT)               { strextend (&command, "-skip-galphot"); }
     if (SKIP_STARPAR)               { strextend (&command, "-skip-starpar"); }
Index: trunk/Ohana/src/dvomerge/src/merge_catalogs_old.c
===================================================================
--- trunk/Ohana/src/dvomerge/src/merge_catalogs_old.c	(revision 39536)
+++ trunk/Ohana/src/dvomerge/src/merge_catalogs_old.c	(revision 39926)
@@ -14,6 +14,6 @@
   double *X1, *Y1, *X2, *Y2;
   double dX, dY, dR;
-  off_t *N1, *N2, *next_meas, *next_lens, *next_star, *next_galp;
-  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch, Nlens, NLENS, Nstar, NSTAR, Ngalp, NGALP;
+  off_t *N1, *N2, *next_measure, *next_lensing, *next_lensobj, *next_starpar, *next_galphot;
+  off_t Nave, NAVE, Nmeasure, NMEASURE, Nmatch, Nlensing, NLENSING, Nlensobj, NLENSOBJ, Nstarpar, NSTARPAR, Ngalphot, NGALPHOT;
   int NsecfiltIn;
   int NsecfiltOut;
@@ -51,8 +51,9 @@
   /* internal counters */
   Nmatch = 0;
-  NMEAS = Nmeas = output[0].Nmeasure;
-  NLENS = Nlens = output[0].Nlensing;
-  NSTAR = Nstar = output[0].Nstarpar;
-  NGALP = Ngalp = output[0].Ngalphot;
+  NMEASURE = Nmeasure = output[0].Nmeasure;
+  NLENSING = Nlensing = output[0].Nlensing;
+  NLENSOBJ = Nlensobj = output[0].Nlensobj;
+  NSTARPAR = Nstarpar = output[0].Nstarpar;
+  NGALPHOT = Ngalphot = output[0].Ngalphot;
 
   // current max obj ID for this catalog
@@ -116,13 +117,15 @@
     // this version is only valid if we have done a full catalog load, and if the catalog
     // is sorted while processed
-    next_meas = init_measure_links (output[0].average, Nave, output[0].measure, Nmeas);
-    next_lens = init_lensing_links (output[0].average, Nave, output[0].lensing, Nlens);
-    next_star = init_starpar_links (output[0].average, Nave, output[0].starpar, Nstar);
-    next_galp = init_galphot_links (output[0].average, Nave, output[0].galphot, Ngalp);
+    next_measure = init_measure_links (output[0].average, Nave, output[0].measure, Nmeasure);
+    next_lensing = init_lensing_links (output[0].average, Nave, output[0].lensing, Nlensing);
+    next_lensobj = init_lensobj_links (output[0].average, Nave, output[0].lensobj, Nlensobj);
+    next_starpar = init_starpar_links (output[0].average, Nave, output[0].starpar, Nstarpar);
+    next_galphot = init_galphot_links (output[0].average, Nave, output[0].galphot, Ngalphot);
   } else {
-    next_meas = build_measure_links (output[0].average, Nave, output[0].measure, Nmeas);
-    next_lens = build_lensing_links (output[0].average, Nave, output[0].lensing, Nlens);
-    next_star = build_starpar_links (output[0].average, Nave, output[0].starpar, Nstar);
-    next_galp = build_galphot_links (output[0].average, Nave, output[0].galphot, Ngalp);
+    next_measure = build_measure_links (output[0].average, Nave, output[0].measure, Nmeasure);
+    next_lensing = build_lensing_links (output[0].average, Nave, output[0].lensing, Nlensing);
+    next_lensobj = build_lensobj_links (output[0].average, Nave, output[0].lensobj, Nlensobj);
+    next_starpar = build_starpar_links (output[0].average, Nave, output[0].starpar, Nstarpar);
+    next_galphot = build_galphot_links (output[0].average, Nave, output[0].galphot, Ngalphot);
   }    
 
@@ -183,23 +186,28 @@
 
     /* make sure there is space for next Nmeasure entries */
-    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
-      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
-      REALLOCATE (next_meas, off_t, NMEAS);
-      REALLOCATE (output[0].measure, Measure, NMEAS);
-    }
-    if (Nlens + input[0].average[N].Nlensing >= NLENS) {
-      NLENS = Nlens + input[0].average[N].Nlensing + 1000;
-      REALLOCATE (next_lens, off_t, NLENS);
-      REALLOCATE (output[0].lensing, Lensing, NLENS);
-    }
-    if (Nstar + input[0].average[N].Nstarpar >= NSTAR) {
-      NSTAR = Nstar + input[0].average[N].Nstarpar + 1000;
-      REALLOCATE (next_star, off_t, NSTAR);
-      REALLOCATE (output[0].starpar, StarPar, NSTAR);
-    }
-    if (Ngalp + input[0].average[N].Ngalphot >= NGALP) {
-      NGALP = Ngalp + input[0].average[N].Ngalphot + 1000;
-      REALLOCATE (next_galp, off_t, NGALP);
-      REALLOCATE (output[0].galphot, GalPhot, NGALP);
+    if (Nmeasure + input[0].average[N].Nmeasure >= NMEASURE) {
+      NMEASURE = Nmeasure + input[0].average[N].Nmeasure + 1000;
+      REALLOCATE (next_measure, off_t, NMEASURE);
+      REALLOCATE (output[0].measure, Measure, NMEASURE);
+    }
+    if (Nlensing + input[0].average[N].Nlensing >= NLENSING) {
+      NLENSING = Nlensing + input[0].average[N].Nlensing + 1000;
+      REALLOCATE (next_lensing, off_t, NLENSING);
+      REALLOCATE (output[0].lensing, Lensing, NLENSING);
+    }
+    if (Nlensobj + input[0].average[N].Nlensobj >= NLENSOBJ) {
+      NLENSOBJ = Nlensobj + input[0].average[N].Nlensobj + 1000;
+      REALLOCATE (next_lensobj, off_t, NLENSOBJ);
+      REALLOCATE (output[0].lensobj, Lensobj, NLENSOBJ);
+    }
+    if (Nstarpar + input[0].average[N].Nstarpar >= NSTARPAR) {
+      NSTARPAR = Nstarpar + input[0].average[N].Nstarpar + 1000;
+      REALLOCATE (next_starpar, off_t, NSTARPAR);
+      REALLOCATE (output[0].starpar, StarPar, NSTARPAR);
+    }
+    if (Ngalphot + input[0].average[N].Ngalphot >= NGALPHOT) {
+      NGALPHOT = Ngalphot + input[0].average[N].Ngalphot + 1000;
+      REALLOCATE (next_galphot, off_t, NGALPHOT);
+      REALLOCATE (output[0].galphot, GalPhot, NGALPHOT);
     }
 
@@ -212,7 +220,7 @@
       if (REPLACE_TYCHO) {
 	int Minp =  input[0].average[N].measureOffset;
-	Nreplace = replace_tycho (&output[0].average[n], output[0].measure, next_meas, &input[0].average[N], &input[0].measure[Minp]);
+	Nreplace = replace_tycho (&output[0].average[n], output[0].measure, next_measure, &input[0].average[N], &input[0].measure[Minp]);
 	if (Nreplace == 6) {
-	  output[0].found_t[n] = Nmeas;
+	  output[0].found_t[n] = Nmeasure;
 	  i++;
 	  continue;
@@ -227,13 +235,13 @@
 	  // index to first measure for this object
 	  // XXX this does not support lensing, starpar, or galphot measurements
-	  if (replace_match (&output[0].average[n], output[0].measure, next_meas, &input[0].average[N], &input[0].measure[offset])) {
+	  if (replace_match (&output[0].average[n], output[0].measure, next_measure, &input[0].average[N], &input[0].measure[offset])) {
 	    continue;
 	  }
 	}
 	/* add to end of measurement list */
-	add_meas_link (&output[0].average[n], next_meas, Nmeas, NMEAS);
+	add_measure_link (&output[0].average[n], next_measure, Nmeasure, NMEASURE);
 	
 	// set the new measurements
-	output[0].measure[Nmeas] = input[0].measure[offset];
+	output[0].measure[Nmeasure] = input[0].measure[offset];
 
 	// old code: find R,D using average_in[0], the get offset relative to average_out[0].  no longer
@@ -241,27 +249,27 @@
 	// Rin = input[0].average[N].R - input[0].measure[offset].dR / 3600.0;
 	// Din = input[0].average[N].D - input[0].measure[offset].dD / 3600.0;
-	// output[0].measure[Nmeas].dR = 3600.0*(output[0].average[n].R - Rin);
-	// output[0].measure[Nmeas].dD = 3600.0*(output[0].average[n].D - Din);
-
-	output[0].measure[Nmeas].dbFlags  = 0;  // XXX why reset these?
-	output[0].measure[Nmeas].averef   = n;
-	output[0].measure[Nmeas].objID    = output[0].average[n].objID;
-	output[0].measure[Nmeas].catID    = output[0].catID;
-
-	assert (output[0].measure[Nmeas].averef < Nave);
-
-	// fprintf (stderr, "Nave : "OFF_T_FMT", Nmeas : "OFF_T_FMT", dR: %f, dD: %f, catID: %d\n",  n,  Nmeas, output[0].measure[Nmeas].dR, output[0].measure[Nmeas].dD, output[0].measure[i].catID);
-
-	float dRoff = dvoOffsetR(&output[0].measure[Nmeas], &output[0].average[n]);
+	// output[0].measure[Nmeasure].dR = 3600.0*(output[0].average[n].R - Rin);
+	// output[0].measure[Nmeasure].dD = 3600.0*(output[0].average[n].D - Din);
+
+	output[0].measure[Nmeasure].dbFlags  = 0;  // XXX why reset these?
+	output[0].measure[Nmeasure].averef   = n;
+	output[0].measure[Nmeasure].objID    = output[0].average[n].objID;
+	output[0].measure[Nmeasure].catID    = output[0].catID;
+
+	assert (output[0].measure[Nmeasure].averef < Nave);
+
+	// fprintf (stderr, "Nave : "OFF_T_FMT", Nmeasure : "OFF_T_FMT", dR: %f, dD: %f, catID: %d\n",  n,  Nmeasure, output[0].measure[Nmeasure].dR, output[0].measure[Nmeasure].dD, output[0].measure[i].catID);
+
+	float dRoff = dvoOffsetR(&output[0].measure[Nmeasure], &output[0].average[n]);
 
 	// rationalize R
 	if (dRoff > +180.0*3600.0) {
 	  // average on high end of boundary, move star up
-	  output[0].measure[Nmeas].R += 360.0;
+	  output[0].measure[Nmeasure].R += 360.0;
 	  dRoff -= 360.0*3600.0;
 	}
 	if (dRoff < -180.0*3600.0) {
 	  // average on low end of boundary, move star down
-	  output[0].measure[Nmeas].R -= 360.0;
+	  output[0].measure[Nmeasure].R -= 360.0;
 	  dRoff += 360.0*3600.0;
 	}
@@ -272,5 +280,5 @@
 	    fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", 
 		     output[0].average[n].R, output[0].average[n].D, 
-		     output[0].measure[Nmeas].R, output[0].measure[Nmeas].D,
+		     output[0].measure[Nmeasure].R, output[0].measure[Nmeasure].D,
 		     X1[i], X2[Jmin], Y1[i], Y2[Jmin]);
 	    // XXX abort on this? -- this is a bad failure...
@@ -278,5 +286,5 @@
 	}
 	output[0].average[n].Nmeasure ++;
-	Nmeas ++;
+	Nmeasure ++;
       }
     }
@@ -286,15 +294,33 @@
       for (Nin = 0; Nin < input[0].average[N].Nlensing; Nin++) {
 	/* add to end of lensing list */
-	add_lens_link (&output[0].average[n], next_lens, Nlens, NLENS);
+	add_lensing_link (&output[0].average[n], next_lensing, Nlensing, NLENSING);
 	
 	// set the new lensing
 	off_t lensoff = input[0].average[N].lensingOffset + Nin;
-	output[0].lensing[Nlens] = input[0].lensing[lensoff];
-
-	output[0].lensing[Nlens].averef   = n;
-	output[0].lensing[Nlens].objID    = output[0].average[n].objID;
-	output[0].lensing[Nlens].catID    = output[0].catID;
+	output[0].lensing[Nlensing] = input[0].lensing[lensoff];
+
+	output[0].lensing[Nlensing].averef   = n;
+	output[0].lensing[Nlensing].objID    = output[0].average[n].objID;
+	output[0].lensing[Nlensing].catID    = output[0].catID;
 	output[0].average[n].Nlensing ++;
-	Nlens ++;
+	Nlensing ++;
+      }
+    }
+
+    // if lensobj measurements exist, add them too
+    if (output[0].lensobj && !SKIP_LENSOBJ) {
+      for (Nin = 0; Nin < input[0].average[N].Nlensobj; Nin++) {
+	/* add to end of lensobj list */
+	add_lensobj_link (&output[0].average[n], next_lensobj, Nlensobj, NLENSOBJ);
+	
+	// set the new lensobj
+	off_t lensoff = input[0].average[N].lensobjOffset + Nin;
+	output[0].lensobj[Nlensobj] = input[0].lensobj[lensoff];
+
+	// output[0].lensobj[Nlensobj].averef   = n;
+	output[0].lensobj[Nlensobj].objID    = output[0].average[n].objID;
+	output[0].lensobj[Nlensobj].catID    = output[0].catID;
+	output[0].average[n].Nlensobj ++;
+	Nlensobj ++;
       }
     }
@@ -304,15 +330,15 @@
       for (Nin = 0; Nin < input[0].average[N].Nstarpar; Nin++) {
 	/* add to end of lensing list */
-	add_star_link (&output[0].average[n], next_star, Nstar, NSTAR);
+	add_starpar_link (&output[0].average[n], next_starpar, Nstarpar, NSTARPAR);
 	
 	// set the new starpar
 	off_t staroff = input[0].average[N].starparOffset + Nin;
-	output[0].starpar[Nstar] = input[0].starpar[staroff];
-
-	output[0].starpar[Nstar].averef   = n;
-	output[0].starpar[Nstar].objID    = output[0].average[n].objID;
-	output[0].starpar[Nstar].catID    = output[0].catID;
+	output[0].starpar[Nstarpar] = input[0].starpar[staroff];
+
+	output[0].starpar[Nstarpar].averef   = n;
+	output[0].starpar[Nstarpar].objID    = output[0].average[n].objID;
+	output[0].starpar[Nstarpar].catID    = output[0].catID;
 	output[0].average[n].Nstarpar ++;
-	Nstar ++;
+	Nstarpar ++;
       }
     }
@@ -322,15 +348,15 @@
       for (Nin = 0; Nin < input[0].average[N].Ngalphot; Nin++) {
 	/* add to end of galphot list */
-	add_galp_link (&output[0].average[n], next_galp, Ngalp, NGALP);
+	add_galphot_link (&output[0].average[n], next_galphot, Ngalphot, NGALPHOT);
 	
 	// set the new galphot
 	off_t galpoff = input[0].average[N].galphotOffset + Nin;
-	output[0].galphot[Ngalp] = input[0].galphot[galpoff];
-
-	output[0].galphot[Ngalp].averef   = n;
-	output[0].galphot[Ngalp].objID    = output[0].average[n].objID;
-	output[0].galphot[Ngalp].catID    = output[0].catID;
+	output[0].galphot[Ngalphot] = input[0].galphot[galpoff];
+
+	output[0].galphot[Ngalphot].averef   = n;
+	output[0].galphot[Ngalphot].objID    = output[0].average[n].objID;
+	output[0].galphot[Ngalphot].catID    = output[0].catID;
 	output[0].average[n].Ngalphot ++;
-	Ngalp ++;
+	Ngalphot ++;
       }
     }
@@ -373,8 +399,8 @@
     /* Nm is updated, but not written out in -update mode (for existing entries)
        Nm is recalculated in build_meas_links if loaded table is not sorted */
-    output[0].found_t[n] = Nmeas;
+    output[0].found_t[n] = Nmeasure;
     i++;
   }
-  // MARKTIME("find matched stars: %f sec for "OFF_T_FMT","OFF_T_FMT" stars ("OFF_T_FMT" meas)\n", dtime, Nstars, Nave, Nmeas);
+  // MARKTIME("find matched stars: %f sec for "OFF_T_FMT","OFF_T_FMT" stars ("OFF_T_FMT" meas)\n", dtime, Nstars, Nave, Nmeasure);
 
   /** incorporate unmatched image stars, if this star is in field of this catalog **/
@@ -384,23 +410,28 @@
 
     /* make sure there is space for next entry */
-    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
-      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
-      REALLOCATE (next_meas, off_t, NMEAS);
-      REALLOCATE (output[0].measure, Measure, NMEAS);
-    }
-    if (Nlens + input[0].average[N].Nlensing >= NLENS) {
-      NLENS = Nlens + input[0].average[N].Nlensing + 1000;
-      REALLOCATE (next_lens, off_t, NLENS);
-      REALLOCATE (output[0].lensing, Lensing, NLENS);
-    }
-    if (Nstar + input[0].average[N].Nstarpar >= NSTAR) {
-      NSTAR = Nstar + input[0].average[N].Nstarpar + 1000;
-      REALLOCATE (next_star, off_t, NSTAR);
-      REALLOCATE (output[0].starpar, StarPar, NSTAR);
-    }
-    if (Ngalp + input[0].average[N].Ngalphot >= NGALP) {
-      NGALP = Ngalp + input[0].average[N].Ngalphot + 1000;
-      REALLOCATE (next_galp, off_t, NGALP);
-      REALLOCATE (output[0].galphot, GalPhot, NGALP);
+    if (Nmeasure + input[0].average[N].Nmeasure >= NMEASURE) {
+      NMEASURE = Nmeasure + input[0].average[N].Nmeasure + 1000;
+      REALLOCATE (next_measure, off_t, NMEASURE);
+      REALLOCATE (output[0].measure, Measure, NMEASURE);
+    }
+    if (Nlensing + input[0].average[N].Nlensing >= NLENSING) {
+      NLENSING = Nlensing + input[0].average[N].Nlensing + 1000;
+      REALLOCATE (next_lensing, off_t, NLENSING);
+      REALLOCATE (output[0].lensing, Lensing, NLENSING);
+    }
+    if (Nlensobj + input[0].average[N].Nlensobj >= NLENSOBJ) {
+      NLENSOBJ = Nlensobj + input[0].average[N].Nlensobj + 1000;
+      REALLOCATE (next_lensobj, off_t, NLENSOBJ);
+      REALLOCATE (output[0].lensobj, Lensobj, NLENSOBJ);
+    }
+    if (Nstarpar + input[0].average[N].Nstarpar >= NSTARPAR) {
+      NSTARPAR = Nstarpar + input[0].average[N].Nstarpar + 1000;
+      REALLOCATE (next_starpar, off_t, NSTARPAR);
+      REALLOCATE (output[0].starpar, StarPar, NSTARPAR);
+    }
+    if (Ngalphot + input[0].average[N].Ngalphot >= NGALPHOT) {
+      NGALPHOT = Ngalphot + input[0].average[N].Ngalphot + 1000;
+      REALLOCATE (next_galphot, off_t, NGALPHOT);
+      REALLOCATE (output[0].galphot, GalPhot, NGALPHOT);
     }
     if (Nave >= NAVE) {
@@ -465,27 +496,27 @@
     /** add measurements for this input average object **/
     if (output[0].measure && !SKIP_MEASURE && input[0].average[N].Nmeasure) {
-      output[0].average[Nave].measureOffset  = Nmeas;
+      output[0].average[Nave].measureOffset  = Nmeasure;
       for (Nin = 0; Nin < input[0].average[N].Nmeasure; Nin ++) {
 	offset = input[0].average[N].measureOffset + Nin;
 	
 	// supply the measurments from this detection
-	output[0].measure[Nmeas]           = input[0].measure[offset];
+	output[0].measure[Nmeasure]           = input[0].measure[offset];
 	
 	// the following measure elements cannot be set until here:
-	output[0].measure[Nmeas].dbFlags  = 0;
-	output[0].measure[Nmeas].averef   = Nave;
-	output[0].measure[Nmeas].objID    = output[0].average[Nave].objID;
-	output[0].measure[Nmeas].catID    = output[0].catID;
+	output[0].measure[Nmeasure].dbFlags  = 0;
+	output[0].measure[Nmeasure].averef   = Nave;
+	output[0].measure[Nmeasure].objID    = output[0].average[Nave].objID;
+	output[0].measure[Nmeasure].catID    = output[0].catID;
 	
 	// as we add measurements, update Nmeasure to match
 	output[0].average[Nave].Nmeasure ++;
 
-	/* we set next[Nmeas] to -1 here, and update correctly below */
-	next_meas[Nmeas] = -1;
-	Nmeas ++;
+	/* we set next[Nmeasure] to -1 here, and update correctly below */
+	next_measure[Nmeasure] = -1;
+	Nmeasure ++;
       }
       int Ngroup = input[0].average[N].Nmeasure;
       for (j = 0; j < Ngroup - 1; j++) {
-	next_meas[Nmeas - Ngroup + j] = Nmeas - Ngroup + j + 1;
+	next_measure[Nmeasure - Ngroup + j] = Nmeasure - Ngroup + j + 1;
       }
     }
@@ -493,25 +524,51 @@
     /** add lensing for this input average object **/
     if (output[0].lensing && !SKIP_LENSING && input[0].average[N].Nlensing) {
-      output[0].average[Nave].lensingOffset  = Nlens;
+      output[0].average[Nave].lensingOffset  = Nlensing;
       for (Nin = 0; Nin < input[0].average[N].Nlensing; Nin ++) {
 	// supply the lensing values from this detection
 	off_t lensoff = input[0].average[N].lensingOffset + Nin;
-	output[0].lensing[Nlens]           = input[0].lensing[lensoff];
+	output[0].lensing[Nlensing]           = input[0].lensing[lensoff];
 
 	// the following lensing elements cannot be set until here:
-	output[0].lensing[Nlens].averef   = Nave;
-	output[0].lensing[Nlens].objID    = output[0].average[Nave].objID;
-	output[0].lensing[Nlens].catID    = output[0].catID;
+	output[0].lensing[Nlensing].averef   = Nave;
+	output[0].lensing[Nlensing].objID    = output[0].average[Nave].objID;
+	output[0].lensing[Nlensing].catID    = output[0].catID;
 
 	// as we add lensing, update Nlensing to match
 	output[0].average[Nave].Nlensing ++;
 
-	/* we set next[Nlens] to -1 here, and update correctly below */
-	next_lens[Nlens] = -1;
-	Nlens ++;
+	/* we set next[Nlensing] to -1 here, and update correctly below */
+	next_lensing[Nlensing] = -1;
+	Nlensing ++;
       }
       int Ngroup = input[0].average[N].Nlensing;
       for (j = 0; j < Ngroup - 1; j++) {
-	next_lens[Nlens - Ngroup + j] = Nlens - Ngroup + j + 1;
+	next_lensing[Nlensing - Ngroup + j] = Nlensing - Ngroup + j + 1;
+      }
+    }
+
+    /** add lensobj for this input average object **/
+    if (output[0].lensobj && !SKIP_LENSOBJ && input[0].average[N].Nlensobj) {
+      output[0].average[Nave].lensobjOffset  = Nlensobj;
+      for (Nin = 0; Nin < input[0].average[N].Nlensobj; Nin ++) {
+	// supply the lensobj values from this detection
+	off_t lensoff = input[0].average[N].lensobjOffset + Nin;
+	output[0].lensobj[Nlensobj]           = input[0].lensobj[lensoff];
+
+	// the following lensobj elements cannot be set until here:
+	// output[0].lensobj[Nlensobj].averef   = Nave;
+	output[0].lensobj[Nlensobj].objID    = output[0].average[Nave].objID;
+	output[0].lensobj[Nlensobj].catID    = output[0].catID;
+
+	// as we add lensobj, update Nlensobj to match
+	output[0].average[Nave].Nlensobj ++;
+
+	/* we set next[Nlensobj] to -1 here, and update correctly below */
+	next_lensobj[Nlensobj] = -1;
+	Nlensobj ++;
+      }
+      int Ngroup = input[0].average[N].Nlensobj;
+      for (j = 0; j < Ngroup - 1; j++) {
+	next_lensobj[Nlensobj - Ngroup + j] = Nlensobj - Ngroup + j + 1;
       }
     }
@@ -519,25 +576,25 @@
     /** add starpar for this input average object **/
     if (output[0].starpar && !SKIP_STARPAR && input[0].average[N].Nstarpar) {
-      output[0].average[Nave].starparOffset  = Nstar;
+      output[0].average[Nave].starparOffset  = Nstarpar;
       for (Nin = 0; Nin < input[0].average[N].Nstarpar; Nin ++) {
 	// supply the starpar values from this detection
 	off_t staroff = input[0].average[N].starparOffset + Nin;
-	output[0].starpar[Nstar]           = input[0].starpar[staroff];
+	output[0].starpar[Nstarpar]           = input[0].starpar[staroff];
 
 	// the following starpar elements cannot be set until here:
-	output[0].starpar[Nstar].averef   = Nave;
-	output[0].starpar[Nstar].objID    = output[0].average[Nave].objID;
-	output[0].starpar[Nstar].catID    = output[0].catID;
+	output[0].starpar[Nstarpar].averef   = Nave;
+	output[0].starpar[Nstarpar].objID    = output[0].average[Nave].objID;
+	output[0].starpar[Nstarpar].catID    = output[0].catID;
 
 	// as we add starpar, update Nstarpar to match
 	output[0].average[Nave].Nstarpar ++;
 
-	/* we set next[Nstar] to -1 here, and update correctly below */
-	next_star[Nstar] = -1;
-	Nstar ++;
+	/* we set next[Nstarpar] to -1 here, and update correctly below */
+	next_starpar[Nstarpar] = -1;
+	Nstarpar ++;
       }
       int Ngroup = input[0].average[N].Nstarpar;
       for (j = 0; j < Ngroup - 1; j++) {
-	next_star[Nstar - Ngroup + j] = Nstar - Ngroup + j + 1;
+	next_starpar[Nstarpar - Ngroup + j] = Nstarpar - Ngroup + j + 1;
       }
     }
@@ -545,25 +602,25 @@
     /** add galphot for this input average object **/
     if (output[0].galphot && !SKIP_GALPHOT && input[0].average[N].Ngalphot) {
-      output[0].average[Nave].galphotOffset  = Ngalp;
+      output[0].average[Nave].galphotOffset  = Ngalphot;
       for (Nin = 0; Nin < input[0].average[N].Ngalphot; Nin ++) {
 	// supply the galphot values from this detection
 	off_t galpoff = input[0].average[N].galphotOffset + Nin;
-	output[0].galphot[Ngalp]           = input[0].galphot[galpoff];
+	output[0].galphot[Ngalphot]           = input[0].galphot[galpoff];
 
 	// the following galphot elements cannot be set until here:
-	output[0].galphot[Ngalp].averef   = Nave;
-	output[0].galphot[Ngalp].objID    = output[0].average[Nave].objID;
-	output[0].galphot[Ngalp].catID    = output[0].catID;
+	output[0].galphot[Ngalphot].averef   = Nave;
+	output[0].galphot[Ngalphot].objID    = output[0].average[Nave].objID;
+	output[0].galphot[Ngalphot].catID    = output[0].catID;
 
 	// as we add galphot, update Ngalphot to match
 	output[0].average[Nave].Ngalphot ++;
 
-	/* we set next[Ngalp] to -1 here, and update correctly below */
-	next_galp[Ngalp] = -1;
-	Ngalp ++;
+	/* we set next[Ngalphot] to -1 here, and update correctly below */
+	next_galphot[Ngalphot] = -1;
+	Ngalphot ++;
       }
       int Ngroup = input[0].average[N].Ngalphot;
       for (j = 0; j < Ngroup - 1; j++) {
-	next_galp[Ngalp - Ngroup + j] = Ngalp - Ngroup + j + 1;
+	next_galphot[Ngalphot - Ngroup + j] = Ngalphot - Ngroup + j + 1;
       }
     }
@@ -575,8 +632,9 @@
 
   REALLOCATE (output[0].average, Average, Nave);
-  if (!SKIP_MEASURE) { REALLOCATE (output[0].measure, Measure, Nmeas); }
-  if (!SKIP_LENSING) { REALLOCATE (output[0].lensing, Lensing, Nlens); }
-  if (!SKIP_STARPAR) { REALLOCATE (output[0].starpar, StarPar, Nstar); }
-  if (!SKIP_GALPHOT) { REALLOCATE (output[0].galphot, GalPhot, Ngalp); }
+  if (!SKIP_MEASURE) { REALLOCATE (output[0].measure, Measure, Nmeasure); }
+  if (!SKIP_LENSING) { REALLOCATE (output[0].lensing, Lensing, Nlensing); }
+  if (!SKIP_LENSOBJ) { REALLOCATE (output[0].lensobj, Lensobj, Nlensobj); }
+  if (!SKIP_STARPAR) { REALLOCATE (output[0].starpar, StarPar, Nstarpar); }
+  if (!SKIP_GALPHOT) { REALLOCATE (output[0].galphot, GalPhot, Ngalphot); }
  
 # define NOSORT 0
@@ -585,8 +643,9 @@
   } else {
     output[0].sorted = TRUE;
-    if (!SKIP_MEASURE) { output[0].measure = sort_measure (output[0].average, Nave, output[0].measure, Nmeas, next_meas); }
-    if (!SKIP_LENSING) { output[0].lensing = sort_lensing (output[0].average, Nave, output[0].lensing, Nlens, next_lens); }
-    if (!SKIP_STARPAR) { output[0].starpar = sort_starpar (output[0].average, Nave, output[0].starpar, Nstar, next_star); }
-    if (!SKIP_GALPHOT) { output[0].galphot = sort_galphot (output[0].average, Nave, output[0].galphot, Ngalp, next_galp); }
+    if (!SKIP_MEASURE) { output[0].measure = sort_measure (output[0].average, Nave, output[0].measure, Nmeasure, next_measure); }
+    if (!SKIP_LENSING) { output[0].lensing = sort_lensing (output[0].average, Nave, output[0].lensing, Nlensing, next_lensing); }
+    if (!SKIP_LENSOBJ) { output[0].lensobj = sort_lensobj (output[0].average, Nave, output[0].lensobj, Nlensobj, next_lensobj); }
+    if (!SKIP_STARPAR) { output[0].starpar = sort_starpar (output[0].average, Nave, output[0].starpar, Nstarpar, next_starpar); }
+    if (!SKIP_GALPHOT) { output[0].galphot = sort_galphot (output[0].average, Nave, output[0].galphot, Ngalphot, next_galphot); }
   }
 
@@ -594,15 +653,17 @@
   output[0].objID    = objID; // new max value, save on catalog close
   output[0].Naverage = Nave;
-  if (!SKIP_MEASURE) { output[0].Nmeasure = Nmeas; }
-  if (!SKIP_LENSING) { output[0].Nlensing = Nlens; }
-  if (!SKIP_STARPAR) { output[0].Nstarpar = Nstar; }
-  if (!SKIP_GALPHOT) { output[0].Ngalphot = Ngalp; }
+  if (!SKIP_MEASURE) { output[0].Nmeasure = Nmeasure; }
+  if (!SKIP_LENSING) { output[0].Nlensing = Nlensing; }
+  if (!SKIP_LENSOBJ) { output[0].Nlensobj = Nlensobj; }
+  if (!SKIP_STARPAR) { output[0].Nstarpar = Nstarpar; }
+  if (!SKIP_GALPHOT) { output[0].Ngalphot = Ngalphot; }
   output[0].Nsecfilt_mem = Nave*NsecfiltOut;
-  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas, Nlens, Ngalp: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nlens, Ngalp, Nmatch);
-
-  free (next_meas);
-  free (next_lens);
-  free (next_star);
-  free (next_galp);
+  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeasure, Nlensing, Ngalphot: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeasure,  Nlensing, Ngalphot, Nmatch);
+
+  free (next_measure);
+  free (next_lensing);
+  free (next_lensobj);
+  free (next_starpar);
+  free (next_galphot);
 
   free (X2);
@@ -625,5 +686,5 @@
    images have boundaries which are lines in pixels coords, but curve in RA and DEC
    
-   output[0].found_t[Ncat] but stars[Nstar].found
+   output[0].found_t[Ncat] but stars[Nstars].found
    
 */