diff --git a/src/dump.h b/src/dump.h
index 85d69de4b0..8e2ed70627 100644
--- a/src/dump.h
+++ b/src/dump.h
@@ -87,7 +87,6 @@ class Dump : protected Pointers {
   double *bufsort;
   int *idsort,*index,*proclist;
 
-
   class Irregular *irregular;
 
   virtual void init_style() = 0;
diff --git a/src/dump_cfg.cpp b/src/dump_cfg.cpp
index e6a272d971..33244f9343 100755
--- a/src/dump_cfg.cpp
+++ b/src/dump_cfg.cpp
@@ -45,8 +45,7 @@ DumpCFG::DumpCFG(LAMMPS *lmp, int narg, char **arg) :
       strcmp(arg[5],"id") != 0 || strcmp(arg[6],"type") != 0 ||
       (strcmp(arg[7],"xs") != 0 && strcmp(arg[7],"xsu") != 0) || 
       (strcmp(arg[8],"ys") != 0 && strcmp(arg[8],"ysu") != 0) ||
-      (strcmp(arg[9],"zs") != 0 && strcmp(arg[9],"zsu") != 0)
-      )
+      (strcmp(arg[9],"zs") != 0 && strcmp(arg[9],"zsu") != 0))
     error->all("Dump cfg arguments must start with "
 	       "'id type xs ys zs' or 'id type xsu ysu zsu'");
 
@@ -120,71 +119,7 @@ void DumpCFG::init_style()
 {
   if (multifile == 0) error->all("Dump cfg requires one snapshot per file");
 
-  // setup format strings
-
-  delete [] format;
-  char *str;
-  if (format_user) str = format_user;
-  else str = format_default;
-
-  int n = strlen(str) + 1;
-  format = new char[n];
-  strcpy(format,str);
-
-  // default for element names = C
-
-  if (typenames == NULL) {
-    typenames = new char*[ntypes+1];
-    for (int itype = 1; itype <= ntypes; itype++) {
-      typenames[itype] = new char[2];
-      strcpy(typenames[itype],"C");
-    }
-  }
-
-  // tokenize the format string and add space at end of each format element
-
-  char *ptr;
-  for (int i = 0; i < size_one; i++) {
-    if (i == 0) ptr = strtok(format," \0");
-    else ptr = strtok(NULL," \0");
-    delete [] vformat[i];
-    vformat[i] = new char[strlen(ptr) + 2];
-    strcpy(vformat[i],ptr);
-    vformat[i] = strcat(vformat[i]," ");
-  }
-
-  // find current ptr for each compute,fix,variable
-  // check that fix frequency is acceptable
-
-  int icompute;
-  for (int i = 0; i < ncompute; i++) {
-    icompute = modify->find_compute(id_compute[i]);
-    if (icompute < 0) error->all("Could not find dump cfg compute ID");
-    compute[i] = modify->compute[icompute];
-  }
-
-  int ifix;
-  for (int i = 0; i < nfix; i++) {
-    ifix = modify->find_fix(id_fix[i]);
-    if (ifix < 0) error->all("Could not find dump cfg fix ID");
-    fix[i] = modify->fix[ifix];
-    if (nevery % modify->fix[ifix]->peratom_freq)
-      error->all("Dump cfg and fix not computed at compatible times");
-  }
-
-  int ivariable;
-  for (int i = 0; i < nvariable; i++) {
-    ivariable = input->variable->find(id_variable[i]);
-    if (ivariable < 0) error->all("Could not find dump cfg variable name");
-    variable[i] = ivariable;
-  }
-
-  // set index and check validity of region
-
-  if (iregion >= 0) {
-    iregion = domain->find_region(idregion);
-    if (iregion == -1) error->all("Region ID for dump cfg does not exist");
-  }
+  DumpCustom::init_style();
 }
 
 /* ---------------------------------------------------------------------- */
@@ -192,10 +127,9 @@ void DumpCFG::init_style()
 void DumpCFG::write_header(bigint n)
 {
   // special handling for atom style peri
-  // use average volume of particles to scale particles to mimic C atoms
-  // scale box dimension to sc lattice for C with sigma = 1.44 Angstroms  
-
-  // Special handling for unwrapped coordinates
+  //   use average volume of particles to scale particles to mimic C atoms
+  //   scale box dimension to sc lattice for C with sigma = 1.44 Angstroms  
+  // special handling for unwrapped coordinates
 
   double scale;
   if (atom->peri_flag) {
@@ -254,8 +188,6 @@ void DumpCFG::write_data(int n, double *mybuf)
 
   double *rmass = atom->rmass;
   double *mass = atom->mass;
-  int *type = atom->type;
-  int nlocal = atom->nlocal;
 
   // transfer data from buf to rbuf
   // if write by proc 0, transfer chunk by chunk
@@ -266,7 +198,7 @@ void DumpCFG::write_data(int n, double *mybuf)
     nlines++;
   }
 
-  //  write data lines in rbuf to file after transfer is done
+  // write data lines in rbuf to file after transfer is done
   
   double unwrap_coord;
 
diff --git a/src/dump_custom.cpp b/src/dump_custom.cpp
index 1e511fde00..66bfd353e9 100644
--- a/src/dump_custom.cpp
+++ b/src/dump_custom.cpp
@@ -59,7 +59,9 @@ DumpCustom::DumpCustom(LAMMPS *lmp, int narg, char **arg) :
 
   nevery = atoi(arg[3]);
 
-  size_one = nfield = narg-5;
+  // size_one may be shrunk below if additional optional args exist
+
+  size_one = nfield = narg - 5;
   pack_choice = new FnPtrPack[nfield];
   vtype = new int[nfield];
 
@@ -89,8 +91,14 @@ DumpCustom::DumpCustom(LAMMPS *lmp, int narg, char **arg) :
   vbuf = NULL;
 
   // process attributes
+  // ioptional = start of additional optional args
+  // only dump image style processes optional args
 
-  parse_fields(narg,arg);
+  ioptional = parse_fields(narg,arg);
+
+  if (ioptional < narg && strcmp(style,"image") != 0)
+    error->all("Invalid attribute in dump custom command");
+  size_one = nfield = ioptional - 5;
 
   // atom selection arrays
 
@@ -397,17 +405,14 @@ int DumpCustom::count()
   // choose all local atoms for output
 
   for (i = 0; i < nlocal; i++) choose[i] = 1;
-  nmine = nlocal;
 
   // un-choose if not in group
 
   if (igroup) {
     int *mask = atom->mask;
     for (i = 0; i < nlocal; i++)
-      if (!(mask[i] & groupbit)) {
+      if (!(mask[i] & groupbit))
 	choose[i] = 0;
-	nmine--;
-      }
   }
 
   // un-choose if not in region
@@ -416,10 +421,8 @@ int DumpCustom::count()
     Region *region = domain->regions[iregion];
     double **x = atom->x;
     for (i = 0; i < nlocal; i++)
-      if (choose[i] && region->match(x[i][0],x[i][1],x[i][2]) == 0) {
+      if (choose[i] && region->match(x[i][0],x[i][1],x[i][2]) == 0) 
 	choose[i] = 0;
-	nmine--;
-      }
   }
 
   // un-choose if any threshhold criterion isn't met
@@ -834,45 +837,35 @@ int DumpCustom::count()
 
       if (thresh_op[ithresh] == LT) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr >= value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr >= value) choose[i] = 0;
       } else if (thresh_op[ithresh] == LE) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr > value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr > value) choose[i] = 0;
       } else if (thresh_op[ithresh] == GT) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr <= value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr <= value) choose[i] = 0;
       } else if (thresh_op[ithresh] == GE) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr < value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr < value) choose[i] = 0;
       } else if (thresh_op[ithresh] == EQ) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr != value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr != value) choose[i] = 0;
       } else if (thresh_op[ithresh] == NEQ) {
 	for (i = 0; i < nlocal; i++, ptr += nstride)
-	  if (choose[i] && *ptr == value) {
-	    choose[i] = 0;
-	    nmine--;
-	  }
+	  if (choose[i] && *ptr == value) choose[i] = 0;
       }
     }
   }
 
-  return nmine;
+  // compress choose list
+  // nchoose = # of selected atoms
+  // choose[i] = local index of each selected atom
+
+  nchoose = 0;
+  for (i = 0; i < nlocal; i++)
+    if (choose[i]) choose[nchoose++] = i;
+
+  return nchoose;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -882,10 +875,8 @@ void DumpCustom::pack(int *ids)
   for (int n = 0; n < size_one; n++) (this->*pack_choice[n])(n);
   if (ids) {
     int *tag = atom->tag;
-    int nlocal = atom->nlocal;
-    int n = 0;
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) ids[n++] = tag[i];
+    for (int i = 0; i < nchoose; i++)
+      ids[i] = tag[choose[i]];
   }
 }
 
@@ -926,7 +917,7 @@ void DumpCustom::write_text(int n, double *mybuf)
 
 /* ---------------------------------------------------------------------- */
 
-void DumpCustom::parse_fields(int narg, char **arg)
+int DumpCustom::parse_fields(int narg, char **arg)
 {
   // customize by adding to if statement
 
@@ -1217,8 +1208,10 @@ void DumpCustom::parse_fields(int narg, char **arg)
       field2index[i] = add_variable(suffix);
       delete [] suffix;
 
-    } else error->all("Invalid attribute in dump custom command");
+    } else return iarg;
   }
+
+  return narg;
 }
 
 /* ----------------------------------------------------------------------
@@ -1317,7 +1310,7 @@ int DumpCustom::modify_param(int narg, char **arg)
     return 2;
     
   } else if (strcmp(arg[0],"element") == 0) {
-    if (narg != ntypes+1)
+    if (narg < ntypes+1)
       error->all("Dump modify element names do not match atom types");
 
     if (typenames) {
@@ -1556,12 +1549,6 @@ int DumpCustom::modify_param(int narg, char **arg)
 
     nthresh++;
     return 4;
-
-  // pass along unknown params to child class
-
-  } else {
-    int n = modify_param2(narg,arg);
-    return n;
   }
 
   return 0;
@@ -1589,21 +1576,18 @@ void DumpCustom::pack_compute(int n)
   double *vector = compute[field2index[n]]->vector_atom;
   double **array = compute[field2index[n]]->array_atom;
   int index = argindex[n];
-  int nlocal = atom->nlocal;
 
   if (index == 0) {
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = vector[i];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = vector[choose[i]];
+      n += size_one;
+    }
   } else {
     index--;
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = array[i][index];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = array[choose[i]][index];
+      n += size_one;
+    }
   }
 }
 
@@ -1614,21 +1598,18 @@ void DumpCustom::pack_fix(int n)
   double *vector = fix[field2index[n]]->vector_atom;
   double **array = fix[field2index[n]]->array_atom;
   int index = argindex[n];
-  int nlocal = atom->nlocal;
 
   if (index == 0) {
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = vector[i];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = vector[choose[i]];
+      n += size_one;
+    }
   } else {
     index--;
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = array[i][index];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = array[choose[i]][index];
+      n += size_one;
+    }
   }
 }
 
@@ -1637,13 +1618,11 @@ void DumpCustom::pack_fix(int n)
 void DumpCustom::pack_variable(int n)
 {
   double *vector = vbuf[field2index[n]];
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = vector[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = vector[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ----------------------------------------------------------------------
@@ -1657,13 +1636,11 @@ void DumpCustom::pack_variable(int n)
 void DumpCustom::pack_id(int n)
 {
   int *tag = atom->tag;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = tag[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = tag[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1671,13 +1648,11 @@ void DumpCustom::pack_id(int n)
 void DumpCustom::pack_molecule(int n)
 {
   int *molecule = atom->molecule;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = molecule[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = molecule[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1685,13 +1660,11 @@ void DumpCustom::pack_molecule(int n)
 void DumpCustom::pack_type(int n)
 {
   int *type = atom->type;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = type[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = type[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1701,20 +1674,17 @@ void DumpCustom::pack_mass(int n)
   int *type = atom->type;
   double *mass = atom->mass;
   double *rmass = atom->rmass;
-  int nlocal = atom->nlocal;
 
   if (rmass) {
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = rmass[i];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = rmass[choose[i]];
+      n += size_one;
+    }
   } else {
-    for (int i = 0; i < nlocal; i++)
-      if (choose[i]) {
-	buf[n] = mass[type[i]];
-	n += size_one;
-      }
+    for (int i = 0; i < nchoose; i++) {
+      buf[n] = mass[type[choose[i]]];
+      n += size_one;
+    }
   }
 }
 
@@ -1723,13 +1693,11 @@ void DumpCustom::pack_mass(int n)
 void DumpCustom::pack_x(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = x[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1737,13 +1705,11 @@ void DumpCustom::pack_x(int n)
 void DumpCustom::pack_y(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = x[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1751,13 +1717,11 @@ void DumpCustom::pack_y(int n)
 void DumpCustom::pack_z(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = x[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1765,16 +1729,14 @@ void DumpCustom::pack_z(int n)
 void DumpCustom::pack_xs(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double boxxlo = domain->boxlo[0];
   double invxprd = 1.0/domain->xprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][0] - boxxlo) * invxprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (x[choose[i]][0] - boxxlo) * invxprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1782,16 +1744,14 @@ void DumpCustom::pack_xs(int n)
 void DumpCustom::pack_ys(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double boxylo = domain->boxlo[1];
   double invyprd = 1.0/domain->yprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][1] - boxylo) * invyprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (x[choose[i]][1] - boxylo) * invyprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1799,51 +1759,49 @@ void DumpCustom::pack_ys(int n)
 void DumpCustom::pack_zs(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double boxzlo = domain->boxlo[2];
   double invzprd = 1.0/domain->zprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][2] - boxzlo) * invzprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (x[choose[i]][2] - boxzlo) * invzprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_xs_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[0]*(x[i][0]-boxlo[0]) + 
-	h_inv[5]*(x[i][1]-boxlo[1]) + h_inv[4]*(x[i][2]-boxlo[2]);
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = h_inv[0]*(x[j][0]-boxlo[0]) + h_inv[5]*(x[j][1]-boxlo[1]) + 
+      h_inv[4]*(x[j][2]-boxlo[2]);
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_ys_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[1]*(x[i][1]-boxlo[1]) + h_inv[3]*(x[i][2]-boxlo[2]);
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = h_inv[1]*(x[j][1]-boxlo[1]) + h_inv[3]*(x[j][2]-boxlo[2]);
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1851,241 +1809,235 @@ void DumpCustom::pack_ys_triclinic(int n)
 void DumpCustom::pack_zs_triclinic(int n)
 {
   double **x = atom->x;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[2]*(x[i][2]-boxlo[2]);
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = h_inv[2]*(x[choose[i]][2]-boxlo[2]);
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_xu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double xprd = domain->xprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][0] + ((image[i] & 1023) - 512) * xprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = x[j][0] + ((image[j] & 1023) - 512) * xprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_yu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double yprd = domain->yprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][1] + ((image[i] >> 10 & 1023) - 512) * yprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = x[j][1] + ((image[j] >> 10 & 1023) - 512) * yprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_zu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double zprd = domain->zprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = x[i][2] + ((image[i] >> 20) - 512) * zprd;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = x[j][2] + ((image[j] >> 20) - 512) * zprd;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_xu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *h = domain->h;
   int xbox,ybox,zbox;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      xbox = (image[i] & 1023) - 512;
-      ybox = (image[i] >> 10 & 1023) - 512;
-      zbox = (image[i] >> 20) - 512;
-      buf[n] = x[i][0] + h[0]*xbox + h[5]*ybox + h[4]*zbox;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    xbox = (image[j] & 1023) - 512;
+    ybox = (image[j] >> 10 & 1023) - 512;
+    zbox = (image[j] >> 20) - 512;
+    buf[n] = x[j][0] + h[0]*xbox + h[5]*ybox + h[4]*zbox;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_yu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *h = domain->h;
   int ybox,zbox;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      ybox = (image[i] >> 10 & 1023) - 512;
-      zbox = (image[i] >> 20) - 512;
-      buf[n] = x[i][1] + h[1]*ybox + h[3]*zbox;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    ybox = (image[j] >> 10 & 1023) - 512;
+    zbox = (image[j] >> 20) - 512;
+    buf[n] = x[j][1] + h[1]*ybox + h[3]*zbox;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_zu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *h = domain->h;
   int zbox;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      zbox = (image[i] >> 20) - 512;
-      buf[n] = x[i][2] + h[2]*zbox;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    zbox = (image[j] >> 20) - 512;
+    buf[n] = x[j][2] + h[2]*zbox;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_xsu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double boxxlo = domain->boxlo[0];
   double invxprd = 1.0/domain->xprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][0] - boxxlo) * invxprd + (image[i] & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = (x[j][0] - boxxlo) * invxprd + (image[j] & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_ysu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double boxylo = domain->boxlo[1];
   double invyprd = 1.0/domain->yprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][1] - boxylo) * invyprd + (image[i] >> 10 & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = (x[j][1] - boxylo) * invyprd + (image[j] >> 10 & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_zsu(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double boxzlo = domain->boxlo[2];
   double invzprd = 1.0/domain->zprd;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (x[i][2] - boxzlo) * invzprd + (image[i] >> 20) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = (x[j][2] - boxzlo) * invzprd + (image[j] >> 20) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_xsu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[0]*(x[i][0]-boxlo[0]) + 
-	h_inv[5]*(x[i][1]-boxlo[1]) + 
-	h_inv[4]*(x[i][2]-boxlo[2]) +
-	(image[i] & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = h_inv[0]*(x[j][0]-boxlo[0]) + h_inv[5]*(x[j][1]-boxlo[1]) + 
+      h_inv[4]*(x[j][2]-boxlo[2]) + (image[j] & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_ysu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[1]*(x[i][1]-boxlo[1]) + 
-	h_inv[3]*(x[i][2]-boxlo[2]) +
-	(image[i] >> 10 & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = h_inv[1]*(x[j][1]-boxlo[1]) + h_inv[3]*(x[j][2]-boxlo[2]) +
+      (image[j] >> 10 & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
 
 void DumpCustom::pack_zsu_triclinic(int n)
 {
+  int j;
   double **x = atom->x;
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
   double *boxlo = domain->boxlo;
   double *h_inv = domain->h_inv;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = h_inv[2]*(x[i][2]-boxlo[2]) + 
-	(image[i] >> 20) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    j = choose[i];
+    buf[n] = h_inv[2]*(x[j][2]-boxlo[2]) + (image[j] >> 20) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2093,13 +2045,11 @@ void DumpCustom::pack_zsu_triclinic(int n)
 void DumpCustom::pack_ix(int n)
 {
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (image[i] & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (image[choose[i]] & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2107,13 +2057,11 @@ void DumpCustom::pack_ix(int n)
 void DumpCustom::pack_iy(int n)
 {
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (image[i] >> 10 & 1023) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (image[choose[i]] >> 10 & 1023) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2121,13 +2069,11 @@ void DumpCustom::pack_iy(int n)
 void DumpCustom::pack_iz(int n)
 {
   int *image = atom->image;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = (image[i] >> 20) - 512;
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = (image[choose[i]] >> 20) - 512;
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2135,13 +2081,11 @@ void DumpCustom::pack_iz(int n)
 void DumpCustom::pack_vx(int n)
 {
   double **v = atom->v;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = v[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = v[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2149,13 +2093,11 @@ void DumpCustom::pack_vx(int n)
 void DumpCustom::pack_vy(int n)
 {
   double **v = atom->v;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = v[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = v[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2163,13 +2105,11 @@ void DumpCustom::pack_vy(int n)
 void DumpCustom::pack_vz(int n)
 {
   double **v = atom->v;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = v[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = v[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2177,13 +2117,11 @@ void DumpCustom::pack_vz(int n)
 void DumpCustom::pack_fx(int n)
 {
   double **f = atom->f;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = f[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = f[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2191,13 +2129,11 @@ void DumpCustom::pack_fx(int n)
 void DumpCustom::pack_fy(int n)
 {
   double **f = atom->f;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = f[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = f[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2205,13 +2141,11 @@ void DumpCustom::pack_fy(int n)
 void DumpCustom::pack_fz(int n)
 {
   double **f = atom->f;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = f[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = f[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2219,13 +2153,11 @@ void DumpCustom::pack_fz(int n)
 void DumpCustom::pack_q(int n)
 {
   double *q = atom->q;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = q[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = q[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2233,13 +2165,11 @@ void DumpCustom::pack_q(int n)
 void DumpCustom::pack_mux(int n)
 {
   double **mu = atom->mu;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = mu[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = mu[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2247,13 +2177,11 @@ void DumpCustom::pack_mux(int n)
 void DumpCustom::pack_muy(int n)
 {
   double **mu = atom->mu;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = mu[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = mu[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2261,13 +2189,11 @@ void DumpCustom::pack_muy(int n)
 void DumpCustom::pack_muz(int n)
 {
   double **mu = atom->mu;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = mu[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = mu[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2275,13 +2201,11 @@ void DumpCustom::pack_muz(int n)
 void DumpCustom::pack_mu(int n)
 {
   double **mu = atom->mu;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = mu[i][3];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = mu[choose[i]][3];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2289,13 +2213,11 @@ void DumpCustom::pack_mu(int n)
 void DumpCustom::pack_radius(int n)
 {
   double *radius = atom->radius;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = radius[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = radius[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2303,13 +2225,11 @@ void DumpCustom::pack_radius(int n)
 void DumpCustom::pack_diameter(int n)
 {
   double *radius = atom->radius;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = 2.0*radius[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = 2.0*radius[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2317,13 +2237,11 @@ void DumpCustom::pack_diameter(int n)
 void DumpCustom::pack_omegax(int n)
 {
   double **omega = atom->omega;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = omega[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = omega[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2331,13 +2249,11 @@ void DumpCustom::pack_omegax(int n)
 void DumpCustom::pack_omegay(int n)
 {
   double **omega = atom->omega;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = omega[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = omega[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2345,13 +2261,11 @@ void DumpCustom::pack_omegay(int n)
 void DumpCustom::pack_omegaz(int n)
 {
   double **omega = atom->omega;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = omega[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = omega[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2359,13 +2273,11 @@ void DumpCustom::pack_omegaz(int n)
 void DumpCustom::pack_angmomx(int n)
 {
   double **angmom = atom->angmom;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = angmom[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = angmom[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2373,13 +2285,11 @@ void DumpCustom::pack_angmomx(int n)
 void DumpCustom::pack_angmomy(int n)
 {
   double **angmom = atom->angmom;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = angmom[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = angmom[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2387,13 +2297,11 @@ void DumpCustom::pack_angmomy(int n)
 void DumpCustom::pack_angmomz(int n)
 {
   double **angmom = atom->angmom;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = angmom[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = angmom[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2401,13 +2309,11 @@ void DumpCustom::pack_angmomz(int n)
 void DumpCustom::pack_tqx(int n)
 {
   double **torque = atom->torque;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = torque[i][0];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = torque[choose[i]][0];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2415,13 +2321,11 @@ void DumpCustom::pack_tqx(int n)
 void DumpCustom::pack_tqy(int n)
 {
   double **torque = atom->torque;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = torque[i][1];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = torque[choose[i]][1];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2429,13 +2333,11 @@ void DumpCustom::pack_tqy(int n)
 void DumpCustom::pack_tqz(int n)
 {
   double **torque = atom->torque;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = torque[i][2];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = torque[choose[i]][2];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2443,13 +2345,11 @@ void DumpCustom::pack_tqz(int n)
 void DumpCustom::pack_spin(int n)
 {
   int *spin = atom->spin;
-  int nlocal = atom->nlocal;
   
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = spin[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = spin[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2457,13 +2357,11 @@ void DumpCustom::pack_spin(int n)
 void DumpCustom::pack_eradius(int n)
 {
   double *eradius = atom->eradius;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = eradius[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = eradius[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2471,13 +2369,11 @@ void DumpCustom::pack_eradius(int n)
 void DumpCustom::pack_ervel(int n)
 {
   double *ervel = atom->ervel;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = ervel[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = ervel[choose[i]];
+    n += size_one;
+  }
 }
 
 /* ---------------------------------------------------------------------- */
@@ -2485,11 +2381,9 @@ void DumpCustom::pack_ervel(int n)
 void DumpCustom::pack_erforce(int n)
 {
   double *erforce = atom->erforce;
-  int nlocal = atom->nlocal;
 
-  for (int i = 0; i < nlocal; i++)
-    if (choose[i]) {
-      buf[n] = erforce[i];
-      n += size_one;
-    }
+  for (int i = 0; i < nchoose; i++) {
+    buf[n] = erforce[choose[i]];
+    n += size_one;
+  }
 }
diff --git a/src/dump_custom.h b/src/dump_custom.h
index 280f858d47..17c25106e0 100644
--- a/src/dump_custom.h
+++ b/src/dump_custom.h
@@ -44,11 +44,13 @@ class DumpCustom : public Dump {
 
   char *columns;             // column labels
 
+  int nchoose;               // # of selected atoms
   int maxlocal;              // size of atom selection and variable arrays
-  int *choose;               // 1 if output this atom, 0 if no
+  int *choose;               // local indices of selected atoms
   double *dchoose;           // value for each atom to threshhold against
 
   int nfield;                // # of keywords listed by user
+  int ioptional;             // index of start of optional args
 
   int *field2index;          // which compute,fix,variable calcs this field
   int *argindex;             // index into compute,fix scalar_atom,vector_atom
@@ -79,12 +81,11 @@ class DumpCustom : public Dump {
   virtual void write_data(int, double *);
   bigint memory_usage();
 
-  void parse_fields(int, char **);
+  int parse_fields(int, char **);
   int add_compute(char *);
   int add_fix(char *);
   int add_variable(char *);
-  int modify_param(int, char **);
-  virtual int modify_param2(int, char **) {return 0;}
+  virtual int modify_param(int, char **);
 
   typedef void (DumpCustom::*FnPtrHeader)(bigint);
   FnPtrHeader header_choice;           // ptr to write header functions